Caricamenti multiparte dell'API XML

Questa pagina descrive i caricamenti in più parti dell'API XML in Cloud Storage. Questo metodo di caricamento carica i file in parti e poi li assembla in un unico oggetto utilizzando una richiesta finale. I caricamenti multiparte dell'API XML sono compatibili con i caricamenti multiparte di Amazon S3.

Nota: all'interno dell'API JSON, esiste un tipo di caricamento a richiesta singola non correlato, chiamato anche "caricamento in più parti".

Panoramica

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

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

• Se una delle operazioni di caricamento non va a buon fine, devi ricaricare solo una parte dell'oggetto complessivo, anziché ricominciare dall'inizio.

• Poiché le dimensioni totali del file non sono specificate in anticipo, puoi utilizzare i caricamenti in più parti dell'API XML per i caricamenti in streaming o per comprimere i dati al volo durante il caricamento.

Un caricamento multiparte dell'API XML prevede tre passaggi obbligatori:

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

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

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

Non esiste un limite al tempo per cui un caricamento multiparte e le relative parti caricate possono rimanere non completati o inattivi in un bucket.

• Le parti caricate correttamente vengono conteggiate ai fini dell'utilizzo mensile dello spazio di archiviazione.
• Puoi evitare l'accumulo di caricamenti in più parti abbandonati utilizzando la gestione del ciclo di vita degli oggetti per rimuovere automaticamente i caricamenti in più parti quando raggiungono un'età specificata.

Considerazioni

Si applicano le seguenti limitazioni all'utilizzo dei caricamenti in più parti dell'API XML:

• Esistono limiti per le dimensioni minime e massime di una parte e per il numero di parti utilizzate per assemblare il caricamento completato.
• Le precondizioni 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 nell&Google Cloud CLI.

Quando utilizzi i caricamenti multiparte dell'API XML, tieni presente quanto segue:

• I caricamenti multiparte dell'API XML hanno autorizzazioni IAM specifiche. Se utilizzi ruoli IAM personalizzati, devi assicurarti che questi ruoli dispongano delle autorizzazioni necessarie.

• Anche se puoi avviare un caricamento e caricare le parti, la richiesta di completamento del caricamento non va a buon fine se sovrascriverebbe un oggetto su cui è presente un blocco o un periodo di conservazione non soddisfatto.

• Puoi elencare i caricamenti in corso in un bucket, ma solo un caricamento completato viene visualizzato nel normale elenco di oggetti nel bucket.

• Una parte caricata può essere soggetta a tariffe per l'eliminazione anticipata se non viene mai utilizzata.

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

Questa sezione fornisce informazioni sull'esecuzione di caricamenti in più parti dell'API XML con librerie client che lo supportano.

Librerie client

Java

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

La libreria client Java non supporta i caricamenti in più parti dell'API XML. Utilizza invece i caricamenti compositi paralleli.

Node.js

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

Puoi eseguire caricamenti multiparte dell'API XML utilizzando il metodo 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 filePath = '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 saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

Puoi eseguire caricamenti multiparte dell'API XML utilizzando il metodo 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}.")


if __name__ == "__main__":
    argparse = argparse.ArgumentParser(
        description="Upload a file to GCS in chunks concurrently."
    )
    argparse.add_argument(
        "--bucket_name", help="The name of the GCS bucket to upload to."
    )
    argparse.add_argument(
        "--source_filename", help="The local path to the file to upload."
    )
    argparse.add_argument(
        "--destination_blob_name", help="The name of the object in GCS."
    )
    argparse.add_argument(
        "--chunk_size",
        type=int,
        default=32 * 1024 * 1024,
        help="The size of each chunk in bytes (default: 32 MiB). The remote\
              service has a minimum of 5 MiB and a maximum of 5 GiB",
    )
    argparse.add_argument(
        "--workers",
        type=int,
        default=8,
        help="The number of worker processes to use (default: 8).",
    )
    args = argparse.parse_args()
    upload_chunks_concurrently(
        args.bucket_name,
        args.source_filename,
        args.destination_blob_name,
        args.chunk_size,
        args.workers,
    )

Passaggi successivi

• Esplora altri metodi di caricamento per Cloud Storage.
• Scopri di più sul backoff esponenziale troncato e su quando riprovare a inviare le richieste.