Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Caricamento degli oggetti
Quando un file viene caricato in Amazon S3, viene archiviato come *oggetto* S3. Gli oggetti sono composti dai dati e dai metadata dei file che descrivono l'oggetto. Un bucket può avere un numero illimitato di oggetti. Per caricare file e cartelle in un bucket Amazon S3, è necessario disporre delle autorizzazioni in scrittura per il bucket. Per ulteriori informazioni sulle autorizzazioni di accesso, consultare [Identity and Access Management per Amazon S3](security-iam.md).
In un bucket S3 è possibile caricare qualsiasi tipo di file: immagini, backup, dati, film e così via. La dimensione massima di un file che è possibile caricare utilizzando la console di Amazon S3 è 160 GB. Per caricare un file di dimensioni superiori a 160 GB, usa AWS Command Line Interface (AWS CLI) o l' AWS SDKsAPI REST di Amazon S3.
Se si carica un oggetto con un nome della chiave già esistente in un bucket che supporta la funzione Controllo delle versioni, Amazon S3 crea un'altra versione dell'oggetto anziché sostituire l'oggetto esistente. Per ulteriori informazioni sull'abilitazione del controllo delle versioni, consulta [Abilitazione della funzione Controllo delle versioni sui bucket](manage-versioning-examples.md).
A seconda della dimensione dei dati da caricare, in Amazon S3 sono disponibili le seguenti opzioni:
+ **Carica un oggetto con un'unica operazione utilizzando l' AWS SDKsAPI REST oppure AWS CLI** — Con una sola `PUT` operazione, puoi caricare un singolo oggetto di dimensioni fino a 5 GB.
+ **Carica un singolo oggetto tramite la console di Amazon S3****: **con la console di Amazon S3, è possibile caricare un singolo oggetto fino a 160 GB di dimensioni.
+ **Carica un oggetto in parti utilizzando l' AWS SDKsAPI REST oppure AWS CLI****:** utilizzando l'operazione API di caricamento multiparte, puoi caricare un singolo oggetto di grandi dimensioni, di dimensioni fino a 50 TB.
L'operazione API per il caricamento in più parti è concepita per migliorare l'esperienza di caricamento per gli oggetti di dimensioni maggiori. È possibile caricare un oggetto in parti. Queste parti possono essere caricate in modo indipendente, in qualsiasi ordine e in parallelo. Puoi utilizzare un caricamento in più parti per oggetti di dimensioni comprese tra 5 MB e 50 TB. Per ulteriori informazioni, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
Per caricare file di dimensioni superiori a 5 TB, usa S3 Transfer Manager in Java v1/v2, Python o. AWS CLI SDKs Per prestazioni ottimali, utilizzate l'ultima versione di AWS Common Runtime (CRT) SDKs, che è stata ottimizzata per un migliore utilizzo delle risorse.
Quando si caricano oggetti di grandi dimensioni dal flusso di memoria, CRT memorizza nel buffer di ogni parte fino a 5 GB di memoria, limitando il throughput complessivo in base alla memoria allocata. È possibile regolare il limite di memoria CRT utilizzando opzioni di configurazione come per Java SDK. `maxNativeMemoryLimitInBytes` Per i caricamenti da disco, CRT passa automaticamente allo streaming diretto su disco anziché al buffering intermedio delle parti, migliorando l'utilizzo della memoria. Questo comportamento è abilitato automaticamente per oggetti di grandi dimensioni, ma può essere abilitato anche per file più piccoli tramite parametri di richiesta come per e `should_stream` per AWS CLI Java SDK. `CRT_MEMORY_BUFFER_DISABLED`
Al momento del caricamento, l'oggetto viene crittografato automaticamente per impostazione predefinita utilizzando la crittografia lato server con chiavi gestite da Amazon S3 (SSE-S3). Quando lo scarichi, l'oggetto viene decrittato. Per ulteriori informazioni, consultare [Impostazione del comportamento predefinito della crittografia lato server per i bucket Amazon S3](bucket-encryption.md) e [Protezione dei dati con la crittografia](UsingEncryption.md).
Quando carichi un oggetto, se desideri utilizzare un tipo diverso di crittografia predefinita, puoi anche specificare la crittografia lato server con chiavi AWS Key Management Service (AWS KMS) (SSE-KMS) nelle tue `PUT` richieste S3 o impostare la configurazione di crittografia predefinita nel bucket di destinazione per utilizzare SSE-KMS per crittografare i tuoi dati. Per ulteriori informazioni su SSE-KMS, consulta [Specificare la crittografia lato server con AWS KMS (SSE-KMS)](specifying-kms-encryption.md). Se desideri utilizzare una chiave KMS di proprietà di un account diverso, devi avere l'autorizzazione necessaria per l'uso della chiave. Per ulteriori informazioni sulle autorizzazioni tra account per le chiavi KMS, vedi [Creazione di chiavi KMS utilizzabili da altri account](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console) nella *Guida per gli sviluppatori di AWS Key Management Service *.
Se si verifica un errore di Accesso negato (403 Forbidden) in Amazon S3, consulta [Risoluzione dei problemi relativi agli errori di accesso negato (403 Forbidden) in Amazon S3](troubleshoot-403-errors.md) per saperne di più sulle cause comuni.
## Caricamento di un oggetto
### Utilizzo della console S3
Questa procedura spiega come caricare oggetti e cartelle in un bucket Amazon S3 utilizzando la console.
Quando carichi un oggetto, il nome della chiave oggetto è costituito dal nome del file e da qualsiasi prefisso facoltativo. Nella console di Amazon S3, puoi creare cartelle per organizzare i tuoi oggetti. In Amazon S3, le cartelle sono rappresentate come prefissi visualizzati nel nome della chiave oggetto. Se carichi un singolo oggetto in una cartella nella console di Amazon S3, il nome della cartella viene incluso nel nome della chiave oggetto.
Ad esempio, se carichi un oggetto denominato `sample1.jpg` in una cartella denominata `backup`, il nome della chiave è `backup/sample1.jpg`. Tuttavia, l'oggetto viene visualizzato nella console come `sample1.jpg` nella cartella `backup`. Per ulteriori informazioni sui nomi delle chiavi, consultare [Utilizzo dei metadati degli oggetti](UsingMetadata.md).
**Nota**
Se rinomini un oggetto o modifichi una delle proprietà nella console di Amazon S3, ad esempio **Classe di storage**, **Crittografia** o **Metadati**, viene creato un nuovo oggetto per sostituire quello precedente. Se è abilitata la funzione Controllo delle versioni S3, viene creata una nuova versione dell'oggetto e l'oggetto esistente diventa una versione precedente. Il ruolo che modifica la proprietà diventa anche il proprietario del nuovo oggetto o della versione dell'oggetto.
Quando si carica una cartella, Amazon S3 carica nel bucket tutti i file e le sottocartelle inclusi nella cartella specificata, quindi assegna un nome della chiave dell'oggetto, ossia una combinazione del nome del file caricato e del nome della cartella. Ad esempio, se si carica una cartella denominata `/images` contenente due file, `sample1.jpg` e `sample2.jpg`, Amazon S3 carica i file, quindi assegna i nomi delle chiavi corrispondenti, `images/sample1.jpg` e `images/sample2.jpg`. I nomi delle chiavi includono il nome della cartella come prefisso. La console di Amazon S3 visualizza solo la parte del nome della chiave che segue l'ultimo simbolo `/`. Ad esempio, in una cartella di `images`, gli oggetti `images/sample1.jpg` e `images/sample2.jpg` sono visualizzati come `sample1.jpg` e `sample2.jpg`.
**Per caricare cartelle e file in un bucket S3**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel pannello di navigazione a sinistra, scegli **Buckets** (Bucket).
1. Nell'elenco **Buckets (Bucket)** scegliere il nome del bucket in cui si desidera caricare le cartelle o i file.
1. Scegli **Carica**.
1. Nella finestra **Carica** completa una delle seguenti operazioni:
+ Trascina e rilascia file e cartelle nella finestra **Carica** .
+ Scegli **Aggiungi file** o **Aggiungi cartella**, seleziona i file o le cartelle da caricare e scegli **Apri**.
1. Per abilitare il controllo delle versioni, in **Destinazione**, seleziona **Abilita controllo delle versioni del bucket**.
1. Per caricare i file e le cartelle elencati senza configurare ulteriori opzioni di caricamento, nella parte inferiore della pagina scegli **Carica**.
Amazon S3 caricherà i tuoi oggetti e le tue cartelle. Al termine del caricamento viene visualizzato un messaggio di esito positivo nella pagina **Carica: stato**.
**Per configurare proprietà aggiuntive dell'oggetto**
1. Per modificare le autorizzazioni della lista di controllo degli accessi, scegli **Permissions (Autorizzazioni)**.
1. In **Access control list (ACL) Lista di controllo degli accessi (ACL)**, modifica le autorizzazioni.
Per informazioni sulle autorizzazioni di accesso agli oggetti, consulta [Utilizzo della console S3 per impostare le autorizzazioni ACL per un oggetto](managing-acls.md#set-object-permissions). Puoi concedere l'accesso in lettura ai tuoi oggetti al pubblico (chiunque) per tutti i file che stai caricando. Ti consigliamo di non modificare l'impostazione di default per l'accesso pubblico in lettura. La concessione dell'accesso pubblico in lettura si applica a un piccolo sottoinsieme di casi d'uso, ad esempio quando i bucket vengono usati per i siti Web. È sempre possibile apportare modifiche alle autorizzazioni dell'oggetto dopo averlo caricato.
1. Per configurare altre proprietà scegli **Properties (Proprietà)**.
1. Nella sezione **Classe di storage** seleziona la classe di storage per i file che si stanno caricando.
Per ulteriori informazioni sulle classi di storage, consulta [Comprensione e gestione delle classi di storage Amazon S3](storage-class-intro.md).
1. Per aggiornare le impostazioni di crittografia per gli oggetti, in **Impostazioni di crittografia lato server** completa le operazioni riportate di seguito.
1. Scegli **Specify an encryption key (Specifica una chiave di crittografia)**.
1. In **Impostazioni di crittografia**, scegli **Utilizza le impostazioni del bucket per la crittografia predefinita** o **Ignora le impostazioni del bucket per la crittografia predefinita**.
1. Se scegli **Ignora le impostazioni del bucket per la crittografia predefinita**, dovrai configurare le seguenti impostazioni di crittografia.
+ Per crittografare i file caricati utilizzando chiavi gestite da Amazon S3, seleziona **Chiave gestita da Amazon S3 (SSE-S3)**.
Per ulteriori informazioni, consulta [Uso della crittografia lato server con chiavi gestite da Amazon S3 (SSE-S3)](UsingServerSideEncryption.md).
+ Per crittografare i file caricati utilizzando le chiavi memorizzate in AWS Key Management Service (AWS KMS), scegli **AWS Key Management Service chiave (SSE-KMS**). Quindi scegli una delle seguenti opzioni per **Chiave AWS KMS **:
+ Per scegliere da un elenco di chiavi KMS disponibili, seleziona **Scegli tra le chiavi AWS KMS keys**, quindi scegli la **chiave KMS** dall'elenco delle chiavi disponibili.
In questo elenco vengono visualizzate sia la chiave Chiave gestita da AWS (`aws/s3`) che quella gestita dal cliente. Per ulteriori informazioni sulle chiavi gestite dal cliente, consulta [Chiavi gestite dal cliente e chiavi AWS](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt) nella *Guida per gli sviluppatori di AWS Key Management Service *.
+ Per inserire l'ARN della chiave KMS, scegli **Inserisci AWS KMS key ARN**, quindi inserisci l'ARN della chiave KMS nel campo visualizzato.
+ **Per creare una nuova chiave gestita dal cliente nella AWS KMS console, scegli Crea una chiave KMS.**
Per ulteriori informazioni sulla creazione di una AWS KMS key, consulta [Creating keys](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html) nella *AWS Key Management Service Developer Guide*.
**Importante**
Puoi utilizzare solo le chiavi KMS disponibili nello Regione AWS stesso bucket. La console Amazon S3 elenca solo le prime 100 chiavi KMS nella stessa Regione del bucket. Per utilizzare una chiave KMS non elencata, devi inserire l'ARN della chiave KMS. Se desideri utilizzare una chiave KMS di proprietà di un account diverso, è necessario innanzitutto disporre dell'autorizzazione necessaria per l'uso della chiave e quindi inserire l'ARN della chiave KMS.
Amazon S3 supporta solo chiavi KMS di crittografia simmetriche e non chiavi KMS asimmetriche. Per ulteriori informazioni, consulta [Identificazione delle chiavi KMS simmetriche e asimmetriche](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html) nella *Guida per gli sviluppatori di AWS Key Management Service *.
1. Per utilizzare checksum aggiuntivi, scegli **On (Attivato)**. Per **Checksum function (Funzione checksum)**, scegli la funzione che desideri utilizzare. Amazon S3 calcola e archivia il valore del checksum dopo aver ricevuto l'intero oggetto. Puoi utilizzare la casella **Precalculated value (Valore precalcolato)** per fornire un valore precalcolato. In tal caso, Amazon S3 confronta il valore specificato con il valore calcolato. Se i due valori non corrispondono, Amazon S3 genera un errore.
I checksum aggiuntivi ti consentono di specificare l'algoritmo di checksum che desideri utilizzare per verificare i dati. Per ulteriori informazioni sui checksum aggiuntivi, consulta [Verifica dell'integrità degli oggetti in Amazon S3](checking-object-integrity.md).
1. Per aggiungere tag a tutti gli oggetti che si stanno caricando, scegliere **Add tag (Aggiungi tag)**. Immetti un nome di tag nel campo **Chiave**. Immetti un valore per il tag.
Il tagging ti consente di catalogare lo storage. Ogni tag è una coppia chiave-valore. I valori delle chiavi e dei tag fanno distinzione tra maiuscole e minuscole. Puoi avere un massimo di 10 tag per oggetto. Una chiave di tag può essere composta da un massimo di 128 caratteri Unicode e i valori di tag possono essere composti da un massimo di 255 caratteri Unicode. Per ulteriori informazioni sui tag degli oggetti, consulta [Classificazione degli oggetti utilizzando i tag](object-tagging.md).
1. Per aggiungere metadati, seleziona **Aggiungi metadati**.
1. In **Tipo** seleziona **Definito dal sistema** o **Definito dall'utente**.
Per i metadati definiti dal sistema, puoi selezionare le intestazioni HTTP comuni, ad esempio **Content-Type** e **Content-Disposition**. Per un elenco di metadati definiti dal sistema e informazioni sulla possibilità di aggiungere il valore, consulta [Metadata di oggetti definiti dal sistema](UsingMetadata.md#SysMetadata). Eventuali metadata che iniziano con il prefisso `x-amz-meta-` sono considerati come metadata definiti dall'utente. I metadati definiti dall'utente vengono archiviati con l'oggetto e vengono restituiti quando si scarica l'oggetto. Sia le chiavi che i relativi valori devono essere conformi agli standard US-ASCII. I metadata definiti dall'utente possono avere una dimensione massima di 2 KB. Per ulteriori informazioni sui metadati definiti dal sistema e definiti dall'utente, consulta [Utilizzo dei metadati degli oggetti](UsingMetadata.md).
1. Per **Chiave**, seleziona una chiave.
1. Digitare un valore per la chiave.
1. Per caricare i tuoi oggetti, scegli **Carica**.
Amazon S3 caricherà l'oggetto. Al termine del caricamento, sarà visualizzato un messaggio di successo nella pagina **Carica: stato** .
1. Scegliere **Exit (Esci)**.
### Usando il AWS CLI
È possibile inviare una richiesta `PUT` per caricare un oggetto di un massimo di 5 GB in una singola operazione. Per ulteriori informazioni ed esempi, consulta l'esempio [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples) in *Riferimento ai comandi della AWS CLI *.
### Utilizzo della REST API
Per caricare un oggetto puoi inviare richieste REST. È possibile inviare una richiesta `PUT` per caricare i dati in una singola operazione. Per ulteriori informazioni, consulta [PUT Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html).
### Utilizzando il AWS SDKs
Per esempi su come caricare un oggetto con AWS SDKs, consulta [Code Examples](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_PutObject_section.html) nel *riferimento all'API di Amazon Simple Storage Service*.
Per informazioni generali sull'utilizzo di diversi AWS SDKs, consulta [Sviluppo con Amazon S3 utilizzando il](https://docs.aws.amazon.com/AmazonS3/latest/API/sdk-general-information-section.html) riferimento all'*API di riferimento AWS SDKs di Amazon Simple Storage Service*.
## Impedisci il caricamento di oggetti con nomi di chiavi identici
È possibile verificare l'esistenza di un oggetto nel bucket prima di crearlo, utilizzando una scrittura condizionale sulle operazioni di caricamento. In questo modo si può evitare la sovrascrittura dei dati esistenti. Le scritture condizionali convalidano l'assenza di oggetti esistenti con lo stesso nome chiave nel bucket durante il caricamento.
Si possono usare le scritture condizionali per richieste [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) o [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html).
Per ulteriori informazioni sulle richieste condizionali, consulta [Aggiunta di precondizioni alle operazioni S3 con richieste condizionali](conditional-requests.md).
# Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3
Il caricamento multiparte consente di caricare un singolo oggetto su Amazon S3 come un insieme di parti. Ciascuna parte è una parte contigua dei dati dell'oggetto. È possibile caricare queste parti di oggetto in modo indipendente e in qualsiasi ordine. Per i caricamenti, il AWS client aggiornato calcola automaticamente un checksum dell'oggetto e lo invia ad Amazon S3 insieme alla dimensione dell'oggetto come parte della richiesta. Se la trasmissione di una parte non riesce, è possibile ritrasmettere tale parte senza influire sulle altre. Dopo aver caricato tutte le parti dell'oggetto, Amazon S3 le assembla per creare l'oggetto. È consigliabile utilizzare il caricamento multiparte per gli oggetti di dimensioni pari o superiori a 100 MB, anziché caricarli in un'unica operazione.
Il caricamento in più parti comporta i vantaggi riportati di seguito.
+ **Throughput migliorato**: puoi caricare le parti in parallelo per migliorare il throughput.
+ **Ripristino rapido dai problemi di rete**: la dimensione più piccola delle parti riduce al minimo l'impatto del riavvio di un caricamento fallito a causa di un errore di rete.
+ **Messa in pausa e ripresa dei caricamenti dell'oggetto**: puoi caricare le parti dell'oggetto nel corso del tempo. Una volta avviato, un caricamento in più parti continua finché non viene completato o interrotto in modo esplicito.
+ **Inizia il caricamento prima di conoscere le dimensioni finali dell'oggetto** - È possibile caricare un oggetto mentre lo si crea.
È consigliabile utilizzare il caricamento in più parti come indicato di seguito:
+ Se carichi oggetti di grandi dimensioni su una rete stabile ad alta larghezza di banda, utilizza il caricamento multiparte per massimizzare l'uso della larghezza di banda disponibile caricando le parti dell'oggetto in parallelo per ottenere prestazioni multi-thread.
+ Se esegui il caricamento su una rete discontinua, utilizza il caricamento multiparte per aumentare la resilienza contro gli errori di rete evitando il riavvio del caricamento. Quando si utilizza il caricamento multiparte, è necessario riprovare a caricare solo le parti interrotte durante il caricamento. Non è necessario riavviare il caricamento dell'oggetto dall'inizio.
**Nota**
Per ulteriori informazioni sull'utilizzo della classe di archiviazione Amazon S3 Express One Zone con bucket di directory, consulta [S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone) e [Operazioni con i bucket di directory](directory-buckets-overview.md). Per ulteriori informazioni sull'utilizzo del caricamento in più parti con S3 Express One Zone e i bucket di directory, consulta [Utilizzo dei caricamenti multiparte con i bucket di directory](s3-express-using-multipart-upload.md).
## Processo di caricamento in più parti
Il caricamento multiparte è un processo in tre fasi: si avvia il caricamento, si caricano le parti dell'oggetto e, dopo aver caricato tutte le parti, si completa il caricamento multiparte. Una volta ricevuta la richiesta di caricamento multiparte completa, Amazon S3 costruisce l'oggetto a partire dalle parti caricate e si può accedere all'oggetto come a qualsiasi altro oggetto nel bucket.
È possibile elencare tutti i caricamenti in più parti in corso oppure ottenere un elenco delle parti caricate per un caricamento in più parti specifico. Ognuna di queste operazioni viene descritta in questa sezione.
**Avvio del caricamento in più parti**
Quando si invia una richiesta per avviare un caricamento multiparte, assicurarsi di specificare un tipo di checksum. Amazon S3 restituirà quindi una risposta con un ID di caricamento, che è un identificatore unico per il caricamento multiparte. Questo ID di caricamento è necessario quando si caricano e si elencano parti oppure si completa o interrompe un caricamento. Se si desidera fornire metadati che descrivono l'oggetto da caricare, è necessario fornirli nella richiesta di avvio del caricamento multiparte. Gli utenti anonimi non possono avviare caricamenti in più parti.
**Caricamento delle parti**
Quando si carica una parte, è necessario specificare un numero di parte oltre all'ID di caricamento. È possibile scegliere qualsiasi numero compreso tra 1 e 10.000. Il numero della parte identifica in modo univoco una parte e la relativa posizione nell'oggetto che si sta caricando. Il numero della parte scelto non deve essere in sequenza (ad esempio può essere 1, 5 e 14). Tieni presente che, se carichi una nuova parte usando lo stesso numero di parte di una caricata in precedenza, la parte caricata in precedenza viene sovrascritta.
Quando si carica una parte, Amazon S3 restituisce il tipo di algoritmo di checksum con il valore di checksum per ogni parte come intestazione della risposta. Per ogni caricamento di parti, è necessario registrare il numero e il valore della parte. ETag Occorre includere questi valori nella successiva richiesta di complemento del caricamento in più parti. Ogni parte avrà il suo ETag al momento del caricamento. Tuttavia, una volta completato il caricamento in più parti e consolidate tutte le parti, tutte le parti appartengono a un'unica parte ETag come checksum dei checksum.
**Importante**
Dopo aver avviato un caricamento multiparte e aver caricato una o più parti, è necessario completare o interrompere il caricamento multiparte per non incorrere nei costi di archiviazione delle parti caricate. Solo *dopo* aver completato o interrotto un caricamento multiparte, Amazon S3 libererà l'archiviazione di parti e smetterà di fatturare per l'archiviazione delle parti.
Dopo aver interrotto il caricamento multiparte, non è più possibile caricare alcuna parte usando l'ID di caricamento. Se il caricamento di una parte era in corso, può continuare ad avere successo o fallire anche dopo aver interrotto il caricamento. Per essere sicuri di liberare tutto lo spazio di archiviazione consumato da tutte le parti, è necessario interrompere un caricamento multiparte solo dopo che tutti i caricamenti di parti sono stati completati.
**Completamento del caricamento in più parti**
Una volta completato un caricamento in più parti, Amazon S3 crea un oggetto concatenando le parti in ordine crescente in base al numero della parte. Se nella richiesta di *avvio del caricamento in più parti* sono stati forniti i metadati dell'oggetto, Amazon S3 li associa all'oggetto. Una volta *completata* la richiesta, le parti non esisteranno più.
La richiesta di *caricamento multiparte completa* deve includere l'ID di caricamento e un elenco di numeri di parte e dei valori corrispondenti. ETag La risposta di Amazon S3 include un codice ETag che identifica in modo univoco i dati combinati dell'oggetto. Questo non ETag è necessariamente un MD5 hash dei dati dell'oggetto.
Quando fornisci un checksum completo dell'oggetto durante un caricamento in più parti, l' AWS SDK trasmette il checksum ad Amazon S3 e S3 convalida l'integrità dell'oggetto lato server, confrontandola con il valore ricevuto. Quindi, S3 memorizza l'oggetto se i valori corrispondono. Se i due valori non corrispondono, Amazon S3 rifiuta la richiesta con un errore `BadDigest`. Il checksum dell'oggetto viene memorizzato anche nei metadati dell'oggetto, che verranno utilizzati in seguito per convalidare l'integrità dei dati di un oggetto.
**Chiamate di caricamento in più parti di esempio**
Per questo esempio, si supponga di generare un caricamento multiparte per un file di 100 GB. In questo caso, sarebbero disponibili le seguenti chiamate API per l'intero processo. Il totale delle chiamate API è di 1.002.
+ Una chiamata `[CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)` per avviare il processo.
+ 1.000 chiamate individuali a `[UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)`, ciascuna delle quali carica una parte di 100 MB, per una dimensione totale di 100 GB.
+ Una chiamata a `[CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)` per completare il processo.
**Elenchi dei caricamenti in più parti**
È possibile elencare le parti di un caricamento in più parti specifico o tutti i caricamenti in più parti in corso. L'operazione Elenca parti restituisce le informazioni sulle parti caricate per uno specifico caricamento multiparte. Per ogni richiesta di elenco delle parti, Amazon S3 restituisce informazioni sulle parti per il caricamento in più parti specificato, fino a un massimo di 1000 parti. Se il caricamento multiparte contiene più di 1.000 parti, è necessario inviare una serie di richieste Elenca parti per recuperare tutte le parti. Tieni presente che l'elenco di parti restituito non include le parti per le quali non è stato completato il caricamento. L'operazione *list multipart uploads (elenco dei caricamenti in più parti)* consente di ottenere l'elenco dei caricamenti in più parti in corso.
Un caricamento in più parti in corso è un caricamento avviato, ma non ancora completato o annullato. Ogni richiesta restituisce al massimo 1.000 caricamenti in più parti. Se sono in corso più di 1.000 caricamenti in più parti, è necessario inviare richieste aggiuntive per recuperare i caricamenti rimanenti. Utilizza l'elenco restituito solo per la verifica.
**Importante**
Non utilizzarlo per inviare la richiesta *complete multipart upload (completamento del caricamento in più parti)*. Gestisci invece il tuo elenco dei codici articolo che hai specificato durante il caricamento delle parti e i ETag valori corrispondenti restituiti da Amazon S3.
## Checksum con operazioni di caricamento in più parti
Quando carichi un oggetto in Amazon S3 puoi specificare un algoritmo di checksum che Amazon S3 deve utilizzare. Per impostazione predefinita, l' AWS SDK e la console S3 utilizzano un algoritmo per tutti i caricamenti di oggetti, che puoi sovrascrivere. Se si utilizza un SDK precedente e l’oggetto caricato non ha un checksum specificato, Amazon S3 utilizza automaticamente l’algoritmo di checksum CRC-64/NVME (`CRC64NVME`). (questa è anche l'opzione consigliata per una verifica efficiente dell'integrità dei dati). Quando utilizza CRC-64/NVME, Amazon S3 calcola il checksum dell’oggetto completo al termine del caricamento in più parti o di una singola parte. L’algoritmo di checksum CRC-64/NVME viene utilizzato per calcolare un checksum diretto dell’intero oggetto o un checksum dei checksum per ogni singola parte.
Dopo aver caricato un oggetto su S3 utilizzando il caricamento in più parti, Amazon S3 calcola il valore del checksum per ogni parte o per l’intero oggetto e archivia i valori. Puoi utilizzare l'API o l' AWS SDK di S3 per recuperare il valore del checksum nei seguenti modi:
+ Per le singole parti, si può usare [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) o [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html). Se si desidera recuperare i valori di checksum per le singole parti dei caricamenti multiparte mentre sono ancora in corso, si può usare [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html).
+ Per l'intero oggetto, si può usare [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html). Se vuoi eseguire un caricamento multiparte con un checksum completo dell'oggetto, utilizza i comandi [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload) e [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload) specificando il tipo di checksum dell'oggetto completo. Per convalidare il valore del checksum dell'intero oggetto o per confermare quale tipo di checksum viene utilizzato nel caricamento multiparte, usa [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html).
**Importante**
Se si utilizza un caricamento in più parti con **Checksum**, i numeri di parte per ciascun caricamento (nel caricamento in più parti) devono essere numeri consecutivi e iniziare con 1. Quando si utilizzano i **Checksum**, se si tenta di completare una richiesta di caricamento multiparte con numeri di parte non consecutivi, Amazon S3 genera un errore `HTTP 500 Internal Server`.
Per ulteriori informazioni sul funzionamento dei checksum con gli oggetti di caricamento multiparte, consulta [Verifica dell'integrità degli oggetti in Amazon S3](checking-object-integrity.md).
Per una end-to-end procedura che dimostra come caricare un oggetto utilizzando il caricamento in più parti con un checksum aggiuntivo, consulta. [Esercitazione: caricamento di un oggetto tramite caricamento multiparte per verificarne l'integrità dei dati](tutorial-s3-mpu-additional-checksums.md)
## Operazioni simultanee di caricamento in più parti
In un ambiente di sviluppo distribuito è possibile che l'applicazione avvii più aggiornamenti sullo stesso oggetto contemporaneamente. L'applicazione potrebbe avviare vari caricamenti in più parti utilizzando la stessa chiave dell'oggetto. Per ciascuno di questi caricamenti, l'applicazione può quindi caricare le parti e inviare una richiesta di completamento del caricamento ad Amazon S3 per creare l'oggetto. Se per i bucket è abilitato il controllo delle versioni S3, il completamento di un caricamento in più parti crea sempre una nuova versione. Quando si avviano più caricamenti multiparte che utilizzano la stessa chiave oggetto in un bucket con controllo delle versioni abilitato, la versione corrente dell'oggetto è determinata da quale caricamento è stato avviato più di recente (`createdDate`).
Ad esempio, si avvia una richiesta a `CreateMultipartUpload` per un oggetto alle 10:00. Quindi, si invia una seconda richiesta a `CreateMultipartUpload` per lo stesso oggetto alle 11:00. Poiché la seconda richiesta è stata presentata più di recente, l'oggetto caricato dalla richiesta delle 11:00 diventa la versione corrente, anche se il primo caricamento è stato completato dopo il secondo. Per i bucket che non hanno il controllo delle versioni abilitato, è possibile che qualsiasi altra richiesta ricevuta tra l'avvio del caricamento multiparte e il suo completamento abbia la precedenza.
Un altro esempio di quando una richiesta di caricamento multiparte simultaneo può avere la precedenza è il caso in cui un'altra operazione cancella una chiave dopo aver avviato un caricamento multiparte con quella chiave. Prima di completare l'operazione, la risposta completa del caricamento multiparte potrebbe indicare che la creazione dell'oggetto è avvenuta con successo, senza che l'utente abbia mai visto l'oggetto.
## Impedisci il caricamento di oggetti con nomi di chiavi identici durante il caricamento multiparte
È possibile verificare l'esistenza di un oggetto nel bucket prima di crearlo, utilizzando una scrittura condizionale sulle operazioni di caricamento. In questo modo si può evitare la sovrascrittura dei dati esistenti. Le scritture condizionali convalidano l'assenza di oggetti esistenti con lo stesso nome chiave nel bucket durante il caricamento.
Si possono usare le scritture condizionali per richieste [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) o [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html).
Per ulteriori informazioni sulle richieste condizionali, consulta [Aggiunta di precondizioni alle operazioni S3 con richieste condizionali](conditional-requests.md).
## Caricamento in più parti e prezzi
Una volta avviato un caricamento in più parti, Amazon S3 mantiene tutte le parti finché il caricamento non viene completato o interrotto. Per tutta la durata del processo, all'utente vengono fatturati i costi per lo storage, la larghezza di banda e le richieste per questo tipo di caricamento e per le parti associate.
Queste parti vengono fatturate in base alla classe di storage specificata al momento del caricamento delle parti. Tuttavia, queste parti non vengono addebitate se vengono caricate su Recupero flessibile S3 Glacier o S3 Glacier Deep Archive. Le parti multiparte in corso per una richiesta PUT nella classe di storage Recupero flessibile S3 Glacier vengono fatturate come storage di staging Recupero flessibile S3 Glacier alle tariffe di archiviazione S3 Standard fino al completamento del caricamento. Inoltre, sia `CreateMultipartUpload` sia `UploadPart` sono fatturati alle tariffe S3 Standard. Solo la richiesta `CompleteMultipartUpload` viene fatturata alla tariffa di Recupero flessibile S3 Glacier. Analogamente, le parti multiparte in corso per PUT alla classe di storage S3 Glacier Deep Archive sono fatturate come storage di staging Recupero flessibile S3 Glacier alle tariffe di storage S3 Standard fino al completamento del caricamento, con l'addebito della sola richiesta `CompleteMultipartUpload` alle tariffe S3 Glacier Deep Archive.
Se si interrompe il caricamento multiparte, Amazon S3 elimina gli artefatti di caricamento e tutte le parti caricate. Tali artefatti non verranno addebitati. Non sono previsti costi di cancellazione anticipata per l'eliminazione di caricamenti incompleti in più parti indipendentemente dalla classe di archiviazione specificata. Per ulteriori informazioni sui prezzi, consulta [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Nota**
Per ridurre al minimo i costi di archiviazione, ti consigliamo di configurare una regola del ciclo di vita per eliminare i caricamenti in più parti incompleti dopo un numero di giorni specificato utilizzando l'operazione `AbortIncompleteMultipartUpload`. Per ulteriori informazioni sulla creazione di una regola del ciclo di vita per eliminare i caricamenti in più parti incompleti, consulta [Configurazione del ciclo di vita del bucket per l'eliminazione dei caricamenti in più parti incompleti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html).
## Supporto per l'API per il caricamento in più parti
Le seguenti sezioni di *Riferimento API di Amazon Simple Storage Service* descrivono la REST API per il caricamento multiparte.
Per una procedura dettagliata di caricamento in più parti che utilizza le funzioni AWS Lambda, consulta [Caricamento di oggetti di grandi dimensioni su Amazon S3 utilizzando l'accelerazione di caricamento](https://aws.amazon.com/blogs/compute/uploading-large-objects-to-amazon-s3-using-multipart-upload-and-transfer-acceleration/) e trasferimento in più parti.
+ [Creazione di un caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [Upload Part (Copy)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Completamento del caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [Abort Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [List Parts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [Elenco dei caricamenti in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## AWS Command Line Interface supporto per il caricamento in più parti
Gli argomenti seguenti AWS Command Line Interface descrivono le operazioni per il caricamento in più parti.
+ [Avvio del caricamento in più parti](https://docs.aws.amazon.com/cli/latest/reference/s3api/create-multipart-upload.html)
+ [Upload Part](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [Upload Part (Copy)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Completamento del caricamento in più parti](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [Abort Multipart Upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [List Parts](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [Elenco dei caricamenti in più parti](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## AWS Supporto SDK per il caricamento in più parti
Puoi usare an AWS SDKs per caricare un oggetto in più parti. Per un elenco delle azioni AWS SDKs supportate dall'API, consulta:
+ [Creazione di un caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [Upload Part (Copy)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Completamento del caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [Abort Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [List Parts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [Elenco dei caricamenti in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## Autorizzazioni e API per il caricamento in più parti
Per eseguire le operazioni di caricamento in più parti, devi disporre delle autorizzazioni necessarie. Puoi utilizzare le liste di controllo degli accessi (ACLs), la policy del bucket o la politica degli utenti per concedere alle persone le autorizzazioni per eseguire queste operazioni. La tabella seguente elenca le autorizzazioni richieste per varie operazioni di caricamento in più parti quando si utilizza ACLs una policy bucket o una policy utente.
| Azione | Autorizzazioni richieste |
| --- | --- |
| Creazione di un caricamento in più parti | Per creare una richiesta di caricamento multiparte, è necessario essere autorizzati a eseguire l'azione `s3:PutObject` su un oggetto. Il proprietario del bucket può consentire ad altri principali di eseguire l'azione `s3:PutObject`. |
| Avvio del caricamento in più parti | Per avviare un caricamento multiparte, è necessario essere autorizzati a eseguire l'azione `s3:PutObject` su un oggetto. Il proprietario del bucket può consentire ad altri principali di eseguire l'azione `s3:PutObject`. |
| Iniziatore | Elemento del container che identifica l'utente che ha avviato il caricamento in più parti. Se l'iniziatore è un Account AWS, questo elemento fornisce le stesse informazioni dell'elemento Owner. Se è un utente IAM, questo elemento fornisce l'ARN e il nome visualizzato dell'utente. |
| Upload Part | Per caricare una parte, è necessario essere autorizzati a eseguire l'operazione `s3:PutObject` su un oggetto. Il proprietario del bucket deve consentire all'iniziatore di eseguire l'operazione `s3:PutObject` su un oggetto affinché quest'ultimo possa caricare una parte di tale oggetto. |
| Upload Part (Copy) | Per caricare una parte, è necessario essere autorizzati a eseguire l'operazione `s3:PutObject` su un oggetto. Poiché si sta caricando una parte da un oggetto esistente, è necessario essere autorizzati a eseguire `s3:GetObject` sull'oggetto di origine. Perché l'iniziatore possa caricare una parte di un oggetto, il proprietario del bucket deve consentire all'iniziatore di eseguire l'operazione `s3:PutObject` sull'oggetto. |
| Completamento del caricamento in più parti | Per completare il caricamento in più parti, è necessario essere autorizzati a eseguire l'operazione `s3:PutObject` su un oggetto. Il proprietario del bucket deve consentire all'iniziatore di eseguire l'operazione `s3:PutObject` su un oggetto affinché quest'ultimo possa completare un caricamento in più parti di tale oggetto. |
| Stop Multipart Upload | Per interrompere un caricamento in più parti, è necessario essere autorizzati a eseguire l'operazione `s3:AbortMultipartUpload`. Per impostazione predefinita, il proprietario del bucket e l'iniziatore del caricamento multiparte sono autorizzati a eseguire questa azione come parte delle policy IAM e del bucket S3. Se l'iniziatore è un utente IAM, anche a quell'utente Account AWS è consentito interrompere il caricamento in più parti. Con le policy degli endpoint VPC, l'iniziatore del caricamento multiparte non ottiene automaticamente l'autorizzazione a eseguire l'azione `s3:AbortMultipartUpload`. Oltre alle impostazioni predefinite, il proprietario del bucket può consentire ad altri principali di eseguire l'azione `s3:AbortMultipartUpload` su oggetti. Il proprietario del bucket può negare a qualsiasi entità di eseguire l'operazione `s3:AbortMultipartUpload`. |
| List Parts | Per elencare un caricamento in più parti, è necessario essere autorizzati a eseguire l'operazione `s3:ListMultipartUploadParts`. Per default, il proprietario del bucket dispone dell'autorizzazione per elencare le parti per qualsiasi caricamento in più parti nel bucket. L'iniziatore del caricamento in più parti dispone dell'autorizzazione per elencare le parti di un caricamento in più parti specifico. Se l'iniziatore del caricamento in più parti è un utente IAM, l'utente IAM che Account AWS controlla tale utente ha anche l'autorizzazione a elencare parti di tale caricamento. Oltre alle impostazioni predefinite, il proprietario del bucket può consentire ad altri principali di eseguire l'azione `s3:ListMultipartUploadParts` su oggetti. Il proprietario del bucket può anche negare alle entità l'esecuzione dell'operazione `s3:ListMultipartUploadParts`. |
| Elenco dei caricamenti in più parti | Per elencare i caricamenti in più parti in corso in un bucket, è necessario essere autorizzati a eseguire l'operazione `s3:ListBucketMultipartUploads` su tale bucket. Oltre a queste impostazioni di default, il proprietario del bucket può consentire ad altre entità di eseguire l'operazione `s3:ListBucketMultipartUploads` sul bucket. |
| AWS KMS Autorizzazioni relative alla crittografia e alla decrittografia | Per eseguire un caricamento multiparte con crittografia utilizzando una chiave AWS Key Management Service (AWS KMS) KMS, il richiedente deve disporre delle seguenti autorizzazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonS3/latest/userguide/mpuoverview.html) Queste autorizzazioni sono obbligatorie perché Amazon S3 deve decrittografare e leggere i dati dalle parti di file crittografate prima di completare il caricamento in più parti. L'autorizzazione `kms:Decrypt` e la crittografia lato server con chiavi di crittografia fornite dal cliente sono necessarie anche per ottenere il valore di checksum di un oggetto. Se non si dispone di queste autorizzazioni necessarie quando si utilizza l'API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html), l'oggetto viene creato senza il valore di checksum. Se il tuo utente o ruolo IAM è lo Account AWS stesso della chiave KMS, verifica di disporre delle autorizzazioni sia sulla chiave che sulle policy IAM. Se l'utente o il ruolo IAM appartiene a un account diverso rispetto alla chiave KMS, devi disporre delle autorizzazioni sulla policy delle chiavi e sull'utente o sul ruolo IAM. |
| SSE-C (crittografia lato server con chiavi di crittografia fornite dal cliente) | Quando si utilizza l'API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) è necessario fornire l'SSE-C (crittografia lato server con chiavi di crittografia fornite dal cliente), altrimenti l'oggetto verrà creato senza checksum e non verrà restituito alcun valore di checksum. |
Per informazioni sulle relazioni tra le autorizzazioni nelle liste di controllo accessi (ACL) e le autorizzazioni nelle policy di accesso, consulta la sezione [Mappatura delle autorizzazioni ACL e delle autorizzazioni della policy di accesso](acl-overview.md#acl-access-policy-permission-mapping). Per informazioni su utenti, ruoli e best practice di IAM, consulta [Identità IAM (utenti, gruppi di utenti e ruoli)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) nella *Guida per l'utente di IAM*.
## Checksum con operazioni di caricamento in più parti
Esistono tre Amazon S3 APIs che vengono utilizzati per eseguire il caricamento multiparte effettivo: [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html),, [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)e. [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) La tabella seguente indica quali intestazioni e valori di checksum devono essere forniti per ciascuno di: APIs
| Algoritmo di checksum | Tipo di checksum | `CreateMultipartUpload` | `UploadPart` | `CompleteMultipartUpoad` |
| --- | --- | --- | --- | --- |
| CRC-64/NVME (`CRC64NVME`) | Oggetto completo | Intestazioni richieste: `x-amz-checksum-algorithm` | Intestazioni opzionali: `x-amz-checksum-crc64nvme` | Intestazioni opzionali: `x-amz-checksum-algorithm` `x-amz-crc64` |
| CRC-32 (`CRC32`) CRC 32-C (`CRC32C`) | Oggetto completo | Intestazioni richieste: `x-amz-checksum-algorithm` `x-amz-checksum-type` | Intestazioni opzionali: `x-amz-checksum-crc64nvme` | Intestazioni opzionali: `x-amz-checksum-algorithm` `x-amz-crc32` `x-amz-crc32c` |
| CRC-32 (`CRC32`) CRC-32C (`CRC32C`) SHA-1 () `SHA1` SHA256 () `SHA256` | Composita | Intestazioni richieste: `x-amz-checksum-algorithm` | Intestazioni richieste: `x-amz-checksum-crc32` `x-amz-checksum-crc32c` `x-amz-checksum-sha1` `x-amz-checksum-sha256` | Intestazioni richieste: Tutti i checksum a livello di parte devono essere inclusi nella richiesta `CompleteMultiPartUpload`. Intestazioni opzionali: `x-amz-crc32` `x-amz-crc32c` `x-amz-sha1` `x-amz-sha256` |
**Topics**
+ [
## Processo di caricamento in più parti
](#mpu-process)
+ [
## Checksum con operazioni di caricamento in più parti
](#mpuchecksums)
+ [
## Operazioni simultanee di caricamento in più parti
](#distributedmpupload)
+ [
## Impedisci il caricamento di oggetti con nomi di chiavi identici durante il caricamento multiparte
](#multipart-upload-objects-with-same-key-name)
+ [
## Caricamento in più parti e prezzi
](#mpuploadpricing)
+ [
## Supporto per l'API per il caricamento in più parti
](#apisupportformpu)
+ [
## AWS Command Line Interface supporto per il caricamento in più parti
](#clisupportformpu)
+ [
## AWS Supporto SDK per il caricamento in più parti
](#sdksupportformpu)
+ [
## Autorizzazioni e API per il caricamento in più parti
](#mpuAndPermissions)
+ [
## Checksum con operazioni di caricamento in più parti
](#Checksums-mpu-operations)
+ [
# Configurazione del ciclo di vita del bucket per l'eliminazione dei caricamenti in più parti incompleti
](mpu-abort-incomplete-mpu-lifecycle-config.md)
+ [
# Caricamento di un oggetto utilizzando il caricamento in più parti
](mpu-upload-object.md)
+ [
# Caricamento di una directory utilizzando la classe.NET di alto livello TransferUtility
](HLuploadDirDotNet.md)
+ [
# Elenco dei caricamenti in più parti
](list-mpu.md)
+ [
# Monitoraggio di un caricamento in più parti con AWS SDKs
](track-mpu.md)
+ [
# Interruzione di un caricamento in più parti
](abort-mpu.md)
+ [
# Copia di un oggetto utilizzando il caricamento in più parti
](CopyingObjectsMPUapi.md)
+ [
# Esercitazione: caricamento di un oggetto tramite caricamento multiparte per verificarne l'integrità dei dati
](tutorial-s3-mpu-additional-checksums.md)
+ [
# Limiti del caricamenti in più parti di Amazon S3
](qfacts.md)
# Configurazione del ciclo di vita del bucket per l'eliminazione dei caricamenti in più parti incompleti
Consigliamo, come best practice, di configurare una regola per il ciclo di vita utilizzando l'operazione `AbortIncompleteMultipartUpload` per ridurre al minimo i costi di archiviazione. Per ulteriori informazioni sull'interruzione di un caricamento in più parti, consulta [Interruzione di un caricamento in più parti](abort-mpu.md).
Amazon S3 supporta una regola per il ciclo di vita del bucket che può essere utilizzata per indicare ad Amazon S3 di interrompere i caricamenti in più parti che non sono stati completati entro un determinato numero di giorni dopo l'avvio. Quando un caricamento in più parti non viene completato entro il periodo di tempo specificato, diventa idoneo per un'operazione di interruzione. Quando Amazon S3 interrompe un caricamento in più parti, elimina tutte le parti associate al caricamento in più parti. Questa regola si applica sia ai caricamenti multiparte esistenti che a quelli creati successivamente.
Di seguito è riportata una configurazione del ciclo di vita di esempio che specifica una regola con l'operazione `AbortIncompleteMultipartUpload`.
```
sample-rule
Enabled
7
```
Nell'esempio, la regola non specifica un valore per l'elemento `Prefix` ([prefisso nome della chiave oggetto](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#keyprefix)). Pertanto, la regola viene applicata a tutti gli oggetti nel bucket per i quali sono stati avviati caricamenti in più parti. Tutti i caricamenti in più parti che sono stati avviati e non sono stati completati entro sette giorni diventano idonei per un'operazione di interruzione. L'azione di interruzione non ha alcun effetto sui caricamenti in più parti completati.
Per ulteriori informazioni sulla configurazione del ciclo di vita dei bucket, consulta [Gestione del ciclo di vita degli oggetti](object-lifecycle-mgmt.md).
**Nota**
Se il caricamento in più parti viene completato entro il numero di giorni specificato nella regola, l'operazione `AbortIncompleteMultipartUpload` del ciclo di vita non viene eseguita e Amazon S3 non intraprende alcuna operazione. Inoltre, questa operazione non si applica agli oggetti. Nessun oggetto viene eliminato da questa operazione del ciclo di vita. Inoltre, non dovrai sostenere costi per l'eliminazione anticipata del ciclo di vita S3 quando rimuovi parti caricate in più parti incomplete.
## Utilizzo della console S3
Per gestire automaticamente caricamenti in più parti incompleti, puoi utilizzare la console S3 per creare una regola del ciclo di vita per far scadere byte dei caricamenti in più parti incompleti dal bucket dopo un determinato numero di giorni. Nella seguente procedura viene illustrato come aggiungere una regola del ciclo di vita per eliminare caricamenti in più parti dopo 7 giorni. Per ulteriori informazioni sull'aggiunta di regole del ciclo di vita, consulta [Impostazione di una configurazione del ciclo di vita S3 in un bucket](how-to-set-lifecycle-configuration-intro.md).
**Per aggiungere una regola del ciclo di vita per interrompere i caricamenti in più parti incompleti che risalgono a più di 7 giorni**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nell'elenco **Buckets (Bucket)** scegliere il nome del bucket per il quale si desidera creare una regola del ciclo di vita.
1. Scegliere la scheda **Management (Gestione)**, quindi **Create lifecycle rule (Crea regola ciclo di vita)**.
1. In **Lifecycle rule name (Nome regola ciclo di vita)** immettere un nome per la regola.
Il nome deve essere univoco all'interno del bucket.
1. Scegliere l'ambito della regola del ciclo di vita:
+ Per creare una regola del ciclo di vita per tutti gli oggetti con un prefisso specifico, scegli **Limit the scope of this rule using one or more filters** (Limita l'ambito di questa regola utilizzando uno o più filtri) e inserisci il prefisso nel campo **Prefix** (Prefisso).
+ Per applicare una regola del ciclo di vita a tutti gli oggetti nel bucket, scegli **This rule applies to **all** objects in the bucket** (Questa regola si applica a tutti gli oggetti nel bucket) e quindi scegli **I acknowledge that this rule applies to all objects in the bucket** (Confermo che questa regola si applica a tutti gli oggetti nel bucket).
1. In **Lifecycle rule actions** (Operazioni regola ciclo di vita), seleziona **Delete expired object delete markers or incomplete multipart uploads** (Elimina contrassegni di eliminazione oggetti scaduti o caricamenti in più parti incompleti).
1. In **Delete expired delete markers or incomplete multipart uploads** (Elimina contrassegni di eliminazione scaduti o caricamenti in più parti incompleti), seleziona **Delete incomplete multipart uploads** (Elimina caricamenti in più parti incompleti).
1. Nel campo **Number of days** (Numero di giorni), inserisci il numero di giorni trascorsi i quali eliminare i caricamenti in più parti incompleti (per questo esempio, 7 giorni).
1. Scegli **Crea regola**.
## Usando il AWS CLI
Il comando seguente `put-bucket-lifecycle-configuration`AWS Command Line Interface (AWS CLI) aggiunge la configurazione del ciclo di vita per il bucket specificato. Per utilizzare questo comando, sostituisci `user input placeholders` con le tue informazioni.
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration filename-containing-lifecycle-configuration
```
L'esempio seguente mostra come aggiungere una regola del ciclo di vita per interrompere i caricamenti in più parti incompleti utilizzando la AWS CLI. Include un esempio di configurazione del ciclo di vita JSON per interrompere i caricamenti in più parti incompleti che risalgono a più di 7 giorni.
Per utilizzare i comandi CLI in questo esempio, sostituisci `user input placeholders` con le tue informazioni.
**Per aggiungere una regola del ciclo di vita per interrompere i caricamenti in più parti incompleti**
1. Configura il. AWS CLI*Per istruzioni, consulta [Sviluppo con Amazon S3 utilizzando la AWS CLI nel riferimento all'API](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html) Amazon S3.*
1. Salva la configurazione del ciclo di vita di esempio riportata di seguito in un file (ad esempio, *`lifecycle.json`*``). Questa configurazione di esempio specifica un prefisso vuoto e pertanto non si applica a tutti gli oggetti nel bucket. È possibile specificare un prefisso per limitare la configurazione a un sottoinsieme di oggetti.
```
{
"Rules": [
{
"ID": "Test Rule",
"Status": "Enabled",
"Filter": {
"Prefix": ""
},
"AbortIncompleteMultipartUpload": {
"DaysAfterInitiation": 7
}
}
]
}
```
1. Esegui il comando della CLI riportato di seguito per impostare la configurazione del ciclo di vita sul bucket.
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration file://lifecycle.json
```
1. Per verificare che la configurazione del ciclo di vita sia stata impostata sul bucket, recupera la configurazione del ciclo di vita utilizzando il seguente comando `get-bucket-lifecycle`.
```
aws s3api get-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
1. Per eliminare la configurazione del ciclo di vita, utilizza il seguente comando `delete-bucket-lifecycle`.
```
aws s3api delete-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
# Caricamento di un oggetto utilizzando il caricamento in più parti
Puoi usare il caricamento in più parti per caricare un singolo oggetto a livello di programmazione su Amazon S3. Ogni oggetto viene caricato come insieme di parti. Ciascuna parte è una parte contigua dei dati dell'oggetto. È possibile caricare queste parti dell'oggetto in modo indipendente e in qualsiasi ordine. Se la trasmissione di una parte non riesce, è possibile ritrasmettere tale parte senza influire sulle altre. Una volta caricate tutte le parti dell'oggetto, Amazon S3 le assembla e crea l'oggetto. Gli utenti anonimi non possono avviare caricamenti in più parti.
Per una end-to-end procedura sul caricamento di un oggetto con caricamento in più parti con un checksum aggiuntivo, consulta. [Esercitazione: caricamento di un oggetto tramite caricamento multiparte per verificarne l'integrità dei dati](tutorial-s3-mpu-additional-checksums.md)
La sezione seguente mostra come utilizzare il caricamento in più parti con, and. AWS Command Line Interface AWS SDKs
## Utilizzo della console S3
In un bucket S3 è possibile caricare qualsiasi tipo di file: immagini, backup, dati, film e così via. La dimensione massima di un file che è possibile caricare utilizzando la console di Amazon S3 è 160 GB. Per caricare un file di dimensioni superiori a 160 GB, usa AWS Command Line Interface (AWS CLI) o l' AWS SDKsAPI REST di Amazon S3.
Per istruzioni su come caricare un oggetto tramite il Console di gestione AWS, consulta. [Caricamento degli oggetti](upload-objects.md)
## Utilizzando il AWS CLI
Di seguito vengono descritte le operazioni di Amazon S3 per il caricamento multiparte utilizzando AWS CLI.
+ [Avvio del caricamento in più parti](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-multipart-upload.html)
+ [Upload Part](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [Upload Part (Copy)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Completamento del caricamento in più parti](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [Abort Multipart Upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [List Parts](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [Elenco dei caricamenti in più parti](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## Utilizzo della REST API
Le sezioni seguenti della *Documentazione di riferimento delle API di Amazon Simple Storage Service* descrivono REST API per il caricamento in più parti.
+ [Avvio del caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Completamento del caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Stop Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [List Parts](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [Elenco dei caricamenti in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
## Utilizzando l'API AWS SDKs (di alto livello)
Alcuni AWS SDKs espongono un'API di alto livello che semplifica il caricamento in più parti combinando le diverse operazioni API necessarie per completare un caricamento multiparte in un'unica operazione. Per ulteriori informazioni, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
Se è necessario sospendere e riprendere il caricamento multiparte, variare le dimensioni delle parti durante il caricamento, oppure non conosci in anticipo le dimensioni dei dati, utilizza i metodi API di basso livello. I metodi API di basso livello per il caricamento multiparte offrono ulteriori funzionalità; per ulteriori informazioni, consulta [Utilizzo dell'API (di basso livello AWS SDKs )](#mpu-upload-low-level).
------
#### [ Java ]
*Per esempi di come eseguire un caricamento in più parti con l' AWS SDK per Java, [consulta Caricare o scaricare file di grandi dimensioni da e verso Amazon S3 utilizzando AWS un SDK nell'Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html) API Reference.*
------
#### [ .NET ]
Per caricare un file in un bucket S3, utilizzare la classe `TransferUtility`. Se si caricano dati da un file, è necessario specificare il nome della chiave dell'oggetto. In caso contrario, l'API utilizza il nome file per il nome della chiave. Durante il caricamento di dati da un flusso, è necessario specificare il nome della chiave dell'oggetto.
Per impostare opzioni di caricamento avanzate, come la dimensione delle parti, il numero di thread durante il caricamento simultaneo di parti, i metadati, la classe di storage o la lista di controllo accessi, utilizza la classe `TransferUtilityUploadRequest`.
**Nota**
Se l'origine dei dati è costituita da un flusso, la classe `TransferUtility` non esegue caricamenti simultanei.
Il seguente esempio di codice C\$1 consente di caricare un file in un bucket Amazon S3 in più parti. Mostra come utilizzare diversi overload `TransferUtility.Upload` per caricare un file. Ciascuna chiamata successiva al caricamento sostituisce il caricamento precedente. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta [Getting Started with the AWS SDK for .NET nella AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET *Developer Guide*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPUHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadFileAsync().Wait();
}
private static async Task UploadFileAsync()
{
try
{
var fileTransferUtility =
new TransferUtility(s3Client);
// Option 1. Upload a file. The file name is used as the object key name.
await fileTransferUtility.UploadAsync(filePath, bucketName);
Console.WriteLine("Upload 1 completed");
// Option 2. Specify object key name explicitly.
await fileTransferUtility.UploadAsync(filePath, bucketName, keyName);
Console.WriteLine("Upload 2 completed");
// Option 3. Upload data from a type of System.IO.Stream.
using (var fileToUpload =
new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
await fileTransferUtility.UploadAsync(fileToUpload,
bucketName, keyName);
}
Console.WriteLine("Upload 3 completed");
// Option 4. Specify advanced settings.
var fileTransferUtilityRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
StorageClass = S3StorageClass.StandardInfrequentAccess,
PartSize = 6291456, // 6 MB.
Key = keyName,
CannedACL = S3CannedACL.PublicRead
};
fileTransferUtilityRequest.Metadata.Add("param1", "Value1");
fileTransferUtilityRequest.Metadata.Add("param2", "Value2");
await fileTransferUtility.UploadAsync(fileTransferUtilityRequest);
Console.WriteLine("Upload 4 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
#### [ JavaScript ]
**Example**
Carica un file di grandi dimensioni.
```
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import {
ProgressBar,
logger,
} from "@aws-doc-sdk-examples/lib/utils/util-log.js";
const twentyFiveMB = 25 * 1024 * 1024;
export const createString = (size = twentyFiveMB) => {
return "x".repeat(size);
};
/**
* Create a 25MB file and upload it in parts to the specified
* Amazon S3 bucket.
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
const str = createString();
const buffer = Buffer.from(str, "utf8");
const progressBar = new ProgressBar({
description: `Uploading "${key}" to "${bucketName}"`,
barLength: 30,
});
try {
const upload = new Upload({
client: new S3Client({}),
params: {
Bucket: bucketName,
Key: key,
Body: buffer,
},
});
upload.on("httpUploadProgress", ({ loaded, total }) => {
progressBar.update({ current: loaded, total });
});
await upload.done();
} catch (caught) {
if (caught instanceof Error && caught.name === "AbortError") {
logger.error(`Multipart upload was aborted. ${caught.message}`);
} else {
throw caught;
}
}
};
```
**Example**
Scarica un file di grandi dimensioni.
```
import { fileURLToPath } from "node:url";
import { GetObjectCommand, NoSuchKey, S3Client } from "@aws-sdk/client-s3";
import { createWriteStream, rmSync } from "node:fs";
const s3Client = new S3Client({});
const oneMB = 1024 * 1024;
export const getObjectRange = ({ bucket, key, start, end }) => {
const command = new GetObjectCommand({
Bucket: bucket,
Key: key,
Range: `bytes=${start}-${end}`,
});
return s3Client.send(command);
};
/**
* @param {string | undefined} contentRange
*/
export const getRangeAndLength = (contentRange) => {
const [range, length] = contentRange.split("/");
const [start, end] = range.split("-");
return {
start: Number.parseInt(start),
end: Number.parseInt(end),
length: Number.parseInt(length),
};
};
export const isComplete = ({ end, length }) => end === length - 1;
const downloadInChunks = async ({ bucket, key }) => {
const writeStream = createWriteStream(
fileURLToPath(new URL(`./${key}`, import.meta.url)),
).on("error", (err) => console.error(err));
let rangeAndLength = { start: -1, end: -1, length: -1 };
while (!isComplete(rangeAndLength)) {
const { end } = rangeAndLength;
const nextRange = { start: end + 1, end: end + oneMB };
const { ContentRange, Body } = await getObjectRange({
bucket,
key,
...nextRange,
});
console.log(`Downloaded bytes ${nextRange.start} to ${nextRange.end}`);
writeStream.write(await Body.transformToByteArray());
rangeAndLength = getRangeAndLength(ContentRange);
}
};
/**
* Download a large object from and Amazon S3 bucket.
*
* When downloading a large file, you might want to break it down into
* smaller pieces. Amazon S3 accepts a Range header to specify the start
* and end of the byte range to be downloaded.
*
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
try {
await downloadInChunks({
bucket: bucketName,
key: key,
});
} catch (caught) {
if (caught instanceof NoSuchKey) {
console.error(`Failed to download object. No such key "${key}".`);
rmSync(key);
}
}
};
```
------
#### [ Go ]
Per ulteriori informazioni sull'esempio di codice Go per il caricamento in più parti, consulta [Caricare o scaricare file di grandi dimensioni da e verso Amazon S3 utilizzando AWS](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html) un SDK.
**Example**
Carica un oggetto di grandi dimensioni utilizzando un gestore di caricamento per suddividere i dati in parti e caricarli contemporaneamente.
```
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"log"
"os"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/smithy-go"
)
// BucketBasics encapsulates the Amazon Simple Storage Service (Amazon S3) actions
// used in the examples.
// It contains S3Client, an Amazon S3 service client that is used to perform bucket
// and object actions.
type BucketBasics struct {
S3Client *s3.Client
}
```
```
// UploadLargeObject uses an upload manager to upload data to an object in a bucket.
// The upload manager breaks large data into parts and uploads the parts concurrently.
func (basics BucketBasics) UploadLargeObject(ctx context.Context, bucketName string, objectKey string, largeObject []byte) error {
largeBuffer := bytes.NewReader(largeObject)
var partMiBs int64 = 10
uploader := manager.NewUploader(basics.S3Client, func(u *manager.Uploader) {
u.PartSize = partMiBs * 1024 * 1024
})
_, err := uploader.Upload(ctx, &s3.PutObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
Body: largeBuffer,
})
if err != nil {
var apiErr smithy.APIError
if errors.As(err, &apiErr) && apiErr.ErrorCode() == "EntityTooLarge" {
log.Printf("Error while uploading object to %s. The object is too large.\n"+
"The maximum size for a multipart upload is 5TB.", bucketName)
} else {
log.Printf("Couldn't upload large object to %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
} else {
err = s3.NewObjectExistsWaiter(basics.S3Client).Wait(
ctx, &s3.HeadObjectInput{Bucket: aws.String(bucketName), Key: aws.String(objectKey)}, time.Minute)
if err != nil {
log.Printf("Failed attempt to wait for object %s to exist.\n", objectKey)
}
}
return err
}
```
**Example**
Scarica un oggetto di grandi dimensioni utilizzando un gestore di download per ottenere i dati in parti e scaricarli contemporaneamente.
```
// DownloadLargeObject uses a download manager to download an object from a bucket.
// The download manager gets the data in parts and writes them to a buffer until all of
// the data has been downloaded.
func (basics BucketBasics) DownloadLargeObject(ctx context.Context, bucketName string, objectKey string) ([]byte, error) {
var partMiBs int64 = 10
downloader := manager.NewDownloader(basics.S3Client, func(d *manager.Downloader) {
d.PartSize = partMiBs * 1024 * 1024
})
buffer := manager.NewWriteAtBuffer([]byte{})
_, err := downloader.Download(ctx, buffer, &s3.GetObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
})
if err != nil {
log.Printf("Couldn't download large object from %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
return buffer.Bytes(), err
}
```
------
#### [ PHP ]
Questo argomento spiega come utilizzare la `Aws\S3\Model\MultipartUpload\UploadBuilder` classe di alto livello di AWS SDK per PHP per i caricamenti di file in più parti. Per ulteriori informazioni sull'API AWS SDK for Ruby, [AWS vai a SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Versione 2.
Il seguente esempio del PHP indica come caricare un file in un bucket Amazon S3. L'esempio dimostra come impostare i parametri per l'oggetto `MultipartUploader`.
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Prepare the upload parameters.
$uploader = new MultipartUploader($s3, '/path/to/large/file.zip', [
'bucket' => $bucket,
'key' => $keyname
]);
// Perform the upload.
try {
$result = $uploader->upload();
echo "Upload complete: {$result['ObjectURL']}" . PHP_EOL;
} catch (MultipartUploadException $e) {
echo $e->getMessage() . PHP_EOL;
}
```
------
#### [ Python ]
Il seguente esempio di codice mostra come caricare un oggetto utilizzando l'API Python di caricamento in più parti di alto livello (la classe `TransferManager`).
```
import sys
import threading
import boto3
from boto3.s3.transfer import TransferConfig
MB = 1024 * 1024
s3 = boto3.resource("s3")
class TransferCallback:
"""
Handle callbacks from the transfer manager.
The transfer manager periodically calls the __call__ method throughout
the upload and download process so that it can take action, such as
displaying progress to the user and collecting data about the transfer.
"""
def __init__(self, target_size):
self._target_size = target_size
self._total_transferred = 0
self._lock = threading.Lock()
self.thread_info = {}
def __call__(self, bytes_transferred):
"""
The callback method that is called by the transfer manager.
Display progress during file transfer and collect per-thread transfer
data. This method can be called by multiple threads, so shared instance
data is protected by a thread lock.
"""
thread = threading.current_thread()
with self._lock:
self._total_transferred += bytes_transferred
if thread.ident not in self.thread_info.keys():
self.thread_info[thread.ident] = bytes_transferred
else:
self.thread_info[thread.ident] += bytes_transferred
target = self._target_size * MB
sys.stdout.write(
f"\r{self._total_transferred} of {target} transferred "
f"({(self._total_transferred / target) * 100:.2f}%)."
)
sys.stdout.flush()
def upload_with_default_configuration(
local_file_path, bucket_name, object_key, file_size_mb
):
"""
Upload a file from a local folder to an Amazon S3 bucket, using the default
configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_chunksize_and_meta(
local_file_path, bucket_name, object_key, file_size_mb, metadata=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart chunk size and adding metadata to the Amazon S3 object.
The multipart chunk size controls the size of the chunks of data that are
sent in the request. A smaller chunk size typically results in the transfer
manager using more threads for the upload.
The metadata is a set of key-value pairs that are stored with the object
in Amazon S3.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_chunksize=1 * MB)
extra_args = {"Metadata": metadata} if metadata else None
s3.Bucket(bucket_name).upload_file(
local_file_path,
object_key,
Config=config,
ExtraArgs=extra_args,
Callback=transfer_callback,
)
return transfer_callback.thread_info
def upload_with_high_threshold(local_file_path, bucket_name, object_key, file_size_mb):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard upload instead of
a multipart upload.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_sse(
local_file_path, bucket_name, object_key, file_size_mb, sse_key=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, adding server-side
encryption with customer-provided encryption keys to the object.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_default_configuration(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using the
default configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_single_thread(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using a
single thread.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(use_threads=False)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_high_threshold(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard download instead
of a multipart download.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_sse(
bucket_name, object_key, download_file_path, file_size_mb, sse_key
):
"""
Download a file from an Amazon S3 bucket to a local folder, adding a
customer-provided encryption key to the request.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
```
------
## Utilizzo dell'API (di basso livello AWS SDKs )
L' AWS SDK espone un'API di basso livello molto simile all'API REST di Amazon S3 per caricamenti multiparte (vedi. [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md) Utilizza l'API di basso livello quando devi mettere in pausa e riprendere i caricamenti in più parti, variare le dimensioni delle parti durante il caricamento o non conosci in anticipo la dimensione dei dati di caricamento. Se non hai questi requisiti, utilizza l'API di alto livello (vedi). [Utilizzando l'API AWS SDKs (di alto livello)](#multipart-upload-high-level)
------
#### [ Java ]
L'esempio che segue mostra come utilizzare le classi Java di basso livello per il caricamento di un file. Tale esempio esegue i seguenti passaggi:
+ Avvia un caricamento in più parti usando il metodo`AmazonS3Client.initiateMultipartUpload()` e passa un oggetto `InitiateMultipartUploadRequest`.
+ Salva l'ID di caricamento che viene restituito dal metodo `AmazonS3Client.initiateMultipartUpload()`. Questo ID di caricamento deve essere specificato per ogni operazione di caricamento in più parti successiva.
+ Carica le parti dell'oggetto. Per ogni parte, occorre chiamare il metodo `AmazonS3Client.uploadPart()`. Le informazioni sul caricamento della parte devono essere fornite usando un oggetto `UploadPartRequest`.
+ Per ogni parte, salva la ETag risposta del `AmazonS3Client.uploadPart()` metodo in un elenco. I ETag valori vengono utilizzati per completare il caricamento in più parti.
+ Chiama il metodo `AmazonS3Client.completeMultipartUpload()` per completare il caricamento in più parti.
**Example**
Per istruzioni su come creare e testare un esempio funzionante, consulta [Getting Started](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) nella AWS SDK per Java Developer Guide.
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class LowLevelMultipartUpload {
public static void main(String[] args) throws IOException {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String keyName = "*** Key name ***";
String filePath = "*** Path to file to upload ***";
File file = new File(filePath);
long contentLength = file.length();
long partSize = 5 * 1024 * 1024; // Set part size to 5 MB.
try {
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(clientRegion)
.withCredentials(new ProfileCredentialsProvider())
.build();
// Create a list of ETag objects. You retrieve ETags for each object part
// uploaded,
// then, after each individual part has been uploaded, pass the list of ETags to
// the request to complete the upload.
List partETags = new ArrayList();
// Initiate the multipart upload.
InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(bucketName, keyName);
InitiateMultipartUploadResult initResponse = s3Client.initiateMultipartUpload(initRequest);
// Upload the file parts.
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++) {
// Because the last part could be less than 5 MB, adjust the part size as
// needed.
partSize = Math.min(partSize, (contentLength - filePosition));
// Create the request to upload a part.
UploadPartRequest uploadRequest = new UploadPartRequest()
.withBucketName(bucketName)
.withKey(keyName)
.withUploadId(initResponse.getUploadId())
.withPartNumber(i)
.withFileOffset(filePosition)
.withFile(file)
.withPartSize(partSize);
// Upload the part and add the response's ETag to our list.
UploadPartResult uploadResult = s3Client.uploadPart(uploadRequest);
partETags.add(uploadResult.getPartETag());
filePosition += partSize;
}
// Complete the multipart upload.
CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest(bucketName, keyName,
initResponse.getUploadId(), partETags);
s3Client.completeMultipartUpload(compRequest);
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
}
```
------
#### [ .NET ]
Il seguente esempio in C\$1 mostra come utilizzare l'API di caricamento SDK per .NET multiparte di basso livello per caricare un file in un bucket S3. Per informazioni sul caricamento in più parti di Amazon S3, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
**Nota**
Quando utilizzi l' SDK per .NET API per caricare oggetti di grandi dimensioni, potrebbe verificarsi un timeout durante la scrittura dei dati nel flusso di richieste. Puoi impostare un timeout esplicito utilizzando la richiesta `UploadPartRequest`.
Il seguente esempio di codice \$1C mostra come caricare un file in un bucket S3 utilizzando l'API per il caricamento in più parti di basso livello. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta [Getting Started with the AWS SDK for .NET nella AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET *Developer Guide*.
```
using Amazon;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPULowLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Uploading an object");
UploadObjectAsync().Wait();
}
private static async Task UploadObjectAsync()
{
// Create list to store upload part responses.
List uploadResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Upload parts.
long contentLength = new FileInfo(filePath).Length;
long partSize = 5 * (long)Math.Pow(2, 20); // 5 MB
try
{
Console.WriteLine("Uploading parts");
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++)
{
UploadPartRequest uploadRequest = new UploadPartRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId,
PartNumber = i,
PartSize = partSize,
FilePosition = filePosition,
FilePath = filePath
};
// Track upload progress.
uploadRequest.StreamTransferProgress +=
new EventHandler(UploadPartProgressEventCallback);
// Upload a part and add the response to our list.
uploadResponses.Add(await s3Client.UploadPartAsync(uploadRequest));
filePosition += partSize;
}
// Setup to complete the upload.
CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(uploadResponses);
// Complete the upload.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (Exception exception)
{
Console.WriteLine("An AmazonS3Exception was thrown: { 0}", exception.Message);
// Abort the upload.
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await s3Client.AbortMultipartUploadAsync(abortMPURequest);
}
}
public static void UploadPartProgressEventCallback(object sender, StreamTransferProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
#### [ PHP ]
Questo argomento mostra come utilizzare il `uploadPart` metodo di basso livello della versione 3 di AWS SDK per PHP per caricare un file in più parti. Per ulteriori informazioni sull'API AWS SDK for Ruby, [AWS vai a SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Versione 2.
Il seguente esempio di codice PHP mostra come caricare un file in un bucket Amazon S3 utilizzando il caricamento in più parti con l'API del PHP di basso livello.
```
require 'vendor/autoload.php';
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$filename = '*** Path to and Name of the File to Upload ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
$result = $s3->createMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'StorageClass' => 'REDUCED_REDUNDANCY',
'Metadata' => [
'param1' => 'value 1',
'param2' => 'value 2',
'param3' => 'value 3'
]
]);
$uploadId = $result['UploadId'];
// Upload the file in parts.
try {
$file = fopen($filename, 'r');
$partNumber = 1;
while (!feof($file)) {
$result = $s3->uploadPart([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'PartNumber' => $partNumber,
'Body' => fread($file, 5 * 1024 * 1024),
]);
$parts['Parts'][$partNumber] = [
'PartNumber' => $partNumber,
'ETag' => $result['ETag'],
];
$partNumber++;
echo "Uploading part $partNumber of $filename." . PHP_EOL;
}
fclose($file);
} catch (S3Exception $e) {
$result = $s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId
]);
echo "Upload of $filename failed." . PHP_EOL;
}
// Complete the multipart upload.
$result = $s3->completeMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'MultipartUpload' => $parts,
]);
$url = $result['Location'];
echo "Uploaded $filename to $url." . PHP_EOL;
```
------
## Usando il AWS SDK per Ruby
La AWS SDK per Ruby versione 3 supporta i caricamenti multiparte di Amazon S3 in due modi. Il primo metodo prevede la possibilità di utilizzare caricamenti file gestiti. Per ulteriori informazioni, consulta la sezione [Caricamento di file in Amazon S3](https://aws.amazon.com/blogs/developer/uploading-files-to-amazon-s3/) nel *Blog per sviluppatori di AWS *. I caricamenti file gestiti rappresentano il metodo consigliato per caricare i file in un bucket. Offrono i seguenti vantaggi:
+ Gestiscono i caricamenti in più parti per gli oggetti con una dimensione maggiore di 15 MB.
+ Aprono correttamente i file in modalità binaria per evitare problemi di codifica.
+ Utilizzano più thread per il caricamento in parallelo delle parti degli oggetti di grandi dimensioni.
In alternativa, è possibile utilizzare direttamente le seguenti operazioni del client di caricamento in più parti:
+ [create\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#create_multipart_upload-instance_method) - Avvia un caricamento in più parti e restituisce un ID di caricamento.
+ [upload\$1part](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part-instance_method) - Carica una parte in un caricamento in più parti.
+ [upload\$1part\$1copy](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part_copy-instance_method) - Carica una parte copiando i dati da un oggetto esistente come origine dati.
+ [complete\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#complete_multipart_upload-instance_method) - Completa un caricamento in più parti assemblando le parti caricate in precedenza.
+ [abort\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#abort_multipart_upload-instance_method) - Interrompe un caricamento in più parti.
# Caricamento di una directory utilizzando la classe.NET di alto livello TransferUtility
Puoi utilizzare la classe `TransferUtility` per caricare un'intera directory. Per impostazione predefinita, l'API carica solo i file nella posizione root della directory specificata. È tuttavia possibile specificare il caricamento ricorsivo dei file in tutte le sottodirectory.
Per selezionare i file nella directory specificata in base ai criteri di filtro, specificare espressioni di filtro. Ad esempio, per caricare solo i file `PDF` da una directory, specifica l'espressione del filtro `"*.pdf"`.
Quando si caricano file da una directory, non è possibile specificare i nomi delle chiavi per l'oggetto risultante. Amazon S3 crea i nomi delle chiavi utilizzando il percorso file originale. Supponiamo, ad esempio, di avere una la directory denominata `c:\myfolder` con la seguente struttura:
**Example**
```
1. C:\myfolder
2. \a.txt
3. \b.pdf
4. \media\
5. An.mp3
```
Quando effettui un caricamento in questa directory, Amazon S3 utilizza questi nomi della chiave dell'oggetto:
**Example**
```
1. a.txt
2. b.pdf
3. media/An.mp3
```
**Example**
Il seguente esempio di codice C\$1 consente di caricare una directory in un bucket Amazon S3. Mostra come utilizzare diversi overload `TransferUtility.UploadDirectory` per caricare la directory. Ciascuna chiamata successiva al caricamento sostituisce il caricamento precedente. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta [Getting Started with the AWS SDK for .NET nella AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET *Developer Guide*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadDirMPUHighLevelAPITest
{
private const string existingBucketName = "*** bucket name ***";
private const string directoryPath = @"*** directory path ***";
// The example uploads only .txt files.
private const string wildCard = "*.txt";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadDirAsync().Wait();
}
private static async Task UploadDirAsync()
{
try
{
var directoryTransferUtility =
new TransferUtility(s3Client);
// 1. Upload a directory.
await directoryTransferUtility.UploadDirectoryAsync(directoryPath,
existingBucketName);
Console.WriteLine("Upload statement 1 completed");
// 2. Upload only the .txt files from a directory
// and search recursively.
await directoryTransferUtility.UploadDirectoryAsync(
directoryPath,
existingBucketName,
wildCard,
SearchOption.AllDirectories);
Console.WriteLine("Upload statement 2 completed");
// 3. The same as Step 2 and some optional configuration.
// Search recursively for .txt files to upload.
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = existingBucketName,
Directory = directoryPath,
SearchOption = SearchOption.AllDirectories,
SearchPattern = wildCard
};
await directoryTransferUtility.UploadDirectoryAsync(request);
Console.WriteLine("Upload statement 3 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine(
"Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine(
"Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
# Elenco dei caricamenti in più parti
Puoi utilizzare l' AWS CLI API REST o AWS SDKs, per recuperare un elenco di caricamenti multiparte in corso in Amazon S3. Puoi usare il caricamento in più parti per caricare un singolo oggetto a livello di programmazione su Amazon S3. I caricamenti multiparte spostano gli oggetti in Amazon S3 spostando una parte dei dati di un oggetto alla volta. Per informazioni più generiche sui caricamenti multiparte, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
Per una end-to-end procedura sul caricamento di un oggetto con caricamento in più parti con un checksum aggiuntivo, consulta. [Esercitazione: caricamento di un oggetto tramite caricamento multiparte per verificarne l'integrità dei dati](tutorial-s3-mpu-additional-checksums.md)
La sezione seguente mostra come elencare i caricamenti multiparte in corso con AWS Command Line Interface, l'API REST di Amazon S3 e. AWS SDKs
## Elencare i caricamenti in più parti utilizzando il AWS CLI
Le seguenti sezioni AWS Command Line Interface descrivono le operazioni per elencare i caricamenti in più parti.
+ [list-parts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-parts.html): elenca le parti caricate di un caricamento in più parti specifico.
+ [list-multipart-uploads](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)‐Elenca i caricamenti multiparte in corso.
# Elenco dei caricamenti in più parti tramite REST API
Le sezioni seguenti della *Documentazione di riferimento delle API di Amazon Simple Storage Service* descrivono REST API per l'elenco dei caricamenti in più parti.
+ [ListParts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)‐elenca le parti caricate per un caricamento multiparte specifico.
+ [ListMultipartUploads](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)‐elenca i caricamenti multiparte in corso.
## Elencare i caricamenti in più parti utilizzando l'SDK (API di basso livello) AWS
------
#### [ Java ]
Per elencare tutti i caricamenti multiparte in corso su un bucket utilizzando l'SDK for AWS Java, puoi utilizzare le classi API di basso livello per:
**Processo di creazione di un elenco di caricamenti in più parti tramite l'API di basso livello**
| | |
| --- |--- |
| 1 | Creare un'istanza della classe `ListMultipartUploadsRequest` e specificare il nome del bucket. |
| 2 | Eseguire il metodo `listMultipartUploads` S3Client. Questo metodo restituisce un'istanza della classe `ListMultipartUploadsResponse` che fornisce le informazioni sui caricamenti in più parti in corso. |
*Per esempi su come elencare caricamenti multiparte con l' AWS SDK for Java, consulta [Elencare caricamenti multiparte nell'](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_ListMultipartUploads_section.html)Amazon S3 API Reference.*
------
#### [ .NET ]
Per elencare tutti i caricamenti in più parti in corso in uno specifico bucket, utilizza la classe `ListMultipartUploadsRequest` dell'API di basso livello di SDK per .NET per il caricamento in più parti. Il metodo `AmazonS3Client.ListMultipartUploads` restituisce un'istanza della classe `ListMultipartUploadsResponse` che fornisce informazioni sui caricamenti in più parti in corso.
Un caricamento in più parti in corso è un caricamento che è stato avviato utilizzando la richiesta Initiate Multipart Upload, ma che non è ancora stato completato o interrotto. Per ulteriori informazioni sui caricamenti in più parti di Amazon S3, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
Il seguente esempio in C\$1 mostra come utilizzare per elencare tutti i caricamenti multiparte SDK per .NET in corso su un bucket. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta [Getting Started with the AWS SDK for .NET nella AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET *Developer Guide*.
```
ListMultipartUploadsRequest request = new ListMultipartUploadsRequest
{
BucketName = bucketName // Bucket receiving the uploads.
};
ListMultipartUploadsResponse response = await AmazonS3Client.ListMultipartUploadsAsync(request);
```
------
#### [ PHP ]
Questo argomento mostra come utilizzare le classi API di basso livello della versione 3 di AWS SDK per PHP per elencare tutti i caricamenti multiparte in corso su un bucket. Per ulteriori informazioni sull'API AWS SDK for Ruby, [AWS vai a SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Versione 2.
Il seguente esempio di codice PHP mostra come creare un elenco di tutti i caricamenti in più parti in corso in un bucket.
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Retrieve a list of the current multipart uploads.
$result = $s3->listMultipartUploads([
'Bucket' => $bucket
]);
// Write the list of uploads to the page.
print_r($result->toArray());
```
------
# Monitoraggio di un caricamento in più parti con AWS SDKs
È possibile seguire l'avanzamento del caricamento di un oggetto su Amazon S3 con un'interfaccia listen. L'API di caricamento multiparte di alto livello fornisce un'interfaccia listen, chiamata `ProgressListener`. Gli eventi di stato si verificano periodicamente e inviano al listener la notifica dell'avvenuto trasferimento dei dati. Per informazioni più generiche sui caricamenti multiparte, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
Per una end-to-end procedura sul caricamento di un oggetto con caricamento in più parti con un checksum aggiuntivo, vedi. [Esercitazione: caricamento di un oggetto tramite caricamento multiparte per verificarne l'integrità dei dati](tutorial-s3-mpu-additional-checksums.md)
La sezione seguente mostra come tenere traccia di un caricamento in più parti con. AWS SDKs
------
#### [ Java ]
**Example**
Il seguente codice Java carica un file e utilizza `ExecutionInterceptor` per monitorare lo stato del caricamento. Per istruzioni su come creare e testare un esempio funzionante, consulta la [Guida introduttiva](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html) nella Guida per gli sviluppatori AWS SDK per Java 2.x.
```
import java.nio.file.Paths;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.interceptor.Context;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.ExecutionInterceptor;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
public class TrackMPUProgressUsingHighLevelAPI {
static class ProgressListener implements ExecutionInterceptor {
private long transferredBytes = 0;
@Override
public void beforeTransmission(Context.BeforeTransmission context, ExecutionAttributes executionAttributes) {
if (context.httpRequest().firstMatchingHeader("Content-Length").isPresent()) {
String contentLength = context.httpRequest().firstMatchingHeader("Content-Length").get();
long partSize = Long.parseLong(contentLength);
transferredBytes += partSize;
System.out.println("Transferred bytes: " + transferredBytes);
}
}
}
public static void main(String[] args) throws Exception {
String existingBucketName = "*** Provide bucket name ***";
String keyName = "*** Provide object key ***";
String filePath = "*** file to upload ***";
S3AsyncClient s3Client = S3AsyncClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.overrideConfiguration(c -> c.addExecutionInterceptor(new ProgressListener()))
.build();
// For more advanced uploads, you can create a request object
// and supply additional request parameters (ex: progress listeners,
// canned ACLs, etc.)
PutObjectRequest request = PutObjectRequest.builder()
.bucket(existingBucketName)
.key(keyName)
.build();
AsyncRequestBody requestBody = AsyncRequestBody.fromFile(Paths.get(filePath));
// You can ask the upload for its progress, or you can
// add a ProgressListener to your request to receive notifications
// when bytes are transferred.
// S3AsyncClient processes all transfers asynchronously,
// so this call will return immediately.
var upload = s3Client.putObject(request, requestBody);
try {
// You can block and wait for the upload to finish
upload.join();
} catch (Exception exception) {
System.out.println("Unable to upload file, upload aborted.");
exception.printStackTrace();
} finally {
s3Client.close();
}
}
}
```
------
#### [ .NET ]
Il seguente esempio di codice C\$1 consente di caricare un file in un bucket S3 utilizzando la classe `TransferUtility` e monitorare lo stato di avanzamento del caricamento. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta [Getting Started with the AWS SDK for .NET nella AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET *Developer Guide*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class TrackMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide the bucket name ***";
private const string keyName = "*** provide the name for the uploaded object ***";
private const string filePath = " *** provide the full path name of the file to upload **";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
TrackMPUAsync().Wait();
}
private static async Task TrackMPUAsync()
{
try
{
var fileTransferUtility = new TransferUtility(s3Client);
// Use TransferUtilityUploadRequest to configure options.
// In this example we subscribe to an event.
var uploadRequest =
new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
Key = keyName
};
uploadRequest.UploadProgressEvent +=
new EventHandler
(uploadRequest_UploadPartProgressEvent);
await fileTransferUtility.UploadAsync(uploadRequest);
Console.WriteLine("Upload completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
static void uploadRequest_UploadPartProgressEvent(object sender, UploadProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
# Interruzione di un caricamento in più parti
Dopo aver avviato un caricamento in più parti, le parti vengono caricate. Amazon S3 memorizza queste parti e crea l'oggetto solo dopo aver caricato tutte le parti e aver inviato una richiesta per completare il caricamento multiparte. Quando riceve la richiesta di completamento del caricamento in più parti, Amazon S3 assembla le parti e crea un oggetto. Se la richiesta di caricamento multiparte completa non viene inviata correttamente, S3 non assembla le parti e non crea alcun oggetto. Se si desidera non completare un caricamento multiparte dopo aver caricato le parti, è necessario interrompere il caricamento multiparte.
Ti viene addebitato tutto lo spazio di storage associato alle parti caricate. Si consiglia di completare sempre il caricamento multiparte o di interromperlo per rimuovere le parti caricate. Per ulteriori informazioni sui prezzi, consultare [Caricamento in più parti e prezzi](mpuoverview.md#mpuploadpricing).
È inoltre possibile interrompere un caricamento in più parti incompleto utilizzando una configurazione del ciclo di vita del bucket. Per ulteriori informazioni, consulta [Configurazione del ciclo di vita del bucket per l'eliminazione dei caricamenti in più parti incompleti](mpu-abort-incomplete-mpu-lifecycle-config.md).
La sezione seguente mostra come interrompere un caricamento multiparte in corso in Amazon S3 utilizzando AWS Command Line Interface l'API REST o. AWS SDKs
## Usando il AWS CLI
Per ulteriori informazioni sull'utilizzo di AWS CLI per interrompere un caricamento in più parti, vedere [abort-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/abort-multipart-upload.html)nella Guida ai *AWS CLI comandi*.
## Utilizzo della REST API
Per ulteriori informazioni sull'utilizzo dell'API REST per interrompere un caricamento [AbortMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)in più parti, consulta *Amazon Simple Storage Service API Reference*.
## Utilizzo dell' AWS SDKs (API di alto livello)
------
#### [ Java ]
Per interrompere i caricamenti in più parti in corso utilizzando l' AWS SDK for Java, puoi interrompere i caricamenti iniziati prima di una data specificata e che sono ancora in corso. Un caricamento è considerato in esecuzione dopo l'avvio e finché non viene completato o interrotto.
Per arrestare i caricamenti in più parti, puoi:
| | |
| --- |--- |
| 1 | Creare un’istanza S3Client. |
| 2 | Utilizzare i metodi di interruzione del client passando il nome del bucket e altri parametri richiesti. |
**Nota**
È anche possibile interrompere un caricamento in più parti specifico. Per ulteriori informazioni, consulta [Utilizzo della AWS SDKs (API di basso livello)](#abort-mpu-low-level).
*Per esempi di come interrompere i caricamenti multiparte con l'SDK for AWS Java, [consulta Annullare un caricamento multiparte nel](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html) riferimento all'API Amazon S3.*
------
#### [ .NET ]
L'esempio di codice C\$1 seguente interrompe l'esecuzione di tutti i caricamenti in più parti avviati su un bucket nella settimana precedente. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta [Getting Started with the AWS SDK for .NET nella AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET *Developer Guide*.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class AbortMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
AbortMPUAsync().Wait();
}
private static async Task AbortMPUAsync()
{
try
{
var transferUtility = new TransferUtility(s3Client);
// Abort all in-progress uploads initiated before the specified date.
await transferUtility.AbortMultipartUploadsAsync(
bucketName, DateTime.Now.AddDays(-7));
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
**Nota**
È anche possibile interrompere un caricamento in più parti specifico. Per ulteriori informazioni, consulta [Utilizzo della AWS SDKs (API di basso livello)](#abort-mpu-low-level).
------
## Utilizzo della AWS SDKs (API di basso livello)
È possibile interrompere l'esecuzione di un caricamento in più parti chiamando il metodo `AmazonS3.abortMultipartUpload`. Questo metodo elimina tutte le parti che sono state caricate in Amazon S3 e libera le risorse. È necessario specificare l'ID di caricamento, il nome del bucket e il nome della chiave. Il seguente esempio di codice Java mostra come interrompere l'esecuzione di un caricamento in più parti.
Per interrompere un caricamento in più parti, devi fornire l'ID di caricamento e i nomi di bucket e chiave utilizzati nel caricamento. Dopo aver interrotto un caricamento in più parti, non puoi utilizzare l'ID di caricamento per caricare altre parti. Per ulteriori informazioni sui caricamenti in più parti di Amazon S3, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
------
#### [ Java ]
Per interrompere uno specifico caricamento multiparte in corso utilizzando l' AWS SDK for Java, puoi utilizzare l'API di basso livello per interrompere il caricamento fornendo il nome del bucket, la chiave dell'oggetto e l'ID di caricamento.
**Nota**
Invece di interrompere un caricamento in più parti specifico, è possibile arrestare tutti i caricamenti in più parti avviati prima di un orario specifico che sono ancora in corso. Questa operazione di pulizia è utile per interrompere caricamenti in più parti obsoleti che sono stati avviati ma che non sono stati completati o interrotti. Per ulteriori informazioni, consulta [Utilizzo dell' AWS SDKs (API di alto livello)](#abort-mpu-high-level).
*Per esempi di come interrompere un caricamento multiparte specifico con l' AWS SDK for Java, consulta [Annullare un caricamento multiparte nel](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html) riferimento alle API di Amazon S3.*
------
#### [ .NET ]
L'esempio di codice \$1C seguente mostra come interrompere un caricamento in più parti. Per un esempio in C\$1 completo che include il codice seguente, consulta [Utilizzo dell'API (di basso livello AWS SDKs )](mpu-upload-object.md#mpu-upload-low-level).
```
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = existingBucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await AmazonS3Client.AbortMultipartUploadAsync(abortMPURequest);
```
Puoi anche interrompere tutti i caricamenti in più parti in corso che sono stati avviati prima di un determinato orario. Questa operazione di pulizia è utile per interrompere caricamenti in più parti che non sono stati completati o interrotti. Per ulteriori informazioni, consulta [Utilizzo dell' AWS SDKs (API di alto livello)](#abort-mpu-high-level).
------
#### [ PHP ]
Questo esempio mostra come utilizzare una classe dalla versione 3 di AWS SDK per PHP per interrompere un caricamento in più parti in corso. Per ulteriori informazioni sull'API AWS SDK for Ruby, [AWS vai a SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Versione 2. Nell'esempio il metodo `abortMultipartUpload()`.
Per ulteriori informazioni sull'API AWS SDK for Ruby, [AWS vai a SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Versione 2.
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$uploadId = '*** Upload ID of upload to Abort ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Abort the multipart upload.
$s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
]);
```
------
# Copia di un oggetto utilizzando il caricamento in più parti
Il caricamento multiparte consente di copiare oggetti su un insieme di parti. Gli esempi in questa sezione mostrano come copiare oggetti con dimensioni superiori a 5 GB utilizzando l'API per il caricamento in più parti. Per informazioni sui caricamenti multiparte, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
È possibile copiare oggetti inferiori a 5 GB in una singola operazione senza utilizzare l'API di caricamento multiparte. Puoi copiare oggetti di dimensioni inferiori a 5 GB utilizzando l'API Console di gestione AWS, AWS CLI, REST o. AWS SDKs Per ulteriori informazioni, consulta [Copia, spostamento e denominazione di oggetti](copy-object.md).
Per una end-to-end procedura sul caricamento di un oggetto con caricamento in più parti con un checksum aggiuntivo, consulta. [Esercitazione: caricamento di un oggetto tramite caricamento multiparte per verificarne l'integrità dei dati](tutorial-s3-mpu-additional-checksums.md)
La sezione seguente mostra come copiare un oggetto con caricamento in più parti con l'API REST o. AWS SDKs
## Utilizzo della REST API
Le sezioni seguenti della *Documentazione di riferimento delle API di Amazon Simple Storage Service* descrivono REST API per il caricamento in più parti. Per copiare un oggetto esistente, utilizza l'API Upload Part (Copy) e specifica l'oggetto di origine aggiungendo l'intestazione `x-amz-copy-source` nella richiesta.
+ [Avvio del caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Upload Part (Copy)](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)
+ [Completamento del caricamento in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Abort Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [List Parts](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [Elenco dei caricamenti in più parti](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
Puoi usarli APIs per creare le tue richieste REST oppure puoi utilizzare una delle SDKs nostre. Per ulteriori informazioni sull'utilizzo di Multipart Upload con AWS CLI, consulta[Utilizzando il AWS CLI](mpu-upload-object.md#UsingCLImpUpload). Per ulteriori informazioni su SDKs, vedere[AWS Supporto SDK per il caricamento in più parti](mpuoverview.md#sdksupportformpu).
## Utilizzando il AWS SDKs
Per copiare un oggetto utilizzando l'API di basso livello, effettua le seguenti operazioni:
+ Avvia il caricamento in più parti chiamando il metodo `AmazonS3Client.initiateMultipartUpload()`.
+ Salvare l'ID caricamento dall'oggetto della risposta restituito dal metodo `AmazonS3Client.initiateMultipartUpload()`. Si fornisce questo ID di caricamento per ciascuna operazione di caricamento di parte.
+ Copia tutte le parti. Per ciascuna parte che è necessario copiare, creare una nuova istanza della classe `CopyPartRequest`. Fornisci le informazioni sulla parte, inclusi i nomi bucket di origine e destinazione, le chiavi dell'oggetto di origine e destinazione, l'ID di caricamento, le posizioni dei primi e degli ultimi byte della parte e il numero della parte.
+ Salva le risposte che il metodo `AmazonS3Client.copyPart()` chiama. Ogni risposta include il valore `ETag` e il numero della parte per la parte caricata. Tali informazioni saranno necessarie per completare il caricamento in più parti.
+ Chiama il metodo `AmazonS3Client.completeMultipartUpload()` per completare l'operazione di copia.
------
#### [ Java ]
Per esempi su come copiare oggetti utilizzando il caricamento in più parti con l' AWS SDK for Java, [consulta Copiare parte di un oggetto da un altro oggetto](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_UploadPartCopy_section.html) nel riferimento alle API di *Amazon S3*.
------
#### [ .NET ]
Il seguente esempio in C\$1 mostra come utilizzare SDK per .NET per copiare un oggetto Amazon S3 di dimensioni superiori a 5 GB da una posizione di origine a un'altra, ad esempio da un bucket all'altro. Per copiare gli oggetti con dimensioni inferiori a 5 GB, utilizza la procedura di copia in una sola operazione come descritto in [Usando il AWS SDKs](copy-object.md#CopyingObjectsUsingSDKs). Per ulteriori informazioni sui caricamenti in più parti di Amazon S3, consulta [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
Questo esempio mostra come copiare un oggetto Amazon S3 di dimensioni superiori a 5 GB da un bucket S3 a un altro utilizzando l' SDK per .NET API di caricamento multipart.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class CopyObjectUsingMPUapiTest
{
private const string sourceBucket = "*** provide the name of the bucket with source object ***";
private const string targetBucket = "*** provide the name of the bucket to copy the object to ***";
private const string sourceObjectKey = "*** provide the name of object to copy ***";
private const string targetObjectKey = "*** provide the name of the object copy ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Copying an object");
MPUCopyObjectAsync().Wait();
}
private static async Task MPUCopyObjectAsync()
{
// Create a list to store the upload part responses.
List uploadResponses = new List();
List copyResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest =
new InitiateMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Save the upload ID.
String uploadId = initResponse.UploadId;
try
{
// Get the size of the object.
GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest
{
BucketName = sourceBucket,
Key = sourceObjectKey
};
GetObjectMetadataResponse metadataResponse =
await s3Client.GetObjectMetadataAsync(metadataRequest);
long objectSize = metadataResponse.ContentLength; // Length in bytes.
// Copy the parts.
long partSize = 5 * (long)Math.Pow(2, 20); // Part size is 5 MB.
long bytePosition = 0;
for (int i = 1; bytePosition < objectSize; i++)
{
CopyPartRequest copyRequest = new CopyPartRequest
{
DestinationBucket = targetBucket,
DestinationKey = targetObjectKey,
SourceBucket = sourceBucket,
SourceKey = sourceObjectKey,
UploadId = uploadId,
FirstByte = bytePosition,
LastByte = bytePosition + partSize - 1 >= objectSize ? objectSize - 1 : bytePosition + partSize - 1,
PartNumber = i
};
copyResponses.Add(await s3Client.CopyPartAsync(copyRequest));
bytePosition += partSize;
}
// Set up to complete the copy.
CompleteMultipartUploadRequest completeRequest =
new CompleteMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(copyResponses);
// Complete the copy.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
# Esercitazione: caricamento di un oggetto tramite caricamento multiparte per verificarne l'integrità dei dati
Il caricamento in più parti consente di caricare un singolo oggetto come un insieme di parti. Ciascuna parte è una parte contigua dei dati dell'oggetto. È possibile caricare queste parti dell'oggetto in modo indipendente e in qualsiasi ordine. Se la trasmissione di una parte non riesce, è possibile ritrasmettere tale parte senza influire sulle altre. Una volta caricate tutte le parti dell'oggetto, Amazon S3 le assembla e crea l'oggetto. In generale, quando la dimensione dell'oggetto raggiunge i 100 MB, si consiglia di valutare la possibilità di eseguire caricamenti in più parti anziché caricare l'oggetto in una singola operazione. Per ulteriori informazioni sui caricamenti in più parti, consulta la sezione [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md). Per i limiti relativi ai caricamenti multiparte, consulta [Limiti del caricamenti in più parti di Amazon S3](qfacts.md).
È possibile utilizzare i checksum per verificare che le risorse non vengano alterate quando vengono copiate. L'esecuzione di un checksum consiste nell'utilizzare un algoritmo per iterare sequenzialmente su ogni byte di un file. Amazon S3 offre diverse opzioni di checksum per verificare l'integrità dei dati. Si consiglia di eseguire questi controlli di integrità come best practice di durata e per confermare che ogni byte viene trasferito senza alterazioni. Amazon S3 supporta anche i seguenti algoritmi: SHA-1, SHA-256 e C. CRC32 CRC32 Amazon S3 utilizza uno o più di questi algoritmi per calcolare un valore di checksum aggiuntivo e memorizzarlo come parte dei metadati dell'oggetto. Per ulteriori informazioni sui checksum, consulta [Verifica dell'integrità degli oggetti in Amazon S3](checking-object-integrity.md).
**Obiettivo**
In questo tutorial, imparerai come caricare un oggetto su Amazon S3 utilizzando un caricamento multiparte e un checksum SHA-256 aggiuntivo tramite l'interfaccia a AWS riga di comando (CLI).AWS Imparerai anche come verificare l'integrità dei dati dell'oggetto calcolando l' MD5hash e il checksum SHA-256 dell'oggetto caricato.
**Topics**
+ [
## Prerequisiti
](#mpu-prerequisites)
+ [
## Fase 1: creazione di un file di grandi dimensioni
](#create-large-file-step1)
+ [
## Fase 2: suddivisione del file in più file
](#split-large-file-step2)
+ [
## Fase 3: creazione del caricamento multiparte con checksum aggiuntivo
](#create-multipart-upload-step3)
+ [
## Fase 4: caricamento delle parti del caricamento multiparte
](#upload-parts-step4)
+ [
## Fase 5: elenco di tutte le parti del caricamento multiparte
](#list-parts-step5)
+ [
## Fase 6: completamento del caricamento multiparte
](#complete-multipart-upload-step6)
+ [
## Fase 7: conferma del fatto che l'oggetto è stato caricato nel proprio bucket
](#confirm-upload-step7)
+ [
## Fase 8: Verifica l'integrità dell'oggetto con un checksum MD5
](#verify-object-integrity-step8)
+ [
## Fase 9: verifica dell'integrità dell'oggetto con un checksum aggiuntivo
](#verify-object-integrity-sha256-step9)
+ [
## Fase 10: eliminare le risorse
](#clean-up-step10)
## Prerequisiti
+ Prima di iniziare questa esercitazione, assicurati di avere accesso a un bucket Amazon S3 su cui effettuare l'upload. Per ulteriori informazioni, consulta [Creazione di un bucket per uso generico](create-bucket-overview.md).
+ È necessario che la AWS CLI sia installata e configurata. Se non hai installato la CLI AWS , consulta [Installazione o aggiornamento alla versione più recente di AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html) nella *Guida all'utente AWS Command Line Interface *.
+ In alternativa, puoi eseguire i comandi AWS CLI dalla console utilizzando. AWS CloudShell AWS CloudShell è una shell preautenticata basata su browser che è possibile avviare direttamente da. Console di gestione AWS[Per ulteriori informazioni, consulta Cos'è? CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) e [Guida introduttiva AWS CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html) nella *Guida AWS CloudShell per l'utente*.
## Fase 1: creazione di un file di grandi dimensioni
Se hai già un file pronto per il caricamento, puoi utilizzarlo per questa esercitazione. In caso contrario, crea un file di 15 MB utilizzando i seguenti passaggi. Per i limiti relativi ai caricamenti multiparte, consulta [Limiti del caricamenti in più parti di Amazon S3](qfacts.md).
**Creazione un file di grandi dimensioni**
Per creare il file, utilizza uno dei seguenti comandi, a seconda del sistema operativo in uso.
**Linux o macOS**
Per creare un file da 15 MB, apri il terminale locale ed esegui il seguente comando:
```
dd if=/dev/urandom of=census-data.bin bs=1M count=15
```
Questo comando crea un file chiamato `census-data.bin` pieno di byte casuali, con una dimensione di 15 MB.
**Windows**
Per creare un file da 15 MB, apri il terminale locale ed esegui il seguente comando:
```
fsutil file createnew census-data.bin 15728640
```
Questo comando crea un file chiamato `census-data.bin` con una dimensione di 15 MB di dati arbitrari (15728640 byte).
## Fase 2: suddivisione del file in più file
Per eseguire il caricamento multiparte, è necessario dividere il file di grandi dimensioni in parti più piccole. È quindi possibile caricare le parti più piccole utilizzando il processo di caricamento multiparte. Questo passaggio mostra come suddividere il file di grandi dimensioni creato nella [Fase 1](#create-large-file-step1) in parti più piccole. L'esempio seguente utilizza un file di 15 MB denominato `census-data.bin`.
**Suddivisione di un file di grandi dimensioni in parti**
**Linux o macOS**
Per dividere il file di grandi dimensioni in parti da 5 MB, utilizza il comando `split`. Apri il terminale ed esegui il seguente comando:
```
split -b 5M -d census-data.bin census-part
```
Questo comando divide `census-data.bin` in parti da 5 MB denominate `census-part**`, dove `**` è un suffisso numerico che parte da `00`.
**Windows**
Per dividere il file di grandi dimensioni, usa PowerShell. Apri [Powershell](https://learn.microsoft.com/en-us/powershell/) ed esegui il seguente script:
```
$inputFile = "census-data.bin"
$outputFilePrefix = "census-part"
$chunkSize = 5MB
$fs = [System.IO.File]::OpenRead($inputFile)
$buffer = New-Object byte[] $chunkSize
$fileNumber = 0
while ($fs.Position -lt $fs.Length) {
$bytesRead = $fs.Read($buffer, 0, $chunkSize)
$outputFile = "{0}{1:D2}" -f $outputFilePrefix, $fileNumber
$fileStream = [System.IO.File]::Create($outputFile)
$fileStream.Write($buffer, 0, $bytesRead)
$fileStream.Close()
$fileNumber++
}
$fs.Close()
```
Questo PowerShell script legge il file di grandi dimensioni in blocchi di 5 MB e scrive ogni blocco in un nuovo file con un suffisso numerico.
Dopo aver eseguito il comando appropriato, si dovrebbero vedere le parti nella directory in cui è stato eseguito il comando. Ogni parte avrà un suffisso corrispondente al suo numero di parte, ad esempio:
```
census-part00 census-part01 census-part02
```
## Fase 3: creazione del caricamento multiparte con checksum aggiuntivo
Per iniziare il processo di caricamento multiparte, è necessario creare la richiesta di caricamento multiparte. Questa fase prevede l'avvio del caricamento multiparte e la specifica di un checksum aggiuntivo per l'integrità dei dati. L'esempio seguente utilizza il checksum SHA-256. Se si desidera fornire metadati che descrivono l'oggetto da caricare, è necessario fornirli nella richiesta di avvio del caricamento multiparte.
**Nota**
In questa fase e in quelle successive, l'esercitazione utilizza l'algoritmo aggiuntivo SHA-256. Facoltativamente, è possibile utilizzare un altro checksum aggiuntivo per questi passaggi, ad esempio C o SHA-1. CRC32 CRC32 Se si utilizza un algoritmo diverso, è necessario utilizzarlo per tutte le fasi dell'esercitazione.
**Per avviare il caricamento multiparte**
Nel terminale, utilizza il seguente comando `create-multipart-upload` per avviare un caricamento multiparte per il bucket. Sostituisci `amzn-s3-demo-bucket1` con il nome effettivo del bucket. Inoltre, sostituisci `census_data_file` con il nome del file scelto. Questo nome di file diventa la chiave dell'oggetto al termine del caricamento.
```
aws s3api create-multipart-upload --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --checksum-algorithm sha256
```
Se la richiesta ha successo, si vedrà un output JSON come il seguente:
```
{
"ServerSideEncryption": "AES256",
"ChecksumAlgorithm": "SHA256",
"Bucket": "amzn-s3-demo-bucket1",
"Key": "census_data_file",
"UploadId": "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz"
}
```
**Nota**
Quando invii una richiesta di avvio di un caricamento in più parti, Amazon S3 restituisce una risposta con un ID di caricamento, che è un identificativo univoco per il caricamento in più parti. È necessario includere questo ID di caricamento ogni volta che si caricano o si elencano le parti oppure ogni volta che si completa o si interrompe un caricamento. I valori `UploadId`, `Key` e `Bucket` dovranno essere utilizzati per le fasi successive per assicurarsi di salvarli.
Inoltre, se si utilizza il caricamento multiparte con checksum aggiuntivi, i numeri di parte devono essere consecutivi. Se si utilizzano numeri di parte non consecutivi, la richiesta `complete-multipart-upload` può determinare un HTTP `500 Internal Server Error`.
## Fase 4: caricamento delle parti del caricamento multiparte
In questa fase, si caricheranno le parti del caricamento multiparte sul bucket S3. Usa il comando `upload-part` per caricare ogni parte singolarmente. Questo processo richiede di specificare l'ID di caricamento, il numero di parte e il file da caricare per ogni parte.
**Per caricare le parti**
1. Quando si carica una parte, è necessario specificare un numero di parte oltre all'ID di caricamento usando l'argomento `--part-number`. È possibile scegliere qualsiasi numero compreso tra 1 e 10.000. Il numero della parte identifica in modo univoco una parte e la relativa posizione nell'oggetto che si sta caricando. Il numero di parte scelto non deve necessariamente essere in sequenza (ad esempio, può essere 1, 2 e 3). Se si carica una nuova parte che utilizza lo stesso numero di una parte caricata in precedenza, quest'ultima viene sovrascritta.
1. Usa il comando `upload-part` per caricare ogni parte del caricamento multiparte. `--upload-id` è lo stesso che si trovava nell'output creato dal comando `create-multipart-upload` nella [Fase 3](#create-multipart-upload-step3). Per caricare la prima parte dei dati, utilizza il seguente comando:
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number 1 --body census-part00 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
Al termine di ogni comando `upload-part`, si dovrebbe vedere un output come quello dell'esempio seguente:
```
{
"ServerSideEncryption": "AES256",
"ETag": "\"e611693805e812ef37f96c9937605e69\"",
"ChecksumSHA256": "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0="
}
```
1. Per le parti successive, incrementa il numero di parte di conseguenza:
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number --body --upload-id "" --checksum-algorithm SHA256
```
Ad esempio, utilizza il seguente comando per caricare la seconda parte:
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number 2 --body census-part01 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
Amazon S3 restituisce un tag di entità (ETag) e checksum aggiuntivi per ogni parte caricata come intestazione nella risposta.
1. Continua a usare il comando `upload-part` finché non si sono caricate tutte le parti dell'oggetto.
## Fase 5: elenco di tutte le parti del caricamento multiparte
Per completare il caricamento multiparte, è necessario un elenco di tutte le parti che sono state caricate per quel determinato caricamento multiparte. L'output del `list-parts` comando fornisce informazioni come il nome del bucket, la chiave, l'ID di caricamento, il numero di parte, checksum aggiuntivi e altro ETag ancora. È utile salvare questo risultato in un file, in modo da poterlo utilizzare per il passaggio successivo, quando si completa il processo di caricamento multiparte. È possibile creare un file di output JSON chiamato `parts.json` utilizzando il metodo seguente.
**Per creare un file che elenchi tutte le parti**
1. Per generare un file JSON con i dettagli di tutte le parti caricate, utilizza il seguente comando `list-parts`. Sostituisci ***amzn-s3-demo-bucket1*** con il nome effettivo del bucket e **** con l'ID di caricamento ricevuto nella [Fase 3](#create-multipart-upload-step3). Per ulteriori informazioni sul comando `list-parts` consulta [https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html) nella *Guida all'utente AWS Command Line Interface *.
```
aws s3api list-parts --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --upload-id --query '{Parts: Parts[*].{PartNumber: PartNumber, ETag: ETag, ChecksumSHA256: ChecksumSHA256}}' --output json > parts.json
```
Viene generato un nuovo file chiamato `parts.json`. Il file contiene le informazioni formattate in JSON di tutte le parti caricate. Il `parts.json` file include informazioni essenziali per ogni parte del caricamento in più parti, come i numeri di parte e i ETag valori corrispondenti, necessari per completare il processo di caricamento in più parti.
1. Apri `parts.json` utilizzando un qualsiasi editor di testo o tramite il terminale. Ecco l'esempio di output:
```
{
"Parts": [
{
"PartNumber": 1,
"ETag": "\"3c3097f89e2a2fece47ac54b243c9d97\"",
"ChecksumSHA256": "fTPVHfyNHdv5VkR4S3EewdyioXECv7JBxN+d4FXYYTw="
},
{
"PartNumber": 2,
"ETag": "\"03c71cc160261b20ab74f6d2c476b450\"",
"ChecksumSHA256": "VDWTa8enjOvULBAO3W2a6C+5/7ZnNjrnLApa1QVc3FE="
},
{
"PartNumber": 3,
"ETag": "\"81ae0937404429a97967dffa7eb4affb\"",
"ChecksumSHA256": "cVVkXehUlzcwrBrXgPIM+EKQXPUvWist8mlUTCs4bg8="
}
]
}
```
## Fase 6: completamento del caricamento multiparte
Dopo aver caricato tutte le parti del caricamento multiparte e averle elencate, il passaggio finale consiste nel completare il caricamento multiparte. Questo passaggio unisce tutte le parti caricate in un unico oggetto nel bucket S3.
**Nota**
È possibile calcolare il checksum dell'oggetto prima di chiamare `complete-multipart-upload`, includendo `--checksum-sha256` nella richiesta. Se i checksum non corrispondono, Amazon S3 rifiuta la richiesta. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html) nella *Guida per l'utente di AWS Command Line Interface *.
**Per completare il caricamento multiparte**
Per finalizzare il caricamento multiparte, utilizza il comando `complete-multipart-upload`. Questo comando richiede il file `parts.json` creato nella [Fase 5](#list-parts-step5), il nome del bucket e l'ID di caricamento. Sostituisci **<*amzn-s3-demo-bucket1*>** con il nome del bucket e **** con l'ID di caricamento di `parts.json`.
```
aws s3api complete-multipart-upload --multipart-upload file://parts.json --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --upload-id
```
Ecco l'esempio di output:
```
{
"ServerSideEncryption": "AES256",
"Location": "https://amzn-s3-demo-bucket1.s3.us-east-2.amazonaws.com/census_data_file",
"Bucket": "amzn-s3-demo-bucket1",
"Key": "census_data_file",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3"
}
```
**Nota**
Non eliminare ancora i file delle singole parti. È necessario disporre delle singole parti, in modo da poter eseguire checksum su di esse per verificare l'integrità dell'oggetto unito.
## Fase 7: conferma del fatto che l'oggetto è stato caricato nel proprio bucket
Dopo aver completato il caricamento multiparte, è possibile verificare che l'oggetto sia stato caricato correttamente sul bucket S3. Per elencare gli oggetti nel bucket e confermare la presenza del file appena caricato, utilizza il comando `list-objects-v2`
**Per elencare l'oggetto caricato**
Per elencare gli oggetti presenti, utilizza il comando `list-objects-v2` del bucket. Sostituisci ***amzn-s3-demo-bucket1*** con il nome effettivo del bucket:
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-bucket1
```
Questo comando restituisce un elenco di oggetti presenti nel bucket. Cerca il file caricato (ad esempio, `census_data_file`) nell'elenco degli oggetti.
Per ulteriori informazioni, consulta la sezione [Esempi](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects-v2.html) del comando `list-objects-v2` nella *Guida all'utente AWS Command Line Interface *.
## Fase 8: Verifica l'integrità dell'oggetto con un checksum MD5
Quando si carica un oggetto, è possibile specificare un algoritmo di checksum da utilizzare per Amazon S3. Per impostazione predefinita, Amazon S3 memorizza il MD5 digest di byte come oggetto. ETag Per i caricamenti in più parti, non ETag è il checksum per l'intero oggetto, ma piuttosto un insieme di checksum per ogni singola parte.
**Per verificare l'integrità dell'oggetto utilizzando un checksum MD5**
1. Per recuperare l' ETag oggetto caricato, esegui una `head-object` richiesta:
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key census_data_file
```
Ecco l'esempio di output:
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
Alla fine viene ETag aggiunto «-3". Questo indica che l'oggetto è stato caricato in tre parti utilizzando il caricamento multiparte.
1. Quindi, calcola il MD5 checksum di ogni parte usando il comando. `md5sum` Assicurati di fornire il percorso corretto dei file delle parti:
```
md5sum census-part*
```
Ecco l'esempio di output:
```
e611693805e812ef37f96c9937605e69 census-part00
63d2d5da159178785bfd6b6a5c635854 census-part01
95b87c7db852451bb38b3b44a4e6d310 census-part02
```
1. Per questo passaggio, combina manualmente gli MD5 hash in un'unica stringa. Quindi, esegui il comando seguente per convertire la stringa in binario e calcolare il MD5 checksum del valore binario:
```
echo "e611693805e812ef37f96c9937605e6963d2d5da159178785bfd6b6a5c63585495b87c7db852451bb38b3b44a4e6d310" | xxd -r -p | md5sum
```
Ecco l'esempio di output:
```
f453c6dccca969c457efdf9b1361e291 -
```
Questo valore hash deve corrispondere al valore hash del ETag valore originale nel [passaggio 1](#create-large-file-step1), che convalida l'integrità dell'oggetto. `census_data_file`
Quando chiedi ad Amazon S3 di utilizzare checksum aggiuntivi, Amazon S3 calcola il valore del checksum per ogni parte e archivia i valori. Se si desidera recuperare i valori di checksum per le singole parti dei caricamenti multiparte mentre sono ancora in corso, si può usare `list-parts`.
Per ulteriori informazioni sul funzionamento dei checksum con gli oggetti di caricamento multiparte, consulta [Verifica dell'integrità degli oggetti in Amazon S3](checking-object-integrity.md).
## Fase 9: verifica dell'integrità dell'oggetto con un checksum aggiuntivo
In questo passaggio, l'esercitazione utilizza SHA-256 come checksum aggiuntivo per convalidare l'integrità dell'oggetto. Se è stato utilizzato un checksum aggiuntivo diverso, utilizza invece quel valore di checksum.
**Per verificare l'integrità dell'oggetto con SHA256**
1. Esegui il seguente comando nel terminale, includendo l'argomento `--checksum-mode enabled`, per visualizzare il valore `ChecksumSHA256` dell'oggetto:
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key census_data_file --checksum-mode enabled
```
Ecco l'esempio di output:
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
1. Usa i seguenti comandi per decodificare i valori `ChecksumSHA256` delle singole parti in base64 e salvarli in un file binario chiamato `outfile`. Questi valori si trovano nel file `parts.json`. Sostituisci le stringhe base64 di esempio con i valori reali di `ChecksumSHA256`.
```
echo "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0=" | base64 --decode >> outfile
echo "xCdgs1K5Bm4jWETYw/CmGYr+m6O2DcGfpckx5NVokvE=" | base64 --decode >> outfile
echo "f5wsfsa5bB+yXuwzqG1Bst91uYneqGD3CCidpb54mAo=" | base64 --decode >> outfile
```
1. Esegui il comando seguente per calcolare il SHA256 checksum di`outfile`:
```
sha256sum outfile
```
Ecco l'esempio di output:
```
688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9 outfile
```
Nella fase successiva, si prende il valore hash e lo si converte in un valore binario. Questo valore binario deve corrispondere al valore `ChecksumSHA256` della [Fase 1](#create-large-file-step1).
1. [Convertite il SHA256 checksum del [passaggio 3](#create-multipart-upload-step3) in binario, quindi codificatelo in base64 per verificare che corrisponda al valore del `ChecksumSHA256` passaggio 1:](#create-large-file-step1)
```
echo "688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9" | xxd -r -p | base64
```
Ecco l'esempio di output:
```
aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=
```
Questo risultato dovrebbe confermare che l'output base64 corrisponde al valore `ChecksumSHA256` dall'output del comando `head-object`. Se l'output corrisponde al valore del checksum, l'oggetto è valido.
**Importante**
Quando si indica ad Amazon S3 di utilizzare checksum aggiuntivi, Amazon S3 calcola il valore di checksum per ogni parte e memorizza i valori.
Se si desidera recuperare i valori di checksum per le singole parti dei caricamenti multiparte mentre sono ancora in corso, si può usare il comando `list-parts`.
## Fase 10: eliminare le risorse
Se desideri ripulire i file creati in questa esercitazione, utilizza il metodo seguente. Per istruzioni sull'eliminazione dei file caricati sul bucket S3, consulta [Eliminazione di oggetti Amazon S3](DeletingObjects.md).
**Elimina i file locali creati nella [Fase 1](#create-large-file-step1):**
Per rimuovere i file creati per il caricamento multiparte, esegui il seguente comando dalla tua directory di lavoro:
```
rm census-data.bin census-part* outfile parts.json
```
# Limiti del caricamenti in più parti di Amazon S3
Il caricamento in più parti consente di caricare un singolo oggetto come un insieme di parti. Ciascuna parte è una parte contigua dei dati dell'oggetto. Una volta caricate tutte le parti dell'oggetto, Amazon S3 le assembla e crea l'oggetto. In generale, quando la dimensione dell'oggetto raggiunge i 100 MB, si consiglia di valutare la possibilità di eseguire caricamenti in più parti anziché caricare l'oggetto in una singola operazione. Per ulteriori informazioni sui caricamenti in più parti, consulta la sezione [Caricamento e copia di oggetti utilizzando il caricamento multiparte in Amazon S3](mpuoverview.md).
La tabella riportata di seguito fornisce le specifiche di base di un caricamento in più parti. Ciò include la dimensione massima dell'oggetto, il numero massimo di parti, la dimensione massima delle parti e altro. Non vi è alcun limite minimo di dimensione per l'ultima parte del caricamento in più parti.
| Elemento | Specifica |
| --- | --- |
| Dimensione massima oggetto | 48,8 TiB |
| Numero massimo di parti per caricamento | 10.000 |
| Numeri delle parti | Da 1 a 10.000 (inclusi) |
| Dimensione parte | Da 5 MiB a 5 GiB. Non vi è alcun limite minimo di dimensione per l'ultima parte del caricamento in più parti. |
| Numero massimo di parti restituite per una richiesta di elenco delle parti | 1000 |
| Numero massimo di caricamenti in più parti restituiti per una richiesta di elenco dei caricamenti in più parti | 1000 |