Caricamenti multiparte API XML

Questa pagina illustra i caricamenti multiparte delle API XML in Cloud Storage. Questo caricamento carica i file in parti e li assembla in un singolo oggetto utilizzando una richiesta finale. I caricamenti multiparte dell'API XML sono compatibili con Amazon S3 caricamenti multiparte.

Panoramica

Il caricamento multiparte dell'API XML consente di caricare i dati in più parti. e poi assemblarli per creare un oggetto finale. Questo comportamento offre diversi vantaggi, in particolare per i file di grandi dimensioni:

  • Puoi caricare le parti contemporaneamente, riducendo il tempo necessario per caricare dati nella loro interezza.

  • Se una delle operazioni di caricamento non va a buon fine, devi caricare di nuovo solo una parte dell'oggetto complessivo, invece di riavviarlo dall'inizio.

  • Poiché le dimensioni totali del file non vengono specificate in anticipo, puoi utilizzare l'API XML per i caricamenti in streaming o per la compressione dei dati in tempo reale durante il caricamento.

Un caricamento multiparte in un'API XML prevede tre passaggi obbligatori:

  1. Avvia il caricamento utilizzando una richiesta POST, che include la specifica tutti i metadati che l'oggetto completato dovrebbe avere. La risposta restituisce un UploadId che utilizzi in tutte le richieste successive associate a per completare il caricamento.

  2. Carica i dati utilizzando una o più richieste PUT.

  3. Completa il caricamento utilizzando una richiesta POST. Questa richiesta sovrascrive per qualsiasi oggetto esistente nel bucket con lo stesso nome.

Non esiste un limite alla durata di un caricamento multiparte e delle relative parti caricate non vengono completati o restano inattivi in un bucket.

Considerazioni

All'utilizzo dei caricamenti multiparte dell'API XML si applicano le seguenti limitazioni:

  • Esistono dei limiti relativi alle dimensioni minime di un componente, alla dimensione massima di e il numero di parti utilizzate per assemblare il caricamento completato.
  • Le condizioni preliminari non sono supportate nelle richieste.
  • Gli hash MD5 non esistono per gli oggetti caricati utilizzando questo metodo.
  • Questo metodo di caricamento non è supportato nella console Google Cloud o nella Google Cloud CLI.

Tieni presente quanto segue quando lavori con i caricamenti multiparte dell'API XML:

In che modo le librerie client utilizzano i caricamenti multiparte dell'API XML

Questa sezione fornisce informazioni sull'esecuzione di caricamenti multiparte nelle API XML con le librerie client che lo supportano.

Librerie client

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.

La libreria client Java non supporta i caricamenti multiparte API XML. Utilizza invece caricamenti compositi paralleli.

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.

Puoi eseguire caricamenti multiparte dell'API XML utilizzando uploadFileInChunks . Ad esempio:

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

// The path of file to upload
// const fileName = 'path/to/your/file';

// The size of each chunk to be uploaded
// const chunkSize = 32 * 1024 * 1024;

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

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

// Creates a transfer manager client
const transferManager = new TransferManager(storage.bucket(bucketName));

async function uploadFileInChunksWithTransferManager() {
  // Uploads the files
  await transferManager.uploadFileInChunks(filePath, {
    chunkSizeBytes: chunkSize,
  });

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

uploadFileInChunksWithTransferManager().catch(console.error);

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.

Puoi eseguire caricamenti multiparte dell'API XML utilizzando upload_chunks_concurrently . Ad esempio:

def upload_chunks_concurrently(
    bucket_name,
    source_filename,
    destination_blob_name,
    chunk_size=32 * 1024 * 1024,
    workers=8,
):
    """Upload a single file, in chunks, concurrently in a process pool."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The path to your file to upload
    # source_filename = "local/path/to/file"

    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

    # The size of each chunk. The performance impact of this value depends on
    # the use case. The remote service has a minimum of 5 MiB and a maximum of
    # 5 GiB.
    # chunk_size = 32 * 1024 * 1024 (32 MiB)

    # The maximum number of processes to use for the operation. The performance
    # impact of this value depends on the use case. Each additional process
    # occupies some CPU and memory resources until finished. Threads can be used
    # instead of processes by passing `worker_type=transfer_manager.THREAD`.
    # workers=8

    from google.cloud.storage import Client, transfer_manager

    storage_client = Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    transfer_manager.upload_chunks_concurrently(
        source_filename, blob, chunk_size=chunk_size, max_workers=workers
    )

    print(f"File {source_filename} uploaded to {destination_blob_name}.")

Passaggi successivi