Téléchargements en flux continu

Cloud Storage permet de diffuser des données en streaming d'un bucket vers un processus sans avoir à les enregistrer au préalable dans un fichier.

Utiliser la validation de somme de contrôle lors de l'insertion en flux continu

Vous ne devez pas utiliser de téléchargement en flux continu si vous devez valider les sommes de contrôle avant que les données ne soient accessibles. En effet, les téléchargements en flux continu utilisent l'en-tête Range et Cloud Storage ne renvoie pas les sommes de contrôle qui ne s'appliquent qu'à la partie demandée des données d'objet dans la réponse.

Il est recommandé de toujours effectuer la validation de la somme de contrôle, et vous pouvez le faire manuellement une fois le téléchargement en flux continu terminé. Toutefois, la validation une fois le téléchargement terminé signifie que toutes les données corrompues sont accessibles pendant le délai nécessaire à la confirmation de la corruption et à leur suppression.

Rôles requis

Pour obtenir les autorisations requises pour les téléchargements en flux continu, demandez à votre administrateur de vous attribuer le rôle de lecteur des objets de l'espace de stockage (roles/storage.objectViewer) sur le bucket.

Ce rôle contient l'autorisation requise pour les téléchargements en flux continu. Pour afficher l'autorisation exacte requise, développez la section Autorisations requises:

Autorisations requises

storage.objects.get

Vous pouvez également obtenir cette autorisation avec d'autres rôles prédéfinis ou rôles personnalisés.

Pour savoir comment attribuer des rôles aux buckets, consultez la section Utiliser IAM avec des buckets.

Téléchargement en flux continu

Les exemples suivants montrent comment effectuer le téléchargement d'un objet Cloud Storage dans un processus :

Console

La console Google Cloud n'est pas compatible avec les téléchargements en streaming. Utilisez plutôt Google Cloud CLI.

Ligne de commande

Exécutez la commande gcloud storage cp en utilisant un tiret pour l'URL de destination, puis dirigez les données vers le processus :
```
gcloud storage cp gs://BUCKET_NAME/OBJECT_NAME - | PROCESS_NAME
```
Où :
- BUCKET_NAME est le nom du bucket contenant l'objet. Par exemple, my_app_bucket.
- OBJECT_NAME est le nom de l'objet que vous diffusez vers le processus. Exemple : data_measurements.
- PROCESS_NAME est le nom du processus dans lequel vous chargez les données. Exemple :analyze_data

Vous pouvez également diffuser des données à partir d'un objet Cloud Storage vers une commande Linux standard de type sort :

gcloud storage cp gs://my_app_bucket/data_measurements - | sort

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 Configurer l'authentification pour un environnement de développement local.

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  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 DownloadFileSample
{
    public void DownloadFile(
        string bucketName = "your-unique-bucket-name",
        string objectName = "my-file-name",
        string localPath = "my-local-path/my-file-name")
    {
        var storage = StorageClient.Create();
        using var outputFile = File.OpenWrite(localPath);
        storage.DownloadObject(bucketName, objectName, outputFile);
        Console.WriteLine($"Downloaded {objectName} to {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"
)

// downloadFileIntoMemory downloads an object.
func downloadFileIntoMemory(w io.Writer, bucket, object string) ([]byte, error) {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	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.ReadChannel;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import com.google.common.io.ByteStreams;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class StreamObjectDownload {

  public static void streamObjectDownload(
      String projectId, String bucketName, String objectName, String targetFile)
      throws IOException {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The path to the file to download the object to
    // String targetFile = "path/to/your/file";
    Path targetFilePath = Paths.get(targetFile);

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    try (ReadChannel reader = storage.reader(BlobId.of(bucketName, objectName));
        FileChannel targetFileChannel =
            FileChannel.open(targetFilePath, StandardOpenOption.WRITE)) {

      ByteStreams.copy(reader, targetFileChannel);

      System.out.println(
          "Downloaded object "
              + objectName
              + " from bucket "
              + bucketName
              + " to "
              + targetFile
              + " using a ReadChannel.");
    }
  }
}

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 fileName = 'your-file-name';

// The filename and file path where you want to download the file
// 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 streamFileDownload() {
  // The example below demonstrates how we can reference a remote file, then
  // pipe its contents to a local file.
  // Once the stream is created, the data can be piped anywhere (process, sdout, etc)
  await storage
    .bucket(bucketName)
    .file(fileName)
    .createReadStream() //stream is created
    .pipe(fs.createWriteStream(destFileName))
    .on('finish', () => {
      // The file download is complete
    });

  console.log(
    `gs://${bucketName}/${fileName} downloaded to ${destFileName}.`
  );
}

streamFileDownload().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Download an object from Cloud Storage and save it as a local file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $destination The local destination to save the object.
 *        (e.g. '/path/to/your/file')
 */
function download_object(string $bucketName, string $objectName, string $destination): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->downloadToFile($destination);
    printf(
        'Downloaded gs://%s/%s to %s' . PHP_EOL,
        $bucketName,
        $objectName,
        basename($destination)
    );
}

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_blob_to_stream(bucket_name, source_blob_name, file_obj):
    """Downloads a blob to a stream or other file-like object."""

    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The ID of your GCS object (blob)
    # source_blob_name = "storage-object-name"

    # The stream or file (file-like object) to which the blob will be written
    # import io
    # file_obj = io.BytesIO()

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)

    # Construct a client-side representation of a blob.
    # Note `Bucket.blob` differs from `Bucket.get_blob` in that it doesn't
    # retrieve metadata from Google Cloud Storage. As we don't use metadata in
    # this example, using `Bucket.blob` is preferred here.
    blob = bucket.blob(source_blob_name)
    blob.download_to_file(file_obj)

    print(f"Downloaded blob {source_blob_name} to file-like object.")

    return file_obj
    # Before reading from file_obj, remember to rewind with file_obj.seek(0).

Ruby

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

# Downloads a blob to a stream or other file-like object.

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"

# Name of a file in the Storage bucket
# file_name   = "some_file.txt"

# The stream or file (file-like object) to which the contents will be written
# local_file_obj = StringIO.new

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.download local_file_obj, verify: :none

# rewind the object before starting to read the downloaded contents
local_file_obj.rewind
puts "The full downloaded file contents are: #{local_file_obj.read.inspect}"

API REST

API JSON

Pour effectuer un téléchargement en flux continu, suivez les instructions pour télécharger un objet en tenant compte des points suivants :

Avant de lancer le téléchargement, récupérez les métadonnées de l'objet et enregistrez le numéro de génération de l'objet. Incluez ce numéro de génération dans chacune de vos requêtes pour vous assurer de ne pas télécharger les données de deux générations différentes si l'original est écrasé.
Utilisez l'en-tête Range de votre requête pour récupérer un fragment de l'objet global, que vous pouvez envoyer au processus local souhaité.
Continuez d'envoyer des requêtes pour les fragments successifs de l'objet, jusqu'à ce que l'objet entier soit récupéré.

API XML

Pour effectuer un téléchargement en flux continu, suivez les instructions pour télécharger un objet en tenant compte des points suivants :

Avant de lancer le téléchargement, récupérez les métadonnées de l'objet et enregistrez le numéro de génération de l'objet. Incluez ce numéro de génération dans chacune de vos requêtes pour vous assurer de ne pas télécharger les données de deux générations différentes si l'original est écrasé.
Utilisez l'en-tête Range de votre requête pour récupérer un fragment de l'objet global, que vous pouvez envoyer au processus local souhaité.
Continuez d'envoyer des requêtes pour les fragments successifs de l'objet, jusqu'à ce que l'objet entier soit récupéré.

Étape suivante

Diffuser une importation
En savoir plus sur le Transcodage par décompression
En savoir plus sur les Importations et téléchargements