Caricamenti in streaming

Cloud Storage supporta i flussi di dati in un bucket senza che venga richiesto salvare prima i dati in un file. Questo è utile quando vuoi caricare dati, non conoscono la dimensione finale all'inizio del caricamento, ad esempio durante la generazione i dati di caricamento da un processo o quando si comprime un oggetto in tempo reale.

Utilizzo della convalida del checksum durante il flusso di dati

Poiché un checksum può essere fornito solo nella richiesta iniziale di un caricamento, spesso non è possibile utilizzare la convalida del checksum di Cloud Storage durante lo streaming. È consigliabile utilizzare sempre la convalida del checksum puoi farlo manualmente al termine di un caricamento in streaming; tuttavia, convalidare al termine del trasferimento significa che i dati danneggiati sono accessibili durante il tempo necessario per confermare il danno e rimuoverlo.

Se è necessaria la convalida del checksum prima del completamento del caricamento e dei dati diventano accessibili, allora non dovresti usare un caricamento in streaming. Dovresti usare un'opzione di caricamento diversa che esegua la convalida del checksum prima per finalizzare l'oggetto.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per lo streaming dei caricamenti, chiedi all'amministratore di concederti uno dei seguenti ruoli:

• Per i caricamenti che includono un blocco per la conservazione degli oggetti, chiedi al tuo che ti conceda il ruolo di Amministratore oggetti Storage (roles/storage.objectAdmin) Ruolo IAM per il bucket.

• In tutti gli altri casi, chiedi all'amministratore di concederti l'oggetto Storage Ruolo IAM dell'utente (roles/storage.objectUser) per il bucket.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per trasmettere i caricamenti in streaming di archiviazione ideale in Cloud Storage. Per vedere le autorizzazioni esatte obbligatorie, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

• storage.objects.create
• storage.objects.delete
• Questa autorizzazione è richiesta solo per i caricamenti che sovrascrivono un file .
• storage.objects.get
• storage.objects.list
• Questa autorizzazione è richiesta solo per utilizzare Google Cloud CLI per seguire le istruzioni riportate in questa pagina.
• storage.objects.setRetention
  • Questa autorizzazione è richiesta solo per i caricamenti che includono un oggetto Blocco conservazione.

Puoi ottenere queste autorizzazioni anche con altri ruoli predefiniti oppure ruoli personalizzati.

Per informazioni sulla concessione dei ruoli nei bucket, consulta Utilizzare IAM con i bucket.

Riprodurre in streaming un caricamento

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

Console

La console Google Cloud non supporta i caricamenti di flussi di dati. Utilizza la con gcloud CLI.

Riga di comando

1. Effettua la pipeline dei 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 raccogli i dati. Ad esempio: collect_measurements.
   • BUCKET_NAME è il nome del bucket che contiene l'oggetto. Ad esempio, my_app_bucket.
   • OBJECT_NAME è il nome dell'oggetto che viene creato a partire dai dati. Ad esempio, data_measurements.

Librerie client

C++

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

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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::move(metadata).status();
  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

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

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 API Cloud Storage Go documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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: %w", 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: %w", 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: %w", err)
	}
	fmt.Fprintf(w, "%v uploaded to %v.\n", object, bucket)

	return nil
}

Java

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

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 API Cloud Storage Node.js documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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 API Cloud Storage PHP documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 API Cloud Storage Python documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 API Cloud Storage Ruby documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

# 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 tenendo conto delle seguenti considerazioni:

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

• Poiché non conosci le dimensioni totali del file prima di passare al usa un valore * per le dimensioni totali del file nell'intestazione Content-Range di blocchi intermedi.

  Ad esempio, se il primo blocco che carichi ha una dimensione di 512 KiB, L'intestazione Content-Range per il blocco è bytes 0-524287/*. Se le tue rimangono 64.000 byte dopo il primo blocco, quindi invia un blocco finale che contiene i byte rimanenti e ha Intestazione Content-Range con il valore bytes 524288-588287/588288.

API XML

Per eseguire il caricamento di un flusso di dati, utilizza uno dei seguenti metodi:

• Un caricamento multiparte dell'API XML

• Un caricamento ripristinabile con le seguenti modifiche:

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

  • Poiché non conosci le dimensioni totali del file finché non arrivi alle blocco finale, utilizza * per le dimensioni totali del file Intestazione Content-Range di 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, invia quindi un blocco finale contenente i byte rimanenti un'intestazione Content-Range con il valore bytes 524288-588287/588288.

Passaggi successivi

• Riprodurre in streaming un download.
• Scopri di più sulla transcodifica decompressiva.
• Scopri di più su caricamenti e download.