Vérification de l'intégrité des objets

Amazon S3 utilise des valeurs de total de contrôle pour vérifier l'intégrité des données que vous chargez ou téléchargez depuis Amazon S3. En outre, vous pouvez demander qu'un autre total de contrôle soit calculé pour tout objet que vous stockez dans Amazon S3. Vous pouvez choisir parmi plusieurs algorithmes de total de contrôle à utiliser lorsque vous chargez ou copiez vos données. Amazon S3 utilise cet algorithme pour calculer un total de contrôle supplémentaire et le stocker dans les métadonnées de l'objet. Pour en savoir plus sur l'utilisation de totaux de contrôle supplémentaires pour vérifier l'intégrité des données, consultez Tutoriel : vérifier l'intégrité des données dans Amazon S3 avec des totaux de contrôle supplémentaires.

Lorsque vous chargez un objet, vous pouvez éventuellement inclure un total de contrôle précalculé dans votre requête. Amazon S3 compare le total de contrôle fourni au total de contrôle qu'il calcule en utilisant l'algorithme que vous avez spécifié. Si les deux valeurs ne correspondent pas, Amazon S3 génère une erreur.

Utilisation des algorithmes de total de contrôle pris en charge

Amazon S3 vous offre la possibilité de sélectionner l'algorithme de total de contrôle utilisé pour valider vos données pendant le chargement ou le téléchargement. Vous pouvez sélectionner l'un des algorithmes de hachage sécurisé (SHA) ou de contrôle de redondance cyclique () suivants pour vérifier l'intégrité des données CRC :

• CRC32

• CRC32C

• SHA-1

• SHA-256

Lorsque vous chargez un objet, vous pouvez spécifier l'algorithme que vous souhaitez utiliser :

• Lorsque vous utilisez le AWS Management Console, vous sélectionnez l'algorithme de somme de contrôle que vous souhaitez utiliser. Dans ce cas, vous pouvez éventuellement spécifier la valeur du total de contrôle de l'objet. Lorsque Amazon S3 reçoit l'objet, il calcule le total de contrôle en utilisant l'algorithme que vous avez spécifié. Si les deux valeurs ne correspondent pas, Amazon S3 génère une erreur.

• Lorsque vous utilisez un SDK, vous pouvez définir la valeur du ChecksumAlgorithm paramètre selon l'algorithme que vous souhaitez qu'Amazon S3 utilise lors du calcul de la somme de contrôle. Amazon S3 calcule automatiquement la valeur du total de contrôle.

• Lorsque vous utilisez le REST API, vous n'utilisez pas le x-amz-sdk-checksum-algorithm paramètre. Vous devez plutôt utiliser l'un des en-têtes spécifiques à l'algorithme (par exemple, x-amz-checksum-crc32).

Pour en savoir plus sur le chargement d'objets, consultez Chargement d'objets.

Pour appliquer l'une de ces valeurs de total de contrôle à des objets déjà chargés sur Amazon S3, vous pouvez copier l'objet. Lorsque vous copiez un objet, vous pouvez préciser si vous souhaitez utiliser l'algorithme de total de contrôle existant ou en utiliser un nouveau. Vous pouvez spécifier un algorithme de total de contrôle lors de l'utilisation de tout mécanisme pris en charge pour la copie d'objets, y compris les opérations par lots S3. Pour plus d’informations sur les opérations par lots S3, consultez Exécution des opérations par lot à grande échelle sur des objets Amazon S3.

Important

Si vous utilisez un chargement partitionné avec des totaux de contrôle supplémentaires, les numéros de partie partitionnés doivent utiliser des numéros de parties consécutifs. Lorsque vous utilisez des checksums supplémentaires, si vous essayez de traiter une demande de téléchargement partitionné avec des numéros de pièce non consécutifs, Amazon S3 génère une erreur. HTTP 500 Internal Server Error

Après avoir chargé des objets, vous pouvez obtenir la valeur du total de contrôle et la comparer à une valeur de total de contrôle précalculée ou précédemment stockée, calculée à l'aide du même algorithme.

Utilisation de la console S3

Pour en savoir plus sur l'utilisation de la console et la définition des algorithmes de somme de contrôle à utiliser lors du chargement d'objets, consultez Chargement d'objets et Didacticiel : Vérification de l'intégrité des données dans Amazon S3 avec des sommes de contrôle supplémentaires.

À l'aide du AWS SDKs

L'exemple suivant montre comment vous pouvez utiliser le AWS SDKs pour charger un fichier volumineux avec un chargement en plusieurs parties, télécharger un fichier volumineux et valider un fichier en plusieurs parties, le tout en utilisant SHA -256 pour la validation du fichier.

Java

Exemple : chargement, téléchargement et vérification d'un fichier volumineux avec -256 SHA

Pour obtenir des instructions sur la création et le test d'un échantillon fonctionnel, voir Getting Started dans le guide du AWS SDK for Java développeur.

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

En utilisant le REST API

Vous pouvez envoyer des REST demandes pour télécharger un objet avec une valeur de somme de contrôle afin de vérifier l'intégrité des PutObjectdonnées. Vous pouvez également récupérer la valeur de la somme de contrôle pour les objets à l'aide de GetObjectou HeadObject.

En utilisant le AWS CLI

Vous pouvez envoyer une demande PUT pour télécharger un objet d'une taille maximale de 5 Go en une seule opération. Pour plus d'informations, reportez-vous à la section PutObject dans la référence des commandes AWS CLI . Vous pouvez également utiliser get-object et head-object pour récupérer le total de contrôle d'un objet déjà chargé afin de vérifier l'intégrité des données.

Pour plus d'informations, consultez Amazon S3 CLI FAQ dans le guide de AWS Command Line Interface l'utilisateur.

Utilisation de Content- MD5 lors du téléchargement d'objets

Une autre façon de vérifier l'intégrité de votre objet après le téléchargement consiste à fournir un MD5 résumé de l'objet lorsque vous le chargez. Si vous calculez le MD5 résumé de votre objet, vous pouvez le fournir avec la PUT commande en utilisant l'Content-MD5en-tête.

Après avoir chargé l'objet, Amazon S3 calcule le MD5 résumé de l'objet et le compare à la valeur que vous avez fournie. La requête n'aboutit que si les deux récapitulatifs correspondent.

Il n'est pas nécessaire de fournir un MD5 résumé, mais vous pouvez l'utiliser pour vérifier l'intégrité de l'objet dans le cadre du processus de téléchargement.

Utilisation du contenu MD5 et du ETag pour vérifier les objets téléchargés

La balise d'entité (ETag) d'un objet représente une version spécifique de cet objet. N'oubliez pas que cela ETag reflète uniquement les modifications apportées au contenu d'un objet, et non à ses métadonnées. Si seules les métadonnées d'un objet changent, elles ETag restent les mêmes.

Selon l'objet, ETag l'objet peut être un MD5 condensé des données de l'objet :

• Si un objet est créé par l'CopyObjectopération PutObjectPostObject, ou par le biais de AWS Management Console, et que cet objet est également en texte brut ou chiffré par chiffrement côté serveur avec des clés gérées Amazon S3 (SSE-S3), cet objet possède un MD5 condensé de ETag ses données d'objet.

• Si un objet est créé par l'CopyObjectopération PutObjectPostObject, ou par le biais de AWS Management Console, et que cet objet est chiffré par chiffrement côté serveur avec des clés fournies par le client (SSE-C) ou par chiffrement côté serveur avec des clés () AWS Key Management Service (SSE-AWS KMS KMS), cet objet possède un code qui n'est pas un ETag condensé de ses données d'objet. MD5

• Si un objet est créé par l'Part Copyopération Multipart Upload ou, il ne ETag s'agit pas d'un MD5 condensé, quelle que soit la méthode de chiffrement utilisée. Si la taille d'un objet est supérieure à 16 Mo, il AWS Management Console télécharge ou copie cet objet sous forme de téléchargement partitionné ; il ne s'agit donc ETag pas d'un MD5 résumé.

Pour les objets dont le résumé ETag est le Content-MD5 condensé de l'objet, vous pouvez comparer la ETag valeur de l'objet avec un Content-MD5 résumé calculé ou enregistré précédemment.

Utilisation des totaux de contrôle de fin

Lorsque vous chargez des objets sur Amazon S3, vous pouvez soit fournir une somme de contrôle précalculée pour l'objet, soit utiliser an pour créer automatiquement des sommes de contrôle AWS SDK de suivi en votre nom. Si vous décidez d'utiliser un total de contrôle de fin, Amazon S3 génère automatiquement le total de contrôle en utilisant l'algorithme que vous avez spécifié et l'utilise pour valider l'intégrité de l'objet pendant le chargement.

Pour créer une somme de contrôle finale lorsque vous utilisez un AWS SDK, renseignez le ChecksumAlgorithm paramètre avec votre algorithme préféré. Il SDK utilise cet algorithme pour calculer la somme de contrôle pour votre objet (ou des parties de l'objet) et l'ajoute automatiquement à la fin de votre demande de téléchargement. Ce comportement vous fait gagner du temps car Amazon S3 effectue la vérification et le chargement de vos données en une seule opération.

Important

Si vous utilisez S3 Object Lambda, toutes les requêtes adressées à S3 Object Lambda sont signées en utilisant s3-object-lambda au lieu de s3. Ce comportement affecte la signature des valeurs de total de contrôle de fin. Pour en savoir plus sur S3 Object Lambda, consultez Transformation d'objets avec S3 Object Lambda.

Utilisation de totaux de contrôle au niveau des parties pour les chargements partitionnés

Lorsque des objets sont chargés sur Amazon S3, ils peuvent être chargés en tant qu'objet unique ou par le biais du processus de chargement partitionné. Les objets dont la taille est supérieure à 16 Mo et qui sont chargés par le biais de la console sont automatiquement chargés à l'aide de chargements partitionnés. Pour en savoir plus sur le chargement partitionné, consultez Chargement et copie d'objets à l'aide d'un chargement partitionné.

Lorsqu'un objet est chargé en plusieurs parties, le résumé de l'ETagobjet n'est pas un MD5 condensé de l'objet dans son intégralité. Amazon S3 calcule le MD5 résumé de chaque partie individuelle au fur et à mesure de son chargement. Les MD5 résumés sont utilisés pour déterminer l'ETagobjet final. Amazon S3 concatène les octets des MD5 résumés, puis calcule le MD5 condensé de ces valeurs concaténées. La dernière étape pour créer le ETag est quand Amazon S3 ajoute un tiret avec le nombre total de pièces à la fin.

Par exemple, considérez un objet chargé avec un téléchargement en plusieurs parties dont le nom est ETag deC9A5A6878D97B48CC965C1E41859F034-14. Dans ce cas, le MD5 condensé de tous les résumés C9A5A6878D97B48CC965C1E41859F034 est-il concaténé ensemble ? -14 indique que 14 parties sont associées au chargement partitionné de cet objet.

Si vous avez activé des valeurs de contrôle supplémentaires pour votre objet en plusieurs parties, Amazon S3 calcule le total de contrôle pour chaque partie individuelle en utilisant l'algorithme de total de contrôle spécifié. La somme de contrôle pour l'objet terminé est calculée de la même manière qu'Amazon S3 calcule le MD5 résumé du téléchargement partitionné. Vous pouvez utiliser ce total de contrôle pour vérifier l'intégrité de l'objet.

Pour récupérer des informations sur l'objet, notamment le nombre de parties composant l'objet entier, vous pouvez utiliser cette GetObjectAttributesopération. Avec des totaux de contrôle supplémentaires, vous pouvez également récupérer des informations pour chaque partie individuelle qui incluent la valeur du total de contrôle de chaque partie.

Pour les téléchargements terminés, vous pouvez obtenir la somme de contrôle d'une partie individuelle en utilisant les HeadObjectopérations GetObjector et en spécifiant un numéro de pièce ou une plage d'octets alignée sur une seule partie. Si vous souhaitez récupérer les valeurs de contrôle pour les différentes parties des téléchargements partitionnés toujours en cours, vous pouvez utiliser. ListParts

En raison de la façon dont Amazon S3 calcule le total de contrôle pour les objets à plusieurs parties, la valeur du total de contrôle de l'objet peut changer si vous le copiez. Si vous utilisez un SDK ou le REST API et que vous appelez CopyObject, Amazon S3 copie n'importe quel objet dans les limites de taille de l'CopyObjectAPIopération. Amazon S3 effectue cette copie en une seule action, que l'objet ait été chargé en une seule requête ou dans le cadre d'un chargement partitionné. Avec une commande de copie, le total de contrôle de l'objet est un total de contrôle direct de l'objet complet. Si l'objet a été initialement chargé à l'aide d'un chargement partitionné, la valeur du total de contrôle change même si les données ne changent pas.

Note

Les objets dont la taille dépasse les limites de taille de l'CopyObjectAPIopération doivent utiliser des commandes de copie en plusieurs parties.

Important

Lorsque vous effectuez certaines opérations à l'aide du AWS Management Console, Amazon S3 utilise un téléchargement partitionné si la taille de l'objet est supérieure à 16 Mo. Dans ce cas, le total de contrôle n'est pas un total de contrôle direct de l'objet complet, mais plutôt un calcul basé sur les valeurs de total de contrôle de chaque partie individuelle.

Par exemple, considérez un objet de 100 Mo que vous avez chargé en tant que téléchargement direct en une seule partie à l'aide du RESTAPI. Dans ce cas, le total de contrôle est un total de contrôle de l'objet entier. Si vous utilisez ensuite la console pour renommer cet objet, le copier, changer sa classe de stockage ou modifier les métadonnées, Amazon S3 utilise la fonctionnalité de chargement partitionné pour mettre à jour l'objet. Par conséquent, Amazon S3 crée une nouvelle valeur de total de contrôle pour l'objet qui est calculée sur la base des valeurs de total de contrôle des parties individuelles.

La liste précédente des opérations de console n'est pas une liste complète de toutes les actions possibles que vous pouvez entreprendre pour AWS Management Console qu'Amazon S3 mette à jour l'objet à l'aide de la fonctionnalité de téléchargement partitionné. Gardez à l'esprit que lorsque vous utilisez la console pour agir sur des objets d'une taille supérieure à 16 Mo, la valeur du total de contrôle peut ne pas correspondre au total de contrôle de l'objet entier.