Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Didacticiel : chargement partitionné d’un objet et vérification de l’intégrité de ses données
Le chargement partitionné vous permet de charger un seul objet en tant qu’ensemble de parties. Chaque partie est une portion contiguë des données de l'objet. Vous pouvez charger ces parties d’objet indépendamment et dans n’importe quel ordre. Si le transfert d'une partie échoue, vous pouvez la retransférer sans affecter les autres. Une fois toutes les parties de l'objet chargées, Amazon S3 les assemble et crée l'objet. En général, lorsque l’objet atteint la taille de 100 Mo, vous devez préférer les chargements partitionnés au chargement d’objet en une seule opération. Pour en savoir plus sur les chargements partitionnés, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md). Pour obtenir les limites liées aux chargements partitionnés, consultez [Limites de la fonction de chargement partitionné Amazon S3](qfacts.md).
Vous pouvez utiliser des sommes de contrôle pour vérifier que les ressources ne sont pas altérées lors de la copie. L’exécution d’une somme de contrôle consiste à utiliser un algorithme pour itérer séquentiellement chaque octet d’un fichier. Amazon S3 propose plusieurs options de somme de contrôle pour vérifier l’intégrité des données. Nous vous recommandons d’effectuer ces contrôles d’intégrité en tant que bonne pratique de durabilité et pour confirmer que chaque octet est transféré sans modification. Amazon S3 prend également en charge les algorithmes suivants : SHA-1, SHA-256 et C. CRC32 CRC32 Amazon S3 utilise un ou plusieurs de ces algorithmes pour calculer la valeur d’une somme de contrôle supplémentaire et la stocker dans les métadonnées de l’objet. Pour en savoir plus sur le total de contrôle, consultez [Vérification de l’intégrité des objets dans Amazon S3](checking-object-integrity.md).
**Objectif**
Dans ce didacticiel, vous allez apprendre à charger un objet sur Amazon S3 à l'aide d'un téléchargement en plusieurs parties et d'une somme de contrôle SHA-256 supplémentaire via l'interface de ligne de AWS commande (CLI).AWS Vous apprendrez également à vérifier l'intégrité des données de l'objet en calculant le MD5 hachage et la somme de contrôle SHA-256 de l'objet chargé.
**Topics**
+ [Conditions préalables](#mpu-prerequisites)
+ [Étape 1 : création d’un gros fichier](#create-large-file-step1)
+ [Étape 2 : division du fichier en plusieurs fichiers](#split-large-file-step2)
+ [Étape 3 : création du chargement partitionné avec une somme de contrôle supplémentaire](#create-multipart-upload-step3)
+ [Étape 4 : chargement des différentes parties du chargement partitionné](#upload-parts-step4)
+ [Étape 5 : affichage de la liste de toutes les parties du chargement partitionné](#list-parts-step5)
+ [Étape 6 : finalisation du chargement partitionné](#complete-multipart-upload-step6)
+ [Étape 7 : vérification du chargement de l’objet est dans votre compartiment](#confirm-upload-step7)
+ [Étape 8 : vérifier l'intégrité de l'objet à l'aide d'une somme MD5 de contrôle](#verify-object-integrity-step8)
+ [Étape 9 : vérification de l’intégrité de l’objet à l’aide d’une somme de contrôle supplémentaire](#verify-object-integrity-sha256-step9)
+ [Étape 10 : nettoyage de vos ressources](#clean-up-step10)
## Conditions préalables
+ Avant de commencer ce didacticiel, vérifiez que vous avez accès à un compartiment Amazon S3 dans lequel vous pouvez charger un objet. Pour de plus amples informations, veuillez consulter [Création d’un compartiment à usage général](create-bucket-overview.md).
+ La AWS CLI doit être installée et configurée. Pour installer l’interface de ligne de commande AWS , consultez [Installation ou mise à jour de la dernière version de l’ AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html) dans le *Guide de l’utilisateur AWS Command Line Interface *.
+ Vous pouvez également exécuter des commandes AWS CLI depuis la console en utilisant AWS CloudShell. AWS CloudShell est un shell pré-authentifié basé sur un navigateur que vous pouvez lancer directement depuis le. AWS Management Console Pour plus d'informations, voir [Qu'est-ce que c'est CloudShell ?](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) et [Mise en route AWS CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html) dans le *guide de AWS CloudShell l'utilisateur*.
## Étape 1 : création d’un gros fichier
Si vous avez déjà un fichier prêt à être chargé, vous pouvez l’utiliser pour ce didacticiel. Dans le cas contraire, créez un fichier de 15 Mo en procédant comme suit. Pour obtenir les limites liées aux chargements partitionnés, consultez [Limites de la fonction de chargement partitionné Amazon S3](qfacts.md).
**Pour créer un gros fichier**
Utilisez l’une des commandes suivantes pour créer le fichier, selon le système d’exploitation que vous utilisez.
**Linux ou macOS**
Pour créer un fichier de 15 Mo, ouvrez votre terminal local et exécutez la commande suivante :
```
dd if=/dev/urandom of=census-data.bin bs=1M count=15
```
Cette commande crée un fichier nommé `census-data.bin` rempli d’octets aléatoires, d’une taille de 15 Mo.
**Windows**
Pour créer un fichier de 15 Mo, ouvrez votre terminal local et exécutez la commande suivante :
```
fsutil file createnew census-data.bin 15728640
```
Cette commande crée un fichier nommé `census-data.bin` avec une taille de 15 Mo de données arbitraires (15 728 640 octets).
## Étape 2 : division du fichier en plusieurs fichiers
Pour effectuer le chargement partitionné, vous devez diviser le gros fichier en parties de plus petite taille. Vous pourrez ensuite charger ces parties de plus petite taille en utilisant le processus de chargement partitionné. Cette étape montre comment diviser le gros fichier créé à l’[étape 1](#create-large-file-step1) en plusieurs parties de plus petite taille. L’exemple suivant utilise un fichier de 15 Mo nommé `census-data.bin`.
**Pour diviser un gros fichier en plusieurs parties**
**Linux ou macOS**
Pour diviser le gros fichier en parties de 5 Mo, utilisez la commande `split`. Ouvrez le terminal et exécutez ce qui suit :
```
split -b 5M -d census-data.bin census-part
```
Cette commande divise `census-data.bin` en parties de 5 Mo nommées `census-part**`, où `**` est un suffixe numérique commençant par `00`.
**Windows**
Pour diviser le gros fichier, utilisez PowerShell. Ouvrez [PowerShell](https://learn.microsoft.com/en-us/powershell/) et exécutez le script suivant :
```
$inputFile = "census-data.bin"
$outputFilePrefix = "census-part"
$chunkSize = 5MB
$fs = [System.IO.File]::OpenRead($inputFile)
$buffer = New-Object byte[] $chunkSize
$fileNumber = 0
while ($fs.Position -lt $fs.Length) {
$bytesRead = $fs.Read($buffer, 0, $chunkSize)
$outputFile = "{0}{1:D2}" -f $outputFilePrefix, $fileNumber
$fileStream = [System.IO.File]::Create($outputFile)
$fileStream.Write($buffer, 0, $bytesRead)
$fileStream.Close()
$fileNumber++
}
$fs.Close()
```
Ce PowerShell script lit le gros fichier par blocs de 5 Mo et écrit chaque bloc dans un nouveau fichier avec un suffixe numérique.
Après avoir exécuté la commande appropriée, vous devriez voir les différentes parties dans le répertoire dans lequel vous l’avez exécutée. Chaque partie a un suffixe correspondant à son numéro de partie, par exemple :
```
census-part00 census-part01 census-part02
```
## Étape 3 : création du chargement partitionné avec une somme de contrôle supplémentaire
Pour pouvoir lancer le processus de chargement partitionné, vous devez créer la demande de chargement partitionné. Cette étape consiste à lancer le chargement partitionné et à spécifier une somme de contrôle supplémentaire pour l’intégrité des données. L’exemple suivant utilise la somme de contrôle SHA-256. Si vous souhaitez fournir des métadonnées qui décrivent l’objet en cours de chargement, vous devez le faire dans la demande de lancement du chargement partitionné.
**Note**
Dans cette étape et dans les étapes suivantes, ce didacticiel utilise l’algorithme supplémentaire SHA-256. Vous pouvez éventuellement utiliser une autre somme de contrôle supplémentaire pour ces étapes, telle que CRC32 CRC32 C ou SHA-1. Si vous choisissez un algorithme différent, vous devrez l’utiliser tout au long des étapes de ce didacticiel.
**Pour lancer le chargement partitionné**
Sur le terminal, utilisez la commande `create-multipart-upload` suivante afin de lancer un chargement partitionné pour votre compartiment. Remplacez `{{{{amzn-s3-demo-bucket1}}}}` par le nom de votre compartiment. Remplacez également `census_data_file` par le nom de fichier que vous avez choisi. Ce nom de fichier deviendra la clé d’objet une fois le chargement terminé.
```
aws s3api create-multipart-upload --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --checksum-algorithm sha256
```
Si la demande aboutit, vous obtenez une sortie JSON semblable à la suivante :
```
{
"ServerSideEncryption": "AES256",
"ChecksumAlgorithm": "SHA256",
"Bucket": "{{amzn-s3-demo-bucket1}}",
"Key": "census_data_file",
"UploadId": "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz"
}
```
**Note**
Lorsque vous envoyez une demande pour lancer un chargement partitionné, Amazon S3 renvoie une réponse avec un ID de chargement, qui est un identifiant unique pour le chargement partitionné. Vous devez inclure cet ID de chargement dès que vous chargez les parties, listez les parties, terminez un chargement ou arrêtez un chargement. Vous devrez utiliser les valeurs `UploadId`, `Key` et `Bucket` pour les étapes ultérieures. Veillez donc à les enregistrer.
Si vous utilisez un chargement partitionné avec des sommes de contrôle supplémentaires, les numéros des différentes parties doivent être consécutifs. Dans le cas contraire, la demande `complete-multipart-upload` pourra générer une erreur HTTP `500 Internal Server Error`.
## Étape 4 : chargement des différentes parties du chargement partitionné
Au cours de cette étape, vous chargerez les parties du chargement partitionné dans le compartiment S3. Utilisez la commande `upload-part` pour charger chaque partie individuellement. Ce processus nécessite de spécifier l’ID de chargement, le numéro des parties et le fichier à charger pour chaque partie.
**Pour charger les différentes parties de l’objet**
1. Lorsque vous chargez une partie, outre l’ID de chargement, vous devez spécifier un numéro de partie à l’aide de l’argument `--part-number`. Vous pouvez choisir n’importe quel numéro de partie compris entre 1 et 10 000. Un numéro de partie identifie de manière unique une partie et sa place dans l’objet que vous chargez. Le numéro de partie que vous choisissez doit obligatoirement constituer une séquence consécutive (par exemple, 1, 2 ou 3). Si vous chargez une nouvelle partie avec le même numéro qu’une partie précédemment chargée, cette dernière est remplacée.
1. Utilisez la commande `upload-part` pour charger chaque partie du chargement partitionné. L’`--upload-id` est le même que dans la sortie créée par la commande `create-multipart-upload` à l’[étape 3](#create-multipart-upload-step3). Pour charger la première partie de vos données, utilisez la commande suivante :
```
aws s3api upload-part --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --part-number {{1}} --body {{census-part00}} --upload-id "{{cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz}}" --checksum-algorithm {{SHA256}}
```
À la fin de chaque commande `upload-part`, vous devriez voir une sortie semblable à l’exemple suivant :
```
{
"ServerSideEncryption": "AES256",
"ETag": "\"e611693805e812ef37f96c9937605e69\"",
"ChecksumSHA256": "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0="
}
```
1. Pour les parties suivantes, incrémentez leur numéro en conséquence :
```
aws s3api upload-part --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --part-number {{}} --body --upload-id "" --checksum-algorithm SHA256
```
Par exemple, utilisez la commande suivante pour charger la deuxième partie :
```
aws s3api upload-part --bucket {{amzn-s3-demo-bucket1}} --key 'census_data_file' --part-number 2 --body census-part01 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
Amazon S3 renvoie un tag d'entité (ETag) et des sommes de contrôle supplémentaires pour chaque partie téléchargée sous forme d'en-tête dans la réponse.
1. Continuez à utiliser la commande `upload-part` jusqu’à ce que vous ayez chargé toutes les parties de l’objet.
## Étape 5 : affichage de la liste de toutes les parties du chargement partitionné
Pour finaliser le chargement partitionné, vous aurez besoin d’une liste de toutes les parties qui ont été chargées pour ce chargement partitionné spécifique. Le résultat de la `list-parts` commande fournit des informations telles que le nom du compartiment, la clé, l'ID de téléchargement, le numéro de pièce ETag, des sommes de contrôle supplémentaires, etc. Il est utile d’enregistrer cette sortie dans un fichier afin de pouvoir l’utiliser à l’étape suivante lorsque vous finaliserez le processus de chargement partitionné. Vous pouvez créer un fichier de sortie JSON appelé `parts.json` en utilisant la méthode suivante.
**Pour créer un fichier répertoriant toutes les parties**
1. Pour générer un fichier JSON contenant les détails de toutes les parties chargées, utilisez la commande `list-parts` suivante. Remplacez **{{amzn-s3-demo-bucket1}}** par le nom réel de votre compartiment et **** par l’ID de chargement que vous avez reçu à l’[étape 3](#create-multipart-upload-step3). Pour plus d’informations sur la commande `list-parts`, consultez [https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html) dans le *Guide de l’utilisateur AWS Command Line Interface *.
```
aws s3api list-parts --bucket {{amzn-s3-demo-bucket1}} --key '{{census_data_file}}' --upload-id {{}} --query '{Parts: Parts[*].{PartNumber: PartNumber, ETag: ETag, ChecksumSHA256: ChecksumSHA256}}' --output json > parts.json
```
Un nouveau fichier appelé `parts.json` est généré. Ce fichier contient les informations, au format JSON, de toutes les parties que vous avez chargées. Le `parts.json` fichier contient des informations essentielles pour chaque partie de votre téléchargement partitionné, telles que les numéros de pièce et les ETag valeurs correspondantes, qui sont nécessaires pour terminer le processus de téléchargement partitionné.
1. Ouvrez `parts.json` à l’aide de n’importe quel éditeur de texte ou via le terminal. Voici l’exemple de sortie :
```
{
"Parts": [
{
"PartNumber": 1,
"ETag": "\"3c3097f89e2a2fece47ac54b243c9d97\"",
"ChecksumSHA256": "fTPVHfyNHdv5VkR4S3EewdyioXECv7JBxN+d4FXYYTw="
},
{
"PartNumber": 2,
"ETag": "\"03c71cc160261b20ab74f6d2c476b450\"",
"ChecksumSHA256": "VDWTa8enjOvULBAO3W2a6C+5/7ZnNjrnLApa1QVc3FE="
},
{
"PartNumber": 3,
"ETag": "\"81ae0937404429a97967dffa7eb4affb\"",
"ChecksumSHA256": "cVVkXehUlzcwrBrXgPIM+EKQXPUvWist8mlUTCs4bg8="
}
]
}
```
## Étape 6 : finalisation du chargement partitionné
Après le chargement et l’affichage de toutes les parties du chargement partitionné, la dernière étape consiste à finaliser le chargement partitionné. Cette étape fusionne toutes les parties chargées en un seul objet dans votre compartiment S3.
**Note**
Vous pouvez calculer la somme de contrôle de l’objet avant d’appeler `complete-multipart-upload` en incluant `--checksum-sha256` dans votre demande. Si les sommes ne correspondent pas, Amazon S3 ne répondra pas à la demande. Pour plus d’informations, consultez [https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html) dans le *Guide de l’utilisateur AWS Command Line Interface *.
**Pour finaliser le chargement partitionné**
Pour finaliser le chargement partitionné, utilisez la commande `complete-multipart-upload`. Cette commande nécessite le fichier `parts.json` créé à l’[étape 5](#list-parts-step5), le nom de votre compartiment et l’ID de chargement. Remplacez **<{{amzn-s3-demo-bucket1}}>** par le nom de votre compartiment et **** par l’ID de chargement de `parts.json`.
```
aws s3api complete-multipart-upload --multipart-upload file://parts.json --bucket {{amzn-s3-demo-bucket1}} --key 'census_data_file' --upload-id
```
Voici l’exemple de sortie :
```
{
"ServerSideEncryption": "AES256",
"Location": "https://{{amzn-s3-demo-bucket1}}.s3.us-east-2.amazonaws.com/census_data_file",
"Bucket": "{{amzn-s3-demo-bucket1}}",
"Key": "census_data_file",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3"
}
```
**Note**
Ne supprimez pas encore les fichiers de chaque partie chargée. Vous en aurez besoin pour pouvoir effectuer des sommes de contrôles correspondantes afin de vérifier l’intégrité de l’objet fusionné.
## Étape 7 : vérification du chargement de l’objet est dans votre compartiment
Une fois le chargement partitionné finalisé, vous pouvez vérifier que l’objet a bien été chargé dans votre compartiment S3. Pour répertorier les objets de votre compartiment et confirmer la présence du fichier qui vient d’être chargé, utilisez la commande `list-objects-v2`.
**Pour répertorier l’objet chargé**
Pour répertorier les objets de votre compartiment, utilisez la commande `list-objects-v2`. Remplacez **{{amzn-s3-demo-bucket1}}** par le nom de votre compartiment :
```
aws s3api list-objects-v2 --bucket {{amzn-s3-demo-bucket1}}
```
Cette commande renvoie une liste des objets qui se trouvent dans votre compartiment. Recherchez le fichier que vous avez chargé (par exemple, `census_data_file`) dans la liste des objets.
Pour plus d’informations, consultez la section [Exemples](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects-v2.html) correspondant à la commande `list-objects-v2` dans le *Guide de l’utilisateur AWS Command Line Interface *.
## Étape 8 : vérifier l'intégrité de l'objet à l'aide d'une somme MD5 de contrôle
Lorsque vous chargez un objet, vous pouvez spécifier un algorithme de somme de contrôle à utiliser par Amazon S3. Par défaut, Amazon S3 stocke le MD5 condensé d'octets sous la forme de celui de l'objet ETag. Pour les chargements partitionnés, ETag il ne s'agit pas de la somme de contrôle pour l'ensemble de l'objet, mais plutôt d'un composite des sommes de contrôle pour chaque partie individuelle.
**Pour vérifier l'intégrité d'un objet à l'aide d'une somme MD5 de contrôle**
1. Pour récupérer ETag l'objet téléchargé, effectuez une `head-object` requête :
```
aws s3api head-object --bucket {{amzn-s3-demo-bucket1}} --key {{census_data_file}}
```
Voici l’exemple de sortie :
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
« -3 » ETag est ajouté à la fin. Cela indique que l’objet a été chargé en trois parties à l’aide du chargement partitionné.
1. Ensuite, calculez la MD5 somme de contrôle de chaque pièce à l'aide de la `md5sum` commande. Veillez à fournir le chemin d’accès correct vers les fichiers partiels :
```
md5sum census-part*
```
Voici l’exemple de sortie :
```
e611693805e812ef37f96c9937605e69 census-part00
63d2d5da159178785bfd6b6a5c635854 census-part01
95b87c7db852451bb38b3b44a4e6d310 census-part02
```
1. Pour cette étape, combinez manuellement les MD5 hachages en une seule chaîne. Exécutez ensuite la commande suivante pour convertir la chaîne en binaire et calculer la MD5 somme de contrôle de la valeur binaire :
```
echo "{{e611693805e812ef37f96c9937605e6963d2d5da159178785bfd6b6a5c63585495b87c7db852451bb38b3b44a4e6d310}}" | xxd -r -p | md5sum
```
Voici l’exemple de sortie :
```
f453c6dccca969c457efdf9b1361e291 -
```
Cette valeur de hachage doit correspondre à la valeur de hachage de la ETag valeur d'origine de l'[étape 1](#create-large-file-step1), qui valide l'intégrité de l'objet. `census_data_file`
Lorsque vous demandez à Amazon S3 d’utiliser des totaux de contrôle supplémentaires, Amazon S3 calcule la valeur du total de contrôle pour chaque partie et stocke les valeurs. Pour récupérer les valeurs de somme de contrôle de chaque partie des chargements partitionnés qui sont toujours en cours, vous pouvez utiliser `list-parts`.
Pour plus d’informations sur le fonctionnement des sommes de contrôle avec les objets d’un chargement partitionné, consultez [Vérification de l’intégrité des objets dans Amazon S3](checking-object-integrity.md).
## Étape 9 : vérification de l’intégrité de l’objet à l’aide d’une somme de contrôle supplémentaire
Dans cette étape, ce didacticiel utilise SHA-256 comme somme de contrôle supplémentaire pour valider l’intégrité de l’objet. Si vous avez opté pour une somme de contrôle supplémentaire différente, utilisez cette valeur.
**Pour vérifier l'intégrité de l'objet avec SHA256**
1. Exécutez la commande suivante dans le terminal, y compris l’argument `--checksum-mode enabled`, pour afficher la valeur `ChecksumSHA256` de l’objet :
```
aws s3api head-object --bucket {{amzn-s3-demo-bucket1}} --key census_data_file --checksum-mode enabled
```
Voici l’exemple de sortie :
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
1. Utilisez les commandes suivantes pour décoder les valeurs `ChecksumSHA256` des différentes parties en base64 et les enregistrer dans un fichier binaire appelé `outfile`. Ces valeurs se trouvent dans le fichier `parts.json`. Remplacez les exemples de chaînes base64 par vos valeurs `ChecksumSHA256` réelles.
```
echo "{{QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0=}}" | base64 --decode >> outfile
echo "{{xCdgs1K5Bm4jWETYw/CmGYr+m6O2DcGfpckx5NVokvE=}}" | base64 --decode >> outfile
echo "{{f5wsfsa5bB+yXuwzqG1Bst91uYneqGD3CCidpb54mAo=}}" | base64 --decode >> outfile
```
1. Exécutez la commande suivante pour calculer la SHA256 somme de contrôle de `outfile` :
```
sha256sum outfile
```
Voici l’exemple de sortie :
```
688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9 outfile
```
À l’étape suivante, convertissez la valeur de hachage en valeur binaire. Cette valeur binaire doit correspondre à la valeur `ChecksumSHA256` de l’[étape 1](#create-large-file-step1).
1. [Convertissez la SHA256 somme de contrôle de l'[étape 3](#create-multipart-upload-step3) en binaire, puis encodez-la en base64 pour vérifier qu'elle correspond à la `ChecksumSHA256` valeur de l'étape 1 :](#create-large-file-step1)
```
echo "688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9" | xxd -r -p | base64
```
Voici l’exemple de sortie :
```
aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=
```
Cette sortie devrait confirmer que la sortie base64 correspond à la valeur `ChecksumSHA256` de la sortie de la commande `head-object`. Si la sortie correspond à la valeur de la somme de contrôle, l’objet est valide.
**Important**
Lorsque vous demandez à Amazon S3 d’utiliser des sommes de contrôle supplémentaires, Amazon S3 calcule les valeurs de sommes de contrôle pour chaque partie et les stocke.
Pour récupérer les valeurs de somme de contrôle de chaque partie des chargements partitionnés qui sont toujours en cours, vous pouvez utiliser la commande `list-parts`.
## Étape 10 : nettoyage de vos ressources
Si vous souhaitez nettoyer les fichiers créés dans ce didacticiel, appliquez la méthode suivante. Pour obtenir des instructions sur la suppression des fichiers chargés dans votre compartiment S3, consultez [Suppression d’objets Amazon S3](DeletingObjects.md).
**Supprimez les fichiers locaux créés à l’[étape 1](#create-large-file-step1) :**
Pour supprimer les fichiers que vous avez créés pour le chargement partitionné, exécutez la commande suivante à partir de votre répertoire de travail :
```
rm {{census-data.bin}} census-part* outfile parts.json
```