Aceda a dados públicos

Alguns dados armazenados no Cloud Storage estão configurados para que sejam legíveis por qualquer pessoa em qualquer altura. Estes dados públicos podem ser acedidos de várias formas, consoante a forma como quer trabalhar com os dados.

Link da API

Nota: o acesso a este link não requer autenticação. É adequado, por exemplo, como um link numa página Web ou para transferência com uma ferramenta de linha de comandos, como o cURL.

1. Obtenha o nome do objeto público e o contentor que armazena o objeto.

2. Use o seguinte URI para aceder a um objeto no contentor:

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

Por exemplo, o contentor público da Google gcp-public-data-landsat contém o conjunto de dados público Landsat. Pode criar um link para o objeto partilhado publicamente LC08/01/001/003/LC08_L1GT_001003_20140812_20170420_01_T2/LC08_L1GT_001003_20140812_20170420_01_T2_B3.TIF com o link:

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

Consola

Nota: o acesso a dados públicos com a Google Cloud consola requer que inicie sessão com uma conta de utilizador. O método descrito no separador Link da API oferece a forma mais amplamente aplicável de aceder a objetos públicos individuais. O método descrito no separador Linha de comandos oferece a forma mais eficiente de aceder a coleções de dados.

1. Obtenha o nome do objeto público e o contentor que armazena o objeto.

2. Usando um navegador de Internet, aceda ao objeto com o seguinte URI (é-lhe pedido que inicie sessão se ainda não tiver sessão iniciada):

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

3. Se o público tiver autorização para listar o conteúdo do contentor, pode listar todos os objetos no contentor com o seguinte URI:

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

Por exemplo, o contentor público da Google gcp-public-data-landsat contém o conjunto de dados público Landsat. Pode aceder ao contentor com:

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

Linha de comandos

Nota: o acesso a dados públicos com a CLI gcloud não requer autenticação. Esta ferramenta é adequada para o acesso geral a contentores que contêm dados públicos listáveis publicamente.

1. Se não tiver a CLI gcloud, siga estas instruções para a instalar.

   • Quando instalar a CLI gcloud, se não quiser autenticar, ignore o passo de execução do comando gcloud init e, em alternativa, execute o seguinte comando:

     gcloud config set auth/disable_credentials True

2. Obtenha o nome do objeto público e o contentor que armazena o objeto.

3. Se a autorização para apresentar o conteúdo do contentor for concedida ao público, pode apresentar alguns ou todos os objetos contidos no contentor através do comando ls.

   Por exemplo, o contentor público da Google gcp-public-data-landsat contém o conjunto de dados público Landsat. Pode listar objetos com o prefixo LC08/01/001/003/LC com o seguinte comando:

   gcloud storage ls --recursive gs://gcp-public-data-landsat/LC08/01/001/003/LC*

   Nota: os shells (como o bash e o zsh) podem tentar expandir os carateres universais antes de passar os argumentos para a CLI gcloud. Para evitar estes problemas, coloque a expressão com carateres universais entre aspas simples (no Linux) ou aspas duplas (no Windows). Para mais informações, consulte o artigo Comportamento potencialmente surpreendente quando usa carateres universais.

4. Transfira objetos públicos específicos contidos no contentor através do comando cp.

   Por exemplo, o comando seguinte transfere um ficheiro do contentor gcp-public-data-landsat para o seu diretório local:

   gcloud storage 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 .

Bibliotecas cliente

C++

Para mais informações, consulte a documentação de referência da API C++ do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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;
  }
  if (stream.bad()) throw google::cloud::Status(stream.status());
  std::cout << "The object has " << count << " lines\n";
}

C#

Para mais informações, consulte a documentação de referência da API C# do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

using Google.Cloud.Storage.V1;
using System;
using System.IO;

public class DownloadPublicFileSample
{
    public string DownloadPublicFile(
        string bucketName = "your-bucket-name",
        string objectName = "your-object-name",
        string localPath = "path/to/download/object/to")
    {
        var storage = StorageClient.CreateUnauthenticated();

        using var outputFile = File.OpenWrite(localPath);
        storage.DownloadObject(bucketName, objectName, outputFile);

        Console.WriteLine($"Downloaded public file {objectName} from bucket {bucketName} to {localPath}.");
        return localPath;
    }
}

Go

Para mais informações, consulte a documentação de referência da API Go do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"
	"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: %w", 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: %w", object, err)
	}
	defer rc.Close()

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

Java

Para mais informações, consulte a documentação de referência da API Java do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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();

    storage.downloadTo(BlobId.of(bucketName, publicObjectName), destFilePath);

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

Node.js

Para mais informações, consulte a documentação de referência da API Node.js do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

/**
 * 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

Para mais informações, consulte a documentação de referência da API Python do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para mais informações, consulte a documentação de referência da API Ruby do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

O que se segue?

• Explore alguns dos conjuntos de dados públicos fornecidos pelo Cloud Storage.

• Saiba como partilhar publicamente um objeto.
• Saiba mais sobre as opções para controlar o acesso aos seus dados.
• Controlar o acesso aos seus dados através de autorizações do IAM.
• Transfira objetos de um contentor.