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.
# Chargement d’objets
Lorsque vous chargez un fichier dans Amazon S3, il est stocké en tant qu’*objet* S3. Les objets se composent des données du fichier et des métadonnées décrivant l’objet. Vous pouvez disposer d’un nombre illimité d’objets dans un compartiment. Avant de pouvoir charger des fichiers dans un compartiment Amazon S3, vous devez disposer d’autorisations en écriture pour le compartiment. Pour plus d’informations sur les autorisations d’accès, consultez [Gestion des identités et des accès pour Amazon S3](security-iam.md).
Vous pouvez charger n’importe quel type de fichier (images, sauvegardes, données, films, etc.) dans un compartiment S3. La console Amazon S3 vous permet de charger des fichiers d’une taille maximale de 160 Go. Pour charger un fichier de plus de 160 Go, utilisez l'API REST AWS Command Line Interface (AWS CLI) ou Amazon S3. AWS SDKs
Si vous chargez un objet avec un nom de clé qui existe déjà dans un compartiment pour lequel la gestion des versions est activée, Amazon S3 crée une autre version de l’objet au lieu de remplacer l’objet existant. Pour plus d’informations sur l’activation de la gestion des versions, consultez [Activation de la gestion des versions sur les compartiments](manage-versioning-examples.md).
Selon la taille des données chargées, Amazon S3 propose les options suivantes :
+ **Chargez un objet en une seule opération à l' AWS SDKsaide de l'API REST ou AWS CLI** : en une seule `PUT` opération, vous pouvez télécharger un seul objet d'une taille maximale de 5 Go.
+ **Charger un seul objet à l’aide de la console Amazon S3**** :** avec la console Amazon S3, vous pouvez charger un seul objet d’une taille maximale de 160 Go.
+ **Chargez un objet en plusieurs parties à l'aide de l' AWS SDKsAPI REST ou AWS CLI** **:** à l'aide de l'opération d'API de téléchargement en plusieurs parties, vous pouvez télécharger un seul objet de grande taille, d'une taille maximale de 50 To.
L’opération d’API de chargement partitionné est conçue pour améliorer l’expérience de chargement pour les objets plus volumineux. Vous pouvez charger un objet en plusieurs parties. Ces parties d’objet peuvent être chargées indépendamment, dans n’importe quel ordre, et en parallèle. Vous pouvez utiliser le téléchargement partitionné pour les objets d'une taille comprise entre 5 Mo et 50 To. Pour de plus amples informations, veuillez consulter [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
Pour télécharger des fichiers de plus de 5 To, utilisez le gestionnaire de transfert S3 dans Java v1/v2, Python ou. AWS CLI SDKs Pour des performances optimales, utilisez la dernière version du AWS Common Runtime (CRT) SDKs, qui a été optimisée pour une meilleure utilisation des ressources.
Lors du téléchargement d'objets volumineux à partir d'un flux de mémoire, le CRT met en mémoire tampon chaque partie jusqu'à 5 Go, limitant ainsi le débit global en fonction de la mémoire allouée. Vous pouvez ajuster la limite de mémoire CRT à l'aide d'options de configuration telles que `maxNativeMemoryLimitInBytes` pour le SDK Java. Pour les téléchargements depuis un disque, le CRT passe automatiquement au streaming direct sur disque au lieu de la mise en mémoire tampon des parties intermédiaires, ce qui améliore l'utilisation de la mémoire. Ce comportement est automatiquement activé pour les objets volumineux, mais peut également être activé pour les petits fichiers via des paramètres de demande tels que `should_stream` pour AWS CLI et `CRT_MEMORY_BUFFER_DISABLED` pour le SDK Java.
Lorsque vous chargez un objet, il est automatiquement chiffré à l’aide du chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3) par défaut. Lorsque vous le téléchargez, l’objet est déchiffré. Pour plus d’informations, consultez [Définition du comportement de chiffrement côté serveur par défaut pour les compartiments Amazon S3](bucket-encryption.md) et [Protection des données à l’aide du chiffrement](UsingEncryption.md).
Lorsque vous chargez un objet, si vous souhaitez utiliser un autre type de chiffrement par défaut, vous pouvez également spécifier un chiffrement côté serveur avec des clés AWS Key Management Service (AWS KMS) (SSE-KMS) dans vos `PUT` requêtes S3 ou définir la configuration de chiffrement par défaut dans le compartiment de destination afin d'utiliser SSE-KMS pour chiffrer vos données. Pour en savoir plus sur SSE-KMS, consultez [Spécification du chiffrement côté serveur avec AWS KMS (SSE-KMS)](specifying-kms-encryption.md). Si vous souhaitez utiliser une clé KMS qui appartient à un autre compte, vous devez avoir l’autorisation d’utiliser la clé. Pour plus d’informations sur les autorisations intercomptes pour les clés KMS, consultez [Création de clés KMS que d’autres comptes peuvent utiliser](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console) dans le *Guide du développeur AWS Key Management Service *.
Si vous rencontrez une erreur (403 Forbidden) liée à un refus d’accès dans Amazon S3, consultez [Résolution des erreurs d’accès refusé (403 Forbidden) dans Amazon S3](troubleshoot-403-errors.md) pour en savoir plus sur ses causes courantes.
## Charger un objet
### Utilisation de la console S3
Cette procédure explique la façon de charger un des objets et des dossiers dans un compartiment Amazon S3 à l’aide de la console.
Lorsque vous chargez un objet, le nom de clé d’objet est le nom du fichier et les préfixes facultatifs. Dans la console Amazon S3, vous pouvez créer des dossiers pour organiser vos objets. Dans Amazon S3, les dossiers sont représentés sous la forme de préfixes qui apparaissent dans le nom de la clé d’objet. Si vous téléchargez un objet individuel dans un dossier de la console Amazon S3, le nom du dossier est inclus dans le nom de la clé de l’objet.
Par exemple, si vous chargez un objet nommé `sample1.jpg` dans un dossier nommé `backup`, le nom de la clé sera `backup/sample1.jpg`. Cependant, l’objet s’affiche dans la console en tant que `sample1.jpg` dans le dossier `backup`. Pour en savoir plus sur les noms de clé, consultez [Utilisation des métadonnées d’objet](UsingMetadata.md).
**Note**
Si vous renommez un objet ou modifiez l’une de ses propriétés dans la console Amazon S3, par exemple **Classe de stockage**, **Chiffrement** ou **Métadonnées**, un nouvel objet est créé pour remplacer l’ancien. Si la gestion des versions S3 est activée, une nouvelle version de l’objet est créée et l’objet existant devient une version plus ancienne. Le rôle qui modifie la propriété devient également le propriétaire du nouvel objet ou (version de l’objet).
Lorsque vous chargez un dossier, Amazon S3 charge tous les fichiers et sous-dossiers du dossier spécifié dans le compartiment. Ensuite, il attribue un nom de clé d’objet qui combine le nom du fichier chargé et le nom du dossier. Par exemple, si vous chargez un dossier nommé `/images` qui contient deux fichiers, `sample1.jpg` et `sample2.jpg`, Amazon S3 charge les fichiers, puis attribue les noms de clé correspondants, `images/sample1.jpg` et `images/sample2.jpg`. Les noms de clé incluent le nom de dossier comme préfixe. La console Amazon S3 affiche uniquement la partie du nom de clé qui suit le dernier signe `/`. Par exemple, dans un dossier `images`, les objets `images/sample1.jpg` et `images/sample2.jpg` s’affichent sous les formes `sample1.jpg` et `sample2.jpg`.
**Pour charger des dossiers et des fichiers dans un compartiment S3**
1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Dans le panneau de navigation de gauche, choisissez **Compartiments**.
1. Dans la liste **Compartiments**, choisissez le nom du compartiment dans lequel vous souhaitez charger vos dossiers ou fichiers.
1. Choisissez **Charger**.
1. Dans la fenêtre **Charger**, procédez de l’une des manières suivantes :
+ Faites glisser et déposez les fichiers et les dossiers dans la fenêtre **Upload** (Charge).
+ Choisissez **Ajouter un fichier** ou **Ajouter un dossier**, puis choisissez les fichiers ou les dossiers à charger et **Ouvrir**.
1. Pour activer la gestion des versions, sous **Destination**, choisissez **Enable Bucket Versioning** (Activer la gestion des versions de compartiment).
1. Pour charger les fichiers et les dossiers répertoriés sans configurer des options de chargement supplémentaires, choisissez **Charger**.
Amazon S3 charge les objets et les dossiers. Lorsque le chargement est terminé, un message de réussite s’affiche sur la page **Charger : statut**.
**Pour configurer des propriétés d’objet supplémentaires**
1. Pour modifier les autorisations de la liste de contrôle d’accès, choisissez **Permissions** (Autorisations).
1. Sous **Access control list (ACL)** (Liste de contrôle d’accès (ACL)), modifiez les autorisations.
Pour plus d’informations sur les autorisations d’accès aux objets, consultez [Utilisation de la console S3 pour définir des autorisations ACL pour un objet](managing-acls.md#set-object-permissions). Vous pouvez octroyer l’accès en lecture à vos objets au public (tout le monde) pour tous les fichiers que vous chargez. Cependant, nous recommandons de ne pas modifier le paramètre par défaut de l’accès public en lecture. L’octroi de l’accès en lecture public est applicable à un petit sous-ensemble de cas d’utilisation, comme lorsque des compartiments sont utilisés pour des sites web. Vous pouvez toujours modifier les autorisations de l’objet après l’avoir chargé.
1. Pour configurer d’autres propriétés supplémentaires, sélectionnez **Properties** (Propriétés).
1. Dans **Classe de stockage**, choisissez la classe de stockage des fichiers à charger.
Pour plus d'informations sur les classes de stockage, consultez [Bien comprendre et gérer les classes de stockage Amazon S3](storage-class-intro.md).
1. Pour mettre à jour les paramètres de chiffrement de vos objets, sous **Server-side encryption settings** (Paramètres de chiffrement côté serveur), procédez comme suit.
1. Choisissez **Specify an encryption key** (Spécifier une clé de chiffrement).
1. Sous **Paramètres de chiffrement**, choisissez **Utiliser les paramètres du compartiment pour le chiffrement par défaut** ou **Ignorer les paramètres du compartiment pour le chiffrement par défaut**.
1. Si vous avez choisi **Ignorer les paramètres du compartiment pour le chiffrement par défaut**, vous devez configurer les paramètres de chiffrement suivants.
+ Pour chiffrer les fichiers chargés à l’aide des clés gérées par Amazon S3, choisissez **Clé gérée par Amazon S3 (SSE-S3)**.
Pour de plus amples informations, veuillez consulter [Utilisation du chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3)](UsingServerSideEncryption.md).
+ Pour chiffrer les fichiers téléchargés à l'aide des clés stockées dans AWS Key Management Service (AWS KMS), choisissez **AWS Key Management Service key (SSE-KMS**). Choisissez ensuite l’une des options suivantes pour **CléAWS KMS **:
+ Pour choisir parmi une liste de clés KMS disponibles, choisissez **Choisir parmi vos AWS KMS keys**, puis sélectionnez votre **Clé KMS** dans la liste des clés disponibles.
La clé Clé gérée par AWS (`aws/s3`) et la clé gérée par votre client apparaissent toutes deux dans cette liste. Pour plus d’informations sur les clés gérées par le client, consultez [Clés de client et clés AWS](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt) dans le *Guide du développeur AWS Key Management Service *.
+ Pour saisir l'ARN de la clé KMS, choisissez **Enter AWS KMS key ARN**, puis entrez l'ARN de votre clé KMS dans le champ qui apparaît.
+ Pour créer une nouvelle clé gérée par le client dans la AWS KMS console, choisissez **Create a KMS key**.
Pour plus d'informations sur la création d'un AWS KMS key, consultez la section [Création de clés](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html) dans le *Guide du AWS Key Management Service développeur*.
**Important**
Vous ne pouvez utiliser que les clés KMS disponibles dans le même compartiment Région AWS que le bucket. La console Amazon S3 répertorie uniquement les 100 premières clés KMS dans la même région que le compartiment. Pour utiliser une clé KMS qui n’est pas répertoriée, vous devez saisir l’ARN de votre clé KMS. Si vous souhaitez utiliser une clé KMS qui appartient à un autre compte, vous devez d'abord avoir l'autorisation d'utiliser cette clé KMS, puis saisir l'ARN de la clé KMS.
Amazon S3 prend uniquement en charge les clés KMS symétriques de chiffrement et ne prend pas en charge les clés KMS asymétriques. Pour plus d'informations, consultez la section [Identifying symmetric and asymmetric KMS keys](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html) (Identification des clés KMS symétriques et asymétriques) dans le *Guide du développeur AWS Key Management Service *.
1. Pour utiliser des sommes de contrôle supplémentaires, sélectionnez **Activé**. Ensuite, pour le champ **Checksum function** (Fonction total de contrôle), sélectionnez la fonction que vous souhaitez utiliser. Amazon S3 calcule et stocke la valeur du total de contrôle après avoir reçu l’objet entier. Vous pouvez utiliser la case **Precalculated value** (Valeur précalculée) pour fournir une valeur précalculée. Si vous le faites, Amazon S3 compare la valeur que vous avez fournie à la valeur qu’il calcule. Si les deux valeurs ne correspondent pas, Amazon S3 génère une erreur.
Les totaux de contrôle supplémentaires vous permettent de spécifier l’algorithme de total de contrôle que vous souhaitez utiliser pour vérifier vos données. Pour plus d’informations sur les totaux de contrôle supplémentaires, consultez [Vérification de l’intégrité des objets dans Amazon S3](checking-object-integrity.md).
1. Pour ajouter des balises à tous les objets que vous chargez, choisissez **Add tag (Ajouter une balise)**. Saisissez un nom de balise dans le champ **Clé**. Saisissez une valeur pour la balise.
Le balisage des objets vous permet de classer le stockage par catégorie. Chaque balise est une paire clés-valeurs. Les valeurs de clés et de balises sont sensibles à la casse. Vous pouvez avoir jusqu’à 10 balises par objet. Une clé de balise peut comporter jusqu’à 128 caractères Unicode et les valeurs de balise peuvent comporter jusqu’à 255 caractères Unicode. Pour en savoir plus sur les balises d’objet, consultez [Catégorisation de vos objets à l’aide de balises](object-tagging.md).
1. Pour ajouter des métadonnées, choisissez **Add metadata** (Ajouter des métadonnées).
1. Sous **Type**, choisissez **System defined** (Défini par le système) ou **User defined** (Défini par l’utilisateur).
Pour les métadonnées définies par le système, vous pouvez sélectionner des en-têtes HTTP courants, tels que **Content-Type** et **Content-Disposition**. Pour obtenir la liste des métadonnées définies par le système et savoir si vous pouvez ajouter la valeur, consultez [Métadonnées d’objet définies par le système](UsingMetadata.md#SysMetadata). Toute métadonnée commençant par le préfixe `x-amz-meta-` est traitée comme une métadonnée définie par l’utilisateur. Les métadonnées définies par l’utilisateur sont stockées avec l’objet et renvoyées une fois que vous avez téléchargé l’objet. Les clés et leurs valeurs doivent respecter les normes US-ASCII. Les métadonnées définies par l’utilisateur peuvent atteindre 2 Ko. Pour plus d’informations sur les métadonnées définies par le système et par l’utilisateur, consultez [Utilisation des métadonnées d’objet](UsingMetadata.md).
1. Pour **Key** (Clé), choisissez une clé.
1. Saisissez une valeur pour la clé.
1. Pour charger vos objets, choisissez **Charger**.
Amazon S3 charge votre objet. Lorsque le chargement est terminé, un message de succès s’affiche sur la page **Load: status** (Charger : statut).
1. Choisissez **Exit (Quitter)**.
### À l'aide du 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, consultez l’exemple [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples) dans la *Référence des commandes de l’AWS CLI *.
### Utilisation de l'API REST
Vous pouvez envoyer des demandes REST pour charger un objet. Vous pouvez envoyer une demande `PUT` pour charger des données en une seule opération. Pour plus d’informations, consultez [Objet PUT](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html).
### À l'aide du AWS SDKs
Pour des exemples de téléchargement d'un objet avec le AWS SDKs, consultez les [exemples de code](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_PutObject_section.html) dans le manuel *Amazon Simple Storage Service API Reference*.
Pour obtenir des informations générales sur l'utilisation de différents éléments AWS SDKs, consultez la section [Développement avec Amazon S3 AWS SDKs à l'aide](https://docs.aws.amazon.com/AmazonS3/latest/API/sdk-general-information-section.html) du *manuel Amazon Simple Storage Service API Reference*.
## Empêcher le chargement d’objets portant des noms de clé identiques
Vous pouvez vérifier l’existence d’un objet dans un compartiment avant de le créer à l’aide d’une écriture conditionnelle lors des opérations de chargement. Cela permet d’éviter l’écrasement de données existantes. Les écritures conditionnelles valident qu’aucun objet portant le même nom de clé ne se trouve déjà dans votre compartiment lors du chargement.
Vous pouvez utiliser des écritures conditionnelles pour les demandes [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) ou [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html).
Pour plus d’informations sur les demandes conditionnelles, consultez [Ajout de conditions préalables aux opérations S3 avec des demandes conditionnelles](conditional-requests.md).
# Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3
Le chargement partitionné vous permet de charger un seul objet dans Amazon S3 en plusieurs 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. Pour les téléchargements, votre AWS client mis à jour calcule automatiquement la somme de contrôle de l'objet et l'envoie à Amazon S3 avec la taille de l'objet dans le cadre de la demande. Si le transfert d’une partie échoue, vous pouvez la retransférer sans affecter les autres. Une fois que toutes les parties de l’objet sont chargées, Amazon S3 les assemble pour créer cet objet. Il est recommandé d’utiliser le chargement partitionné pour les objets d’au moins 100 Mo au lieu de les charger en une seule opération.
L’utilisation du chargement partitionné offre les avantages suivants :
+ **Meilleur débit** : vous pouvez charger des parties en parallèle pour améliorer le débit.
+ **Récupération rapide après des problèmes réseau** : la taille réduite des parties minimise l’impact du redémarrage d’un chargement qui a échoué en raison d’une erreur de réseau.
+ **Pause and resume object uploads** (Interruption et reprise des chargements d'objet) — vous pouvez charger des parties d'objet au fil du temps. Après le lancement d’un chargement partitionné, il n’y a aucune date d’expiration ; vous devez explicitement le terminer ou l’arrêter.
+ **Lancement d’un chargement avant de connaître la taille finale de l’objet** : vous pouvez charger un objet à mesure que vous le créez.
Nous vous recommandons d’utiliser le chargement partitionné comme suit :
+ Si vous chargez des objets volumineux sur un réseau stable à large bande passante, utilisez le chargement partitionné pour optimiser l’utilisation de la bande passante disponible en chargeant plusieurs parties d’objet en parallèle pour bénéficier de performances multithreads.
+ Si vous effectuez le chargement sur un réseau irrégulier, utilisez le chargement partitionné pour augmenter la résilience aux erreurs réseau en évitant les redémarrages du chargement. Lorsque vous utilisez le chargement partitionné, vous n’avez besoin de relancer le chargement que pour les parties d’objet dont le chargement a été interrompu. Vous n’avez pas besoin de redémarrer le chargement de vos objets depuis le début.
**Note**
Pour plus d’informations sur l’utilisation de la classe de stockage Amazon S3 Express One Zone avec des compartiments de répertoires, consultez [S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone) et [Utilisation des compartiments de répertoires](directory-buckets-overview.md). Pour plus d’informations sur l’utilisation du chargement partitionné avec S3 Express One Zone et les compartiments de répertoires, consultez [Utilisation du chargement partitionné avec les compartiments de répertoires](s3-express-using-multipart-upload.md).
## Processus de chargement partitionné
Le chargement partitionné est un processus en trois étapes : vous lancez le chargement, vous chargez les parties de l’objet, et une fois toutes les parties chargées, vous terminez le chargement partitionné. Dès réception de la demande de fin de chargement partitionné, Amazon S3 crée l’objet à partir des parties chargées pour que vous puissiez y accéder comme vous le feriez avec n’importe quel autre objet du compartiment.
Vous pouvez lister tous vos chargements partitionnés en cours ou obtenir une liste des parties que vous avez chargées pour un chargement partitionné spécifique. Chacune de ces opérations est expliquée dans cette section.
**Lancement du chargement partitionné**
Lorsque vous envoyez une demande pour lancer un chargement partitionné, veillez à spécifier un type de somme de contrôle. Amazon S3 renvoie une réponse avec un ID de chargement, qui est un identifiant unique pour le chargement partitionné. Cet ID de chargement est obligatoire lorsque vous chargez les parties, lorsque vous en affichez la liste, lorsque vous terminez un chargement ou lorsque vous arrêtez un chargement. Si vous souhaitez fournir des métadonnées qui décrivent l’objet en cours de chargement, procédez dans la demande de lancement du chargement partitionné. Les utilisateurs anonymes ne peuvent pas lancer de chargements partitionnés.
**Chargement de parties**
Lorsque vous chargez une partie, outre l’ID de chargement, vous devez spécifier un numéro de partie. 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 ne doit pas obligatoirement constituer une séquence consécutive (par exemple, cela peut être 1, 5 et 14). Sachez que si vous chargez une nouvelle partie avec le même numéro qu’une partie précédemment chargée, cette dernière sera écrasée.
Lorsque vous chargez une partie, Amazon S3 renvoie le type d’algorithme de la somme de contrôle avec la valeur de la somme de contrôle pour chaque partie chargée sous forme d’en-tête dans la réponse. Pour chaque téléchargement partiel, vous devez enregistrer le numéro de pièce et la ETag valeur. Vous devez inclure ces valeurs dans la demande ultérieure pour terminer le chargement partitionné. Chaque partie aura la sienne ETag au moment du téléchargement. Cependant, une fois que le téléchargement en plusieurs parties est terminé et que toutes les parties sont consolidées, toutes les parties appartiennent à une seule ETag sous forme de somme de contrôle des sommes de contrôle.
**Important**
Après avoir lancé un chargement partitionné et après avoir chargé une ou plusieurs parties, vous devez finaliser ou arrêter le chargement partitionné afin que le stockage des parties chargées cesse de vous être facturé. Ce n’est qu’*après* la fin ou l’arrêt d’un chargement partitionné qu’Amazon S3 libère le stockage des parties et cesse de vous le facturer.
Après avoir arrêté un chargement partitionné, vous ne pouvez plus charger de partie avec le même ID de chargement. Si des chargements de partie étaient en cours, ils peuvent encore aboutir ou échouer, même après un arrêt du chargement. Pour être sûr de libérer tout le stockage consommé par toutes les parties, n’arrêtez le chargement partitionné qu’après l’aboutissement de tous les chargements partiels.
**Fin du chargement partitionné**
Lorsque vous terminez un chargement partitionné, Amazon S3 crée un objet en concaténant les parties par ordre croissant en fonction des numéros de partie. Si des métadonnées d’objet sont fournies dans la demande de *lancement du chargement partitionné*, Amazon S3 les associe à l’objet. À l’issue d’une demande de *chargement complet*, les parties n’existent plus.
Votre demande *complète de téléchargement en plusieurs parties* doit inclure l'ID de téléchargement et une liste des numéros de pièce et leurs ETag valeurs correspondantes. La réponse Amazon S3 inclut un ETag identifiant unique les données d'objet combinées. Il ne ETag s'agit pas nécessairement d'un MD5 hachage des données 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. S3 stocke ensuite l’objet si les valeurs correspondent. Si les deux valeurs ne correspondent pas, Amazon 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 d’objet que vous utiliserez ultérieurement pour valider l’intégrité des données d’un objet.
**Exemples d’appels de chargement partitionné**
Pour cet exemple, supposons que vous génériez un chargement partitionné pour un fichier de 100 Go. Dans ce cas, vous recevez les appels d’API suivants pour l’ensemble du processus. Il y a un total de 1 002 appels d’API.
+ Appel `[CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)` pour commencer le processus.
+ 1 000 appels `[UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)` individuels, chacun chargeant une partie de 100 Mo, pour une taille totale de 100 Go.
+ Un appel `[CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)` pour finaliser le processus.
**Listes de chargement partitionné**
Vous pouvez lister les parties d’un chargement partitionné spécifique ou de tous les chargements partitionnés en cours. L’opération d’affichage de la liste des parties renvoie des informations sur les parties que vous avez chargées pour un chargement partitionné spécifique. Pour chaque demande de liste des parties, Amazon S3 renvoie des informations sur les parties pour le chargement partitionné spécifié, pour 1 000 parties maximum. S’il y a plus de 1 000 parties dans le chargement partitionné, vous devez envoyer une série de demandes d’affichage des différentes parties chargées pour récupérer toutes les parties. Notez que la liste des parties retournée n’inclut pas les parties qui n’ont pas fini d’être chargées. En utilisant l’opération d’*affichage des chargements partitionnés*, vous pouvez obtenir la liste des chargements partitionnés qui sont en cours.
Un chargement partitionné en cours est un chargement que vous avez lancé, mais que vous n’avez pas encore terminé ou arrêté. Chaque demande renvoie 1 000 chargements partitionnés maximum. S’il y a plus de 1 000 chargements partitionnés en cours, vous devez envoyer des demandes supplémentaires pour récupérer les chargements partitionnés restants. Utilisez la liste renvoyée uniquement pour la vérification.
**Important**
N’utilisez pas le résultat de la liste lorsque vous envoyez une requête de *chargement partitionné complet*. Conservez plutôt votre propre liste des numéros de pièce que vous avez spécifiés lors du chargement des pièces et des ETag valeurs correspondantes renvoyées par Amazon S3.
## Totaux de contrôle avec les opérations de chargement partitionné
Lorsque vous chargez un objet sur Simple Storage Service (Amazon S3), vous pouvez spécifier un algorithme de total de contrôle à utiliser par Amazon S3. Par défaut, le AWS SDK et la console S3 utilisent un algorithme pour tous les téléchargements d'objets, que vous pouvez remplacer. Si vous utilisez un ancien kit SDK et que votre objet chargé ne possède pas de somme de contrôle spécifiée, Amazon S3 utilise automatiquement l’algorithme de somme de contrôle CRC-64/NVME (`CRC64NVME`). Il s’agit également de l’option recommandée pour une vérification efficace de l’intégrité des données. Si vous utilisez CRC-64/NVME, Amazon S3 calcule la somme de contrôle de l’objet complet une fois que le chargement partitionné ou non partitionné est terminé. L’algorithme CRC-64/NVME sert à calculer soit la somme de contrôle directe de l’objet entier, soit la somme de contrôle des sommes de contrôle de chaque partie.
Une fois que vous avez chargé un objet dans S3 à l’aide d’un chargement partitionné, Amazon S3 calcule la somme de contrôle de chaque partie chargée ou de l’objet complet et stocke les valeurs. Vous pouvez utiliser l'API ou le AWS SDK S3 pour récupérer la valeur de la somme de contrôle de la manière suivante :
+ Pour les parties individuelles, vous pouvez utiliser [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) ou [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html). Pour récupérer les valeurs des sommes de contrôle pour chaque partie des chargements partitionnés toujours en cours, vous pouvez utiliser [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html).
+ Pour l’ensemble de l’objet, vous pouvez utiliser [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html). Si vous souhaitez effectuer un chargement partitionné avec la somme de contrôle d’un objet complet, utilisez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload) et [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload) en spécifiant le type de somme de contrôle de l’objet entier. Pour valider la valeur de la somme de contrôle de l’objet entier ou pour confirmer le type de somme de contrôle utilisé dans le chargement partitionné, utilisez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html).
**Important**
Si vous utilisez un chargement partitionné avec des **sommes de contrôle**, les numéros de chaque partie du chargement partitionné doivent être consécutifs. Lorsque vous utilisez des **sommes de contrôle**, si vous essayez de finaliser une demande de chargement partitionné avec des numéros de parties non consécutifs, Amazon S3 génère une erreur `HTTP 500 Internal Server`.
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).
Pour une end-to-end procédure expliquant comment charger un objet à l'aide du téléchargement partitionné avec une somme de contrôle supplémentaire, consultez. [Didacticiel : chargement partitionné d’un objet et vérification de l’intégrité de ses données](tutorial-s3-mpu-additional-checksums.md)
## Opérations simultanées de chargement partitionné
Dans un environnement de développement distribué, il est possible pour l’application de lancer plusieurs mises à jour sur le même objet en même temps. L’application doit lancer plusieurs chargements partitionnés grâce à la même clé d’objet. Pour chacun de ces chargements, l’application peut ensuite charger des parties et envoyer une demande de chargement complet à Amazon S3 pour créer l’objet. Lorsque les compartiments sont activés pour la gestion des versions S3, un chargement partitionné terminé crée toujours une nouvelle version. Lorsque vous lancez plusieurs chargements partitionnés qui utilisent la même clé d’objet dans un compartiment activé pour la gestion des versions, la version actuelle de l’objet est déterminée par le chargement le plus récent (`createdDate`).
Par exemple, vous lancez une demande `CreateMultipartUpload` pour un objet à 10 h. Ensuite, vous soumettez une deuxième demande `CreateMultipartUpload` pour le même objet à 11 h. Comme la deuxième demande a été soumise le plus récemment, l’objet chargé par la demande de 11 h devient la version actuelle, même si le premier chargement se termine après le second. Pour les compartiments pour lesquels la gestion des versions n’a pas été activée, il est possible que d’autres demandes reçues entre le début et la fin d’un chargement partitionné priment.
Un autre exemple de cas où une demande de chargement partitionné simultané peut être prioritaire est le cas d’une autre opération supprimant une clé après que vous avez lancé un chargement partitionné avec cette même clé. Avant que vous ne finalisiez l’opération, la réponse de finalisation du chargement partitionné peut indiquer une création d’objet réussie sans que vous n’ayez jamais vu l’objet.
## Empêcher le chargement d’objets portant des noms de clé identiques lors du chargement partitionné
Vous pouvez vérifier l’existence d’un objet dans un compartiment avant de le créer à l’aide d’une écriture conditionnelle lors des opérations de chargement. Cela permet d’éviter l’écrasement de données existantes. Les écritures conditionnelles valident qu’aucun objet portant le même nom de clé ne se trouve déjà dans votre compartiment lors du chargement.
Vous pouvez utiliser des écritures conditionnelles pour les demandes [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) ou [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html).
Pour plus d’informations sur les demandes conditionnelles, consultez [Ajout de conditions préalables aux opérations S3 avec des demandes conditionnelles](conditional-requests.md).
## Chargement partitionné et tarification
Lorsque vous lancez un chargement partitionné, Amazon S3 conserve toutes les parties jusqu’à ce que vous terminiez ou arrêtiez le chargement. Tout au long de sa durée de vie, le stockage, la bande passante et les demandes pour ce chargement partitionné ainsi que ses parties associées vous sont facturés.
Ces parties sont facturées en fonction de la classe de stockage spécifiée lors du chargement des parties. Toutefois, ces parties ne vous seront pas facturées si elles sont chargées dans S3 Glacier Flexible Retrieval ou S3 Glacier Deep Archive. Les parties multipartites en cours d’exécution d’une commande PUT vers la classe de stockage S3 Glacier Flexible Retrieval sont facturées en tant que stockage de transit S3 Glacier Flexible Retrieval aux tarifs de stockage S3 Standard jusqu’à ce que le chargement soit terminé. De plus, `CreateMultipartUpload` et `UploadPart` sont tous deux facturés aux tarifs S3 Standard. Seule la demande `CompleteMultipartUpload` est facturée au tarif S3 Glacier Flexible Retrieval. De même, les parties multipartites en cours d’exécution d’une commande PUT vers la classe de stockage S3 Glacier Deep Archive sont facturées en tant que stockage de transit S3 Glacier Flexible Retrieval aux tarifs de stockage standard S3 jusqu’à ce que le chargement soit terminé. Seule la demande `CompleteMultipartUpload` est facturée aux tarifs S3 Glacier Deep Archive.
Si vous arrêtez le chargement partitionné, Amazon S3 supprime les artefacts et toutes les parties que vous avez chargées. Ces artefacts ne vous seront pas facturés. Aucuns frais de suppression anticipée ne sont facturés pour la suppression de chargements partitionnés incomplets, quelle que soit la classe de stockage spécifiée. Pour plus d’informations sur la tarification, consultez [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Note**
Pour réduire vos coûts de stockage, nous vous recommandons de configurer une règle du cycle de vie pour supprimer les chargements partitionnés incomplets après un certain nombre de jours à l’aide de l’action `AbortIncompleteMultipartUpload`. Pour plus d’informations sur la création d’une règle de cycle de vie pour supprimer les chargements partitionnés incomplets, consultez [Configuration d’une politique de cycle de vie de compartiment pour abandonner les chargements multiparties incomplets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html).
## Prise en charge de l’API pour le chargement partitionné
Les sections suivantes de la *Référence de l’API Amazon Simple Storage Service* décrivent l’API REST pour le chargement partitionné.
Pour une procédure de téléchargement en plusieurs parties utilisant les fonctions AWS Lambda, consultez la section Chargement d'objets volumineux sur [Amazon S3 à l'aide du téléchargement en plusieurs](https://aws.amazon.com/blogs/compute/uploading-large-objects-to-amazon-s3-using-multipart-upload-and-transfer-acceleration/) parties et de l'accélération du transfert.
+ [Création d’un chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Chargement d’une partie](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [Chargement d’une partie (Copy)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Achèvement du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [Interruption du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [Liste des parties](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [Liste des chargements partitionnés](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## AWS Command Line Interface support pour le téléchargement partitionné
Les rubriques suivantes AWS Command Line Interface décrivent les opérations de téléchargement partitionné.
+ [Lancement du chargement partitionné](https://docs.aws.amazon.com/cli/latest/reference/s3api/create-multipart-upload.html)
+ [Chargement d’une partie](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [Chargement d’une partie (Copy)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Achèvement du chargement partitionné](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [Interruption du chargement partitionné](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [Liste des parties](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [Liste des chargements partitionnés](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## AWS Support du SDK pour le téléchargement en plusieurs parties
Vous pouvez utiliser an AWS SDKs pour télécharger un objet en plusieurs parties. Pour une liste des actions AWS SDKs prises en charge par l'API, voir :
+ [Création d’un chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Chargement d’une partie](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [Chargement d’une partie (Copy)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Achèvement du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [Interruption du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [Liste des parties](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [Liste des chargements partitionnés](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## API de chargement partitionné et autorisations
Vous devez posséder les autorisations nécessaires pour utiliser les opérations de chargement partitionné. Vous pouvez utiliser les listes de contrôle d'accès (ACLs), la politique des compartiments ou la politique utilisateur pour autoriser les individus à effectuer ces opérations. Le tableau suivant répertorie les autorisations requises pour les différentes opérations de téléchargement partitionné lors de l'utilisation ACLs d'une politique de compartiment ou d'une politique utilisateur.
| Action | Autorisations requises |
| --- | --- |
| Création d’un chargement partitionné | Vous devez être autorisé à exécuter l’action `s3:PutObject` sur un objet pour pouvoir créer un chargement partitionné. Le propriétaire du compartiment peut autoriser d’autres personnes habilitées à exécuter l’action `s3:PutObject`. |
| Lancement du chargement partitionné | Vous devez être autorisé à exécuter l’action `s3:PutObject` sur un objet pour pouvoir lancer le chargement partitionné. Le propriétaire du compartiment peut autoriser d’autres personnes habilitées à exécuter l’action `s3:PutObject`. |
| Initiateur | Elément du conteneur qui identifie l’initiateur du chargement partitionné. Si l'initiateur est un Compte AWS, cet élément fournit les mêmes informations que l'élément Owner. Si l’initiateur est un utilisateur IAM, cet élément fournit l’ARN utilisateur et le nom complet. |
| Chargement d’une partie | Vous devez être autorisé à exécuter l’action `s3:PutObject` sur un objet pour charger une partie. Le propriétaire du compartiment doit autoriser l’initiateur à exécuter l’action `s3:PutObject` sur un objet pour que ce dernier charge une partie pour cet objet. |
| Chargement d’une partie (Copy) | Vous devez être autorisé à exécuter l’action `s3:PutObject` sur un objet pour charger une partie. Sachant que vous chargez une partie d’un objet existant, vous devez être autorisé à exécuter l’action `s3:GetObject` sur l’objet source. Pour que l’initiateur puisse charger une partie pour un objet, le propriétaire du compartiment doit l’autoriser à effectuer l’action `s3:PutObject` sur l’objet. |
| Achèvement du chargement partitionné | Vous devez être autorisé à exécuter l’action `s3:PutObject` sur un objet pour terminer le chargement partitionné. Le propriétaire du compartiment doit autoriser l’initiateur à exécuter l’action `s3:PutObject` sur un objet pour que ce dernier termine un chargement partitionné pour cet objet. |
| Arrêt du chargement partitionné | Vous devez être autorisé à exécuter l’action `s3:AbortMultipartUpload` pour arrêter un chargement partitionné. Par défaut, le propriétaire du compartiment et l’initiateur du chargement partitionné sont autorisés à exécuter cette action dans le cadre des politiques IAM et de compartiment S3. Si l'initiateur est un utilisateur IAM, celui-ci Compte AWS est également autorisé à arrêter ce téléchargement partitionné. Dans le cadre des politiques de point de terminaison de VPC, l’initiateur du chargement partitionné n’a pas automatiquement l’autorisation d’effectuer l’action `s3:AbortMultipartUpload`. Outre ces paramètres par défaut, le propriétaire du compartiment peut autoriser d’autres principaux à être habilité à exécuter l’action `s3:AbortMultipartUpload` sur un objet. Le propriétaire du compartiment peut refuser que tout principal soit habilité à exécuter l’action `s3:AbortMultipartUpload`. |
| Liste des parties | Vous devez être autorisé à exécuter l’action `s3:ListMultipartUploadParts` sur un objet pour lister les parties lors d’un chargement partitionné. Par défaut, le propriétaire du compartiment est autorisé à lister les parties pour tout chargement partitionné dans le compartiment. L’initiateur du chargement partitionné est autorisé à lister les parties du chargement partitionné spécifique. Si l'initiateur du téléchargement partitionné est un utilisateur IAM, l'utilisateur IAM Compte AWS contrôlant cet utilisateur est également autorisé à répertorier les parties de ce téléchargement. Outre ces paramètres par défaut, le propriétaire du compartiment peut autoriser d'autres principaux à être habilité à exécuter l'action `s3:ListMultipartUploadParts` sur un objet. Le propriétaire du compartiment peut également refuser que tout principal soit habilité à exécuter l’action `s3:ListMultipartUploadParts`. |
| Liste des chargements partitionnés | Vous devez être autorisé à exécuter l’action `s3:ListBucketMultipartUploads` sur un compartiment pour lister les chargements partitionnés en cours dans ce compartiment. Outre ces paramètres par défaut, le propriétaire du compartiment peut autoriser d’autres personnes habilitées à exécuter l’action `s3:ListBucketMultipartUploads` sur le compartiment. |
| AWS KMS Chiffrer et déchiffrer les autorisations associées | Pour effectuer un téléchargement partitionné avec chiffrement à l'aide d'une clé KMS AWS Key Management Service (AWS KMS), le demandeur doit disposer des autorisations suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonS3/latest/userguide/mpuoverview.html) Ces autorisations sont requises, car Simple Storage Service (Amazon S3) doit déchiffrer et lire les données des parties de fichier chiffrées avant de terminer le chargement partitionné. L’autorisation `kms:Decrypt` et le chiffrement côté serveur avec les clés de chiffrement fournies par le client sont également nécessaires pour obtenir la valeur de la somme de contrôle d’un objet. Si vous ne disposez pas des autorisations requises lorsque vous utilisez l’API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html), l’objet sera créé sans valeur de somme de contrôle. Si votre utilisateur ou rôle IAM est identique Compte AWS à celui de la clé KMS, vérifiez que vous disposez d'autorisations à la fois sur la clé et sur les politiques IAM. Si votre utilisateur ou rôle IAM appartient à un autre compte que la clé KMS, vous devez disposer des autorisations sur la politique de clé et votre utilisateur ou rôle IAM. |
| SSE-C (chiffrement côté serveur à l’aide des clés de chiffrement fournies par le client) | Lorsque vous utilisez l’API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html), vous devez fournir un chiffrement côté serveur avec des clés de chiffrement fournies par le client (SSE-C). Dans le cas contraire, l’objet sera créé sans somme de contrôle et aucune valeur de somme de contrôle ne sera renvoyée. |
Pour en savoir plus sur la relation entre les autorisations de liste ACL et les autorisations des politiques d’accès, consultez [Mappage des autorisations de liste ACL et de stratégie d’accès](acl-overview.md#acl-access-policy-permission-mapping). Pour obtenir plus d’informations sur les utilisateurs IAM, les rôles et les bonnes pratiques, consultez [Identités IAM (utilisateurs, groupes d’utilisateurs et rôles)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) dans le *Guide de l’utilisateur IAM*.
## Totaux de contrôle avec les opérations de chargement partitionné
Trois Amazon S3 APIs sont utilisés pour effectuer le chargement partitionné proprement dit : [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html), [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html), et [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html). Le tableau suivant indique les en-têtes et les valeurs de checksum qui doivent être fournis pour chacun des éléments : APIs
| Algorithme de somme de contrôle | Type de somme de contrôle | `CreateMultipartUpload` | `UploadPart` | `CompleteMultipartUpoad` |
| --- | --- | --- | --- | --- |
| CRC-64/NVME (`CRC64NVME`) | Objet complet | En-têtes obligatoires : `x-amz-checksum-algorithm` | En-têtes facultatifs : `x-amz-checksum-crc64nvme` | En-têtes facultatifs : `x-amz-checksum-algorithm` `x-amz-crc64` |
| CRC-32 (`CRC32`) CRC 32-C (`CRC32C`) | Objet complet | En-têtes obligatoires : `x-amz-checksum-algorithm` `x-amz-checksum-type` | En-têtes facultatifs : `x-amz-checksum-crc64nvme` | En-têtes facultatifs : `x-amz-checksum-algorithm` `x-amz-crc32` `x-amz-crc32c` |
| CRC-32 (`CRC32`) CRC-32C (`CRC32C`) SHA-1 (`SHA1`) SHA-256 (`SHA256`) | Composite | En-têtes obligatoires : `x-amz-checksum-algorithm` | En-têtes obligatoires : `x-amz-checksum-crc32` `x-amz-checksum-crc32c` `x-amz-checksum-sha1` `x-amz-checksum-sha256` | En-têtes obligatoires : Toutes les sommes de contrôle au niveau de chaque partie doivent être incluses dans la demande `CompleteMultiPartUpload`. En-têtes facultatifs : `x-amz-crc32` `x-amz-crc32c` `x-amz-sha1` `x-amz-sha256` |
**Topics**
+ [
## Processus de chargement partitionné
](#mpu-process)
+ [
## Totaux de contrôle avec les opérations de chargement partitionné
](#mpuchecksums)
+ [
## Opérations simultanées de chargement partitionné
](#distributedmpupload)
+ [
## Empêcher le chargement d’objets portant des noms de clé identiques lors du chargement partitionné
](#multipart-upload-objects-with-same-key-name)
+ [
## Chargement partitionné et tarification
](#mpuploadpricing)
+ [
## Prise en charge de l’API pour le chargement partitionné
](#apisupportformpu)
+ [
## AWS Command Line Interface support pour le téléchargement partitionné
](#clisupportformpu)
+ [
## AWS Support du SDK pour le téléchargement en plusieurs parties
](#sdksupportformpu)
+ [
## API de chargement partitionné et autorisations
](#mpuAndPermissions)
+ [
## Totaux de contrôle avec les opérations de chargement partitionné
](#Checksums-mpu-operations)
+ [
# Configuration d’une configuration de cycle de vie de compartiment pour supprimer les chargements partitionnés incomplets
](mpu-abort-incomplete-mpu-lifecycle-config.md)
+ [
# Chargement d’un objet à l’aide du chargement partitionné
](mpu-upload-object.md)
+ [
# Téléchargement d'un répertoire à l'aide de la classe .NET TransferUtility de haut niveau
](HLuploadDirDotNet.md)
+ [
# Liste des chargements partitionnés
](list-mpu.md)
+ [
# Suivi d'un téléchargement en plusieurs parties à l'aide du AWS SDKs
](track-mpu.md)
+ [
# Interruption d’un chargement partitionné
](abort-mpu.md)
+ [
# Copie d’un objet à l’aide du chargement partitionné
](CopyingObjectsMPUapi.md)
+ [
# Didacticiel : chargement partitionné d’un objet et vérification de l’intégrité de ses données
](tutorial-s3-mpu-additional-checksums.md)
+ [
# Limites de la fonction de chargement partitionné Amazon S3
](qfacts.md)
# Configuration d’une configuration de cycle de vie de compartiment pour supprimer les chargements partitionnés incomplets
Dans le cadre des bonnes pratiques, nous vous recommandons de configurer une règle du cycle de vie à l’aide de l’action `AbortIncompleteMultipartUpload` pour réduire les coûts de stockage. Pour plus d’informations sur l’abandon d’un chargement multipartie, consultez [Interruption d’un chargement partitionné](abort-mpu.md).
Simple Storage Service (Amazon S3) prend en charge une règle de cycle de vie de compartiment que vous pouvez utiliser pour demander à Simple Storage Service (Amazon S3) d’arrêter les chargements partitionnés s’ils ne se terminent pas avant la valeur spécifiée pour le nombre de jours après leur lancement. Lorsqu’un chargement partitionné n’est pas terminé dans le délai imparti, il peut être annulé. Amazon S3 arrête alors le chargement partitionné et supprime les pièces associées au chargement partitionné. Cette règle s’applique à la fois aux chargements partitionnés existants et à ceux que vous créerez ultérieurement.
Voici un exemple de configuration du cycle de vie qui spécifie une règle avec l’action `AbortIncompleteMultipartUpload`.
```
sample-rule
Enabled
7
```
Dans l’exemple, la règle ne spécifie pas de valeur pour l’élément `Prefix` (le [préfixe du nom de la clé de l’objet](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#keyprefix)). Par conséquent, la règle s’applique à tous les objets du compartiment pour lesquels vous avez lancé des téléchargements partitionnés. Tous les téléchargements partitionnés qui ont été lancés et qui ne se sont pas terminés dans les sept jours peuvent faire l’objet d’une interruption. L’action Annuler n’a aucun effet sur les téléchargements partitionnés terminés.
Pour en savoir plus sur la configuration du cycle de vie du compartiment, consultez [Gestion du cycle de vie des objets](object-lifecycle-mgmt.md).
**Note**
Si le chargement partitionné est terminé dans le temps imparti spécifié dans la règle, l’action du cycle de vie `AbortIncompleteMultipartUpload` ne s’applique pas (cela signifie qu’Amazon S3 n’applique aucune action). En outre, cette action ne s’applique pas aux objets. Aucun objet n’est supprimé par cette action de cycle de vie. De plus, vous n’aurez pas à payer de frais de suppression anticipée pour le cycle de vie S3 lorsque vous supprimez des parties de chargements partitionnés incomplets.
## Utilisation de la console S3
Pour gérer automatiquement les chargements partitionnés incomplets, vous pouvez utiliser la console S3 pour créer une règle de cycle de vie afin de faire expirer les octets de chargement partitionnés incomplets de votre compartiment après un nombre de jours spécifié. La procédure suivante vous montre comment ajouter une règle de cycle de vie pour supprimer les chargements partitionnés incomplets après sept jours. Pour plus d’informations sur l’ajout de règles de cycle de vie, consultez [Définition d’une configuration du cycle de vie S3 sur un compartiment](how-to-set-lifecycle-configuration-intro.md).
**Pour ajouter une règle de cycle de vie afin d’interrompre les chargements partitionnés incomplets datant de plus de sept jours.**
1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Dans la liste **Compartiments**, choisissez le nom du compartiment pour lequel vous souhaitez créer une stratégie de cycle de vie.
1. Choisissez l’onglet **Management (Gestion)**, puis choisissez **Create lifecycle rule (Créer une règle de cycle de vie)**.
1. Dans **Lifecycle rule name (Nom de la règle du cycle de vie)**, saisissez un nom pour votre règle.
Ce nom doit être unique dans le compartiment.
1. Choisissez l’étendue de la règle de cycle de vie :
+ Pour créer une règle de cycle de vie pour tous les objets ayant un préfixe spécifique, sélectionnez **Limit the scope of this rule using one or more filters** (Limiter l’étendue de cette règle à l’aide d’un ou plusieurs filtres), puis saisissez le préfixe dans le champ **Prefix** (Préfixe).
+ Pour créer une règle de cycle de vie pour tous les objets du compartiment, sélectionnez l’option **This rule applies to **all** objects in the bucket** (Cette règle s’applique à tous les objets du compartiment), puis sélectionnez **I acknowledge that this rule applies to all objects in the bucket** (Je reconnais que cette règle s’applique à tous les objets du compartiment).
1. Sous **Lifecycle rule actions** (Actions des règles de cycle de vie), sélectionnez **Delete expired object delete markers or incomplete multipart uploads** (Supprimer les marqueurs de suppression d’objets expirés ou les chargements partitionnés incomplets).
1. Sous **Delete expired object delete markers or incomplete multipart uploads** (Supprimer les marqueurs de suppression des objets expirés ou les chargements partitionnés incomplets), sélectionnez **Delete incomplete multipart uploads** (Supprimer les chargements partitionnés incomplets).
1. Dans le champ **Number of days** (Nombre de jours), saisissez le nombre de jours au bout duquel vous souhaitez supprimer les chargements partitionnés incomplets (dans cet exemple, sept jours).
1. Choisissez **Créer une règle**.
## À l'aide du AWS CLI
La commande suivante `put-bucket-lifecycle-configuration`AWS Command Line Interface (AWS CLI) ajoute la configuration du cycle de vie pour le compartiment spécifié. Pour utiliser cette commande, remplacez `user input placeholders` par vos informations.
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration filename-containing-lifecycle-configuration
```
L’exemple suivant montre comment ajouter une règle de cycle de vie pour interrompre les chargements partitionnés incomplets en utilisant la AWS CLI. Il comprend un exemple de configuration du cycle de vie JSON pour interrompre les chargements partitionnés incomplets datant de plus de sept jours.
Pour utiliser les commandes CLI de cet exemple, remplacez `user input placeholders` par vos informations.
**Pour ajouter une règle de cycle de vie afin d’interrompre les chargements partitionnés incomplets**
1. Configurez le AWS CLI. Pour obtenir des instructions, consultez la section [Développement avec Amazon S3 à l'aide de la AWS CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html) dans le *manuel Amazon S3 API Reference*.
1. Enregistrez l’exemple de configuration du cycle de vie suivant dans un fichier (par exemple, *`lifecycle.json`*``). Cet exemple de configuration spécifie un préfixe vide, et s’applique donc à tous les objets du compartiment. Pour restreindre la configuration à un sous-ensemble d’objets, vous pouvez spécifier un préfixe.
```
{
"Rules": [
{
"ID": "Test Rule",
"Status": "Enabled",
"Filter": {
"Prefix": ""
},
"AbortIncompleteMultipartUpload": {
"DaysAfterInitiation": 7
}
}
]
}
```
1. Exécutez la commande CLI suivante pour configurer cette configuration du cycle de vie sur le compartiment.
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration file://lifecycle.json
```
1. Pour vérifier que la configuration du cycle de vie a été définie sur votre compartiment, récupérez la configuration du cycle de vie en utilisant la commande `get-bucket-lifecycle` suivante.
```
aws s3api get-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
1. Pour supprimer la configuration du cycle de vie, utilisez la commande `delete-bucket-lifecycle` suivante.
```
aws s3api delete-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
# Chargement d’un objet à l’aide du chargement partitionné
Vous pouvez utiliser le chargement partitionné pour charger par programme un seul objet sur Amazon S3. Chaque objet est chargé 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. Les utilisateurs anonymes ne peuvent pas lancer de chargements partitionnés.
Pour une end-to-end procédure de téléchargement d'un objet avec un téléchargement en plusieurs parties avec une somme de contrôle supplémentaire, voir. [Didacticiel : chargement partitionné d’un objet et vérification de l’intégrité de ses données](tutorial-s3-mpu-additional-checksums.md)
La section suivante explique comment utiliser le téléchargement partitionné avec AWS Command Line Interface, et AWS SDKs.
## Utilisation de la console S3
Vous pouvez charger n’importe quel type de fichier (images, sauvegardes, données, films, etc.) dans un compartiment S3. La console Amazon S3 vous permet de charger des fichiers d’une taille maximale de 160 Go. Pour charger un fichier de plus de 160 Go, utilisez l'API REST AWS Command Line Interface (AWS CLI) ou Amazon S3. AWS SDKs
Pour obtenir des instructions sur le téléchargement d'un objet via le AWS Management Console, consultez[Chargement d’objets](upload-objects.md).
## À l'aide du AWS CLI
La section suivante décrit les opérations Amazon S3 pour le chargement partitionné à l’aide de l’ AWS CLI.
+ [Lancement du chargement partitionné](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-multipart-upload.html)
+ [Chargement d’une partie](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [Chargement d’une partie (Copy)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Achèvement du chargement partitionné](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [Interruption du chargement partitionné](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [Liste des parties](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [Liste des chargements partitionnés](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## Utilisation de l'API REST
Les sections suivantes de la *Référence de l'API Amazon Simple Storage Service* décrivent l'API REST pour le chargement partitionné.
+ [Lancement du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Chargement d’une partie](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Achèvement du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Arrêt du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [Liste des parties](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [Liste des chargements partitionnés](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
## Utilisation de AWS SDKs (API de haut niveau)
Certains AWS SDKs proposent une API de haut niveau qui simplifie le téléchargement en plusieurs parties en combinant les différentes opérations d'API requises pour effectuer un téléchargement en plusieurs parties en une seule opération. Pour de plus amples informations, veuillez consulter [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
Si vous devez interrompre et reprendre des chargements partitionnés, modifiez la taille des parties lors du chargement, ou si vous ignorez la taille des données à charger, utilisez les méthodes d’API de bas niveau. Les méthodes d’API de bas niveau pour les chargements partitionnés offrent des fonctionnalités supplémentaires. Pour plus d’informations, consultez [Utilisation de AWS SDKs (API de bas niveau)](#mpu-upload-low-level).
------
#### [ Java ]
Pour des exemples expliquant comment effectuer un chargement partitionné avec le AWS SDK pour Java, [consultez la section Charger ou télécharger des fichiers volumineux vers et depuis Amazon S3 à l'aide AWS d'un](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html) SDK dans le manuel *Amazon S3 API Reference*.
------
#### [ .NET ]
Pour charger un fichier dans un compartiment S3, utilisez la classe `TransferUtility`. Lorsque vous chargez les données d’un fichier, vous devez fournir le nom de clé de l’objet. Sinon, l’API utilise le nom du fichier comme nom de clé. Lorsque vous chargez les données d’un flux, vous devez fournir le nom de clé de l’objet.
Utilisez la classe `TransferUtilityUploadRequest` pour définir des options avancées, comme la taille des parties, le nombre de threads lors du chargement simultané des parties, les métadonnées, la classe de stockage ou une liste ACL.
**Note**
Lorsque vous utilisez un flux comme source de données, la classe `TransferUtility` n’effectue pas de chargements simultanés.
L’exemple C\$1 suivant charge un fichier dans un compartiment Amazon S3 en plusieurs parties. Il montre comment utiliser différentes surcharges `TransferUtility.Upload` pour charger un fichier. Chaque appel de chargement successif remplace le chargement précédent. Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez [Getting Started with the AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET dans *AWS le Guide du développeur du SDK pour* .NET.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPUHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadFileAsync().Wait();
}
private static async Task UploadFileAsync()
{
try
{
var fileTransferUtility =
new TransferUtility(s3Client);
// Option 1. Upload a file. The file name is used as the object key name.
await fileTransferUtility.UploadAsync(filePath, bucketName);
Console.WriteLine("Upload 1 completed");
// Option 2. Specify object key name explicitly.
await fileTransferUtility.UploadAsync(filePath, bucketName, keyName);
Console.WriteLine("Upload 2 completed");
// Option 3. Upload data from a type of System.IO.Stream.
using (var fileToUpload =
new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
await fileTransferUtility.UploadAsync(fileToUpload,
bucketName, keyName);
}
Console.WriteLine("Upload 3 completed");
// Option 4. Specify advanced settings.
var fileTransferUtilityRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
StorageClass = S3StorageClass.StandardInfrequentAccess,
PartSize = 6291456, // 6 MB.
Key = keyName,
CannedACL = S3CannedACL.PublicRead
};
fileTransferUtilityRequest.Metadata.Add("param1", "Value1");
fileTransferUtilityRequest.Metadata.Add("param2", "Value2");
await fileTransferUtility.UploadAsync(fileTransferUtilityRequest);
Console.WriteLine("Upload 4 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
#### [ JavaScript ]
**Example**
Chargez un fichier volumineux.
```
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import {
ProgressBar,
logger,
} from "@aws-doc-sdk-examples/lib/utils/util-log.js";
const twentyFiveMB = 25 * 1024 * 1024;
export const createString = (size = twentyFiveMB) => {
return "x".repeat(size);
};
/**
* Create a 25MB file and upload it in parts to the specified
* Amazon S3 bucket.
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
const str = createString();
const buffer = Buffer.from(str, "utf8");
const progressBar = new ProgressBar({
description: `Uploading "${key}" to "${bucketName}"`,
barLength: 30,
});
try {
const upload = new Upload({
client: new S3Client({}),
params: {
Bucket: bucketName,
Key: key,
Body: buffer,
},
});
upload.on("httpUploadProgress", ({ loaded, total }) => {
progressBar.update({ current: loaded, total });
});
await upload.done();
} catch (caught) {
if (caught instanceof Error && caught.name === "AbortError") {
logger.error(`Multipart upload was aborted. ${caught.message}`);
} else {
throw caught;
}
}
};
```
**Example**
Téléchargez un fichier volumineux.
```
import { fileURLToPath } from "node:url";
import { GetObjectCommand, NoSuchKey, S3Client } from "@aws-sdk/client-s3";
import { createWriteStream, rmSync } from "node:fs";
const s3Client = new S3Client({});
const oneMB = 1024 * 1024;
export const getObjectRange = ({ bucket, key, start, end }) => {
const command = new GetObjectCommand({
Bucket: bucket,
Key: key,
Range: `bytes=${start}-${end}`,
});
return s3Client.send(command);
};
/**
* @param {string | undefined} contentRange
*/
export const getRangeAndLength = (contentRange) => {
const [range, length] = contentRange.split("/");
const [start, end] = range.split("-");
return {
start: Number.parseInt(start),
end: Number.parseInt(end),
length: Number.parseInt(length),
};
};
export const isComplete = ({ end, length }) => end === length - 1;
const downloadInChunks = async ({ bucket, key }) => {
const writeStream = createWriteStream(
fileURLToPath(new URL(`./${key}`, import.meta.url)),
).on("error", (err) => console.error(err));
let rangeAndLength = { start: -1, end: -1, length: -1 };
while (!isComplete(rangeAndLength)) {
const { end } = rangeAndLength;
const nextRange = { start: end + 1, end: end + oneMB };
const { ContentRange, Body } = await getObjectRange({
bucket,
key,
...nextRange,
});
console.log(`Downloaded bytes ${nextRange.start} to ${nextRange.end}`);
writeStream.write(await Body.transformToByteArray());
rangeAndLength = getRangeAndLength(ContentRange);
}
};
/**
* Download a large object from and Amazon S3 bucket.
*
* When downloading a large file, you might want to break it down into
* smaller pieces. Amazon S3 accepts a Range header to specify the start
* and end of the byte range to be downloaded.
*
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
try {
await downloadInChunks({
bucket: bucketName,
key: key,
});
} catch (caught) {
if (caught instanceof NoSuchKey) {
console.error(`Failed to download object. No such key "${key}".`);
rmSync(key);
}
}
};
```
------
#### [ Go ]
Pour plus d'informations sur l'exemple de code Go pour le chargement en plusieurs parties, consultez [Importer ou télécharger des fichiers volumineux vers et depuis Amazon S3 à l'aide d'un AWS SDK](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html).
**Example**
Chargez un objet volumineux à l’aide d’un gestionnaire de chargement qui divise les données en plusieurs parties et les charge simultanément.
```
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"log"
"os"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/smithy-go"
)
// BucketBasics encapsulates the Amazon Simple Storage Service (Amazon S3) actions
// used in the examples.
// It contains S3Client, an Amazon S3 service client that is used to perform bucket
// and object actions.
type BucketBasics struct {
S3Client *s3.Client
}
```
```
// UploadLargeObject uses an upload manager to upload data to an object in a bucket.
// The upload manager breaks large data into parts and uploads the parts concurrently.
func (basics BucketBasics) UploadLargeObject(ctx context.Context, bucketName string, objectKey string, largeObject []byte) error {
largeBuffer := bytes.NewReader(largeObject)
var partMiBs int64 = 10
uploader := manager.NewUploader(basics.S3Client, func(u *manager.Uploader) {
u.PartSize = partMiBs * 1024 * 1024
})
_, err := uploader.Upload(ctx, &s3.PutObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
Body: largeBuffer,
})
if err != nil {
var apiErr smithy.APIError
if errors.As(err, &apiErr) && apiErr.ErrorCode() == "EntityTooLarge" {
log.Printf("Error while uploading object to %s. The object is too large.\n"+
"The maximum size for a multipart upload is 5TB.", bucketName)
} else {
log.Printf("Couldn't upload large object to %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
} else {
err = s3.NewObjectExistsWaiter(basics.S3Client).Wait(
ctx, &s3.HeadObjectInput{Bucket: aws.String(bucketName), Key: aws.String(objectKey)}, time.Minute)
if err != nil {
log.Printf("Failed attempt to wait for object %s to exist.\n", objectKey)
}
}
return err
}
```
**Example**
Téléchargez un objet volumineux en utilisant un gestionnaire de téléchargement pour obtenir les données en plusieurs parties et les télécharger simultanément.
```
// DownloadLargeObject uses a download manager to download an object from a bucket.
// The download manager gets the data in parts and writes them to a buffer until all of
// the data has been downloaded.
func (basics BucketBasics) DownloadLargeObject(ctx context.Context, bucketName string, objectKey string) ([]byte, error) {
var partMiBs int64 = 10
downloader := manager.NewDownloader(basics.S3Client, func(d *manager.Downloader) {
d.PartSize = partMiBs * 1024 * 1024
})
buffer := manager.NewWriteAtBuffer([]byte{})
_, err := downloader.Download(ctx, buffer, &s3.GetObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
})
if err != nil {
log.Printf("Couldn't download large object from %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
return buffer.Bytes(), err
}
```
------
#### [ PHP ]
Cette rubrique explique comment utiliser la `Aws\S3\Model\MultipartUpload\UploadBuilder` classe de haut niveau de la AWS SDK pour PHP pour les téléchargements de fichiers en plusieurs parties. Pour plus d'informations sur l'API AWS SDK for Ruby, consultez [AWS SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Version 2.
L’exemple de code PHP ci-dessous permet de charger un fichier vers un compartiment Amazon S3. Il explique comment définir les paramètres de l’objet `MultipartUploader`.
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Prepare the upload parameters.
$uploader = new MultipartUploader($s3, '/path/to/large/file.zip', [
'bucket' => $bucket,
'key' => $keyname
]);
// Perform the upload.
try {
$result = $uploader->upload();
echo "Upload complete: {$result['ObjectURL']}" . PHP_EOL;
} catch (MultipartUploadException $e) {
echo $e->getMessage() . PHP_EOL;
}
```
------
#### [ Python ]
L’exemple suivant charge un objet à l’aide de l’API Python de haut niveau de chargements partitionnés (la classe `TransferManager`).
```
import sys
import threading
import boto3
from boto3.s3.transfer import TransferConfig
MB = 1024 * 1024
s3 = boto3.resource("s3")
class TransferCallback:
"""
Handle callbacks from the transfer manager.
The transfer manager periodically calls the __call__ method throughout
the upload and download process so that it can take action, such as
displaying progress to the user and collecting data about the transfer.
"""
def __init__(self, target_size):
self._target_size = target_size
self._total_transferred = 0
self._lock = threading.Lock()
self.thread_info = {}
def __call__(self, bytes_transferred):
"""
The callback method that is called by the transfer manager.
Display progress during file transfer and collect per-thread transfer
data. This method can be called by multiple threads, so shared instance
data is protected by a thread lock.
"""
thread = threading.current_thread()
with self._lock:
self._total_transferred += bytes_transferred
if thread.ident not in self.thread_info.keys():
self.thread_info[thread.ident] = bytes_transferred
else:
self.thread_info[thread.ident] += bytes_transferred
target = self._target_size * MB
sys.stdout.write(
f"\r{self._total_transferred} of {target} transferred "
f"({(self._total_transferred / target) * 100:.2f}%)."
)
sys.stdout.flush()
def upload_with_default_configuration(
local_file_path, bucket_name, object_key, file_size_mb
):
"""
Upload a file from a local folder to an Amazon S3 bucket, using the default
configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_chunksize_and_meta(
local_file_path, bucket_name, object_key, file_size_mb, metadata=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart chunk size and adding metadata to the Amazon S3 object.
The multipart chunk size controls the size of the chunks of data that are
sent in the request. A smaller chunk size typically results in the transfer
manager using more threads for the upload.
The metadata is a set of key-value pairs that are stored with the object
in Amazon S3.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_chunksize=1 * MB)
extra_args = {"Metadata": metadata} if metadata else None
s3.Bucket(bucket_name).upload_file(
local_file_path,
object_key,
Config=config,
ExtraArgs=extra_args,
Callback=transfer_callback,
)
return transfer_callback.thread_info
def upload_with_high_threshold(local_file_path, bucket_name, object_key, file_size_mb):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard upload instead of
a multipart upload.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_sse(
local_file_path, bucket_name, object_key, file_size_mb, sse_key=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, adding server-side
encryption with customer-provided encryption keys to the object.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_default_configuration(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using the
default configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_single_thread(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using a
single thread.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(use_threads=False)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_high_threshold(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard download instead
of a multipart download.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_sse(
bucket_name, object_key, download_file_path, file_size_mb, sse_key
):
"""
Download a file from an Amazon S3 bucket to a local folder, adding a
customer-provided encryption key to the request.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
```
------
## Utilisation de AWS SDKs (API de bas niveau)
Le AWS SDK présente une API de bas niveau qui ressemble beaucoup à l'API REST d'Amazon S3 pour les téléchargements partitionnés (voir. [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md) Utilisez l'API de bas niveau lorsque vous devez suspendre et reprendre les téléchargements partitionnés, faire varier la taille des parties pendant le téléchargement ou si vous ne connaissez pas la taille des données de téléchargement à l'avance. Lorsque vous n'avez pas ces exigences, utilisez l'API de haut niveau (voir[Utilisation de AWS SDKs (API de haut niveau)](#multipart-upload-high-level)).
------
#### [ Java ]
L’exemple suivant montre comment utiliser les classes Java de bas niveau pour charger un fichier. Il exécute les étapes suivantes :
+ Initie un chargement partitionné à l’aide de la méthode `AmazonS3Client.initiateMultipartUpload()` et transmet un objet `InitiateMultipartUploadRequest`.
+ Enregistre l’ID de chargement renvoyé par la méthode `AmazonS3Client.initiateMultipartUpload()`. Vous devez fournir cet ID de chargement pour chaque opération suivante de chargement partitionné.
+ Charge les parties de l’objet. Pour chaque partie, appelez la méthode `AmazonS3Client.uploadPart()`. Vous fournissez les informations de chargement de partie à l’aide d’un objet `UploadPartRequest`.
+ Pour chaque partie, enregistre le ETag résultat de la réponse de la `AmazonS3Client.uploadPart()` méthode dans une liste. Vous utilisez les ETag valeurs pour terminer le téléchargement partitionné.
+ Appelle la méthode `AmazonS3Client.completeMultipartUpload()` pour terminer le chargement partitionné.
**Example**
Pour obtenir des instructions sur la création et le test d'un échantillon de travail, voir [Getting Started](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) dans le guide du AWS SDK pour Java développeur.
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class LowLevelMultipartUpload {
public static void main(String[] args) throws IOException {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String keyName = "*** Key name ***";
String filePath = "*** Path to file to upload ***";
File file = new File(filePath);
long contentLength = file.length();
long partSize = 5 * 1024 * 1024; // Set part size to 5 MB.
try {
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(clientRegion)
.withCredentials(new ProfileCredentialsProvider())
.build();
// Create a list of ETag objects. You retrieve ETags for each object part
// uploaded,
// then, after each individual part has been uploaded, pass the list of ETags to
// the request to complete the upload.
List partETags = new ArrayList();
// Initiate the multipart upload.
InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(bucketName, keyName);
InitiateMultipartUploadResult initResponse = s3Client.initiateMultipartUpload(initRequest);
// Upload the file parts.
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++) {
// Because the last part could be less than 5 MB, adjust the part size as
// needed.
partSize = Math.min(partSize, (contentLength - filePosition));
// Create the request to upload a part.
UploadPartRequest uploadRequest = new UploadPartRequest()
.withBucketName(bucketName)
.withKey(keyName)
.withUploadId(initResponse.getUploadId())
.withPartNumber(i)
.withFileOffset(filePosition)
.withFile(file)
.withPartSize(partSize);
// Upload the part and add the response's ETag to our list.
UploadPartResult uploadResult = s3Client.uploadPart(uploadRequest);
partETags.add(uploadResult.getPartETag());
filePosition += partSize;
}
// Complete the multipart upload.
CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest(bucketName, keyName,
initResponse.getUploadId(), partETags);
s3Client.completeMultipartUpload(compRequest);
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
}
```
------
#### [ .NET ]
L'exemple C\$1 suivant montre comment utiliser l'API de téléchargement SDK pour .NET partitionné de bas niveau pour télécharger un fichier dans un compartiment S3. Pour plus d’informations sur les chargements partitionnés Amazon S3, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
**Note**
Lorsque vous utilisez l' SDK pour .NET API pour télécharger des objets volumineux, un délai d'attente peut se produire lors de l'écriture des données dans le flux de demandes. Vous pouvez définir un délai explicite en utilisant `UploadPartRequest`.
L’exemple de code C\$1 suivant charge un fichier dans un compartiment S3 grâce à l’API de chargement partitionné de bas niveau. Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez [Getting Started with the AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET dans *AWS le Guide du développeur du SDK pour* .NET.
```
using Amazon;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPULowLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Uploading an object");
UploadObjectAsync().Wait();
}
private static async Task UploadObjectAsync()
{
// Create list to store upload part responses.
List uploadResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Upload parts.
long contentLength = new FileInfo(filePath).Length;
long partSize = 5 * (long)Math.Pow(2, 20); // 5 MB
try
{
Console.WriteLine("Uploading parts");
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++)
{
UploadPartRequest uploadRequest = new UploadPartRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId,
PartNumber = i,
PartSize = partSize,
FilePosition = filePosition,
FilePath = filePath
};
// Track upload progress.
uploadRequest.StreamTransferProgress +=
new EventHandler(UploadPartProgressEventCallback);
// Upload a part and add the response to our list.
uploadResponses.Add(await s3Client.UploadPartAsync(uploadRequest));
filePosition += partSize;
}
// Setup to complete the upload.
CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(uploadResponses);
// Complete the upload.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (Exception exception)
{
Console.WriteLine("An AmazonS3Exception was thrown: { 0}", exception.Message);
// Abort the upload.
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await s3Client.AbortMultipartUploadAsync(abortMPURequest);
}
}
public static void UploadPartProgressEventCallback(object sender, StreamTransferProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
#### [ PHP ]
Cette rubrique explique comment utiliser la `uploadPart` méthode de bas niveau de la version 3 de AWS SDK pour PHP pour télécharger un fichier en plusieurs parties. Pour plus d'informations sur l'API AWS SDK for Ruby, consultez [AWS SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Version 2.
L’exemple PHP suivant charge un fichier dans un compartiment Amazon S3 grâce au chargement partitionné de l’API PHP de bas niveau.
```
require 'vendor/autoload.php';
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$filename = '*** Path to and Name of the File to Upload ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
$result = $s3->createMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'StorageClass' => 'REDUCED_REDUNDANCY',
'Metadata' => [
'param1' => 'value 1',
'param2' => 'value 2',
'param3' => 'value 3'
]
]);
$uploadId = $result['UploadId'];
// Upload the file in parts.
try {
$file = fopen($filename, 'r');
$partNumber = 1;
while (!feof($file)) {
$result = $s3->uploadPart([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'PartNumber' => $partNumber,
'Body' => fread($file, 5 * 1024 * 1024),
]);
$parts['Parts'][$partNumber] = [
'PartNumber' => $partNumber,
'ETag' => $result['ETag'],
];
$partNumber++;
echo "Uploading part $partNumber of $filename." . PHP_EOL;
}
fclose($file);
} catch (S3Exception $e) {
$result = $s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId
]);
echo "Upload of $filename failed." . PHP_EOL;
}
// Complete the multipart upload.
$result = $s3->completeMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'MultipartUpload' => $parts,
]);
$url = $result['Location'];
echo "Uploaded $filename to $url." . PHP_EOL;
```
------
## À l'aide du AWS SDK pour Ruby
La AWS SDK pour Ruby version 3 prend en charge les téléchargements partitionnés sur Amazon S3 de deux manières. Pour la première option, vous pouvez utiliser des chargements de fichiers gérés. Pour plus d’informations, consultez [Uploading Files to Amazon S3](https://aws.amazon.com/blogs/developer/uploading-files-to-amazon-s3/) dans le *Blog des développeurs AWS *. Les chargements de fichiers gérés constituent la méthode recommandée pour charger des fichiers dans un compartiment. Ces chargements offrent les avantages suivants :
+ Ils gèrent les chargements partitionnés pour les objets de plus de 15 Mo.
+ Ils ouvrent correctement les fichiers en mode binaire pour éviter les problèmes d’encodage.
+ Ils utilisent plusieurs threads pour le chargement des parties d’objets volumineux en parallèle.
Vous pouvez également utiliser directement les opérations suivantes du client de chargement partitionné :
+ [create\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#create_multipart_upload-instance_method) – Lance un chargement partitionné et renvoie un ID de chargement.
+ [upload\$1part](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part-instance_method) – Charge une partie d’un chargement partitionné.
+ [upload\$1part\$1copy](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part_copy-instance_method) – Charge une partie en copiant les données d’un objet existant comme source de données.
+ [complete\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#complete_multipart_upload-instance_method) – Termine un chargement partitionné en assemblant des parties chargées précédemment.
+ [abort\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#abort_multipart_upload-instance_method) – Arrête un chargement partitionné.
# Téléchargement d'un répertoire à l'aide de la classe .NET TransferUtility de haut niveau
Vous pouvez utiliser la classe `TransferUtility` pour charger un répertoire entier. Par défaut, l’API charge uniquement les fichiers à la racine du répertoire spécifié. Toutefois, vous pouvez spécifier de charger les fichiers de manière récursive dans tous les sous-répertoires.
Indiquez des expressions de filtre pour sélectionner des fichiers dans le répertoire spécifié selon des critères de filtrage. Par exemple, pour ne charger que les fichiers `PDF` d’un répertoire, spécifiez l’expression de filtre `"*.pdf"`.
Quand vous chargez des données depuis un répertoire, vous ne spécifiez pas les noms de clé pour les objets résultants. Amazon S3 génère les noms de clé à l’aide du chemin du fichier d’origine. Par exemple, si vous avez un répertoire appelé `c:\myfolder` avec la structure suivante :
**Example**
```
1. C:\myfolder
2. \a.txt
3. \b.pdf
4. \media\
5. An.mp3
```
Lorsque vous chargez ce répertoire, Amazon S3 utilise les noms de clé suivants :
**Example**
```
1. a.txt
2. b.pdf
3. media/An.mp3
```
**Example**
L’exemple C\$1 suivant charge un répertoire dans un compartiment Amazon S3. Il montre comment utiliser différentes surcharges `TransferUtility.UploadDirectory` pour charger le répertoire. Chaque appel de chargement successif remplace le chargement précédent. Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez [Getting Started with the AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET dans *AWS le Guide du développeur du SDK pour* .NET.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadDirMPUHighLevelAPITest
{
private const string existingBucketName = "*** bucket name ***";
private const string directoryPath = @"*** directory path ***";
// The example uploads only .txt files.
private const string wildCard = "*.txt";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadDirAsync().Wait();
}
private static async Task UploadDirAsync()
{
try
{
var directoryTransferUtility =
new TransferUtility(s3Client);
// 1. Upload a directory.
await directoryTransferUtility.UploadDirectoryAsync(directoryPath,
existingBucketName);
Console.WriteLine("Upload statement 1 completed");
// 2. Upload only the .txt files from a directory
// and search recursively.
await directoryTransferUtility.UploadDirectoryAsync(
directoryPath,
existingBucketName,
wildCard,
SearchOption.AllDirectories);
Console.WriteLine("Upload statement 2 completed");
// 3. The same as Step 2 and some optional configuration.
// Search recursively for .txt files to upload.
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = existingBucketName,
Directory = directoryPath,
SearchOption = SearchOption.AllDirectories,
SearchPattern = wildCard
};
await directoryTransferUtility.UploadDirectoryAsync(request);
Console.WriteLine("Upload statement 3 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine(
"Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine(
"Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
# Liste des chargements partitionnés
Vous pouvez utiliser l' AWS CLI API REST ou AWS SDKs, pour récupérer une liste des téléchargements partitionnés en cours dans Amazon S3. Vous pouvez utiliser le chargement partitionné pour charger par programme un seul objet sur Amazon S3. Les chargements partitionnés déplacent un objet vers Amazon S3 en déplaçant des portions des données de cet objet à la fois. Pour en savoir plus sur le chargement partitionné, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
Pour une end-to-end procédure de téléchargement d'un objet avec un téléchargement en plusieurs parties avec une somme de contrôle supplémentaire, voir. [Didacticiel : chargement partitionné d’un objet et vérification de l’intégrité de ses données](tutorial-s3-mpu-additional-checksums.md)
La section suivante explique comment répertorier les téléchargements partitionnés en cours avec l' AWS Command Line Interface API REST Amazon S3 et. AWS SDKs
## Répertorier les téléchargements partitionnés à l'aide du AWS CLI
Les sections suivantes AWS Command Line Interface décrivent les opérations de listage des téléchargements partitionnés.
+ [list-parts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-parts.html)‐ répertorie les parties chargées pour un chargement partitionné spécifique.
+ [list-multipart-uploads](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)‐liste les téléchargements partitionnés en cours.
# Liste des chargements partitionnés à l’aide de l’API REST
Les sections suivantes de la *Référence de l’API Amazon Simple Storage Service* décrivent l’API REST pour la liste des chargements partitionnés.
+ [ListParts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)‐liste les parties téléchargées pour un téléchargement en plusieurs parties spécifique.
+ [ListMultipartUploads](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)‐liste les téléchargements partitionnés en cours.
## Répertorier les téléchargements partitionnés à l'aide du AWS SDK (API de bas niveau)
------
#### [ Java ]
Pour répertorier tous les téléchargements partitionnés en cours sur un bucket à l'aide du SDK for AWS Java, vous pouvez utiliser les classes d'API de bas niveau pour :
**Processus d’élaboration de la liste des chargements partitionnés via l’API de bas niveau**
| | |
| --- |--- |
| 1 | Créer une instance de la classe `ListMultipartUploadsRequest` et préciser le nom du compartiment. |
| 2 | Exécuter la méthode `listMultipartUploads` S3Client. Cette méthode renvoie une instance de la classe `ListMultipartUploadsResponse`, qui vous fournit des informations sur les chargements partitionnés en cours. |
*Pour des exemples expliquant comment répertorier les téléchargements partitionnés à l'aide du AWS SDK pour Java, consultez la section Répertorier les téléchargements [partitionnés dans](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_ListMultipartUploads_section.html) le manuel Amazon S3 API Reference.*
------
#### [ .NET ]
Pour afficher tous les chargements partitionnés en cours vers un compartiment spécifique, utilisez la classe `ListMultipartUploadsRequest` de l’API de chargement partitionné de bas niveau du kit SDK pour .NET . La méthode `AmazonS3Client.ListMultipartUploads` retourne une instance de la classe `ListMultipartUploadsResponse` qui fournit des informations sur les chargements partitionnés en cours.
Un chargement partitionné en cours est un chargement partitionné qui a été lancé à l’aide d’une demande de lancement de chargement partitionné, mais qui n’a pas encore été terminé ou arrêté. Pour en savoir plus sur les chargements partitionnés Amazon S3, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
L'exemple C\$1 suivant montre comment utiliser le pour SDK pour .NET répertorier tous les téléchargements partitionnés en cours sur un bucket. Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez [Getting Started with the AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET dans *AWS le Guide du développeur du SDK pour* .NET.
```
ListMultipartUploadsRequest request = new ListMultipartUploadsRequest
{
BucketName = bucketName // Bucket receiving the uploads.
};
ListMultipartUploadsResponse response = await AmazonS3Client.ListMultipartUploadsAsync(request);
```
------
#### [ PHP ]
Cette rubrique explique comment utiliser les classes d'API de bas niveau de la version 3 de AWS SDK pour PHP pour répertorier tous les téléchargements partitionnés en cours sur un bucket. Pour plus d'informations sur l'API AWS SDK for Ruby, consultez [AWS SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Version 2.
L’exemple PHP suivant montre comment répertorier tous les chargements partitionnés en cours sur un compartiment.
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Retrieve a list of the current multipart uploads.
$result = $s3->listMultipartUploads([
'Bucket' => $bucket
]);
// Write the list of uploads to the page.
print_r($result->toArray());
```
------
# Suivi d'un téléchargement en plusieurs parties à l'aide du AWS SDKs
Vous pouvez suivre la progression du chargement d’un objet vers Amazon S3 à l’aide d’une interface d’écoute. L’API de chargement partitionné de haut niveau fournit une interface d’écoute appelée `ProgressListener`. Les événements de progression ont lieu de manière périodique et informent l’écouteur que des octets ont été transférés. Pour en savoir plus sur le chargement partitionné, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
Pour une end-to-end procédure de téléchargement d'un objet avec un téléchargement en plusieurs parties avec une somme de contrôle supplémentaire, voir. [Didacticiel : chargement partitionné d’un objet et vérification de l’intégrité de ses données](tutorial-s3-mpu-additional-checksums.md)
La section suivante explique comment suivre un téléchargement partitionné avec le AWS SDKs.
------
#### [ Java ]
**Example**
L’exemple de code Java suivant charge un fichier et utilise le `ExecutionInterceptor` pour suivre la progression du chargement. Pour obtenir des instructions sur la création et le test d'un échantillon de travail, consultez [Getting Started](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html) dans le guide du développeur AWS SDK pour Java 2.x.
```
import java.nio.file.Paths;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.interceptor.Context;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.ExecutionInterceptor;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
public class TrackMPUProgressUsingHighLevelAPI {
static class ProgressListener implements ExecutionInterceptor {
private long transferredBytes = 0;
@Override
public void beforeTransmission(Context.BeforeTransmission context, ExecutionAttributes executionAttributes) {
if (context.httpRequest().firstMatchingHeader("Content-Length").isPresent()) {
String contentLength = context.httpRequest().firstMatchingHeader("Content-Length").get();
long partSize = Long.parseLong(contentLength);
transferredBytes += partSize;
System.out.println("Transferred bytes: " + transferredBytes);
}
}
}
public static void main(String[] args) throws Exception {
String existingBucketName = "*** Provide bucket name ***";
String keyName = "*** Provide object key ***";
String filePath = "*** file to upload ***";
S3AsyncClient s3Client = S3AsyncClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.overrideConfiguration(c -> c.addExecutionInterceptor(new ProgressListener()))
.build();
// For more advanced uploads, you can create a request object
// and supply additional request parameters (ex: progress listeners,
// canned ACLs, etc.)
PutObjectRequest request = PutObjectRequest.builder()
.bucket(existingBucketName)
.key(keyName)
.build();
AsyncRequestBody requestBody = AsyncRequestBody.fromFile(Paths.get(filePath));
// You can ask the upload for its progress, or you can
// add a ProgressListener to your request to receive notifications
// when bytes are transferred.
// S3AsyncClient processes all transfers asynchronously,
// so this call will return immediately.
var upload = s3Client.putObject(request, requestBody);
try {
// You can block and wait for the upload to finish
upload.join();
} catch (Exception exception) {
System.out.println("Unable to upload file, upload aborted.");
exception.printStackTrace();
} finally {
s3Client.close();
}
}
}
```
------
#### [ .NET ]
L’exemple C\$1 suivant charge un fichier dans un compartiment S3 à l’aide de la classe `TransferUtility` et suit la progression du chargement. Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez [Getting Started with the AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET dans *AWS le Guide du développeur du SDK pour* .NET.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class TrackMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide the bucket name ***";
private const string keyName = "*** provide the name for the uploaded object ***";
private const string filePath = " *** provide the full path name of the file to upload **";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
TrackMPUAsync().Wait();
}
private static async Task TrackMPUAsync()
{
try
{
var fileTransferUtility = new TransferUtility(s3Client);
// Use TransferUtilityUploadRequest to configure options.
// In this example we subscribe to an event.
var uploadRequest =
new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
Key = keyName
};
uploadRequest.UploadProgressEvent +=
new EventHandler
(uploadRequest_UploadPartProgressEvent);
await fileTransferUtility.UploadAsync(uploadRequest);
Console.WriteLine("Upload completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
static void uploadRequest_UploadPartProgressEvent(object sender, UploadProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
# Interruption d’un chargement partitionné
Après avoir lancé un chargement partitionné, vous commencez à charger les parties. Amazon S3 stocke ces parties et ne crée l’objet qu’une fois que vous avez chargé toutes les parties et envoyé une demande de finalisation du chargement partitionné. Dès réception de la demande de fin de chargement partitionné, Amazon S3 assemble les parties et crée un objet. Si vous n’envoyez pas correctement la demande de finalisation du chargement partitionné, S3 n’assemble pas les différentes parties et ne crée aucun objet. Si vous ne souhaitez pas finaliser un chargement partitionné après avoir chargé différentes parties, vous devez abandonner le chargement partitionné.
Vous êtes facturé pour tout le stockage associé aux parties chargées. Il est recommandé de toujours finaliser le chargement partitionné ou d’arrêter le chargement partitionné pour supprimer les parties chargées. Pour de plus amples informations sur la tarification, consultez [Chargement partitionné et tarification](mpuoverview.md#mpuploadpricing).
Vous pouvez également arrêter un chargement partitionné incomplet à l’aide d’une configuration de cycle de vie de compartiment. Pour de plus amples informations, veuillez consulter [Configuration d’une configuration de cycle de vie de compartiment pour supprimer les chargements partitionnés incomplets](mpu-abort-incomplete-mpu-lifecycle-config.md).
La section suivante explique comment arrêter un chargement partitionné en cours dans Amazon S3 à l'aide de l' AWS Command Line Interface API REST ou. AWS SDKs
## À l'aide du AWS CLI
Pour plus d'informations sur l'utilisation du AWS CLI pour arrêter un téléchargement partitionné, consultez [abort-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/abort-multipart-upload.html)la *référence des AWS CLI commandes*.
## Utilisation de l'API REST
Pour plus d'informations sur l'utilisation de l'API REST pour arrêter un téléchargement [AbortMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)en plusieurs parties, consultez le manuel *Amazon Simple Storage Service API Reference*.
## Utilisation de AWS SDKs (API de haut niveau)
------
#### [ Java ]
Pour arrêter les téléchargements partitionnés en cours à l'aide du AWS SDK for Java, vous pouvez abandonner les téléchargements qui ont été initiés avant une date spécifiée et qui sont toujours en cours. Un chargement est considéré comme étant en cours dès que vous le lancez et jusqu’à ce qu’il soit terminé ou arrêté.
Pour arrêter des chargements partitionnés, vous pouvez :
| | |
| --- |--- |
| 1 | Créer une instance S3Client. |
| 2 | Utiliser les méthodes d’abandon du client en indiquant le nom du compartiment et les autres paramètres requis. |
**Note**
Vous pouvez également arrêter un chargement partitionné spécifique. Pour de plus amples informations, veuillez consulter [Utilisation de AWS SDKs (API de bas niveau)](#abort-mpu-low-level).
*Pour des exemples expliquant comment abandonner des téléchargements partitionnés avec le SDK for AWS Java, [consultez la section Annuler un téléchargement partitionné dans](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html) le manuel Amazon S3 API Reference.*
------
#### [ .NET ]
L’exemple C\$1 suivant arrête tous les chargements partitionnés en cours initiés sur un compartiment spécifique il y a plus d’une semaine. Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez [Getting Started with the AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET dans *AWS le Guide du développeur du SDK pour* .NET.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class AbortMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
AbortMPUAsync().Wait();
}
private static async Task AbortMPUAsync()
{
try
{
var transferUtility = new TransferUtility(s3Client);
// Abort all in-progress uploads initiated before the specified date.
await transferUtility.AbortMultipartUploadsAsync(
bucketName, DateTime.Now.AddDays(-7));
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
**Note**
Vous pouvez également arrêter un chargement partitionné spécifique. Pour de plus amples informations, veuillez consulter [Utilisation de AWS SDKs (API de bas niveau)](#abort-mpu-low-level).
------
## Utilisation de AWS SDKs (API de bas niveau)
Vous pouvez arrêter un chargement partitionné en cours en appelant la méthode `AmazonS3.abortMultipartUpload`. Cette méthode supprime toutes les parties qui ont été chargées dans Amazon S3 et libère les ressources. Vous devez fournir l’ID de chargement, le nom du compartiment et le nom de la clé. L’exemple de code Java suivant illustre comment arrêter un chargement partitionné en cours.
Pour arrêter un chargement partitionné, vous fournissez l’ID de chargement, ainsi que les noms de compartiment et de clé utilisés dans le chargement. Après avoir arrêté un chargement partitionné, vous ne pouvez pas utiliser l’ID de chargement pour charger les parties supplémentaires. Pour en savoir plus sur les chargements partitionnés Amazon S3, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
------
#### [ Java ]
Pour arrêter un téléchargement partitionné spécifique en cours à l'aide du AWS SDK for Java, vous pouvez utiliser l'API de bas niveau pour abandonner le téléchargement en fournissant le nom du bucket, la clé d'objet et l'ID de téléchargement.
**Note**
Au lieu d’abandonner un chargement partitionné spécifique, vous pouvez arrêter tous les chargements partitionnés lancés avant une heure spécifique et qui sont toujours en cours. Cette opération de nettoyage est utile pour arrêter les anciens chargements partitionnés que vous avez initiés mais que vous n’avez pas terminés ou arrêtés. Pour de plus amples informations, veuillez consulter [Utilisation de AWS SDKs (API de haut niveau)](#abort-mpu-high-level).
*Pour des exemples expliquant comment annuler un téléchargement partitionné spécifique avec le AWS SDK for Java, consultez la section [Annuler un téléchargement partitionné dans le](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html) manuel Amazon S3 API Reference.*
------
#### [ .NET ]
L’exemple C\$1 suivant montre comment arrêter un chargement partitionné. Pour obtenir un exemple C\$1 complet incluant le code suivant, consultez [Utilisation de AWS SDKs (API de bas niveau)](mpu-upload-object.md#mpu-upload-low-level).
```
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = existingBucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await AmazonS3Client.AbortMultipartUploadAsync(abortMPURequest);
```
Vous pouvez aussi annuler tous les chargements partitionnés en cours démarrés avant un moment spécifique. Cette opération de nettoyage est utile pour abandonner les chargements partitionnés que vous n’avez pas terminés ou interrompus. Pour plus d’informations, consultez [Utilisation de AWS SDKs (API de haut niveau)](#abort-mpu-high-level).
------
#### [ PHP ]
Cet exemple illustre comment utiliser une classe de la version 3 du kit AWS SDK pour PHP pour interrompre un chargement partitionné en cours. Pour plus d'informations sur l'API AWS SDK for Ruby, consultez [AWS SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Version 2. L’exemple de la méthode `abortMultipartUpload()`.
Pour plus d'informations sur l'API AWS SDK for Ruby, consultez [AWS SDK for Ruby](https://docs.aws.amazon.com/sdkforruby/api/index.html) - Version 2.
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$uploadId = '*** Upload ID of upload to Abort ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Abort the multipart upload.
$s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
]);
```
------
# Copie d’un objet à l’aide du chargement partitionné
Le chargement partitionné vous permet de copier des objets en plusieurs parties. Les exemples de cette section vous montrent comment copier des objets supérieurs à 5 Go grâce à l’API de chargement partitionné. Pour plus d’informations sur les chargements partitionnés, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
Vous pouvez copier les objets inférieurs à 5 Go en une seule opération sans avoir à utiliser l’API de chargement partitionné. Vous pouvez copier des objets de moins de 5 Go à l' AWS Management Console aide de l'API REST, ou AWS SDKs. AWS CLI Pour de plus amples informations, veuillez consulter [Copie, déplacement et changement de nom des objets](copy-object.md).
Pour une end-to-end procédure de téléchargement d'un objet avec un téléchargement en plusieurs parties avec une somme de contrôle supplémentaire, voir. [Didacticiel : chargement partitionné d’un objet et vérification de l’intégrité de ses données](tutorial-s3-mpu-additional-checksums.md)
La section suivante explique comment copier un objet avec un téléchargement partitionné à l'aide de l'API REST ou AWS SDKs.
## Utilisation de l'API REST
Les sections suivantes de la *Référence de l'API Amazon Simple Storage Service* décrivent l'API REST pour le chargement partitionné. Pour copier un objet existant, utilisez l’API de chargement d’une partie (Copy) et spécifiez l’objet source en ajoutant l’en-tête `x-amz-copy-source` dans votre demande.
+ [Lancement du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Chargement d’une partie](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Chargement d’une partie (Copy)](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)
+ [Achèvement du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Interruption du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [Liste des parties](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [Liste des chargements partitionnés](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
Vous pouvez les utiliser APIs pour effectuer vos propres requêtes REST, ou vous pouvez utiliser l'une des solutions SDKs que nous proposons. Pour plus d'informations sur l'utilisation du téléchargement partitionné avec AWS CLI le. [À l'aide du AWS CLI](mpu-upload-object.md#UsingCLImpUpload) Pour plus d'informations sur le SDKs, consultez[AWS Support du SDK pour le téléchargement en plusieurs parties](mpuoverview.md#sdksupportformpu).
## À l'aide du AWS SDKs
Pour copier un objet à l’aide de l’API de bas niveau, procédez comme suit :
+ Lancez un chargement partitionné en appelant la méthode `AmazonS3Client.initiateMultipartUpload()`.
+ Enregistrez l’ID de chargement de l’objet de la réponse renvoyé par la méthode `AmazonS3Client.initiateMultipartUpload()`. Vous devez fournir cet ID de chargement pour chaque opération de chargement de partie.
+ Copiez toutes les parties. Pour chaque partie que vous devez copier, créez une nouvelle instance de la classe `CopyPartRequest`. Fournissez les informations sur la partie, notamment les noms des compartiments source et de destination, les clés d’objet source et de destination, l’ID de chargement, les emplacement des premier et dernier octets de la partie, ainsi que le numéro de la partie.
+ Enregistrez les réponses des appels de méthode `AmazonS3Client.copyPart()`. Chaque réponse inclut la valeur `ETag` et le numéro de partie de la partie chargée. Vous avez besoin de ces informations pour terminer le chargement partitionné.
+ Appelez la méthode `AmazonS3Client.completeMultipartUpload()` pour terminer l’opération de copie.
------
#### [ Java ]
Pour des exemples de copie d'objets à l'aide du téléchargement partitionné avec le AWS SDK for Java, [consultez Copier une partie d'un objet depuis un autre objet](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_UploadPartCopy_section.html) dans le manuel *Amazon S3 API Reference*.
------
#### [ .NET ]
L'exemple C\$1 suivant montre comment utiliser le SDK pour .NET pour copier un objet Amazon S3 d'une taille supérieure à 5 Go d'un emplacement source à un autre, par exemple d'un compartiment à un autre. Pour copier des objets dont la taille est inférieure à 5 Go, utilisez la procédure de copie en une seule opération décrite dans [À l'aide du AWS SDKs](copy-object.md#CopyingObjectsUsingSDKs). Pour en savoir plus sur les chargements partitionnés Amazon S3, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).
Cet exemple montre comment copier un objet Amazon S3 d'une taille supérieure à 5 Go d'un compartiment S3 vers un autre à l'aide de l'API de téléchargement SDK pour .NET partitionné.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class CopyObjectUsingMPUapiTest
{
private const string sourceBucket = "*** provide the name of the bucket with source object ***";
private const string targetBucket = "*** provide the name of the bucket to copy the object to ***";
private const string sourceObjectKey = "*** provide the name of object to copy ***";
private const string targetObjectKey = "*** provide the name of the object copy ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Copying an object");
MPUCopyObjectAsync().Wait();
}
private static async Task MPUCopyObjectAsync()
{
// Create a list to store the upload part responses.
List uploadResponses = new List();
List copyResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest =
new InitiateMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Save the upload ID.
String uploadId = initResponse.UploadId;
try
{
// Get the size of the object.
GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest
{
BucketName = sourceBucket,
Key = sourceObjectKey
};
GetObjectMetadataResponse metadataResponse =
await s3Client.GetObjectMetadataAsync(metadataRequest);
long objectSize = metadataResponse.ContentLength; // Length in bytes.
// Copy the parts.
long partSize = 5 * (long)Math.Pow(2, 20); // Part size is 5 MB.
long bytePosition = 0;
for (int i = 1; bytePosition < objectSize; i++)
{
CopyPartRequest copyRequest = new CopyPartRequest
{
DestinationBucket = targetBucket,
DestinationKey = targetObjectKey,
SourceBucket = sourceBucket,
SourceKey = sourceObjectKey,
UploadId = uploadId,
FirstByte = bytePosition,
LastByte = bytePosition + partSize - 1 >= objectSize ? objectSize - 1 : bytePosition + partSize - 1,
PartNumber = i
};
copyResponses.Add(await s3Client.CopyPartAsync(copyRequest));
bytePosition += partSize;
}
// Set up to complete the copy.
CompleteMultipartUploadRequest completeRequest =
new CompleteMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(copyResponses);
// Complete the copy.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
# 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
```
# Limites de la fonction de chargement partitionné Amazon S3
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. 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).
Le tableau suivant fournit les principales spécifications du chargement partitionné. Elles incluent notamment la taille maximale de l’objet, le nombre maximal de parties, la taille maximale de chaque partie, etc. Il n’existe pas de limite de taille minimale pour la dernière partie de votre chargement partitionné.
| Élément | Spécification |
| --- | --- |
| Taille maximum de l’objet | 48,8 TiB |
| Nombre maximum de parties par chargement | 10 000 |
| Numéros de partie | 1 à 10 000 (inclus) |
| Taille de partie | 5 Mio à 5 GiO. Il n'existe pas de limite de taille minimale pour la dernière partie de votre chargement partitionné. |
| Nombre maximum de parties renvoyées pour une demande de liste des parties | 1 000 |
| Nombre maximum de chargements partitionnés renvoyés dans une demande de liste de chargements partitionnés | 1 000 |