Cette page a été traduite par l'API Cloud Translation.

Accéder aux données publiques

Certaines données stockées dans Cloud Storage sont configurées afin qu'elles soient lisibles par tout le monde et à tout moment. Vous pouvez accéder à ces données publiques de plusieurs façons selon la manière dont vous souhaitez les utiliser.

Lien d'API

Obtenez le nom de l'objet public et le bucket qui le stocke.
Utilisez l'URI suivant pour accéder à un objet du bucket :

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

Par exemple, le bucket public Google gcp-public-data-landsat contient l'ensemble de données public Landsat. Vous pouvez créer le lien suivant vers l'objet partagé publiquement LC08/01/001/003/LC08_L1GT_001003_20140812_20170420_01_T2/LC08_L1GT_001003_20140812_20170420_01_T2_B3.TIF :

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

Obtenez le nom de l'objet public et le bucket qui le stocke.
À l'aide d'un navigateur Web, accédez à l'objet avec l'URI ci-dessous (vous êtes invité à vous connecter si vous n'êtes pas déjà connecté) :

https://console.cloud.google.com/storage/browser/_details/BUCKET_NAME/OBJECT_NAME
Si le public est autorisé à répertorier le contenu du bucket, vous pouvez répertorier tous les objets qu'il contient avec l'URI suivant :

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

Par exemple, le bucket public Google gcp-public-data-landsat contient l'ensemble de données public Landsat. Vous pouvez y accéder avec l'URI suivant :

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

Ligne de commande

Si vous ne disposez pas de gcloud CLI, suivez ces instructions pour l'installer.
- Lors de l'installation de gcloud CLI, si vous ne souhaitez pas vous authentifier, ignorez l'étape d'exécution de la commande gcloud init et exécutez plutôt la commande suivante :
```
gcloud config set auth/disable_credentials True
```
Obtenez le nom de l'objet public et le bucket qui le stocke.
Si l'autorisation de répertorier le contenu du bucket est accordé au public, vous pouvez répertorier tout ou partie des objets qu'il contient à l'aide de la commande ls.

Par exemple, le bucket public Google gcp-public-data-landsat contient l'ensemble de données public Landsat. Vous pouvez lister les objets comportant le préfixe LC08/01/001/003/LC à l'aide de la commande suivante :
```
gcloud storage ls --recursive gs://gcp-public-data-landsat/LC08/01/001/003/LC*
```
Remarque :Les shells (tels que bash et zsh) peuvent tenter de développer les caractères génériques avant de transmettre les arguments à la gcloud CLI. Pour éviter ces problèmes, placez l'expression entre des guillemets simples (sous Linux) ou guillemets doubles (sous Windows). Pour en savoir plus, consultez la section Comportement potentiellement surprenant lors de l'utilisation de caractères génériques.
Téléchargez des objets publics spécifiques figurant dans le bucket à l'aide de la commande cp.

Par exemple, la commande suivante permet de télécharger un fichier du bucket gcp-public-data-landsat dans votre répertoire 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 .
```

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.


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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage 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: %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 := ioutil.ReadAll(rc)
	if err != nil {
		return nil, fmt.Errorf("ioutil.ReadAll: %w", err)
	}
	fmt.Fprintf(w, "Blob %v downloaded.\n", object)
	return data, nil
}

Java

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage 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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage 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

Étape suivante

Découvrez quelques-uns des ensembles de données publics fournis par Cloud Storage.

Découvrez comment partager un objet publiquement.
Découvrez les options permettant de contrôler l'accès à vos données.
Contrôlez l'accès à vos données en utilisant des autorisations IAM.
Téléchargez des objets depuis un bucket.