Transferts en flux continu

Cloud Storage accepte les transferts en flux continu, ce qui vous permet de diffuser des données vers et depuis votre compte Cloud Storage sans devoir d'abord enregistrer les données dans un fichier. La diffusion en flux continu est utile dans les cas suivants :

• Vous souhaitez importer des données mais vous ne connaissez pas la taille finale au début de l'importation, par exemple lorsque vous générez des données d'importation à partir d'un processus, ou lorsque vous compressez un objet à la volée.

• Vous souhaitez télécharger des données depuis Cloud Storage dans un processus.

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

Étant donné qu'une somme de contrôle ne peut être fournie que dans la requête initiale d'une importation, il est souvent impossible d'utiliser la validation de somme de contrôle de Cloud Storage lors de l'insertion en flux continu. Il est recommandé de toujours effectuer la validation de la somme de contrôle, et vous pouvez le faire manuellement une fois l'importation en flux continu terminée. Toutefois, la validation une fois le transfert terminé signifie que toutes les données corrompues sont accessibles pendant le délai nécessaire à la confirmation de la corruption et à leur suppression.

Si vous souhaitez exiger une validation de la somme de contrôle avant de conclure l'importation des données et leur mise à disposition, vous ne devez pas utiliser d'importation en flux continu. Vous devez choisir une autre option d'importation, qui effectue la validation de la somme de contrôle avant de finaliser l'objet.

De même, vous ne devez pas utiliser de téléchargement en flux continu si vous avez besoin de valider la somme de contrôle avant de terminer le téléchargement et d'ouvrir l'accès aux données. En effet, les téléchargements en flux continu utilisent l'en-tête Range et Cloud Storage n'effectue pas de validation de la somme de contrôle sur ces requêtes.

Prérequis

Les conditions préalables peuvent varier en fonction de l'outil utilisé :

Console

Pour suivre ce guide à l'aide de Google Cloud Console, vous devez disposer des autorisations IAM appropriées. Si le bucket auquel vous souhaitez accéder en streaming existe dans un projet que vous n'avez pas créé, vous devrez peut-être demander au propriétaire du projet qu'il vous attribue un rôle disposant des autorisations nécessaires.

Pour obtenir la liste des autorisations requises pour des actions spécifiques, consultez la page Autorisations IAM pour Google Cloud Console.

Pour obtenir la liste des rôles pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

Command line

Pour suivre ce guide à l'aide d'un utilitaire de ligne de commande, vous devez disposer des autorisations IAM appropriées. Si le bucket cible pour les transferts en flux continu existe dans un projet que vous n'avez pas créé, vous devrez peut-être demander au propriétaire du projet qu'il vous attribue un rôle disposant des autorisations nécessaires.

Pour obtenir la liste des autorisations requises pour des actions spécifiques, consultez la page Autorisations IAM pour les commandes gsutil.

Pour obtenir la liste des rôles pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

Exemples de code

Pour suivre ce guide à l'aide des bibliothèques clientes Cloud Storage, vous devez disposer des autorisations IAM appropriées. Si le bucket auquel vous souhaitez accéder en streaming existe dans un projet que vous n'avez pas créé, vous devrez peut-être demander au propriétaire du projet qu'il vous attribue un rôle disposant des autorisations nécessaires. Sauf indication contraire, les requêtes de bibliothèque cliente sont effectuées via l'API JSON.

Pour obtenir la liste des autorisations requises pour des actions spécifiques, consultez la page Autorisations IAM pour les méthodes JSON.

Pour obtenir la liste des rôles pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

API REST

API JSON

Pour suivre ce guide à l'aide de l'API JSON, vous devez disposer des autorisations IAM appropriées. Si le bucket auquel vous souhaitez accéder en streaming existe dans un projet que vous n'avez pas créé, vous devrez peut-être demander au propriétaire du projet qu'il vous attribue un rôle disposant des autorisations nécessaires.

Pour obtenir la liste des autorisations requises pour des actions spécifiques, consultez la page Autorisations IAM pour les méthodes JSON.

Pour obtenir la liste des rôles pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

Diffuser une importation

Les exemples suivants montrent comment effectuer une importation en flux continu d'un processus vers un objet Cloud Storage :

Console

La console Google Cloud n'accepte pas les importations en flux continu. Utilisez plutôt gcloud CLI.

Ligne de commande

gcloud

1. Dirigez les données vers la commande gcloud storage cp et utilisez un tiret pour l'URL source :

   PROCESS_NAME | gcloud storage cp - gs://BUCKET_NAME/OBJECT_NAME

   Où :

   • PROCESS_NAME est le nom du processus à partir duquel vous collectez des données. Exemple : collect_measurements.
   • BUCKET_NAME est le nom du bucket contenant l'objet. Par exemple, my_app_bucket.
   • OBJECT_NAME est le nom de l'objet créé à partir des données. Par exemple, data_measurements.

gsutil

Remarque : Les importations en streaming ne peuvent pas utiliser l'indicateur gsutil mondial de -m.

1. Dirigez les données vers la commande gsutil cp et utilisez un tiret pour l'URL source :

   PROCESS_NAME | gsutil cp - gs://BUCKET_NAME/OBJECT_NAME

   Où :

   • PROCESS_NAME est le nom du processus à partir duquel vous collectez des données. Exemple : collect_measurements.
   • BUCKET_NAME est le nom du bucket contenant l'objet. Par exemple, my_app_bucket.
   • OBJECT_NAME est le nom de l'objet créé à partir des données. Exemple :data_measurements

Exemples de code

C++

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

Afficher sur GitHub Commentaires

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name, int desired_line_count) {
  std::string const text = "Lorem ipsum dolor sit amet";
  gcs::ObjectWriteStream stream =
      client.WriteObject(bucket_name, object_name);

  for (int lineno = 0; lineno != desired_line_count; ++lineno) {
    // Add 1 to the counter, because it is conventional to number lines
    // starting at 1.
    stream << (lineno + 1) << ": " << text << "\n";
  }

  stream.Close();

  StatusOr<gcs::ObjectMetadata> metadata = std::move(stream).metadata();
  if (!metadata) throw std::runtime_error(metadata.status().message());
  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

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

Afficher sur GitHub Commentaires

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

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

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

Afficher sur GitHub Commentaires

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// streamFileUpload uploads an object via a stream.
func streamFileUpload(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	b := []byte("Hello world.")
	buf := bytes.NewBuffer(b)

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

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	wc.ChunkSize = 0 // note retries are not supported for chunk size 0.

	if _, err = io.Copy(wc, buf); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	// Data can continue to be added to the file until the writer is closed.
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "%v uploaded to %v.\n", object, bucket)

	return nil
}

Java

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

Afficher sur GitHub Commentaires

import com.google.cloud.WriteChannel;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

public class StreamObjectUpload {

  public static void streamObjectUpload(
      String projectId, String bucketName, String objectName, String contents) 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 string of contents you wish to upload
    // String contents = "Hello world!";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    byte[] content = contents.getBytes(StandardCharsets.UTF_8);
    try (WriteChannel writer = storage.writer(blobInfo)) {
      writer.write(ByteBuffer.wrap(content));
      System.out.println(
          "Wrote to " + objectName + " in bucket " + bucketName + " using a WriteChannel.");
    }
  }
}

Node.js

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

Afficher sur GitHub Commentaires

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

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

// The content to be uploaded in the GCS file
// const contents = 'your file content';

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

// Import Node.js stream
const stream = require('stream');

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

// Get a reference to the bucket
const myBucket = storage.bucket(bucketName);

// Create a reference to a file object
const file = myBucket.file(destFileName);

// Create a pass through stream from a string
const passthroughStream = new stream.PassThrough();
passthroughStream.write(contents);
passthroughStream.end();

async function streamFileUpload() {
  passthroughStream.pipe(file.createWriteStream()).on('finish', () => {
    // The file upload is complete
  });

  console.log(`${destFileName} uploaded to ${bucketName}`);
}

streamFileUpload().catch(console.error);

PHP

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

Afficher sur GitHub Commentaires

use Google\Cloud\Storage\StorageClient;
use Google\Cloud\Storage\WriteStream;

/**
 * Upload a chunked file stream.
 *
 * @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 $contents The contents to upload via stream chunks.
 *        (e.g. 'these are my contents')
 */
function upload_object_stream(string $bucketName, string $objectName, string $contents): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $writeStream = new WriteStream(null, [
        'chunkSize' => 1024 * 256, // 256KB
    ]);
    $uploader = $bucket->getStreamableUploader($writeStream, [
        'name' => $objectName,
    ]);
    $writeStream->setUploader($uploader);
    $stream = fopen('data://text/plain,' . $contents, 'r');
    while (($line = stream_get_line($stream, 1024 * 256)) !== false) {
        $writeStream->write($line);
    }
    $writeStream->close();

    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, $contents, $bucketName, $objectName);
}

Python

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

Afficher sur GitHub Commentaires

from google.cloud import storage

def upload_blob_from_stream(bucket_name, file_obj, destination_blob_name):
    """Uploads bytes from a stream or other file-like object to a blob."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The stream or file (file-like object) from which to read
    # import io
    # file_obj = io.BytesIO()
    # file_obj.write(b"This is test data.")

    # The desired name of the uploaded GCS object (blob)
    # destination_blob_name = "storage-object-name"

    # Construct a client-side representation of the blob.
    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    # Rewind the stream to the beginning. This step can be omitted if the input
    # stream will always be at a correct position.
    file_obj.seek(0)

    # Upload data from the stream to your bucket.
    blob.upload_from_file(file_obj)

    print(
        f"Stream data uploaded to {destination_blob_name} in bucket {bucket_name}."
    )

Ruby

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

Afficher sur GitHub Commentaires

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

# The stream or file (file-like object) from which to read
# local_file_obj = StringIO.new "This is test data."

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

require "google/cloud/storage"

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

local_file_obj.rewind
bucket.create_file local_file_obj, file_name

puts "Stream data uploaded to #{file_name} in bucket #{bucket_name}"

API REST

API JSON

Pour effectuer une importation en flux continu, suivez les instructions permettant d'effectuer une importation avec reprise, en prenant en compte les éléments suivants :

• Lorsque vous importez les données du fichier, utilisez une importation par fragments.

• Comme vous ne connaissez pas la taille totale du fichier tant que vous n'avez pas atteint le fragment final, utilisez la valeur * pour la taille totale du fichier dans l'en-tête Content-Range des fragments intermédiaires.

  Par exemple, si le premier fragment importé a une taille de 512 Ko, l'en-tête Content-Range du fragment est bytes 0-524287/*. S'il reste 64 000 octets après le premier fragment, vous envoyez un fragment final contenant les octets restants et ayant un en-tête Content-Range avec la valeur bytes 524288-588287/588288.

API XML

Pour effectuer une importation en flux continu, utilisez l'une des méthodes suivantes :

• Importation en plusieurs parties de l'API XML

• Importation avec reprise, avec les ajustements suivants :

  • Lorsque vous importez les données du fichier, utilisez une importation par fragments.

  • Comme vous ne connaissez pas la taille totale du fichier tant que vous n'avez pas atteint le fragment final, utilisez la valeur * pour la taille totale du fichier dans l'en-tête Content-Range des fragments intermédiaires.

    Par exemple, si le premier fragment importé a une taille de 512 Kio, l'en-tête Content-Range du fragment est bytes 0-524287/*. S'il reste 64 000 octets après le premier fragment, vous envoyez un fragment final contenant les octets restants et ayant un en-tête Content-Range avec la valeur bytes 524288-588287/588288.

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

Ligne de commande

gcloud

1. 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

gsutil

Remarque : Les téléchargements en flux continu ne peuvent pas utiliser l'option globale gsutil -m.

1. Exécutez la commande gsutil cp en utilisant un tiret pour l'URL de destination, puis dirigez les données vers le processus :

   gsutil 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 :

gsutil cp gs://my_app_bucket/data_measurements - | sort

Exemples de code

C++

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

Afficher sur GitHub Commentaires

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;
  }

  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#.

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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: %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

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

# 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

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