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à.
# 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
```