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 contrôle d'intégrité des données suivants : Secure Hash Algorithms (SHA) ou Cyclic Redundancy Check (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 AWS Management Console, vous sélectionnez l'algorithme de total 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 kit SDK, vous pouvez définir la valeur du paramètre x-amz-sdk-checksum-algorithm sur l'algorithme que vous souhaitez que Amazon S3 utilise pour calculer le total de contrôle. Amazon S3 calcule automatiquement la valeur du total de contrôle.

• Lorsque vous utilisez l'API REST, vous n'utilisez pas le paramètre x-amz-sdk-checksum-algorithm. 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 de plus amples informations sur les opérations par lot S3, veuillez consulter 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 totaux de contrôle supplémentaires, si vous essayez de lancer une requête de chargement partitionné avec des numéros de parties non consécutifs, Amazon S3 génère une erreur 500 Internal Server Error HTTP.

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 total de contrôle à utiliser lors du chargement d'objets, consultez Chargement d'objets.

Utilisation des kits SDK AWS

L'exemple suivant montre comment vous pouvez utiliser les kits SDK AWS pour charger un fichier volumineux avec un chargement partitionné, télécharger un fichier volumineux et valider un fichier de chargement partitionné, 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 SHA-256

Pour obtenir les instructions sur la création et le test d'un exemple pratique, consultez Test des exemples de code Java 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();
            }
        }
    }

Utilisation de l'API REST

Vous pouvez envoyer des requêtes REST pour charger un objet avec une valeur de total de contrôle pour vérifier l'intégrité des données avec PutObject. Vous pouvez également extraire la valeur de total de contrôle pour les objets à l'aide de la fonctionnalité GetObject ou HeadObject.

À partir d 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.

Utilisation de Content-MD5 pour charger des objets

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

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

La fourniture d'un récapitulatif MD5 n'est pas obligatoire, mais vous pouvez l'utiliser pour vérifier l'intégrité de l'objet dans le cadre du processus de chargement.

Utilisation de Content-MD5 et de ETag pour vérifier les objets chargés.

Le balise d'entité (ETag) d'un objet représente une version spécifique de cet objet. Gardez à l'esprit que ETag ne reflète que les changements apportés au contenu d'un objet et non à ses métadonnées. Si seules les métadonnées d'un objet changent, la balise ETag reste le même.

Selon l'objet, la balise ETag de l'objet peut être un récapitulatif MD5 des données de l'objet :

• Si un objet est créé par l'opération PUT Object, POST Object, ou Copy, ou via la AWS Management Console et que cet objet est également en texte brut ou chiffré par un chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3), cet objet possède un ETag qui est un récapitulatif MD5 de ses données.

• Si un objet est créé par l'opération PUT Object, POST Object, ou Copy, ou par le AWS Management Console et que cet objet est chiffré par un chiffrement côté serveur avec des clés fournies par le client (SSE-C) ou un chiffrement côté serveur avec des clés AWS Key Management Service (AWS KMS) (SSE-KMS), cet objet a un ETag qui n'est pas un récapitulatif MD5 de ses données d'objet.

• Si un objet est créé par l'opération Multipart Upload ou Part Copy, la balise ETag de l'objet n'est pas un récapitulatif MD5, quelle que soit la méthode de chiffrement. Si un objet est plus grand que 16 Mo, le chargement AWS Management Console ou la copie de cet objet est un chargement partitionné et la balise ETag n'est pas un récapitulatif MD5.

Pour les objets où la balise ETag est le récapitulatif Content-MD5 de l'objet, vous pouvez comparer la valeur ETag de l'objet avec un récapitulatif Content-MD5 calculé ou précédemment stocké.

Utilisation des totaux de contrôle de fin

Lorsque vous chargez des objets sur Amazon S3, vous pouvez soit fournir un total de contrôle précalculé pour l'objet, soit utiliser un kit SDK AWS pour créer automatiquement des totaux de contrôle de fin 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 un total de contrôle de fin lors de l'utilisation d'un kit SDK AWS, remplissez le paramètre ChecksumAlgorithm avec votre algorithme préféré. Le kit SDK utilise cet algorithme pour calculer le total de contrôle de votre objet (ou de ses parties) et l'ajoute automatiquement à la fin de votre requête de 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 tant que chargement partitionné, la balise ETag de l'objet n'est pas un récapitulatif MD5 de l'objet entier. Amazon S3 calcule le récapitulatif MD5 de chaque partie individuelle au fur et à mesure qu'elle est chargée. Les récapitulatifs MD5 sont utilisés pour déterminer la balise ETag de l'objet final. Amazon S3 concatène les octets des récapitulatifs MD5, puis calcule le récapitulatif MD5 de ces valeurs concaténées. L'étape finale de la création de la balise ETag est celle où Amazon S3 ajoute à la fin un tiret avec le nombre total de parties.

Par exemple, prenons un objet chargé avec un chargement partitionné qui possède un ETag de C9A5A6878D97B48CC965C1E41859F034-14. Dans ce cas, C9A5A6878D97B48CC965C1E41859F034 représente le récapitulatif MD5 de tous les récapitulatifs concaténés 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é. Le total de contrôle pour l'objet terminé est calculé de la même manière que Amazon S3 calcule le récapitulatif MD5 pour le 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 qui le composent, vous pouvez utiliser l'opération GetObjectAttributes. 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.

Vous pouvez également obtenir le total de contrôle d'une partie individuelle à l'aide des commandes GetObject ou HeadObject et en spécifiant un numéro de partie ou une plage d'octets qui s'aligne sur une seule partie. Avec cette méthode, vous pouvez utiliser ce total de contrôle pour valider la partie individuelle sans avoir besoin d'attendre que toutes les parties aient fini de se charger avant de vérifier l'intégrité des données. Lorsque vous utilisez cette méthode, vous pouvez également ne demander que les parties individuelles qui ont échoué au test d'intégrité.

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 kit SDK ou l'API REST et que vous appelez CopyObject, Amazon S3 copie tout objet jusqu'aux limites de taille de l'opération API CopyObject. 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 l'opération API CopyObject doivent utiliser des commandes de copie en plusieurs parties.

Important

Lorsque vous effectuez certaines opérations à l'aide de la fonction de la AWS Management Console, Amazon S3 utilise un 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.

Prenons l'exemple d'un objet de 100 Mo que vous avez chargé directement en une seule partie à l'aide de l'API REST. 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 la console n'est pas une liste exhaustive de toutes les actions possibles que vous pouvez entreprendre dans AWS Management Console et qui amènent Amazon S3 à mettre à jour l'objet en utilisant la fonctionnalité de 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.