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

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

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. Per ulteriori informazioni su come utilizzare checksum aggiuntivi per verificare l'integrità dei dati, consulta Tutorial: Verifica dell'integrità dei dati in Amazon S3 con checksum aggiuntivi.

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

  • CRC-32

  • CRC-32 °C

  • SHA-1

  • SHA-256

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

  • Quando si utilizza il AWS Management Console, si seleziona l'algoritmo di checksum che si desidera 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 ChecksumAlgorithm parametro sull'algoritmo che desideri che Amazon S3 utilizzi per il calcolo del checksum. Amazon S3 calcola automaticamente il valore del checksum.

  • Quando usi il REST API, non usi 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 utilizzi checksum aggiuntivi, se tenti di completare una richiesta di caricamento in più parti con numeri di 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 utilizzare durante il caricamento degli oggetti, consultare Caricamento degli oggetti e Tutorial: Verifica dell'integrità dei dati in Amazon S3 con checksum aggiuntivi.

L'esempio seguente mostra come è possibile utilizzare il AWS SDKsper caricare un file di grandi dimensioni con 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 -256 SHA

Per istruzioni sulla creazione e sul test di un esempio funzionante, consulta la Guida introduttiva nella AWS SDK for Java Guida per gli sviluppatori.

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(); } } }

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

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

Per informazioni, consulta Amazon S3 CLI FAQ nel AWS Command Line Interface Guida per l'utente.

Utilizzo dei contenuti: MD5 durante il caricamento di oggetti

Un altro modo per verificare l'integrità dell'oggetto dopo il caricamento consiste nel fornire un MD5 riepilogo dell'oggetto al momento del caricamento. Se si calcola il MD5 digest dell'oggetto, è possibile fornire al digest il PUT comando utilizzando l'intestazione. Content-MD5

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

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

Utilizzo di Content- MD5 and the ETag per verificare gli oggetti caricati

Il tag di entità (ETag) per un oggetto rappresenta una versione specifica di quell'oggetto. Tieni presente che il ETag riflesso modifica solo il contenuto di un oggetto, non i relativi metadati. Se cambiano solo i metadati di un oggetto, ETag rimangono gli stessi.

A seconda dell'oggetto, l'ETagoggetto potrebbe essere un MD5 riassunto dei dati dell'oggetto:

  • Se un oggetto viene creato dall'CopyObjectoperazione PutObjectPostObject, o o tramite AWS Management Console, e quell'oggetto è anche testo semplice o crittografato mediante crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3), quell'oggetto ha un ETag riepilogo dei dati relativi all'oggetto. MD5

  • Se un oggetto viene creato dall'operazione, o o tramite PutObject PostObject CopyObject AWS Management Console, e tale oggetto viene crittografato mediante crittografia lato server con chiavi fornite dal cliente (SSE-C) o crittografia lato server con AWS Key Management Service (AWS KMS) keys (SSE-KMS), quell'oggetto ha un codice che non è un riepilogo dei ETag dati dell'oggetto. MD5

  • Se un oggetto viene creato mediante il processo di caricamento multiparte o l'UploadPartCopyoperazione, quello dell'oggetto non ETag è un MD5 digest, indipendentemente dal metodo di crittografia. Se un oggetto è più grande di 16 MB, AWS Management Console carica o copia quell'oggetto come caricamento in più parti e quindi ETag non è un MD5 digest.

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

Utilizzo dei checksum finali

Quando carichi oggetti su Amazon S3, puoi fornire un checksum precalcolato per l'oggetto o utilizzare un AWS SDKper creare automaticamente checksum finali per tuo conto. 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 AWS SDK, compila il ChecksumAlgorithm parametro con il tuo algoritmo preferito. SDKUtilizza tale 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, il comando ETag for the object non è un MD5 riassunto dell'intero oggetto. Amazon S3 calcola il MD5 digest di ogni singola parte man mano che viene caricata. I MD5 digest vengono utilizzati per determinare l'oggetto finaleETag. Amazon S3 concatena i byte per i digest e quindi calcola il MD5 digest di questi valori concatenati. MD5 Il passaggio finale per la creazione di ETag è quando Amazon S3 aggiunge un trattino con il numero totale di parti alla fine.

Ad esempio, considera un oggetto caricato con un caricamento in più parti con un di. ETag C9A5A6878D97B48CC965C1E41859F034-14 In questo caso, il riepilogo di tutti i MD5 digest C9A5A6878D97B48CC965C1E41859F034 è concatenato insieme. 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 MD5 il digest per il caricamento multiparte. È possibile utilizzare questo checksum per verificare l'integrità dell'oggetto.

Per recuperare 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.

Per i caricamenti completati, potete ottenere il checksum di una singola parte utilizzando le HeadObjectoperazioni GetObjecto e specificando un numero di parte o un intervallo di byte allineato a una singola parte. Se desideri recuperare i valori del checksum per le singole parti dei caricamenti in più parti ancora in corso, puoi utilizzare. ListParts

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 utilizzi una chiamata SDK o la REST API e che chiami CopyObject, Amazon S3 copia qualsiasi oggetto fino ai limiti di dimensione dell'CopyObjectAPIoperazione. 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 superano i limiti di dimensione dell'CopyObjectAPIoperazione devono utilizzare comandi di copia multiparte.

Importante

Quando si eseguono alcune operazioni utilizzando il AWS Management Console, Amazon S3 utilizza un caricamento in più parti se l'oggetto ha una dimensione superiore 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 100 MB che hai caricato come caricamento diretto in una 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 azioni che è possibile eseguire in AWS Management Console che comportano l'aggiornamento dell'oggetto da parte di Amazon S3 utilizzando la funzionalità di caricamento multiparte. 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.