Verifica dell'integrità degli oggetti - Amazon Simple Storage Service

Verifica dell'integrità degli oggetti

Amazon S3 utilizza i valori di checksum per verificare l'integrità dei dati da caricare o scaricare da Amazon S3. Inoltre, puoi richiedere che venga calcolato un altro valore di checksum per qualsiasi oggetto da archiviare in Amazon S3. Puoi selezionare uno dei diversi algoritmi di checksum per utilizzarlo durante il caricamento o la copia dei dati. Amazon S3 usa questo algoritmo per calcolare un valore di checksum aggiuntivo e archiviarlo come parte dei metadati dell'oggetto.

Quando carichi un oggetto, puoi facoltativamente includere un checksum precalcolato come parte della richiesta. Amazon S3 confronta il checksum fornito con il checksum calcolato utilizzando l'algoritmo specificato. Se i due valori non corrispondono, Amazon S3 genera un errore.

Utilizzo di algoritmi di checksum supportati

Amazon S3 ti offre la possibilità di scegliere l'algoritmo di checksum da usare per convalidare i tuoi dati durante il caricamento o il download. Puoi selezionare uno dei seguenti algoritmi di controllo dell'integrità dei dati Secure Hash Algorithms (SHA) o Cyclic Redundancy Check (CRC):

  • CRC32

  • CRC32C

  • SHA-1

  • SHA-256

Quando carichi un oggetto, puoi specificare l'algoritmo da utilizzare:

  • Quando usi la AWS Management Console selezioni l'algoritmo di checksum che desideri utilizzare. Puoi inoltre facoltativamente specificare il valore di checksum dell'oggetto. Quando Amazon S3 riceve l'oggetto, calcola il checksum utilizzando l'algoritmo specificato. Se i due valori di checksum non corrispondono, Amazon S3 genera un errore.

  • Quando usi un SDK puoi impostare il valore del parametro x-amz-sdk-checksum-algorithmsull'algoritmo che Amazon S3 deve utilizzare per il calcolo del checksum. Amazon S3 calcola automaticamente il valore del checksum.

  • Quando usi REST API non utilizzi il parametro x-amz-sdk-checksum-algorithm. Usi invece una delle intestazioni specifiche dell'algoritmo (ad esempio, x-amz-checksum-crc32).

Per ulteriori informazioni sul caricamento degli oggetti, consulta Caricamento degli oggetti.

Per applicare uno di questi valori di checksum agli oggetti già caricati su Amazon S3, puoi copiare l'oggetto. Quando copi un oggetto puoi specificare se vuoi utilizzare l'algoritmo di checksum esistente o utilizzarne uno nuovo. Puoi specificare un algoritmo di checksum quando si utilizza qualsiasi meccanismo supportato per la copia di oggetti, incluso S3 Batch Operations (Operazioni di batch S3). Per ulteriori informazioni sulle operazioni in batch, consulta Esecuzione di operazioni in batch su larga scala su oggetti Amazon S3.

Importante

Se utilizzi un caricamento in più parti con checksum aggiuntivi, i numeri delle parti in più parti devono essere consecutivi. Quando usi i checksum aggiuntivi, se tenti di completare una richiesta di caricamento in più parti con numeri parte non consecutivi, Amazon S3 genera un errore HTTP 500 Internal Server Error.

Dopo aver caricato gli oggetti puoi ottenere il valore di checksum e confrontarlo con un valore di checksum precalcolato o precedentemente archiviato calcolato utilizzando lo stesso algoritmo.

Per ulteriori informazioni sull'utilizzo della console e sulla specifica degli algoritmi di checksum da usare durante il caricamento degli oggetti, consulta Caricamento degli oggetti

L'esempio seguente mostra come puoi utilizzare gli SDK AWS per caricare un file di grandi dimensioni con il caricamento in più parti, scaricare un file di grandi dimensioni e convalidare un file di caricamento in più parti, il tutto utilizzando SHA-256 per la convalida del file.

Java
Esempio: caricamento, download e verifica di un file di grandi dimensioni con SHA-256

Per istruzioni su come creare e testare un esempio di utilizzo, consulta Test degli esempi di codice Java di Amazon S3.

import software.amazon.awssdk.auth.credentials.AwsCredentials; import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider; import software.amazon.awssdk.core.ResponseInputStream; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.AbortMultipartUploadRequest; import software.amazon.awssdk.services.s3.model.ChecksumAlgorithm; import software.amazon.awssdk.services.s3.model.ChecksumMode; import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest; import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadResponse; import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload; import software.amazon.awssdk.services.s3.model.CompletedPart; import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest; import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse; import software.amazon.awssdk.services.s3.model.GetObjectAttributesRequest; import software.amazon.awssdk.services.s3.model.GetObjectAttributesResponse; import software.amazon.awssdk.services.s3.model.GetObjectRequest; import software.amazon.awssdk.services.s3.model.GetObjectResponse; import software.amazon.awssdk.services.s3.model.GetObjectTaggingRequest; import software.amazon.awssdk.services.s3.model.ObjectAttributes; import software.amazon.awssdk.services.s3.model.PutObjectTaggingRequest; import software.amazon.awssdk.services.s3.model.Tag; import software.amazon.awssdk.services.s3.model.Tagging; import software.amazon.awssdk.services.s3.model.UploadPartRequest; import software.amazon.awssdk.services.s3.model.UploadPartResponse; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.nio.ByteBuffer; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.ArrayList; import java.util.Base64; import java.util.List; public class LargeObjectValidation { private static String FILE_NAME = "sample.file"; private static String BUCKET = "sample-bucket"; //Optional, if you want a method of storing the full multipart object checksum in S3. private static String CHECKSUM_TAG_KEYNAME = "fullObjectChecksum"; //If you have existing full-object checksums that you need to validate against, you can do the full object validation on a sequential upload. private static String SHA256_FILE_BYTES = "htCM5g7ZNdoSw8bN/mkgiAhXt5MFoVowVg+LE9aIQmI="; //Example Chunk Size - this must be greater than or equal to 5MB. private static int CHUNK_SIZE = 5 * 1024 * 1024; public static void main(String[] args) { S3Client s3Client = S3Client.builder() .region(Region.US_EAST_1) .credentialsProvider(new AwsCredentialsProvider() { @Override public AwsCredentials resolveCredentials() { return new AwsCredentials() { @Override public String accessKeyId() { return Constants.ACCESS_KEY; } @Override public String secretAccessKey() { return Constants.SECRET; } }; } }) .build(); uploadLargeFileBracketedByChecksum(s3Client); downloadLargeFileBracketedByChecksum(s3Client); validateExistingFileAgainstS3Checksum(s3Client); } public static void uploadLargeFileBracketedByChecksum(S3Client s3Client) { System.out.println("Starting uploading file validation"); File file = new File(FILE_NAME); try (InputStream in = new FileInputStream(file)) { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder() .bucket(BUCKET) .key(FILE_NAME) .checksumAlgorithm(ChecksumAlgorithm.SHA256) .build(); CreateMultipartUploadResponse createdUpload = s3Client.createMultipartUpload(createMultipartUploadRequest); List<CompletedPart> completedParts = new ArrayList<CompletedPart>(); int partNumber = 1; byte[] buffer = new byte[CHUNK_SIZE]; int read = in.read(buffer); while (read != -1) { UploadPartRequest uploadPartRequest = UploadPartRequest.builder() .partNumber(partNumber).uploadId(createdUpload.uploadId()).key(FILE_NAME).bucket(BUCKET).checksumAlgorithm(ChecksumAlgorithm.SHA256).build(); UploadPartResponse uploadedPart = s3Client.uploadPart(uploadPartRequest, RequestBody.fromByteBuffer(ByteBuffer.wrap(buffer, 0, read))); CompletedPart part = CompletedPart.builder().partNumber(partNumber).checksumSHA256(uploadedPart.checksumSHA256()).eTag(uploadedPart.eTag()).build(); completedParts.add(part); sha256.update(buffer, 0, read); read = in.read(buffer); partNumber++; } String fullObjectChecksum = Base64.getEncoder().encodeToString(sha256.digest()); if (!fullObjectChecksum.equals(SHA256_FILE_BYTES)) { //Because the SHA256 is uploaded after the part is uploaded; the upload is bracketed and the full object can be fully validated. s3Client.abortMultipartUpload(AbortMultipartUploadRequest.builder().bucket(BUCKET).key(FILE_NAME).uploadId(createdUpload.uploadId()).build()); throw new IOException("Byte mismatch between stored checksum and upload, do not proceed with upload and cleanup"); } CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder().parts(completedParts).build(); CompleteMultipartUploadResponse completedUploadResponse = s3Client.completeMultipartUpload( CompleteMultipartUploadRequest.builder().bucket(BUCKET).key(FILE_NAME).uploadId(createdUpload.uploadId()).multipartUpload(completedMultipartUpload).build()); Tag checksumTag = Tag.builder().key(CHECKSUM_TAG_KEYNAME).value(fullObjectChecksum).build(); //Optionally, if you need the full object checksum stored with the file; you could add it as a tag after completion. s3Client.putObjectTagging(PutObjectTaggingRequest.builder().bucket(BUCKET).key(FILE_NAME).tagging(Tagging.builder().tagSet(checksumTag).build()).build()); } catch (IOException | NoSuchAlgorithmException e) { e.printStackTrace(); } GetObjectAttributesResponse objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME) .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build()); System.out.println(objectAttributes.objectParts().parts()); System.out.println(objectAttributes.checksum().checksumSHA256()); } public static void downloadLargeFileBracketedByChecksum(S3Client s3Client) { System.out.println("Starting downloading file validation"); File file = new File("DOWNLOADED_" + FILE_NAME); try (OutputStream out = new FileOutputStream(file)) { GetObjectAttributesResponse objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME) .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build()); //Optionally if you need the full object checksum, you can grab a tag you added on the upload List<Tag> objectTags = s3Client.getObjectTagging(GetObjectTaggingRequest.builder().bucket(BUCKET).key(FILE_NAME).build()).tagSet(); String fullObjectChecksum = null; for (Tag objectTag : objectTags) { if (objectTag.key().equals(CHECKSUM_TAG_KEYNAME)) { fullObjectChecksum = objectTag.value(); break; } } MessageDigest sha256FullObject = MessageDigest.getInstance("SHA-256"); MessageDigest sha256ChecksumOfChecksums = MessageDigest.getInstance("SHA-256"); //If you retrieve the object in parts, and set the ChecksumMode to enabled, the SDK will automatically validate the part checksum for (int partNumber = 1; partNumber <= objectAttributes.objectParts().totalPartsCount(); partNumber++) { MessageDigest sha256Part = MessageDigest.getInstance("SHA-256"); ResponseInputStream<GetObjectResponse> response = s3Client.getObject(GetObjectRequest.builder().bucket(BUCKET).key(FILE_NAME).partNumber(partNumber).checksumMode(ChecksumMode.ENABLED).build()); GetObjectResponse getObjectResponse = response.response(); byte[] buffer = new byte[CHUNK_SIZE]; int read = response.read(buffer); while (read != -1) { out.write(buffer, 0, read); sha256FullObject.update(buffer, 0, read); sha256Part.update(buffer, 0, read); read = response.read(buffer); } byte[] sha256PartBytes = sha256Part.digest(); sha256ChecksumOfChecksums.update(sha256PartBytes); //Optionally, you can do an additional manual validation again the part checksum if needed in addition to the SDK check String base64PartChecksum = Base64.getEncoder().encodeToString(sha256PartBytes); String base64PartChecksumFromObjectAttributes = objectAttributes.objectParts().parts().get(partNumber - 1).checksumSHA256(); if (!base64PartChecksum.equals(getObjectResponse.checksumSHA256()) || !base64PartChecksum.equals(base64PartChecksumFromObjectAttributes)) { throw new IOException("Part checksum didn't match for the part"); } System.out.println(partNumber + " " + base64PartChecksum); } //Before finalizing, do the final checksum validation. String base64FullObject = Base64.getEncoder().encodeToString(sha256FullObject.digest()); String base64ChecksumOfChecksums = Base64.getEncoder().encodeToString(sha256ChecksumOfChecksums.digest()); if (fullObjectChecksum != null && !fullObjectChecksum.equals(base64FullObject)) { throw new IOException("Failed checksum validation for full object"); } System.out.println(fullObjectChecksum); String base64ChecksumOfChecksumFromAttributes = objectAttributes.checksum().checksumSHA256(); if (base64ChecksumOfChecksumFromAttributes != null && !base64ChecksumOfChecksums.equals(base64ChecksumOfChecksumFromAttributes)) { throw new IOException("Failed checksum validation for full object checksum of checksums"); } System.out.println(base64ChecksumOfChecksumFromAttributes); out.flush(); } catch (IOException | NoSuchAlgorithmException e) { //Cleanup bad file file.delete(); e.printStackTrace(); } } public static void validateExistingFileAgainstS3Checksum(S3Client s3Client) { System.out.println("Starting existing file validation"); File file = new File("DOWNLOADED_" + FILE_NAME); GetObjectAttributesResponse objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME) .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build()); try (InputStream in = new FileInputStream(file)) { MessageDigest sha256ChecksumOfChecksums = MessageDigest.getInstance("SHA-256"); MessageDigest sha256Part = MessageDigest.getInstance("SHA-256"); byte[] buffer = new byte[CHUNK_SIZE]; int currentPart = 0; int partBreak = objectAttributes.objectParts().parts().get(currentPart).size(); int totalRead = 0; int read = in.read(buffer); while (read != -1) { totalRead += read; if (totalRead >= partBreak) { int difference = totalRead - partBreak; byte[] partChecksum; if (totalRead != partBreak) { sha256Part.update(buffer, 0, read - difference); partChecksum = sha256Part.digest(); sha256ChecksumOfChecksums.update(partChecksum); sha256Part.reset(); sha256Part.update(buffer, read - difference, difference); } else { sha256Part.update(buffer, 0, read); partChecksum = sha256Part.digest(); sha256ChecksumOfChecksums.update(partChecksum); sha256Part.reset(); } String base64PartChecksum = Base64.getEncoder().encodeToString(partChecksum); if (!base64PartChecksum.equals(objectAttributes.objectParts().parts().get(currentPart).checksumSHA256())) { throw new IOException("Part checksum didn't match S3"); } currentPart++; System.out.println(currentPart + " " + base64PartChecksum); if (currentPart < objectAttributes.objectParts().totalPartsCount()) { partBreak += objectAttributes.objectParts().parts().get(currentPart - 1).size(); } } else { sha256Part.update(buffer, 0, read); } read = in.read(buffer); } if (currentPart != objectAttributes.objectParts().totalPartsCount()) { currentPart++; byte[] partChecksum = sha256Part.digest(); sha256ChecksumOfChecksums.update(partChecksum); String base64PartChecksum = Base64.getEncoder().encodeToString(partChecksum); System.out.println(currentPart + " " + base64PartChecksum); } String base64CalculatedChecksumOfChecksums = Base64.getEncoder().encodeToString(sha256ChecksumOfChecksums.digest()); System.out.println(base64CalculatedChecksumOfChecksums); System.out.println(objectAttributes.checksum().checksumSHA256()); if (!base64CalculatedChecksumOfChecksums.equals(objectAttributes.checksum().checksumSHA256())) { throw new IOException("Full object checksum of checksums don't match S3"); } } catch (IOException | NoSuchAlgorithmException e) { e.printStackTrace(); } } }

Puoi inviare richieste REST per caricare un oggetto con un valore di checksum per verificare l'integrità dei dati con PutObject. È inoltre possibile recuperare il valore di checksum per gli oggetti utilizzando GetObject o HeadObject.

È possibile inviare una richiesta PUT per caricare un oggetto di un massimo di 5 GB in una singola operazione. Per ulteriori informazioni, consulta PutObject nella Documentazione di riferimento per i comandi di AWS CLI. Puoi utilizzare anche get-object e head-object per recuperare il checksum di un oggetto già caricato per verificare l'integrità dei dati.

Utilizzo di Content-MD5 durante il caricamento di oggetti

Un altro modo per verificare l'integrità dell'oggetto dopo il caricamento consiste nel fornire un digest MD5 dell'oggetto durante il caricamento. Se calcoli il digest MD5 dell'oggetto, puoi fornire il digest con il comando PUTutilizzando l'intestazione Content-MD5.

Dopo aver caricato l'oggetto, Amazon S3 calcola il digest MD5 dell'oggetto e lo confronta con il valore fornito. La richiesta ha esito positivo solo se i due digest corrispondono.

Non è obbligatorio fornire un digest MD5, ma è possibile utilizzarlo per verificare l'integrità dell'oggetto come parte del processo di caricamento.

Utilizzo di Content-MD5 e di ETag per verificare gli oggetti caricati

Il tag di entità (ETag) di un oggetto rappresenta una versione specifica di tale oggetto. L'ETag riflette solo i cambiamenti al contenuto di un oggetto, non i suoi metadati. Se cambiano solo i metadati di un oggetto, l'ETag rimane invariato.

In base all'oggetto, l'ETag dell'oggetto potrebbe essere un digest MD5 dei dati dell'oggetto:

  • Se un oggetto viene creato dall'operazione PUT Object, POST Object o Copy oppure attraverso la AWS Management Console e l'oggetto è anche in testo normale o crittografato tramite la crittografia lato server con chiavi gestite da Amazon S3 (SSE-S3), l'oggetto ha un ETag che è un digest MD5 dei dati dell'oggetto.

  • Se un oggetto viene creato dall'operazione PUT Object, POST Object o Copy oppure attraverso la AWS Management Console e l'oggetto è crittografato tramite la crittografia lato server con chiavi fornite dal cliente (SSE-C) o la crittografia lato server con chiavi AWS Key Management Service (AWS KMS) (SSE-KMS), l'oggetto ha un ETag che non è un digest MD5 dei dati dell'oggetto.

  • Se un oggetto viene creato dall'operazione Multipart Upload o Part Copy, l'ETag dell'oggetto non è un digest MD5, indipendentemente dal metodo di crittografia. Se un oggetto è più grande di 16 MB, la AWS Management Console carica o copia l'oggetto come caricamento in più parti e quindi l'ETag non è un digest MD5.

Per gli oggetti in cui l'ETag è il digest Content-MD5 dell'oggetto, puoi confrontare il valore ETag dell'oggetto con un digest Content-MD5 calcolato o precedentemente archiviato.

Utilizzo dei checksum finali

Quando si caricano oggetti in Amazon S3, puoi fornire un checksum precalcolato per l'oggetto o utilizzare un SDK AWS per creare automaticamente i checksum finali. Se decidi di utilizzare un checksum finale, Amazon S3 genera automaticamente il checksum utilizzando l'algoritmo specificato e lo utilizza per convalidare l'integrità dell'oggetto durante il caricamento.

Per creare un checksum finale quando si utilizza un SDK AWS, compila il parametro ChecksumAlgorithmcon l'algoritmo preferito. L'SDK utilizza l'algoritmo per calcolare il checksum dell'oggetto (o delle parti dell'oggetto) e lo aggiunge automaticamente alla fine della richiesta di caricamento. Questo comportamento ti consente di risparmiare tempo perché Amazon S3 esegue sia la verifica che il caricamento dei tuoi dati in un unico passaggio.

Importante

Se utilizzi S3 Object Lambda, tutte le richieste a S3 Object Lambda vengono firmate tramite s3-object-lambda anziché s3. Questo comportamento influisce sulla firma dei valori di checksum finali. Per ulteriori informazioni su S3 Object Lambda, consulta Trasformazione di oggetti con S3 Object Lambda.

Utilizzo di checksum a livello di parte per caricamenti in più parti

È possibile caricare gli oggetti in Amazon S3 come un singolo oggetto o tramite il processo di caricamento in più parti. Gli oggetti di dimensioni superiori a 16 MB che vengono caricati tramite la console, vengono caricati automaticamente utilizzando i caricamenti in più parti. Per ulteriori informazioni sui caricamenti in più parti, consulta la sezione Caricamento e copia di oggetti utilizzando il caricamento in più parti.

Quando un oggetto viene caricato come caricamento in più parti, l'ETag dell'oggetto non è un digest MD5 dell'intero oggetto. Amazon S3 calcola il digest MD5 di ogni singola parte durante il caricamento. I digest MD5 vengono utilizzati per determinare l'ETag dell'oggetto finale. Amazon S3 concatena i byte per i digest MD5 e quindi calcola il digest MD5 di questi valori concatenati. Il passaggio finale della creazione dell'ETag consiste nell'aggiunta da parte di Amazon S3 di un trattino con il numero totale di parti alla fine.

Ad esempio, considera un oggetto caricato con un caricamento in più parti con un ETag di C9A5A6878D97B48CC965C1E41859F034-14. In questo caso, C9A5A6878D97B48CC965C1E41859F034 è il digest MD5 di tutti i digest concatenati. La -14 indica che ci sono 14 parti associate al caricamento in più parti di questo oggetto.

Se hai abilitato ulteriori valori di checksum per il tuo oggetto in più parti, Amazon S3 calcola il checksum di ogni singola parte utilizzando l'algoritmo di checksum specificato. Il checksum per l'oggetto completato viene calcolato nello stesso modo in cui Amazon S3 calcola il digest MD5 per il caricamento in più parti. È possibile utilizzare questo checksum per verificare l'integrità dell'oggetto.

Per recuperare le informazioni sull'oggetto, incluso il numero di parti che compongono l'intero oggetto, puoi utilizzare l'operazione GetObjectAttributes. Con i checksum aggiuntivi, puoi recuperare anche le informazioni di ogni singola parte, incluso il valore di checksum di ciascuna parte.

In alternativa, è possibile ottenere il checksum di una singola parte utilizzando l'operazione GetObject o HeadObject e specificando un numero di parte o un intervallo di byte che si allinea a una singola parte. Con questo metodo, puoi utilizzare il checksum per convalidare la singola parte senza dover attendere che tutte le parti finiscano il caricamento prima di verificare l'integrità dei dati. Quando usi questo metodo, puoi anche richiedere solo le singole parti che non hanno passato il test di integrità.

A causa del modo in cui Amazon S3 calcola il checksum per gli oggetti in più parti, il valore del checksum dell'oggetto potrebbe cambiare se lo si copia. Se stai utilizzando un SDK o REST API e chiami CopyObject, Amazon S3 copia qualsiasi oggetto fino alle limitazioni di dimensioni dell'operazione API CopyObject. Amazon S3 esegue questa copia come un'unica operazione, indipendentemente dal fatto che l'oggetto sia stato caricato in una singola richiesta o come parte di un caricamento in più parti. Con il comando copy, il checksum dell'oggetto è un checksum diretto dell'oggetto completo. Se l'oggetto è stato originariamente caricato utilizzando un caricamento in più parti, il valore del checksum cambia anche se i dati non sono stati modificati.

Nota

Gli oggetti che sono più grandi delle limitazioni di dimensioni dell'operazione API CopyObject devono utilizzare i comandi di copia in più parti.

Importante

Quando si eseguono le operazioni utilizzando la AWS Management Console, Amazon S3 utilizza un caricamento in più parti se l'oggetto ha dimensioni superiori a 16 MB. In questo caso, il checksum non è un checksum diretto dell'oggetto completo, ma piuttosto un calcolo basato sui valori di checksum di ogni singola parte.

Ad esempio, considera un oggetto di dimensioni di 100 MB che hai caricato come caricamento diretto di singola parte utilizzando REST API. Il checksum in questo caso è un checksum dell'intero oggetto. Se successivamente utilizzi la console per rinominare l'oggetto, copiarlo, modificare la classe di storage o i metadati, Amazon S3 utilizza la funzionalità di caricamento in più parti per aggiornare l'oggetto. Di conseguenza, Amazon S3 crea un nuovo valore di checksum per l'oggetto calcolato in base ai valori di checksum delle singole parti.

L'elenco precedente delle operazioni della console non è un elenco completo di tutte le possibili operazioni che è possibile intraprendere nella AWS Management Consolee che comportano l'aggiornamento di Amazon S3 dell'oggetto utilizzando la funzionalità di caricamento in più parti. Tieni presente che ogni volta che usi la console per agire su oggetti di dimensioni superiori a 16 MB, il valore del checksum potrebbe non essere il checksum dell'intero oggetto.