Descargas de transmisión

Cloud Storage admite la transmisión de datos de un bucket a un proceso sin necesidad de que los datos se guarden primero en un archivo.

Usa la validación de la suma de verificación durante la transmisión

No debes usar una descarga de transmisión si necesitas una validación de la suma de verificación antes de que los datos se vuelvan accesibles. Esto se debe a que las descargas de transmisión usan el encabezado Range y Cloud Storage no muestra sumas de verificación en la respuesta que se aplican solo a la parte solicitada de los datos del objeto.

Se recomienda que siempre uses la validación de la suma de verificación y puedes hacerlo después de que se complete una descarga de transmisión. Sin embargo, realizar la validación después de que se complete la descarga significa que se puede acceder a los datos dañados durante el tiempo que lleva confirmar el daño y quitarlo.

Roles obligatorios

Para obtener los permisos necesarios para descargas de transmisión, pídele a tu administrador que te otorgue el rol de visualizador de objetos de almacenamiento (roles/storage.objectViewer) en el bucket.

Este rol contiene el permiso necesario para transmitir descargas. Para ver el permiso exacto que es necesario, expande la sección Permisos requeridos:

Permisos necesarios

storage.objects.get

También puedes obtener este permiso con otros roles predefinidos o roles personalizados.

Para obtener instrucciones para otorgar roles a los buckets, consulta Usa IAM con buckets.

Realiza una descarga de transmisión

En los siguientes ejemplos, se muestra cómo realizar una descarga desde un objeto de Cloud Storage a un proceso:

Console

La consola de Google Cloud no admite la descarga de transmisiones. En su lugar, usa Google Cloud CLI.

Línea de comandos

Ejecuta el comando gcloud storage cp con un guion para la URL de destino y, a continuación, canaliza los datos al proceso:
```
gcloud storage cp gs://BUCKET_NAME/OBJECT_NAME - | PROCESS_NAME
```
Aquí:
- BUCKET_NAME es el nombre del bucket que contiene el objeto. Por ejemplo, my_app_bucket.
- OBJECT_NAME es el nombre del objeto que transmites al proceso. Por ejemplo, data_measurements
- PROCESS_NAME es el nombre del proceso al que envías datos. Por ejemplo, analyze_data

También puedes transmitir datos desde un objeto de Cloud Storage hasta un comando estándar de Linux como sort:

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

Bibliotecas cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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 de REST

API de JSON

A fin de realizar una descarga de transmisión, sigue las instrucciones para descargar un objeto con las siguientes consideraciones:

Antes de comenzar la descarga, recupera los metadatos del objeto y guarda el número de generación del objeto. Incluye este número de generación en cada una de tus solicitudes para asegurarte de no descargar datos de dos generaciones diferentes en caso de que se reemplacen los originales.
Usa el encabezado Range en tu solicitud para recuperar una parte del objeto general, que puedes enviar a un proceso local.
Continúa realizando solicitudes para partes sucesivas del objeto, hasta que se haya recuperado todo el objeto.

API de XML

A fin de realizar una descarga de transmisión, sigue las instrucciones para descargar un objeto con las siguientes consideraciones:

Antes de comenzar la descarga, recupera los metadatos del objeto y guarda el número de generación del objeto. Incluye este número de generación en cada una de tus solicitudes para asegurarte de no descargar datos de dos generaciones diferentes en caso de que se reemplacen los originales.
Usa el encabezado Range en tu solicitud para recuperar una parte del objeto general, que puedes enviar a un proceso local.
Continúa realizando solicitudes para partes sucesivas del objeto, hasta que se haya recuperado todo el objeto.

¿Qué sigue?

Realiza una carga de transmisión
Obtén más información sobre la transcodificación descompresiva.
Obtén más información sobre cargas y descargas.