Accede a datos públicos

Algunos datos almacenados en Cloud Storage están configurados para que cualquier persona pueda acceder a ellos en cualquier momento. Se puede acceder a estos datos públicos de varias maneras, según cómo desees trabajar con los datos.

Cuando accedes a datos públicos mediante Google Cloud Console, debes autenticarte con una Cuenta de Google. La cuenta no tiene que estar asociada con el proyecto que contiene los datos públicos, ni tampoco es necesario que esté registrada para el servicio de Cloud Storage.

Por el contrario, si accedes a datos públicos con gsutil o con un vínculo de la API de Cloud Storage, no se requiere autenticación. Estos métodos son apropiados para los vínculos de uso general de los datos compartidos de forma pública. Por ejemplo, el vínculo de una API se puede usar en una página web, con bibliotecas cliente o con una herramienta de línea de comandos como cURL.

Para acceder a los datos públicos, sigue estos pasos:

El acceso a este vínculo no requiere autenticación. Por ejemplo, es adecuado como un vínculo en una página web o para descargar con una herramienta de línea de comandos como cURL.

  1. Obtén el nombre del bucket que contiene los datos públicos.

  2. Usa el siguiente URI para acceder a un objeto en el bucket:

    https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME

Por ejemplo, el bucket público de Google gcp-public-data-landsat contiene el conjunto de datos públicos Landsat dataset. Puedes vincular al objeto compartido públicamente LC08/01/001/003/LC08_L1GT_001003_20140812_20170420_01_T2/LC08_L1GT_001003_20140812_20170420_01_T2_B3.TIF con este vínculo:

https://storage.googleapis.com/gcp-public-data-landsat/LC08/01/001/003/LC08_L1GT_001003_20140812_20170420_01_T2/LC08_L1GT_001003_20140812_20170420_01_T2_B3.TIF

Console

Para acceder a este vínculo se requiere autenticación con Google. Por lo general, debes usar el método descrito en la pestaña de vínculo a la API para acceder a vínculos a objetos individuales en un bucket público. Solo puedes acceder a objetos públicos mediante Cloud Console si tienes el permiso storage.objects.list para el bucket que contiene los objetos.

  1. Obtén el nombre del bucket público.

  2. Mediante un navegador web, accede al bucket con el siguiente URI (se te pedirá acceder si es necesario):

    https://console.cloud.google.com/storage/browser/BUCKET_NAME

Por ejemplo, el bucket público de Google gcp-public-data-landsat contiene el conjunto de datos públicos Landsat dataset. Puedes acceder al bucket con el siguiente vínculo:

https://console.cloud.google.com/storage/browser/gcp-public-data-landsat

gsutil

  1. Si no tienes gsutil, sigue estas instrucciones para su instalación.

  2. Obtén el nombre del bucket que contiene los datos públicos.

  3. Si el bucket es público (y no solo algunos de los datos en él), puedes enumerar algunos o todos los datos (objetos) contenidos en el bucket mediante el comando ls.

    Por ejemplo, el bucket público de Google gcp-public-data-landsat contiene el conjunto de datos públicos Landsat dataset. Puedes enumerar los archivos con el prefijo LC08/01/001/003/LCcon el siguiente comando:

    gsutil ls -r gs://gcp-public-data-landsat/LC08/01/001/003/LC*
  4. Obtén objetos públicos específicos contenidos en el bucket mediante el comando cp.

    Por ejemplo, el siguiente comando descarga un archivo del bucket gcp-public-data-landsat a tu directorio local:

    gsutil cp gs://gcp-public-data-landsat/LC08/01/001/003/LC08_L1GT_001003_20140812_20170420_01_T2/LC08_L1GT_001003_20140812_20170420_01_T2_B3.TIF .

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

namespace gcs = ::google::cloud::storage;
[](std::string const& bucket_name, std::string const& object_name) {
  // Create a client that does not authenticate with the server.
  auto client = gcs::Client{
      google::cloud::Options{}.set<google::cloud::UnifiedCredentialsOption>(
          google::cloud::MakeInsecureCredentials())};

  // Read an object, the object must have been made public.
  gcs::ObjectReadStream stream = client.ReadObject(bucket_name, object_name);

  int count = 0;
  std::string line;
  while (std::getline(stream, line, '\n')) {
    ++count;
  }
  std::cout << "The object has " << count << " lines\n";
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

import (
	"context"
	"fmt"
	"io"
	"io/ioutil"
	"time"

	"cloud.google.com/go/storage"
	"google.golang.org/api/option"
)

// downloadPublicFile downloads a public object.
func downloadPublicFile(w io.Writer, bucket, object string) ([]byte, error) {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	// Create a client that does not authenticate with the server.
	client, err := storage.NewClient(ctx, option.WithoutAuthentication())
	if err != nil {
		return nil, fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer cancel()

	rc, err := client.Bucket(bucket).Object(object).NewReader(ctx)
	if err != nil {
		return nil, fmt.Errorf("Object(%q).NewReader: %v", object, err)
	}
	defer rc.Close()

	data, err := ioutil.ReadAll(rc)
	if err != nil {
		return nil, fmt.Errorf("ioutil.ReadAll: %v", err)
	}
	fmt.Fprintf(w, "Blob %v downloaded.\n", object)
	return data, nil
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.nio.file.Path;

public class DownloadPublicObject {
  public static void downloadPublicObject(
      String bucketName, String publicObjectName, Path destFilePath) {
    // The name of the bucket to access
    // String bucketName = "my-bucket";

    // The name of the remote public file to download
    // String publicObjectName = "publicfile.txt";

    // The path to which the file should be downloaded
    // Path destFilePath = Paths.get("/local/path/to/file.txt");

    // Instantiate an anonymous Google Cloud Storage client, which can only access public files
    Storage storage = StorageOptions.getUnauthenticatedInstance().getService();

    Blob blob = storage.get(BlobId.of(bucketName, publicObjectName));
    blob.downloadTo(destFilePath);

    System.out.println(
        "Downloaded public object "
            + publicObjectName
            + " from bucket name "
            + bucketName
            + " to "
            + destFilePath);
  }
}

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const srcFilename = 'your-file-name';

// The path to which the file should be downloaded
// const destFileName = '/local/path/to/file.txt';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function downloadPublicFile() {
  const options = {
    destination: destFileName,
  };

  // Download public file.
  await storage.bucket(bucketName).file(srcFileName).download(options);

  console.log(
    `Downloaded public file ${srcFileName} from bucket name ${bucketName} to ${destFileName}`
  );
}

downloadPublicFile().catch(console.error);

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

from google.cloud import storage

def download_public_file(bucket_name, source_blob_name, destination_file_name):
    """Downloads a public blob from the bucket."""
    # bucket_name = "your-bucket-name"
    # source_blob_name = "storage-object-name"
    # destination_file_name = "local/path/to/file"

    storage_client = storage.Client.create_anonymous_client()

    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(source_blob_name)
    blob.download_to_filename(destination_file_name)

    print(
        "Downloaded public blob {} from bucket {} to {}.".format(
            source_blob_name, bucket.name, destination_file_name
        )
    )

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

def download_public_file bucket_name:, file_name:, local_file_path:
  # The name of the bucket to access
  # bucket_name = "my-bucket"

  # The name of the remote public file to download
  # file_name = "publicfile.txt"

  # The path to which the file should be downloaded
  # local_file_path = "/local/path/to/file.txt"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.anonymous
  bucket  = storage.bucket bucket_name, skip_lookup: true
  file    = bucket.file file_name

  file.download local_file_path

  puts "Downloaded public object #{file.name} from bucket #{bucket} to #{local_file_path}"
end

Próximos pasos