Vérification de l’intégrité des objets dans Amazon S3

Amazon S3 utilise des valeurs de somme de contrôle pour vérifier l’intégrité des données que vous chargez ou téléchargez. 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 un algorithme de somme de contrôle à utiliser lors du chargement, de la copie standard ou de la copie par lot de vos données.

Lorsque vous chargez vos données, Amazon S3 utilise l’algorithme que vous avez choisi pour calculer une somme de contrôle côté serveur et la valide avec la valeur fournie avant de stocker l’objet et de stocker la somme de contrôle dans le cadre des métadonnées de l’objet. Cette validation fonctionne de manière cohérente quels que soient les modes de chiffrement, les tailles d’objets et les classes de stockage pour les chargements en une seule partie ou les chargements partitionnés. Cependant, lorsque vous copiez vos données de manière standard ou par lot, Amazon S3 calcule la somme de contrôle de l’objet source et la transfère vers l’objet de destination.

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

Avec Amazon S3, vous pouvez choisir un algorithme de somme de contrôle pour valider vos données lors des chargements. L’algorithme de somme de contrôle spécifié est ensuite stocké avec l’objet et peut être utilisé pour valider l’intégrité des données lors des chargements. Vous pouvez sélectionner l’un des algorithmes suivants de somme de contrôle Secure Hash Algorithms (SHA) ou Cyclic Redundancy Check (CRC) pour calculer la valeur de la somme de contrôle :

En outre, vous pouvez fournir une somme de contrôle pour chaque demande à l'aide de l'MD5en-tête Content-.

Lorsque vous chargez un objet, vous spécifiez l’algorithme que vous souhaitez utiliser :

Pour appliquer ces valeurs de somme de contrôle à des objets déjà chargés sur Amazon S3, vous pouvez copier l’objet et spécifier si vous voulez utiliser l’algorithme de somme de contrôle existant ou un autre. Si vous ne spécifiez aucun algorithme, S3 utilise l’algorithme existant. Si l'objet source ne possède pas d'algorithme de somme de contrôle ou de valeur de somme de contrôle spécifié, Amazon S3 utilise l'algorithme CRC-64/NVME pour calculer la valeur de somme de contrôle pour l'objet de destination. Vous pouvez spécifier un algorithme de somme de contrôle lors de la copie d’objets à l’aide des opérations par lot S3.

Types de sommes de contrôle d’objet entier et composites

Dans Amazon S3, deux types de sommes de contrôle sont pris en charge :

Amazon S3 prend en charge les types de sommes de contrôle d’objet entier et les types de sommes de contrôle composites suivants :

Chargements en une seule partie

Les sommes de contrôle des objets chargés en une seule partie (à l’aide de PutObject) sont traitées comme des sommes de contrôle d’objets entiers. Lorsque vous chargez un objet dans la console Amazon S3, vous pouvez choisir l’algorithme de somme de contrôle que vous souhaitez que S3 utilise et, si vous le souhaitez, vous pouvez aussi fournir une valeur précalculée. Amazon S3 valide ensuite cette somme de contrôle avant de stocker l’objet et sa valeur de somme contrôle. Vous pouvez vérifier l’intégrité des données d’un objet lorsque vous demandez la valeur de la somme de contrôle lors du chargement de l’objet.

Chargements partitionnés

Lorsque vous chargez l’objet en plusieurs parties à l’aide de l’API MultipartUpload, vous pouvez spécifier l’algorithme de somme de contrôle que vous souhaitez qu’Amazon S3 utilise et le type de somme de contrôle (objet entier ou composite).

Le tableau suivant indique quel type d’algorithme de somme de contrôle est pris en charge pour chaque algorithme de somme de contrôle d’un chargement partitionné :

Utilisation des sommes de contrôle des objets entiers pour le chargement partitionné

Lorsque vous créez ou effectuez un chargement partitionné, vous pouvez utiliser les sommes de contrôle de l’objet entier pour la validation du chargement. Cela signifie que vous pouvez fournir l’algorithme de somme de contrôle pour l’API MultipartUpload, ce qui simplifie les outils de validation de l’intégrité, car vous n’avez plus besoin de suivre les limites de chaque partie pour les objets chargés. Vous pouvez fournir la somme de contrôle de l’objet entier dans la demande CompleteMultipartUpload, ainsi que la taille de l’objet.

Lorsque vous fournissez une somme de contrôle complète d'un objet lors d'un chargement en plusieurs parties, le AWS SDK transmet la somme de contrôle à Amazon S3, et S3 valide l'intégrité de l'objet côté serveur, en la comparant à la valeur reçue. Amazon S3 stocke ensuite l’objet si les valeurs correspondent. Si les deux valeurs ne correspondent pas, S3 fait échouer la demande et génère une erreur BadDigest. La somme de contrôle de votre objet est également stockée dans les métadonnées de l’objet que vous utiliserez ultérieurement pour valider l’intégrité des données d’un objet.

Pour les sommes de contrôle complètes des objets, vous pouvez utiliser les algorithmes de somme de contrôle CRC-64/NVME (CRC64NVME), CRC-32 (CRC32) ou CRC-32C () dans S3. CRC32C Les sommes de contrôle des objets entiers dans les chargements partitionnés ne sont disponibles que pour les sommes de contrôle basées sur l’algorithme CRC, car elles peuvent être linéarisées en une somme de contrôle pour l’objet entier. Cette linéarisation permet à Amazon S3 de paralléliser vos demandes pour améliorer les performances. S3 peut notamment calculer la somme de contrôle de l’objet entier à partir des sommes de contrôle au niveau de chaque partie. Ce type de validation n'est pas disponible pour les autres algorithmes, tels que SHA et MD5. Comme S3 dispose de protections d'intégrité par défaut, si des objets sont chargés sans somme de contrôle, S3 attache automatiquement l'algorithme de somme de contrôle CRC-64/NVME (CRC64NVME) recommandé pour l'ensemble de l'objet à l'objet.

Utilisation des sommes de contrôle au niveau des parties d’un chargement partitionné

Lorsque des objets sont chargés sur Amazon S3, ils peuvent être chargés en tant qu’objet unique ou en plusieurs parties par le biais du processus de chargement partitionné. Vous pouvez choisir un type de somme de contrôle pour votre chargement partitionné. Pour les sommes de contrôle au niveau de chaque partie d’un chargement partitionné (ou les sommes de contrôle composites), Amazon S3 calcule la somme de contrôle pour chaque partie en utilisant l’algorithme de somme de contrôle spécifié. Vous pouvez utiliser UploadPart pour fournir les valeurs de somme de contrôle pour chaque partie. Si l'objet que vous essayez de télécharger dans la console Amazon S3 est configuré pour utiliser l'algorithme de somme de contrôle CRC-64/NVME (CRC64NVME) et dépasse 16 Mo, il est automatiquement désigné comme somme de contrôle d'objet complète.

Amazon S3 utilise ensuite les valeurs de somme de contrôle stockées au niveau de chaque partie pour confirmer que chacune d’elle est correctement chargée. Lorsque la somme de contrôle de chaque partie (de l’objet entier) est fournie, S3 utilise les valeurs de la somme de contrôle stockées pour chaque partie afin de calculer la somme de contrôle de l’objet entier en interne, en la comparant à la valeur de la somme de contrôle fournie. Les coûts de calcul sont ainsi réduits, car S3 peut calculer une somme de contrôle de l’objet entier en utilisant la somme de contrôle de chaque partie. Pour en savoir plus sur les chargements partitionnés, consultez Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3 et Utilisation des sommes de contrôle des objets entiers pour le chargement partitionné.

Lorsque l’objet est complètement chargé, vous pouvez utiliser la somme de contrôle finale calculée pour vérifier l’intégrité des données de l’objet.

Lors du chargement d’une partie du chargement partitionné, tenez compte des points suivants :

Opérations de somme de contrôle

Après avoir chargé des objets, vous pouvez obtenir la valeur de la somme de contrôle et la comparer à une valeur de somme de contrôle précalculée ou précédemment stockée pour le même type d’algorithme. Les exemples suivants illustrent les opérations ou méthodes de somme de contrôle vous pouvez utiliser pour vérifier l’intégrité des données.

    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 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 reflète ETag uniquement les modifications apportées au contenu d'un objet, et non les modifications apportées à 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 :

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 précédemment stocké.

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 un AWS SDK pour créer automatiquement des sommes de contrôle de suivi pour les téléchargements fragmentés, en votre nom. Si vous utilisez une somme de contrôle finale, Amazon S3 génère automatiquement la somme de contrôle en utilisant l'algorithme que vous avez spécifié pour valider l'intégrité de l'objet dans les téléchargements fragmentés, lorsque vous chargez un objet.

Pour créer une somme de contrôle finale lors de l'utilisation d'un AWS SDK, renseignez le ChecksumAlgorithm paramètre avec votre algorithme préféré. Le 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 segmentée. 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.

En-têtes de somme de contrôle suivants

Pour effectuer une demande de codage de contenu fragmenté, Amazon S3 exige que les serveurs clients incluent plusieurs en-têtes afin d'analyser correctement la demande. Les serveurs clients doivent inclure les en-têtes suivants :

Pièces fragmentées

Lorsque vous chargez un objet sur Amazon S3 à l'aide d'un codage fragmenté, la demande de téléchargement inclut les types de fragments suivants (formatés dans l'ordre indiqué) :

Pour des exemples de mise en forme fragmentée, consultezExemples : téléchargements fragmentés avec des sommes de contrôle.

Morceaux du corps de l'objet

Les fragments du corps de l'objet sont les fragments qui contiennent les données d'objet réelles qui sont téléchargées vers S3. Ces morceaux sont soumis à des contraintes de taille et de format cohérentes.

Taille du morceau du corps de l'objet

Ces fragments doivent contenir au moins 8 192 octets (ou 8 KiB) de données d'objet, à l'exception du dernier segment du corps, qui peut être plus petit. Il n'y a pas de taille maximale explicite, mais vous pouvez vous attendre à ce que tous les morceaux soient inférieurs à la taille de téléchargement maximale de 5 Go. La taille des fragments peut varier d'un morceau à l'autre en fonction de l'implémentation de votre serveur client.

Format de bloc du corps de l'objet

Les fragments de corps d'objet commencent par le codage hexadécimal du nombre d'octets qu'ils contiennent, suivi d'un CRLF (Carriage Return Line Feed), des octets de l'objet correspondant à ce segment et d'un autre CRLF.

Par exemple :

hex-encoding-of-object-bytes-in-chunk\r\n
chunk-object-bytes\r\n

Toutefois, lorsque le fragment est signé, le segment du corps de l'objet suit un format différent, dans lequel la signature est ajoutée à la taille du bloc par un point-virgule. Par exemple :

hex-encoding-of-object-bytes-in-chunk;chunk-signature\r\n
 chunk-object-bytes\r\n

Pour plus d'informations sur la signature fragmentée, voir Calculs de signature pour le Authorization En-tête : transfert d'une charge utile en plusieurs morceaux (AWS Signature Version 4). Pour plus d'informations sur le formatage des blocs, consultez la section Codage de transfert par blocs sur le site Web de l'éditeur RFC.

Morceaux de complétion

Les fragments d'achèvement doivent être le dernier fragment du corps de l'objet de chaque téléchargement fragmenté. Le format d'un segment de complétion est similaire à celui d'un segment de corps, mais il ne contient toujours aucun octet de données d'objet. (Le zéro octet de données d'objet indique que toutes les données ont été téléchargées.) Les téléchargements fragmentés doivent inclure un fragment d'achèvement comme dernier fragment du corps de l'objet, selon un format comme celui-ci :

0\r\n

Toutefois, si la demande de codage de contenu utilise la signature de charge utile, elle suit plutôt le format suivant :

0;chunk-signature\r\n

Morceaux de remorque

Les segments de bande-annonce contiennent la somme de contrôle calculée pour toutes les demandes de téléchargement S3. Les segments de bande-annonce incluent deux champs : un champ de nom d'en-tête et un champ de valeur d'en-tête. Le champ du nom d'en-tête d'une demande de téléchargement doit correspondre à la valeur transmise dans l'en-tête de la x-amz-trailer demande. Par exemple, si une demande contient le nom x-amz-trailer: x-amz-checksum-crc32 d'en-tête du fragment de la bande-annoncex-amz-checksum-sha1, la demande échoue. Le champ de valeur du fragment de bande-annonce inclut un codage base64 de la valeur de la somme de contrôle big-endian pour cet objet. (L'ordre big-endian stocke l'octet de données le plus significatif à l'adresse mémoire la plus basse et l'octet le moins significatif à la plus grande adresse mémoire). L'algorithme utilisé pour calculer cette somme de contrôle est le même que le suffixe du nom d'en-tête (par exemple,crc32).

Format des morceaux de la bande-annonce

Les segments de remorque utilisent le format suivant pour les demandes de charge utile non signées :

x-amz-checksum-lowercase-checksum-algorithm-name:base64-checksum-value\n\r\n\r\n

Pour les demandes contenant des charges utiles signées SigV4, le fragment de remorque inclut une signature de remorque après le morceau de remorque.

trailer-checksum\n\r\n
trailer-signature\r\n

Vous pouvez également ajouter le CRLF directement à la fin de la valeur de la somme de contrôle base64. Par exemple :

x-amz-checksum-lowercase-checksum-algorithm-name:base64-checksum-value\r\n\r\n

Exemples : téléchargements fragmentés avec des sommes de contrôle

Amazon S3 prend en charge les téléchargements fragmentés qui utilisent le codage aws-chunked du contenu PutObject et les UploadPart demandes avec des sommes de contrôle ultérieures.

Voici un exemple de PutObject demande segmentée avec une somme de contrôle CRC-32 à la fin. Dans cet exemple, le client télécharge un objet de 17 Ko en trois segments non signés et ajoute un bloc de somme de contrôle CRC-32 final en utilisant l'en-tête. x-amz-checksum-crc32

PUT /Key+ HTTP/1.1
Host: amzn-s3-demo-bucket
Content-Encoding: aws-chunked
x-amz-decoded-content-length: 17408
x-amz-content-sha256: STREAMING-UNSIGNED-PAYLOAD-TRAILER
x-amz-trailer: x-amz-checksum-crc32

2000\r\n                                   // Object body chunk 1 (8192 bytes)
object-bytes\r\n
2000\r\n                                   // Object body chunk 2 (8192 bytes)
object-bytes\r\n
400\r\n                                    // Object body chunk 3 (1024 bytes)
object-bytes\r\n
0\r\n                                      // Completion chunk
x-amz-checksum-crc32:YABb/g==\n\r\n\r\n    // Trailer chunk (note optional \n character)
\r\n                                         // CRLF

Voici un exemple de réponse :

HTTP/1.1 200
ETag: ETag
x-amz-checksum-crc32: YABb/g==

Voici un exemple de PutObject demande segmentée avec une somme de contrôle CRC-32 à la fin. Cette demande utilise la signature de la charge utile SigV4. Dans cet exemple, le client télécharge un objet de 17 Ko en trois parties signées. En plus des object body morceaux, les completion chunk et trailer chunk sont également signés.

PUT /Key+ HTTP/1.1
Host: amzn-s3-demo-bucket.s3.amazonaws.com
Content-Encoding: aws-chunked
x-amz-decoded-content-length: 17408
x-amz-content-sha256: STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
x-amz-trailer: x-amz-checksum-crc32
		
authorization-code                            // SigV4 headers authorization

2000;chunk-signature=signature-value...\r\n   // Object body chunk 1 (8192 bytes)
object-bytes\r\n
2000;chunk-signature\r\n                      // Object body chunk 2 (8192 bytes)
object-bytes\r\n
400;chunk-signature\r\n                       // Object body chunk 3 (1024 bytes)
object-bytes\r\n
0;chunk-signature\r\n                         // Completion chunk
x-amz-checksum-crc32:YABb/g==\n\r\n            // Trailer chunk (note optional \n character)
trailer-signature\r\n
\r\n                                           // CRLF

Voici un exemple de réponse :

HTTP/1.1 200
ETag: ETag
x-amz-checksum-crc32: YABb/g==