Trasferimenti di flussi di dati

Cloud Storage supporta i trasferimenti di flussi di dati, i quali consentono di trasmettere i flussi di dati da e verso l'account Cloud Storage senza richiedere che i dati vengano salvati in un file. Lo streaming è utile quando:

• Vuoi caricare dati ma non conosci le dimensioni finali all'inizio del caricamento, ad esempio quando vengono generati i dati da un processo o quando comprimi all'istante un oggetto.

• Vuoi scaricare i dati da Cloud Storage in un processo.

Utilizzo della convalida del checksum durante il flusso di dati

Poiché è possibile fornire un checksum solo nella richiesta iniziale di un caricamento, spesso non è possibile utilizzare la convalida del checksum di Cloud Storage durante il flusso di dati. Ti consigliamo di utilizzare sempre la convalida del checksum e di farlo manualmente al termine del caricamento di un flusso; tuttavia, la convalida al termine del trasferimento significa che tutti i dati danneggiati saranno accessibili durante il tempo necessario per confermare il danneggiamento e rimuoverlo.

Se hai bisogno della convalida del checksum prima del completamento del caricamento e dell'accessibilità dei dati, non devi utilizzare un caricamento streaming. Devi utilizzare un'opzione di caricamento diversa, che esegue la convalida del checksum prima di finalizzare l'oggetto.

Analogamente, non devi utilizzare un download in streaming se richiedi la convalida del checksum prima del completamento del download e quando i dati diventano accessibili. Questo perché i download in streaming utilizzano l'intestazione Range e Cloud Storage non esegue la convalida del checksum per queste richieste.

Prerequisiti

I prerequisiti possono variare in base allo strumento utilizzato:

Console

Per completare questa guida utilizzando la Google Cloud Console, devi disporre delle autorizzazioni IAM appropriate. Se il bucket a cui vuoi accedere per il flusso di dati è presente in un progetto che non hai creato, potresti dover richiedere al proprietario del progetto di assegnarti un ruolo contenente le autorizzazioni necessarie.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta le autorizzazioni IAM per la console Google Cloud.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni limitate e specifiche.

Riga di comando

Per completare questa guida utilizzando un'utilità a riga di comando, devi disporre delle autorizzazioni IAM appropriate. Se il bucket a cui vuoi accedere per il flusso di dati è presente in un progetto che non hai creato, potresti aver bisogno del proprietario del progetto per concederti un ruolo contenente le autorizzazioni necessarie.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta le autorizzazioni IAM per i comandi gsutil.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni limitate e specifiche.

Esempi di codice

Per completare questa guida utilizzando le librerie client Cloud Storage, devi disporre delle autorizzazioni IAM appropriate. Se il bucket a cui vuoi accedere per il flusso di dati esiste in un progetto che non hai creato, potrebbe essere necessario che il proprietario del progetto ti assegni un ruolo che contiene le autorizzazioni necessarie. Se non diversamente indicato, le richieste della libreria client vengono effettuate tramite l'API JSON.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta le autorizzazioni IAM per i metodi JSON.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni limitate e specifiche.

API REST

API JSON

Per completare questa guida utilizzando l'API JSON, devi disporre delle autorizzazioni IAM appropriate. Se il bucket a cui vuoi accedere per il flusso di dati è in un progetto che non hai creato, potresti aver bisogno del proprietario del progetto per concederti un ruolo contenente le autorizzazioni necessarie.

Per un elenco delle autorizzazioni necessarie per azioni specifiche, consulta le autorizzazioni IAM per i metodi JSON.

Per un elenco dei ruoli pertinenti, consulta Ruoli di Cloud Storage. In alternativa, puoi creare un ruolo personalizzato con autorizzazioni limitate e specifiche.

Riprodurre in streaming un caricamento

I seguenti esempi mostrano come eseguire un flusso di caricamento da un processo a un oggetto Cloud Storage:

Console

Google Cloud Console non supporta i caricamenti in streaming. Utilizza invece l'interfaccia a riga di comando gcloud.

Riga di comando

gcloud

1. Invia i dati al comando gcloud storage cp e utilizza un trattino per l'URL di origine:

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

   Dove:

   • PROCESS_NAME è il nome del processo da cui stai raccogliendo i dati. Ad esempio, collect_measurements.
   • BUCKET_NAME è il nome del bucket contenente l'oggetto. Ad esempio, my_app_bucket.
   • OBJECT_NAME è il nome dell'oggetto creato dai dati. Ad esempio, data_measurements.

gsutil

Nota: i caricamenti in streaming non possono utilizzare il flag globale gsutil -m.

1. Invia i dati al comando gsutil cp e utilizza un trattino per l'URL di origine:

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

   Dove:

   • PROCESS_NAME è il nome del processo da cui stai raccogliendo i dati. Ad esempio, collect_measurements.
   • BUCKET_NAME è il nome del bucket contenente l'oggetto. Ad esempio, my_app_bucket.
   • OBJECT_NAME è il nome dell'oggetto creato dai dati. Ad esempio, data_measurements.

Esempi di codice

C++

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Visualizza su GitHub Feedback

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#

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Visualizza su GitHub Feedback

# 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

Per eseguire un caricamento in streaming, segui le istruzioni per eseguire un caricamento ripristinabile con le seguenti considerazioni:

• Quando carichi i dati del file stesso, utilizza un caricamento di più blocchi.

• Poiché non conosci le dimensioni totali del file fino a raggiungere il blocco finale, utilizza * per le dimensioni totali del file nell'intestazione Content-Range dei blocchi intermedi.

  Ad esempio, se il primo blocco caricato ha una dimensione di 512 KiB, l'intestazione Content-Range del blocco è bytes 0-524287/*. Se il caricamento ha 64.000 byte rimanenti dopo il primo blocco, devi inviare un blocco finale contenente i byte rimanenti e dotato di un'intestazione Content-Range con valore bytes 524288-588287/588288.

API XML

Per eseguire un caricamento in streaming, utilizza uno dei seguenti metodi:

• Un caricamento di più parti dell'API XML

• Un caricamento ripristinabile, con le seguenti modifiche:

  • Quando carichi i dati del file stesso, utilizza un caricamento di più blocchi.

  • Poiché non conosci le dimensioni totali del file fino ad arrivare al blocco finale, utilizza * per le dimensioni totali del file nell'intestazione Content-Range dei blocchi intermedi.

    Ad esempio, se il primo blocco caricato ha una dimensione di 512 KiB, l'intestazione Content-Range del blocco è bytes 0-524287/*. Se il caricamento ha 64.000 byte rimanenti dopo il primo blocco, devi inviare un blocco finale contenente i byte rimanenti e contenente un'intestazione Content-Range con il valore bytes 524288-588287/588288.

Riprodurre in streaming un download

I seguenti esempi mostrano come eseguire un download da un oggetto Cloud Storage a un processo:

Console

Google Cloud Console non supporta i download in streaming. Utilizza invece l'interfaccia a riga di comando gcloud.

Riga di comando

gcloud

1. Esegui il comando gcloud storage cp utilizzando un trattino per l'URL di destinazione, quindi invia i dati al processo:

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

   Dove:

   • BUCKET_NAME è il nome del bucket contenente l'oggetto. Ad esempio, my_app_bucket.
   • OBJECT_NAME è il nome dell'oggetto di cui trasmetti in streaming al processo. Ad esempio, data_measurements.
   • PROCESS_NAME è il nome del processo in cui feed i dati. Ad esempio, analyze_data.

Puoi anche eseguire il flusso di dati da un oggetto Cloud Storage a un comando Linux standard, come sort:

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

gsutil

Nota: i download in streaming non possono utilizzare il flag -m globale gsutil.

1. Esegui il comando gsutil cp utilizzando un trattino per l'URL di destinazione, quindi invia i dati al processo:

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

   Dove:

   • BUCKET_NAME è il nome del bucket contenente l'oggetto. Ad esempio, my_app_bucket.
   • OBJECT_NAME è il nome dell'oggetto di cui trasmetti in streaming al processo. Ad esempio, data_measurements.
   • PROCESS_NAME è il nome del processo in cui feed i dati. Ad esempio, analyze_data.

Puoi anche eseguire il flusso di dati da un oggetto Cloud Storage a un comando Linux standard, come sort:

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

Esempi di codice

C++

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Visualizza su GitHub Feedback

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#

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Visualizza su GitHub Feedback

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

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Visualizza su GitHub Feedback

# 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

Per eseguire il download in streaming, segui le istruzioni per il download di un oggetto tenendo presente quanto segue:

• Prima di iniziare il download, recupera i metadati dell'oggetto e salva il numero di generazione dell'oggetto. Includi questo numero di generazione in ciascuna delle tue richieste per assicurarti di non scaricare dati da due diverse generazioni nel caso in cui l'originale venga sovrascritto.

• Utilizza l'intestazione Range nella richiesta per recuperare un elemento dell'oggetto generale, che puoi inviare al processo locale desiderato.

• Continua a effettuare richieste per elementi successivi dell'oggetto, fino al recupero dell'intero oggetto.

API XML

Per eseguire il download in streaming, segui le istruzioni per il download di un oggetto tenendo presente quanto segue:

• Prima di iniziare il download, recupera i metadati dell'oggetto e salva il numero di generazione dell'oggetto. Includi questo numero di generazione in ciascuna delle tue richieste per assicurarti di non scaricare dati da due diverse generazioni nel caso in cui l'originale venga sovrascritto.

• Utilizza l'intestazione Range nella richiesta per recuperare un elemento dell'oggetto generale, che puoi inviare al processo locale desiderato.

• Continua a effettuare richieste per elementi successivi dell'oggetto, fino al recupero dell'intero oggetto.

Passaggi successivi

• Scopri di più sulla transcodifica decompressiva.
• Scopri di più su caricamenti e download.