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.
# Utilisation d’objets dans un compartiment de répertoires
Après avoir créé un compartiment d'annuaire Amazon S3, vous pouvez travailler avec des objets à l'aide de la console Amazon S3, AWS Command Line Interface (AWS CLI) et du AWS SDKs.
Pour plus d’informations sur l’exécution d’opérations groupées, l’importation, le chargement, la copie, la suppression et le téléchargement d’objets dans des compartiments de répertoires, consultez les rubriques suivantes.
**Topics**
+ [Importation d’objets dans un compartiment de répertoires](create-import-job.md)
+ [Utilisation du cycle de vie S3 pour les compartiments de répertoires](directory-buckets-objects-lifecycle.md)
+ [Utilisation des opérations par lots avec les compartiments de répertoires](directory-buckets-objects-Batch-Ops.md)
+ [Ajout de données à des objets dans des compartiments de répertoires](directory-buckets-objects-append.md)
+ [Changement de nom des objets de compartiments de répertoires](directory-buckets-objects-rename.md)
+ [Chargement d’objets dans un compartiment de répertoires](directory-buckets-objects-upload.md)
+ [Copie d’objets vers ou depuis un compartiment de répertoires](directory-buckets-objects-copy.md)
+ [Suppression d’objets à partir d’un compartiment de répertoires](directory-bucket-delete-object.md)
+ [Téléchargement d’un objet à partir d’un compartiment de répertoires](directory-buckets-objects-GetExamples.md)
+ [Génération d'un bucket URLs de répertoire présigné pour partager des objets](directory-buckets-objects-generate-presigned-url-Examples.md)
+ [Récupération des métadonnées d’objets à partir de compartiments de répertoires](directory-buckets-objects-HeadObjectExamples.md)
+ [Liste des objets d’un compartiment de répertoires](directory-buckets-objects-listobjectsExamples.md)
# Importation d’objets dans un compartiment de répertoires
Après avoir créé un compartiment de répertoires dans Amazon S3, vous pouvez remplir le nouveau compartiment avec des données à l’aide de l’action d’importation. L’importation est une méthode simplifiée pour créer des tâches S3 Batch Operations afin de copier des objets depuis des compartiments à usage général vers des compartiments de répertoires.
**Note**
Les limites suivantes s’appliquent aux tâches d’importation :
Le compartiment source et le compartiment de destination doivent se trouver dans le même Région AWS compte.
Le compartiment source ne peut pas être un compartiment de répertoires.
Les objets de plus de 5 Go ne sont pas pris en charge et seront omis dans l’opération de copie.
Les objets des classes de stockage de niveau Glacier Flexible Retrieval, Glacier Deep Archive, Intelligent-Tiering Archive Access et Intelligent-Tiering Deep Archive doivent être restaurés avant de pouvoir être importés.
Les objets importés avec des algorithmes MD5 de somme de contrôle sont convertis pour utiliser des sommes de CRC32 contrôle.
Les objets importés utilisent la classe de stockage Express One Zone, dont la structure tarifaire est différente de celle des classes de stockage utilisées par les compartiments à usage général. Tenez compte de cette différence de coût lorsque vous importez un grand nombre d’objets.
Lorsque vous configurez une tâche d’importation, vous spécifiez le compartiment source ou le préfixe source à partir duquel les objets existants seront copiés. Vous fournissez également un rôle Gestion des identités et des accès AWS (IAM) autorisé à accéder aux objets source. Amazon S3 lance ensuite une tâche d’opérations par lots qui copie les objets et applique automatiquement les paramètres de classe de stockage et de somme de contrôle appropriés.
Pour configurer les tâches d’importation, vous utilisez la console Amazon S3.
## Utilisation de la console Amazon S3
**Pour importer des objets dans un compartiment de répertoires**
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 volet de navigation de gauche, choisissez **Compartiments**, puis l’onglet **Compartiments de répertoires**. Choisissez le bouton d’option en regard du compartiment de répertoires dans lequel vous souhaitez importer des objets.
1. Choisissez **Importer**.
1. Pour **Source**, entrez le compartiment à usage général (ou le chemin du compartiment, préfixe inclus) qui contient les objets que vous souhaitez importer. Pour choisir un compartiment à usage général existant dans une liste, choisissez **Parcourir S3**.
1. Pour **Autorisation d’accéder aux objets sources et de les copier**, effectuez l’une des opérations suivantes pour spécifier un rôle IAM doté des autorisations nécessaires pour importer vos objets sources :
+ Pour autoriser Amazon S3 à créer un nouveau rôle IAM en votre nom, choisissez **Créer un nouveau rôle IAM**.
+ Pour choisir un rôle IAM existant dans une liste, choisissez **Sélectionner parmi les rôles IAM existants**.
+ Pour spécifier un rôle IAM existant en entrant son Amazon Resource Name (ARN), choisissez **Saisir l’ARN du rôle IAM**, puis entrez l’ARN dans le champ correspondant.
1. Passez en revue les informations affichées dans les sections **Destination** et **Paramètres de l’objet copié**. Si les informations de la section **Destination** sont correctes, choisissez **Importer** pour démarrer la tâche de copie.
La console Amazon S3 affiche le statut de votre nouvelle tâche sur la page **Opérations par lot**. Pour plus d’informations sur la tâche, choisissez le bouton d’option à côté du nom de la tâche, puis dans le menu **Actions**, choisissez **Afficher les détails**. Pour ouvrir le compartiment de répertoires dans lequel les objets seront importés, choisissez **Afficher la destination de l’importation**.
# Utilisation du cycle de vie S3 pour les compartiments de répertoires
Le cycle de vie S3 vous aide à stocker des objets dans S3 Express One Zone dans des compartiments de répertoires de manière rentable en supprimant les objets ayant expiré en votre nom. Pour gérer le cycle de vie de vos objets, créez une configuration de cycle de vie S3 pour votre compartiment de répertoires. Une configuration de cycle de vie S3 est un ensemble de règles qui définit des actions qu’Amazon S3 applique à un groupe d’objets. Vous pouvez définir une configuration du cycle de vie Amazon S3 sur un compartiment de répertoire à l'aide de l'interface de ligne de AWS commande (AWS CLI) AWS SDKs, de l'API REST Amazon S3 et AWS CloudFormation.
Dans votre configuration du cycle de vie, utilisez des règles pour définir les actions que vous souhaitez qu’Amazon S3 effectue au niveau de vos objets. Pour les objets stockés dans des compartiments de répertoires, vous pouvez créer des règles de cycle de vie pour faire expirer les objets à mesure que le temps passe. Vous pouvez également créer des règles de cycle de vie pour supprimer les chargements partitionnés incomplets dans les compartiments de répertoire à une fréquence quotidienne.
Quand vous ajoutez une configuration de cycle de vie dans un compartiment, les règles de configuration s’appliquent à la fois aux objets existants et à ceux que vous ajouterez ultérieurement. À titre d’exemple, si vous ajoutez aujourd’hui une règle de configuration du cycle de vie avec une action qui entraîne l’expiration des objets dotés d’un préfixe spécifique 30 jours après leur création, S3 mettra dans la file d’attente pour suppression tous les objets de plus de 30 jours qui incluent le préfixe spécifié.
## En quoi le cycle de vie S3 des compartiments de répertoires est différent
Pour les objets qui se trouvent dans des compartiments de répertoires, vous pouvez créer des règles de cycle de vie pour faire expirer ces objets et supprimer les chargements partitionnés incomplets. Toutefois, le cycle de vie S3 des compartiments de répertoires ne prend pas en charge les actions de transition entre les classes de stockage.
**CreateSession**
Le cycle de vie utilise des opérations d’API `DeleteObject` et `DeleteObjects` publiques pour faire expirer les objets dans les compartiments de répertoires. Pour utiliser ces opérations d’API, le cycle de vie S3 utilise l’API `CreateSession` afin d’établir des informations d’identification de sécurité temporaires pour accéder aux objets qui se trouvent dans les compartiments de répertoires. Pour plus d’informations, consultez [`CreateSession` dans la *Référence des API Amazon S3*.](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html)
Si vous avez une politique active qui refuse les autorisations de suppression au principal du cycle de vie, cela vous empêche d’autoriser le cycle de vie S3 à supprimer des objets en votre nom.
### Utilisation d’une stratégie de compartiment pour accorder des autorisations au principal du service de cycle de vie S3
La politique de compartiment suivante accorde au service S3 Lifecycle l'autorisation principale de créer des sessions pour effectuer des opérations telles que `DeleteObject` et`DeleteObjects`. Lorsqu'aucun mode de session n'est spécifié dans une `CreateSession` demande, la session est créée avec le maximum de privilèges autorisés par les autorisations accordées (en essayant d'`ReadWrite`abord, puis `ReadOnly` si ce n'`ReadWrite`est pas autorisé). Toutefois, les `ReadOnly` sessions sont insuffisantes pour les opérations de cycle de vie qui modifient ou suppriment des objets. Par conséquent, cet exemple nécessite explicitement un mode `ReadWrite` session à l'aide de la clé de `s3express:SessionMode` condition.
**Example — Politique de compartiment autorisant les `CreateSession` appels avec un mode de `ReadWrite` session explicite pour les opérations du cycle de vie**
```
{
"Version":"2008-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal": {
"Service":"lifecycle.s3.amazonaws.com"
},
"Action":"s3express:CreateSession",
"Condition": {
"StringEquals": {
"s3express:SessionMode": "ReadWrite"
}
},
"Resource":"arn:aws:s3express:us-east-2:412345678921:bucket/amzn-s3-demo-bucket--use2-az2--x-s3"
}
]
}
```
### Surveillance des règles de cycle de vie
Pour les objets stockés dans des compartiments de répertoire, S3 Lifecycle génère AWS CloudTrail des journaux d'événements de gestion et de données. Pour plus d'informations, consultez les [exemples de fichiers CloudTrail journaux pour S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html).
Pour plus d’informations sur la création de la configuration d’un cycle de vie et sur la résolution des problèmes liés au cycle de vie S3, consultez les rubriques suivantes :
**Topics**
# Création et gestion d’une configuration de cycle de vie pour votre compartiment de répertoires
Vous pouvez créer une configuration du cycle de vie pour les compartiments de répertoire en utilisant the AWS Command Line Interface (AWS CLI) AWS SDKs et REST APIs.
## Utilisation de la AWS CLI
Vous pouvez utiliser les AWS CLI commandes suivantes pour gérer les configurations du cycle de vie S3 :
+ `put-bucket-lifecycle-configuration`
+ `get-bucket-lifecycle-configuration`
+ `delete-bucket-lifecycle`
Pour obtenir des instructions sur la configuration du AWS CLI, 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*.
Notez que la configuration de cycle de vie Amazon S3 est un fichier XML. Mais lorsque vous utilisez le AWS CLI, vous ne pouvez pas spécifier le format XML. Vous devez spécifier le format JSON à la place. Vous trouverez ci-dessous des exemples de configurations de cycle de vie XML et les configurations JSON équivalentes que vous pouvez spécifier dans une AWS CLI commande.
L'exemple de AWS CLI suivant place une politique de configuration du cycle de vie dans un compartiment de répertoire. Cette politique spécifie que tous les objets dont le préfixe est labelisé (myprefix) et qui correspondent à la taille définie expirent après 7 jours. Pour utiliser cet exemple, remplacez chaque *user input placeholder* par vos propres informations.
Enregistrez la stratégie de configuration du cycle de vie dans un fichier JSON. Dans cet exemple, le fichier est nommé lifecycle1.json.
**Example**
```
{
"Rules": [
{
"Expiration": {
"Days": 7
},
"ID": "Lifecycle expiration rule",
"Filter": {
"And": {
"Prefix": "myprefix/",
"ObjectSizeGreaterThan": 500,
"ObjectSizeLessThan": 64000
}
},
"Status": "Enabled"
}
]
}
```
Envoyez le fichier JSON en tant que partie de la commande CLI `put-bucket-lifecycle-configuration`. Pour utiliser cette commande, remplacez chaque *user input placeholder* par vos propres informations.
```
aws s3api put-bucket-lifecycle-configuration --region us-west-2 --profile default --bucket amzn-s3-demo-bucket--usw2-az1--x-s3 --lifecycle-configuration file://lc-policy.json --checksum-algorithm crc32c
```
**Example**
```
Lifecycle expiration rule
myprefix/
500
64000
Enabled
7
```
## À l'aide du AWS SDKs
------
#### [ SDK for Java ]
**Example**
```
import software.amazon.awssdk.services.s3.model.PutBucketLifecycleConfigurationRequest;
import software.amazon.awssdk.services.s3.model.PutBucketLifecycleConfigurationResponse;
import software.amazon.awssdk.services.s3.model.ChecksumAlgorithm;
import software.amazon.awssdk.services.s3.model.BucketLifecycleConfiguration;
import software.amazon.awssdk.services.s3.model.LifecycleRule;
import software.amazon.awssdk.services.s3.model.LifecycleRuleFilter;
import software.amazon.awssdk.services.s3.model.LifecycleExpiration;
import software.amazon.awssdk.services.s3.model.LifecycleRuleAndOperator;
import software.amazon.awssdk.services.s3.model.GetBucketLifecycleConfigurationResponse;
import software.amazon.awssdk.services.s3.model.GetBucketLifecycleConfigurationRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketLifecycleRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketLifecycleResponse;
import software.amazon.awssdk.services.s3.model.AbortIncompleteMultipartUpload;
// PUT a Lifecycle policy
LifecycleRuleFilter objectExpirationFilter = LifecycleRuleFilter.builder().and(LifecycleRuleAndOperator.builder().prefix("dir1/").objectSizeGreaterThan(3L).objectSizeLessThan(20L).build()).build();
LifecycleRuleFilter mpuExpirationFilter = LifecycleRuleFilter.builder().prefix("dir2/").build();
LifecycleRule objectExpirationRule = LifecycleRule.builder().id("lc").filter(objectExpirationFilter).status("Enabled").expiration(LifecycleExpiration.builder()
.days(10)
.build())
.build();
LifecycleRule mpuExpirationRule = LifecycleRule.builder().id("lc-mpu").filter(mpuExpirationFilter).status("Enabled").abortIncompleteMultipartUpload(AbortIncompleteMultipartUpload.builder()
.daysAfterInitiation(10)
.build())
.build();
PutBucketLifecycleConfigurationRequest putLifecycleRequest = PutBucketLifecycleConfigurationRequest.builder()
.bucket("amzn-s3-demo-bucket--usw2-az1--x-s3")
.checksumAlgorithm(ChecksumAlgorithm.CRC32)
.lifecycleConfiguration(
BucketLifecycleConfiguration.builder()
.rules(objectExpirationRule, mpuExpirationRule)
.build()
).build();
PutBucketLifecycleConfigurationResponse resp = client.putBucketLifecycleConfiguration(putLifecycleRequest);
// GET the Lifecycle policy
GetBucketLifecycleConfigurationResponse getResp = client.getBucketLifecycleConfiguration(GetBucketLifecycleConfigurationRequest.builder().bucket("amzn-s3-demo-bucket--usw2-az1--x-s3").build());
// DELETE the Lifecycle policy
DeleteBucketLifecycleResponse delResp = client.deleteBucketLifecycle(DeleteBucketLifecycleRequest.builder().bucket("amzn-s3-demo-bucket--usw2-az1--x-s3").build());
```
------
#### [ SDK for Go ]
**Example**
```
package main
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
)
// PUT a Lifecycle policy
func putBucketLifecycleConfiguration(client *s3.Client, bucketName string ) error {
lifecycleConfig := &s3.PutBucketLifecycleConfigurationInput{
Bucket: aws.String(bucketName),
LifecycleConfiguration: &types.BucketLifecycleConfiguration{
Rules: []types.LifecycleRule{
{
ID: aws.String("lc"),
Filter: &types.LifecycleRuleFilter{
And: &types.LifecycleRuleAndOperator{
Prefix: aws.String("foo/"),
ObjectSizeGreaterThan: aws.Int64(1000000),
ObjectSizeLessThan: aws.Int64(100000000),
},
},
Status: types.ExpirationStatusEnabled,
Expiration: &types.LifecycleExpiration{
Days: aws.Int32(int32(1)),
},
},
{
ID: aws.String("abortmpu"),
Filter: &types.LifecycleRuleFilter{
Prefix: aws.String("bar/"),
},
Status: types.ExpirationStatusEnabled,
AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{
DaysAfterInitiation: aws.Int32(int32(5)),
},
},
},
},
}
_, err := client.PutBucketLifecycleConfiguration(context.Background(), lifecycleConfig)
return err
}
// Get the Lifecycle policy
func getBucketLifecycleConfiguration(client *s3.Client, bucketName string) error {
getLifecycleConfig := &s3.GetBucketLifecycleConfigurationInput{
Bucket: aws.String(bucketName),
}
resp, err := client.GetBucketLifecycleConfiguration(context.Background(), getLifecycleConfig)
if err != nil {
return err
}
return nil
}
// Delete the Lifecycle policy
func deleteBucketLifecycleConfiguration(client *s3.Client, bucketName string) error {
deleteLifecycleConfig := &s3.DeleteBucketLifecycleInput{
Bucket: aws.String(bucketName),
}
_, err := client.DeleteBucketLifecycle(context.Background(), deleteLifecycleConfig)
return err
}
func main() {
cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRegion("us-west-2")) // Specify your region here
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}
s3Client := s3.NewFromConfig(cfg)
bucketName := "amzn-s3-demo-bucket--usw2-az1--x-s3"
putBucketLifecycleConfiguration(s3Client, bucketName)
getBucketLifecycleConfiguration(s3Client, bucketName)
deleteBucketLifecycleConfiguration(s3Client, bucketName)
getBucketLifecycleConfiguration(s3Client, bucketName)
}
```
------
#### [ SDK for .NET ]
**Example**
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class LifecycleTest
{
private const string bucketName = "amzn-s3-demo-bucket--usw2-az1--x-s3";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 client;
public static void Main()
{
client = new AmazonS3Client(bucketRegion);
AddUpdateDeleteLifecycleConfigAsync().Wait();
}
private static async Task AddUpdateDeleteLifecycleConfigAsync()
{
try
{
var lifeCycleConfiguration = new LifecycleConfiguration()
{
Rules = new List
{
new LifecycleRule
{
Id = "delete rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "projectdocs/"
}
},
Status = LifecycleRuleStatus.Enabled,
Expiration = new LifecycleRuleExpiration()
{
Days = 10
}
}
}
};
// Add the configuration to the bucket.
await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);
// Retrieve an existing configuration.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
// Add a new rule.
lifeCycleConfiguration.Rules.Add(new LifecycleRule
{
Id = "mpu abort rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "YearlyDocuments/"
}
},
Expiration = new LifecycleRuleExpiration()
{
Days = 10
},
AbortIncompleteMultipartUpload = new LifecycleRuleAbortIncompleteMultipartUpload()
{
DaysAfterInitiation = 10
}
});
// Add the configuration to the bucket.
await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);
// Verify that there are now two rules.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
Console.WriteLine("Expected # of rulest=2; found:{0}", lifeCycleConfiguration.Rules.Count);
// Delete the configuration.
await RemoveLifecycleConfigAsync(client);
// Retrieve a nonexistent configuration.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
}
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);
}
}
static async Task AddExampleLifecycleConfigAsync(IAmazonS3 client, LifecycleConfiguration configuration)
{
PutLifecycleConfigurationRequest request = new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
};
var response = await client.PutLifecycleConfigurationAsync(request);
}
static async Task RetrieveLifecycleConfigAsync(IAmazonS3 client)
{
GetLifecycleConfigurationRequest request = new GetLifecycleConfigurationRequest
{
BucketName = bucketName
};
var response = await client.GetLifecycleConfigurationAsync(request);
var configuration = response.Configuration;
return configuration;
}
static async Task RemoveLifecycleConfigAsync(IAmazonS3 client)
{
DeleteLifecycleConfigurationRequest request = new DeleteLifecycleConfigurationRequest
{
BucketName = bucketName
};
await client.DeleteLifecycleConfigurationAsync(request);
}
}
}
```
------
#### [ SDK for Python ]
**Example**
```
import boto3
client = boto3.client("s3", region_name="us-west-2")
bucket_name = 'amzn-s3-demo-bucket--usw2-az1--x-s3'
client.put_bucket_lifecycle_configuration(
Bucket=bucket_name,
ChecksumAlgorithm='CRC32',
LifecycleConfiguration={
'Rules': [
{
'ID': 'lc',
'Filter': {
'And': {
'Prefix': 'foo/',
'ObjectSizeGreaterThan': 1000000,
'ObjectSizeLessThan': 100000000,
}
},
'Status': 'Enabled',
'Expiration': {
'Days': 1
}
},
{
'ID': 'abortmpu',
'Filter': {
'Prefix': 'bar/'
},
'Status': 'Enabled',
'AbortIncompleteMultipartUpload': {
'DaysAfterInitiation': 5
}
}
]
}
)
result = client.get_bucket_lifecycle_configuration(
Bucket=bucket_name
)
client.delete_bucket_lifecycle(
Bucket=bucket_name
)
```
------
# Résolution des problèmes liés au cycle de vie S3 pour les compartiments de répertoires
**Topics**
+ [J’ai spécifié la configuration de mon cycle de vie, mais les objets de mon compartiment de répertoires n’expirent pas](#troubleshoot-directory-bucket-lifecycle-1)
+ [Comment puis-je surveiller les actions prises conformément à mes règles de cycle de vie ?](#troubleshoot-directory-bucket-lifecycle-2)
## J’ai spécifié la configuration de mon cycle de vie, mais les objets de mon compartiment de répertoires n’expirent pas
S3 Lifecycle pour les compartiments d'annuaire utilise le public APIs pour supprimer des objets dans S3 Express One Zone. Pour utiliser le public au niveau de l'objet APIs, vous devez autoriser S3 Lifecycle à supprimer vos objets `CreateSession` et autoriser S3 Lifecycle à le supprimer. Si vous avez une politique active qui refuse les autorisations de suppression, cela vous empêche d’autoriser le cycle de vie S3 à supprimer des objets en votre nom.
Il est important de configurer correctement vos politiques de compartiment afin de garantir que les objets que vous souhaitez supprimer sont éligibles à l’expiration. Vous pouvez consulter les AWS CloudTrail journaux de `AccessDenied` Trails for `CreateSession` API invocations CloudTrail afin de vérifier si l'accès a été refusé. La vérification de vos CloudTrail journaux peut vous aider à résoudre les problèmes d'accès et à identifier la cause première des erreurs de refus d'accès. Vous pouvez ensuite corriger les contrôles d’accès incorrects en mettant à jour les politiques pertinentes.
Si vous confirmez que les politiques de vos compartiments sont correctement définies et que vous rencontrez toujours des problèmes, nous vous recommandons de vérifier les règles du cycle de vie pour vous assurer qu’elles sont appliquées au sous-ensemble d’objets approprié.
## Comment puis-je surveiller les actions prises conformément à mes règles de cycle de vie ?
Vous pouvez utiliser AWS CloudTrail les journaux d'événements de données pour surveiller les actions entreprises par S3 Lifecycle dans les compartiments de répertoire. Pour plus d'informations, consultez les [exemples de fichiers CloudTrail journaux](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html).
# Utilisation des opérations par lots avec les compartiments de répertoires
Vous pouvez utiliser les opérations par lots Amazon S3 pour effectuer des opérations sur des objets stockés dans des compartiments S3. Pour en savoir plus sur S3 Batch Operations, consultez [Exécution des opérations par lot à grande échelle sur des objets Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops.html).
Les rubriques suivantes traitent de l’exécution d’opérations par lot sur des objets stockés dans des compartiments de répertoires pour la classe de stockage S3 Express One Zone.
**Topics**
+ [Utilisation des opérations par lots avec les compartiments de répertoires](#UsingBOPsDirectoryBuckets)
+ [Principales différences](#UsingBOPsDirectoryBucketsKeyDiffs)
## Utilisation des opérations par lots avec les compartiments de répertoires
Vous pouvez effectuer les opérations **Copier** et **Invoquer la fonction AWS Lambda ** sur des objets stockés dans des compartiments de répertoires. Avec la fonction **Copier**, vous pouvez copier des objets entre des compartiments du même type (par exemple, d’un compartiment de répertoires à un autre). Vous pouvez également copier entre des compartiments à usage général et des compartiments de répertoires. Avec ** AWS Lambda la fonction Invoke**, vous pouvez utiliser une fonction Lambda pour effectuer des actions sur les objets de votre bucket de répertoire avec le code que vous définissez.
**Copie d’objets**
Vous pouvez copier entre des compartiments de même type ou entre des compartiments de répertoires et des compartiments à usage général. Lorsque vous effectuez une copie vers un compartiment de répertoires, vous devez utiliser le format d’Amazon Resource Name (ARN) approprié pour ce type de compartiment. Le format d’ARN d’un compartiment de répertoires est `arn:aws:s3express:region:account-id:bucket/bucket-base-name--x-s3`.
**Note**
La copie d'objets entre différents Régions AWS n'est pas prise en charge lorsque le compartiment source ou de destination se trouve dans une zone AWS locale. Les compartiments source et de destination doivent avoir la même Région AWS parent. Les compartiments source et de destination peuvent correspondre à différents types d’emplacement de compartiment (zone de disponibilité ou zone locale).
Vous pouvez également remplir votre compartiment de répertoires avec des données à l’aide de l’action **Importer** de la console S3. L’action **Importer** est une méthode simplifiée pour créer des tâches d’opérations par lots afin de copier des objets depuis des compartiments à usage général vers des compartiments de répertoires. Pour les tâches de copie **Importer** depuis des compartiments à usage général vers des compartiments de répertoires, S3 génère automatiquement un manifeste. Pour plus d’informations, consultez [Importation d’objets dans un compartiment de répertoires](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job.html) et [Spécification d’un manifeste](https://docs.aws.amazon.com/AmazonS3/latest/userguide/specify-batchjob-manifest.html).
**Invocation de fonctions Lambda (`LambdaInvoke`)**
L’utilisation d’opérations par lots pour invoquer des fonctions Lambda agissant sur des compartiments de répertoires est soumise à des exigences particulières. Par exemple, vous devez structurer votre demande Lambda à l’aide d’un schéma d’invocation JSON v2 et spécifier InvocationSchemaVersion 2.0 lorsque vous créez la tâche. Pour plus d’informations, consultez [Invoquer une fonction AWS Lambda](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-invoke-lambda.html).
## Principales différences
Voici la liste des principales différences lors de l’utilisation des opérations par lot pour effectuer des opérations groupées sur des objets stockés dans des compartiments de répertoires avec la classe de stockage S3 Express One Zone :
+ Pour les compartiments d'annuaire, le SSE-S3 et le chiffrement côté serveur avec des clés AWS Key Management Service (AWS KMS) (SSE-KMS) sont pris en charge. Si vous effectuez une demande `CopyObject` qui spécifie d’utiliser le chiffrement côté serveur avec des clés fournies par le client (SSE-C) sur un compartiment de répertoires (source ou cible), la réponse renverra une erreur HTTP `400 (Bad Request)`.
Nous recommandons que le chiffrement par défaut du compartiment utilise la configuration de chiffrement souhaitée et que vous ne remplaciez pas le chiffrement par défaut du compartiment dans vos demandes `CreateSession` ni dans vos demandes d’objets `PUT`. Les nouveaux objets seront ensuite automatiquement chiffrés avec les paramètres de chiffrement souhaités. Pour plus d'informations sur les comportements de contournement du chiffrement dans les compartiments de répertoire et sur la façon de chiffrer les nouvelles copies d'objets dans un compartiment d'annuaire avec SSE-KMS, voir [Spécification du chiffrement côté serveur](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html) avec pour les téléchargements de nouveaux objets. AWS KMS
Les clés de compartiment S3 ne sont pas prises en charge lorsque vous copiez des objets chiffrés avec SSE-KMS depuis des compartiments à usage général vers des compartiments de répertoires, depuis des compartiments de répertoires vers des compartiments à usage général ou entre des compartiments de répertoires, par le biais de l’[opération Copy dans les opérations par lot](#directory-buckets-objects-Batch-Ops). Dans ce cas, Amazon S3 effectue un appel à AWS KMS chaque fois qu'une demande de copie est faite pour un objet chiffré par KMS. Pour plus d’informations sur l’utilisation de SSE-KMS au niveau des compartiments de répertoires, consultez [Configuration et surveillance du chiffrement par défaut pour les compartiments de répertoires](s3-express-bucket-encryption.md) et [Utilisation du chiffrement côté serveur avec des AWS KMS clés (SSE-KMS) dans des compartiments de répertoire](s3-express-UsingKMSEncryption.md).
+ Les objets figurant dans des compartiments de répertoires ne peuvent pas être balisés. Vous ne pouvez spécifier qu’un ensemble de balises vide. Par défaut, les opérations par lots copient les balises. Si vous copiez un objet comportant des balises entre des compartiments à usage général et des compartiments de répertoires, vous recevrez une réponse `501 (Not Implemented)`.
+ S3 Express One Zone vous offre la possibilité de choisir l’algorithme de somme de contrôle utilisé pour valider vos données pendant le chargement ou le téléchargement. Vous pouvez sélectionner l'un des algorithmes de hachage sécurisé (SHA) ou de contrôle de redondance cyclique (CRC) suivants : CRC32, CRC32 SHA-1 et SHA-256. MD5les checksums basés sur la base de données ne sont pas pris en charge avec la classe de stockage S3 Express One Zone.
+ Par défaut, tous les compartiments Amazon S3 définissent le paramètre S3 Object Ownership comme étant appliqué par le propriétaire du compartiment et les listes de contrôle d'accès (ACLs) sont désactivées. Pour les compartiments de répertoire, ce paramètre ne peut pas être modifié. Vous pouvez copier un objet à partir de compartiments à usage général vers des compartiments de répertoires. Cependant, vous ne pouvez pas remplacer la liste ACL par défaut lorsque vous effectuez une copie vers ou depuis un compartiment de répertoires.
+ Quelle que soit la manière dont vous spécifiez votre manifeste, la liste elle-même doit être stockée dans un compartiment à usage général. Les opérations par lots ne peuvent pas importer de manifestes existants à partir de compartiments de répertoires, ni enregistrer les manifestes générés dans ces compartiments. Toutefois, les objets décrits dans le manifeste peuvent être stockés dans des compartiments de répertoires.
+ Les opérations par lots ne peuvent pas spécifier un compartiment de répertoires comme emplacement dans un rapport d’inventaire S3. Les rapports d’inventaire ne prennent pas en charge les compartiments de répertoires. Vous pouvez créer un fichier manifeste pour les objets d’un compartiment de répertoires en utilisant l’API `ListObjectsV2` pour répertorier les objets. Vous pouvez ensuite insérer cette liste dans un fichier CSV.
### Octroi d’accès
Pour effectuer des tâches de copie, vous devez disposer des autorisations suivantes :
+ Pour copier des objets d’un compartiment de répertoires vers un autre, vous devez disposer de l’autorisation `s3express:CreateSession`.
+ Pour copier des objets à partir de compartiments de répertoires vers des compartiments à usage général, vous devez disposer de l’autorisation `s3express:CreateSession` et de l’autorisation `s3:PutObject` permettant d’écrire la copie des objets dans le compartiment de destination.
+ Pour copier des objets dans des compartiments de répertoires à partir de compartiments à usage général, vous devez disposer de l’autorisation `s3express:CreateSession` et de l’autorisation `s3:GetObject` permettant de lire l’objet source à copier.
Pour plus d’informations, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) dans la *Référence d’API Amazon Simple Storage Service*.
+ Pour invoquer une fonction Lambda, vous devez accorder des autorisations à votre ressource sur la base de votre fonction Lambda. Vérifiez les autorisations d’API correspondantes pour déterminer quelles autorisations sont requises.
# Ajout de données à des objets dans des compartiments de répertoires
Vous pouvez ajouter des données à la fin des objets existants stockés dans la classe de stockage S3 Express One Zone dans les compartiments de répertoires. Nous vous recommandons d’utiliser la fonctionnalité permettant d’ajouter des données à un objet si les données sont écrites en continu pendant une période de temps spécifique ou si vous devez lire l’objet pendant que vous y ajoutez des données. L’ajout de données à des objets est courant dans des cas d’utilisation tels que l’ajout de nouvelles entrées de journal aux fichiers journaux ou l’ajout de nouveaux segments vidéo aux fichiers vidéo lors de leur transcodage puis de leur diffusion en continu. En ajoutant des données aux objets, vous pouvez simplifier les applications qui combinaient auparavant les données dans le stockage local avant de copier l’objet final sur Amazon S3.
Aucune taille minimale n’est requise pour les données que vous pouvez ajouter à un objet. Toutefois, la taille maximale des données que vous pouvez ajouter à un objet dans une seule demande est de 5 Go. Il s’agit de la même limite que la taille de demande la plus grande lors du chargement de données à l’aide d’une API Amazon S3.
À chaque opération d’ajout réussie, vous créez une partie de l’objet, et chaque objet peut comporter jusqu’à 10 000 parties. Vous pouvez donc ajouter une entité de données à un objet jusqu’à 10 000 fois. Si un objet est créé à l’aide du chargement partitionné S3, chaque partie chargée est prise en compte dans le calcul du quota maximum de 10 000 parties. Par exemple, vous pouvez ajouter jusqu’à 9 000 parties à un objet créé par chargement partitionné comprenant 1 000 parties.
**Note**
Si vous atteignez la limite de pièces, vous recevrez un [TooManyParts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject_Errors)message d'erreur. Vous pouvez utiliser l’API `CopyObject` pour réinitialiser le décompte.
Si vous souhaitez charger des parties dans un objet en parallèle et que vous n’avez pas besoin de les lire pendant le chargement, nous vous recommandons d’utiliser le chargement partitionné Amazon S3. Pour plus d’informations, consultez [Utilisation du chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-using-multipart-upload.html).
L’ajout de données aux objets n’est pris en charge que pour les objets qui se trouvent dans des compartiments de répertoires stockés dans la classe de stockage S3 Express One Zone. Pour plus d’informations sur S3 Express One Zone, consultez [Bien démarrer avec S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-getting-started.html).
Pour commencer à ajouter des données aux objets de vos compartiments de répertoire, vous pouvez utiliser la AWS SDKs AWS CLI et l'`PutObject`API. Lorsque vous effectuez une demande `PutObject`, vous définissez l’en-tête `x-amz-write-offset-bytes` en fonction de la taille de l’objet auquel vous ajoutez des données. Pour utiliser l’opération d’API `PutObject`, vous devez utiliser l’API `CreateSession` afin d’établir des informations d’identification de sécurité temporaires pour accéder aux objets de vos compartiments de répertoires. Pour plus d’informations, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) et [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html) dans la *Référence des API Amazon S3*.
Chaque opération d’ajout réussie est facturée comme une demande `PutObject`. Pour en savoir plus sur la tarification, consultez [https://aws.amazon.com/s3/pricing/](https://aws.amazon.com/s3/pricing/).
**Note**
À partir de la version 1.12, Mountpoint pour Amazon S3 prend en charge l’ajout de données aux objets stockés dans S3 Express One Zone. Pour commencer, vous devez d’abord activer cette fonctionnalité en définissant l’indicateur `--incremental-upload `. Pour plus d’informations sur Mountpoint, consultez [Utilisation de Mountpoint](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mountpoint.html).
Si vous utilisez un algorithme CRC (Cyclic Redundancy Check) lors du chargement des données ajoutées, vous pouvez récupérer les sommes de contrôle CRC de l’objet entier à l’aide de la demande `HeadObject` ou `GetObject`. Si vous utilisez l'algorithme SHA-1 ou SHA-256 lors du téléchargement des données ajoutées, vous pouvez récupérer une somme de contrôle des parties ajoutées et vérifier leur intégrité à l'aide des sommes de contrôle SHA renvoyées lors des réponses précédentes. PutObject Pour plus d’informations, consultez [Protection et chiffrement des données](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-data-protection.html.html).
## Ajout de données à vos objets à l'aide de la AWS CLI AWS SDKs et de l'API REST
Vous pouvez ajouter des données à vos objets à l'aide de l'API AWS Command Line Interface (AWS CLI) AWS SDKs et de l'API REST.
### Utilisation de la AWS CLI
L'`put-object`exemple de commande suivant montre comment utiliser la AWS CLI pour ajouter des données à un objet. Pour exécuter cette commande, remplacez le *user input placeholders* par vos propres informations
```
aws s3api put-object --bucket amzn-s3-demo-bucket--azid--x-s3 --key sampleinput/file001.bin --body bucket-seed/file001.bin --write-offset-bytes size-of-sampleinput/file001.bin
```
### À l'aide du AWS SDKs
------
#### [ SDK for Java ]
Vous pouvez utiliser le AWS SDK pour Java pour ajouter des données à vos objets.
```
var putObjectRequestBuilder = PutObjectRequest.builder()
.key(key)
.bucket(bucketName)
.writeOffsetBytes(9);
var response = s3Client.putObject(putObjectRequestBuilder.build());
```
------
#### [ SDK for Python ]
```
s3.put_object(Bucket='amzn-s3-demo-bucket--use2-az2--x-s3', Key='2024-11-05-sdk-test', Body=b'123456789', WriteOffsetBytes=9)
```
------
### Utilisation de l'API REST
Vous pouvez envoyer des demandes REST pour ajouter des données à un objet. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject).
# Changement de nom des objets de compartiments de répertoires
À l’aide de l’opération `RenameObject`, vous pouvez renommer de manière atomique un objet d’un compartiment de répertoires qui utilise la classe de stockage S3 Express One Zone, sans aucun déplacement de données. Vous pouvez renommer un objet en spécifiant son nom initial comme source et son nouveau nom comme destination dans le même compartiment de répertoires. L’opération d’API `RenameObject` échoue sur les objets qui se terminent par une barre oblique (`/`). Pour plus d’informations, consultez [Attribution d’un nom aux objets Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html).
L’opération `RenameObject` est exécutée généralement en quelques millisecondes, quelle que soit la taille de l’objet. Cette fonctionnalité accélère les applications telles que la gestion des fichiers journaux, le traitement multimédia et l’analytique des données. En outre, `RenameObject` préserve toutes les propriétés des métadonnées des objets, notamment la classe de stockage, le type de chiffrement, la date de création, la date de dernière modification et les propriétés des sommes de contrôle.
**Note**
`RenameObject` n’est pris en charge que pour les objets stockés dans la classe de stockage S3 Express One Zone.
Pour autoriser l’accès à l’opération `RenameObject`, nous vous recommandons d’utiliser l’opération `CreateSession` pour accorder une autorisation basée sur la session. Plus précisément, vous accordez l’autorisation `s3express:CreateSession` au compartiment de répertoires dans le cadre d’une stratégie de compartiment ou d’une politique basée sur l’identité. Ensuite, vous effectuez l’appel d’API `CreateSession` sur le compartiment de répertoires pour obtenir un jeton de session. Avec le jeton de session dans l’en-tête de votre demande, vous pouvez envoyer des demandes d’API à cette opération. À l’expiration du jeton de session, vous effectuez un nouvel appel d’API `CreateSession` pour générer un nouveau jeton de session à utiliser. La AWS CLI créera et AWS SDKs gérera votre session, notamment en actualisant automatiquement le jeton de session pour éviter les interruptions de service lorsqu'une session expire. Pour plus d’information sur l’autorisation, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html) dans la *Référence des API Amazon S3*. Pour plus d’informations sur les opérations d’API de point de terminaison zonal, consultez [Autorisation des opérations d’API de point de terminaison zonal avec `CreateSession`](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-create-session.html).
Si vous ne souhaitez pas remplacer un objet existant, vous pouvez ajouter l’en-tête conditionnel `If-None-Match` avec la valeur `‘*’` dans la demande `RenameObject`. Amazon S3 renvoie une erreur `412 Precondition Failed` si le nom de l’objet existe déjà. Pour plus d’informations, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html) dans la *Référence d’API Amazon S3*.
`RenameObject` est une opération d’API de point de terminaison zonal (niveau de l’objet ou plan de données) qui est journalisée dans AWS CloudTrail. Vous pouvez l'utiliser CloudTrail pour recueillir des informations sur les `RenameObject` opérations effectuées sur vos objets dans des compartiments de répertoire. Pour plus d'informations, consultez la section [Journalisation avec AWS CloudTrail pour les compartiments de répertoire](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone-logging.html) et les [exemples de fichiers CloudTrail journaux pour les compartiments de répertoire](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html).
S3 Express One Zone est la seule classe de stockage qui prend en charge `RenameObject`, au même prix que les demandes `PUT`, `COPY`, `POST` et `LIST` (pour 1 000 demandes) dans S3 Express One Zone. Pour plus d’informations, consultez [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
## Changement de nom d’un objet
Pour renommer un objet dans votre compartiment de répertoire, vous pouvez utiliser la console Amazon S3, la AWS CLI AWS SDKs, l'API REST ou Mountpoint pour Amazon S3 (version 1.19.0 ou ultérieure).
### Utilisation de la console S3
**Pour renommer un objet d’un compartiment de répertoires**
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 volet de navigation, choisissez **Compartiments**, puis l’onglet **Compartiments de répertoires**. Accédez au compartiment de répertoires Amazon S3 contenant l’objet que vous souhaitez renommer.
1. Cochez la case située à côté de l’objet que vous voulez renommer.
1. Dans le menu **Actions**, sélectionnez **Renommer l’objet**.
1. Dans la zone **Nouveau nom d’objet**, saisissez le nouveau nom de l’objet.
**Note**
Si vous spécifiez le nom d’un objet existant, l’opération échoue et Amazon S3 renvoie le message d’erreur `412 Precondition Failed`. La longueur du nom de la clé de l’objet ne peut pas dépasser 1 024 octets. Les préfixes inclus dans le nom de l’objet sont pris en compte dans la longueur totale.
1. Choisissez **Renommer l’objet**. Amazon S3 renommera votre objet.
### Utilisation de la AWS CLI
Les exemples `rename-object` montrent comment utiliser l’interface de ligne de commande AWS pour renommer un objet. Pour exécuter ces commandes, remplacez le *user input placeholders* par vos propres informations
L'exemple suivant montre comment renommer un objet à l'aide d'une vérification conditionnelle sur celui de l'objet source. ETag
```
aws s3api rename-object \
--bucket amzn-s3-demo-bucket--usw2-az1--x-s3 \
--key new-file.txt \
--rename-source original-file.txt \
--source-if-match "\"a1b7c3d2e5f6\""
```
Cette commande exécute les opérations suivantes :
+ Renomme un objet de *original-file.txt* à *new-file.txt* dans le compartiment de *amzn-s3-demo-bucket--usw2-az1--x-s3* répertoire.
+ N'effectue le changement de nom que si l'objet source ETag correspond à « *a1b7c3d4e5f6* ».
Si ce ETag n'est pas le cas, l'opération échouera avec une `412 Precondition Failed` erreur.
L’exemple suivant montre comment renommer un objet avec une vérification conditionnelle du nouveau nom d’objet spécifié.
```
aws s3api rename-object \
--bucket amzn-s3-demo-bucket--usw2-az1--x-s3 \
--key new-file.txt \
--rename-source amzn-s3-demo-bucket--usw2-az1--x-s3/original-file.txt \
--destination-if-none-match "\"e5f3g7h8i9j0\""
```
Cette commande exécute les opérations suivantes :
+ Renomme un objet de *original-file.txt* à *new-file.txt* dans le compartiment de *amzn-s3-demo-bucket--usw2-az1--x-s3* répertoire.
+ N'exécute l'opération de renommage que si l'objet existe et que celui de l'objet ETag ne correspond pas à « *e5f3g7h8i9j0* ».
Si un objet existe déjà avec le nouveau nom spécifié et la correspondance ETag, l'opération échouera avec une `412 Precondition Failed` erreur.
### À l'aide du AWS SDKs
------
#### [ SDK for Java ]
Vous pouvez utiliser le AWS SDK pour Java pour renommer vos objets. Pour utiliser ces exemples, remplacez le *user input placeholders* par vos propres informations
L'exemple suivant montre comment créer un à `RenameObjectRequest` l'aide du AWS SDK for Java
```
String key = "key";
String newKey = "new-key";
String expectedETag = "e5f3g7h8i9j0";
RenameObjectRequest renameRequest = RenameObjectRequest.builder()
.bucket(amzn-s3-demo-bucket--usw2-az1--x-s3)
.key(newKey)
.renameSource(key)
.destinationIfMatch(e5f3g7h8i9j0)
.build();
```
Ce code effectue les opérations suivantes :
+ Créez une demande pour renommer un objet de « » en *key* « *new-key* » dans le compartiment de *amzn-s3-demo-bucket--usw2-az1--x-s3* répertoire.
+ Inclut une condition selon laquelle le changement de nom ne sera effectué que si l'objet ETag correspond à « *e5f3g7h8i9j0* ».
+ Si le ETag ne correspond pas ou si l'objet n'existe pas, l'opération échouera.
L'exemple suivant montre comment créer une `RenameObjectRequest` condition sans correspondance à l'aide du AWS SDK for Java.
```
String key = "key";
String newKey = "new-key";
String noneMatchETag = "e5f3g7h8i9j0";
RenameObjectRequest renameRequest = RenameObjectRequest.builder()
.bucket(amzn-s3-demo-bucket--usw2-az1--x-s3)
.key(newKey)
.renameSource(key)
.destinationIfNoneMatch(noneMatchETag)
.build();
```
Ce code effectue les opérations suivantes :
+ Crée une demande pour renommer un objet de « *key* » à « *new-key* » dans le compartiment de *amzn-s3-demo-bucket--usw2-az1--x-s3* répertoire.
+ Inclut une condition qui garantit `.destinationIfNoneMatch(noneMatchETag)` que le changement de nom n'aura lieu que si celui de l'objet de destination ETag ne correspond pas à « *e5f3g7h8i9j0* ».
L'opération échouera avec une `412 Precondition Failed` erreur si un objet existe avec le nouveau nom spécifié et porte le nom spécifié ETag.
------
#### [ SDK for Python ]
Vous pouvez utiliser le kit SDK pour Python pour renommer vos objets. Pour utiliser ces exemples, remplacez les *user input placeholders* par vos propres informations.
L'exemple suivant montre comment renommer un objet à l'aide du AWS SDK pour Python (Boto3).
```
def basic_rename(bucket, source_key, destination_key):
try:
s3.rename_object(
Bucket=amzn-s3-demo-bucket--usw2-az1--x-s3,
Key=destination_key,
RenameSource=f"{source_key}"
)
print(f"Successfully renamed {source_key} to {destination_key}")
except ClientError as e:
print(f"Error renaming object: {e}")
```
Ce code effectue les opérations suivantes :
+ Renomme un objet de *source\$1key* à *destination\$1key* dans le compartiment de *amzn-s3-demo-bucket--usw2-az1--x-s3* répertoire.
+ Imprimer un message de réussite si le changement de nom de votre objet aboutit ou un message d’erreur s’il échoue.
L'exemple suivant montre comment renommer un objet avec les `DestinationIfNoneMatch` conditions `SourceIfMatch` et à l'aide du AWS SDK pour Python (Boto3).
```
def rename_with_conditions(bucket, source_key, destination_key, source_etag, dest_etag):
try:
s3.rename_object(
Bucket=amzn-s3-demo-bucket--usw2-az1--x-s3,
Key=destination_key,
RenameSource=f"{amzn-s3-demo-bucket--usw2-az1--x-s3}/{source_key}",
SourceIfMatch=source_ETag,
DestinationIfNoneMatch=dest_ETag
)
print(f"Successfully renamed {source_key} to {destination_key} with conditions")
except ClientError as e:
print(f"Error renaming object: {e}")
```
Ce code effectue les opérations suivantes :
+ Effectuer une opération de changement de nom conditionnel et appliquer deux conditions, `SourceIfMatch` et `DestinationIfNoneMatch`. La combinaison de ces conditions garantit que l’objet n’a pas été modifié et qu’aucun objet n’existe déjà avec le nouveau nom spécifié.
+ Renomme un objet de *source\$1key* à *destination\$1key* dans le compartiment de *amzn-s3-demo-bucket--usw2-az1--x-s3* répertoire.
+ Imprimer un message de réussite si le changement de nom de votre objet aboutit ou un message d’erreur s’il échoue ou si les conditions ne sont pas remplies.
------
#### [ SDK for Rust ]
Vous pouvez utiliser le kit SDK pour Rust pour renommer vos objets. Pour utiliser ces exemples, remplacez les *user input placeholders* par vos propres informations.
L’exemple suivant montre comment renommer un objet du compartiment de répertoires *amzn-s3-demo-bucket--usw2-az1--x-s3* à l’aide du kit SDK pour Rust.
```
async fn basic_rename_example(client: &Client) -> Result<(), Box> {
let response = client
.rename_object()
.bucket(" amzn-s3-demo-bucket--usw2-az1--x-s3")
.key("new-name.txt") // New name/path for the object
.rename_source("old-name.txt") // Original object name/path
.send()
.await?;
Ok(())
}
```
Ce code effectue les opérations suivantes :
+ Crée une demande pour renommer un objet de « *old-name.tx* » à « *new-name.txt* » dans le compartiment de *amzn-s3-demo-bucket--usw2-az1--x-s3* répertoire.
+ Renvoyer un type `Result` pour gérer les erreurs potentielles.
------
### Utilisation de l'API REST
Vous pouvez envoyer des demandes REST pour renommer un objet. Pour plus d’informations, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html) dans la *Référence d’API Amazon S3*.
### Utilisation de Mountpoint pour Amazon S3
À partir de la version 1.19.0 ou supérieure, Mountpoint pour Amazon S3 prend en charge le changement de nom des objets dans S3 Express One Zone. Pour plus d’informations sur Mountpoint, consultez [Utilisation de Mountpoint](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mountpoint.html).
# Chargement d’objets dans un compartiment de répertoires
Après avoir créé un compartiment de répertoires Amazon S3, vous pouvez y charger des objets. Les exemples suivants montrent comment télécharger un objet dans un compartiment de répertoire à l'aide de la console S3 et du AWS SDKs. Pour plus d’informations sur les opérations d’objet par lot utilisant S3 Express One Zone, consultez [Gestion des objets](directory-bucket-high-performance.md#s3-express-features-object-management).
## Utilisation de la console 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 volet de navigation de gauche, choisissez **Compartiments de répertoires**.
1. Choisissez le nom du compartiment dans lequel vous souhaitez charger vos dossiers ou fichiers.
1. Dans l’onglet **Objets**, choisissez **Charger**.
1. Sur la page **Charger**, procédez de l’une des manières suivantes :
+ Faites glisser et déposez les fichiers et les dossiers dans la fenêtre de chargement.
+ Choisissez **Ajouter des fichiers** ou **Ajouter un dossier**, puis choisissez les fichiers ou les dossiers à charger et sélectionnez **Ouvrir** ou **Charger**.
1. Sous **Sommes de contrôle**, choisissez la **fonction de somme de contrôle** que vous souhaitez utiliser.
(Facultatif) Si vous chargez un seul objet d’une taille inférieure à 16 Mo, vous pouvez également spécifier une valeur de somme de contrôle précalculée. Lorsque vous fournissez une valeur précalculée, Amazon S3 la compare à la valeur qu’il calcule à l’aide de la fonction de somme de contrôle sélectionnée. Si les valeurs ne correspondent pas, le chargement ne démarrera pas.
1. Les options des sections **Autorisations** et **Propriétés** sont automatiquement définies selon les paramètres par défaut et ne peuvent pas être modifiées. Le blocage de l’accès public est automatiquement activé, et la gestion des versions S3 ainsi que le verrouillage d’objet S3 ne peuvent pas être activés pour les compartiments de répertoires.
(Facultatif) Si vous souhaitez ajouter des métadonnées sous forme de paires clé-valeur aux objets, développez la section **Propriétés**, puis dans la section **Métadonnées**, choisissez **Ajouter des métadonnées**.
1. Pour charger les fichiers et dossiers répertoriés, 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**.
## À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
public static void putObject(S3Client s3Client, String bucketName, String objectKey, Path filePath) {
//Using File Path to avoid loading the whole file into memory
try {
PutObjectRequest putObj = PutObjectRequest.builder()
.bucket(bucketName)
.key(objectKey)
//.metadata(metadata)
.build();
s3Client.putObject(putObj, filePath);
System.out.println("Successfully placed " + objectKey +" into bucket "+bucketName);
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
**Example**
```
import boto3
import botocore
from botocore.exceptions import ClientError
def put_object(s3_client, bucket_name, key_name, object_bytes):
"""
Upload data to a directory bucket.
:param s3_client: The boto3 S3 client
:param bucket_name: The bucket that will contain the object
:param key_name: The key of the object to be uploaded
:param object_bytes: The data to upload
"""
try:
response = s3_client.put_object(Bucket=bucket_name, Key=key_name,
Body=object_bytes)
print(f"Upload object '{key_name}' to bucket '{bucket_name}'.")
return response
except ClientError:
print(f"Couldn't upload object '{key_name}' to bucket '{bucket_name}'.")
raise
def main():
# Share the client session with functions and objects to benefit from S3 Express One Zone auth key
s3_client = boto3.client('s3')
# Directory bucket name must end with --zone-id--x-s3
resp = put_object(s3_client, 'doc-bucket-example--use1-az5--x-s3', 'sample.txt', b'Hello, World!')
print(resp)
if __name__ == "__main__":
main()
```
------
## En utilisant le AWS CLI
L’exemple de commande `put-object` suivant montre comment utiliser l’interface de ligne de commande AWS CLI pour charger un objet depuis Amazon S3. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
```
aws s3api put-object --bucket bucket-base-name--zone-id--x-s3 --key sampleinut/file001.bin --body bucket-seed/file001.bin
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html) dans la *Référence des commandes de l’AWS CLI *.
**Topics**
+ [Utilisation du chargement partitionné avec les compartiments de répertoires](s3-express-using-multipart-upload.md)
# Utilisation du chargement partitionné avec les compartiments de répertoires
Vous pouvez utiliser le chargement partitionné pour 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.
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.
+ **Quick recovery from any network issues** (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 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 finaliser ou abandonner le chargement partitionné.
+ **Begin an upload before you know the final object size** (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 à large bande passante stable, utilisez le chargement partitionné pour optimiser l’utilisation de la bande passante disponible en chargeant des parties d’objet en parallèle pour bénéficier de performances multithreads.
+ Si vous effectuez un 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.
Lorsque vous utilisez des chargements partitionnés pour charger des objets vers la classe de stockage Amazon S3 Express One Zone dans des compartiments de répertoires, le processus est similaire au processus d’utilisation du chargement partitionné pour charger des objets dans des compartiments à usage général. Cependant, il existe quelques différences importantes.
Pour plus d’informations sur l’utilisation du chargement partitionné pour charger des objets dans S3 Express One Zone, consultez les rubriques suivantes.
**Topics**
+ [Processus de chargement partitionné](#s3-express-mpu-process)
+ [Totaux de contrôle avec les opérations de chargement partitionné](#s3-express-mpuchecksums)
+ [Opérations simultanées de chargement partitionné](#s3-express-distributedmpupload)
+ [Chargement partitionné et tarification](#s3-express-mpuploadpricing)
+ [Opérations de l’API de chargement partitionné et autorisations](#s3-express-mpuAndPermissions)
+ [Exemples](#directory-buckets-multipart-upload-examples)
## Processus de chargement partitionné
Un chargement partitionné est un processus en trois étapes :
+ Vous lancez le chargement.
+ Vous chargez les parties de l’objet.
+ Une fois que vous avez chargé toutes les parties, vous pouvez finaliser le chargement partitionné.
Dès réception de la demande de finalisation du chargement partitionné, Amazon S3 crée l’objet à partir des parties chargées pour que vous puissiez ensuite y accéder comme vous le feriez avec n’importe quel autre objet du compartiment.
**Lancement du chargement partitionné**
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 interrompez un chargement.
**Chargement de parties**
Lorsque vous chargez une partie, outre l’ID de chargement, vous devez spécifier un numéro de partie. Lorsque vous utilisez le chargement partitionné avec S3 Express One Zone, les numéros de chaque partie du chargement doivent être consécutifs. Si vous essayez d’effectuer une demande de chargement partitionné avec des numéros de partie non consécutifs, une erreur `HTTP 400 Bad Request` (ordre non valide) est générée.
Un numéro de partie identifie de manière unique une partie et sa place dans l’objet que vous chargez. 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.
Chaque fois que vous chargez une partie, Amazon S3 renvoie un en-tête entity tag (ETag) dans sa réponse. Pour chaque téléchargement partiel, vous devez enregistrer le numéro de pièce et la ETag valeur. Les ETag valeurs de tous les chargements de parties d'objets resteront les mêmes, mais un numéro de pièce différent sera attribué à chaque partie. Vous devez inclure ces valeurs dans la demande ultérieure pour terminer le chargement partitionné.
Amazon S3 chiffre automatiquement tous les nouveaux objets chargés dans un compartiment S3. Dans le cadre d’un chargement partitionné, si vous ne spécifiez pas d’informations de chiffrement dans votre demande, le paramètre de chiffrement des parties chargées est défini sur la configuration de chiffrement par défaut du compartiment de destination. La configuration de chiffrement par défaut d’un compartiment Amazon S3 est toujours activée et est au minimum définie sur le chiffrement côté serveur avec les clés gérées par Amazon S3 (SSE-S3). Pour les compartiments d'annuaire, le SSE-S3 et le chiffrement côté serveur avec AWS KMS clés (SSE-KMS) sont pris en charge. Pour de plus amples informations, veuillez consulter [Protection et chiffrement des données](s3-express-data-protection.md).
**Fin du chargement partitionné**
Lorsque vous terminez un chargement partitionné, Amazon S3 crée l’objet en concaténant les parties par ordre croissant en fonction des numéros de partie. À 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 deux numéros de pièce et de 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 d'un MD5 hachage des données de l'objet.
**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 de 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. Si le chargement partitionné compte plus de 1 000 parties, vous devez utiliser la pagination pour récupérer toutes les parties.
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 interrompu. 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. 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èces que vous avez spécifiés lors du chargement des pièces et des ETag valeurs correspondantes renvoyées par Amazon S3.
Pour plus d’informations sur les listes de chargement partitionné, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html) dans la *Référence des API Amazon Simple Storage Service*.
## Totaux de contrôle avec les opérations de chargement partitionné
Lorsque vous chargez un objet vers, vous pouvez spécifier un algorithme de somme de contrôle pour vérifier l'intégrité de l'objet. MD5 n'est pas pris en charge pour les compartiments de répertoire. Vous pouvez spécifier l’un des algorithmes suivants de contrôle de l’intégrité des données, Secure Hash Algorithms (SHA) ou Cyclic Redundancy Check (CRC) :
+ CRC32
+ CRC32 C
+ SHA-1
+ SHA-256
Vous pouvez utiliser l'API REST Amazon S3 ou AWS SDKs pour récupérer la valeur de la somme de contrôle pour des parties individuelles en utilisant `GetObject` ou`HeadObject`. Pour récupérer les valeurs de contrôle des parties individuelles de téléchargements partitionnés toujours en cours, vous pouvez utiliser `ListParts`.
**Important**
Lorsque vous utilisez les algorithmes de somme de contrôle précédents, les numéros de chaque partie du chargement partitionné doivent être consécutifs. Si vous essayez d’effectuer une demande de chargement partitionné avec des numéros de partie non consécutifs, Amazon S3 génère une erreur `HTTP 400 Bad Request` (ordre non valide).
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).
## Opérations simultanées de chargement partitionné
Dans un environnement de développement distribué, l’application peut lancer plusieurs mises à jour sur le même objet en même temps. Par exemple, l’application peut lancer plusieurs chargements partitionnés à l’aide de 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. Pour S3 Express One Zone, l’instant de création de l’objet correspond à la date d’achèvement du chargement partitionné.
**Important**
La gestion des versions n’est pas prise en charge pour les objets stockés dans les compartiments de répertoires.
## Chargement partitionné et tarification
Lorsque vous lancez un chargement partitionné, Amazon S3 conserve toutes les parties jusqu’à ce que vous terminiez ou annuliez 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. Si vous abandonnez le chargement partitionné, S3 supprime les artefacts de chargement et les parties que vous avez chargées, et ils ne vous sont plus 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/).
**Important**
Si la demande de finalisation du chargement partitionné n’est pas envoyée correctement, les parties de l’objet ne sont pas assemblées et aucun objet n’est créé. Vous êtes facturé pour tout le stockage associé aux parties chargées. Il est donc important de finaliser le chargement partitionné pour que l’objet soit créé, ou d’annuler le chargement partitionné pour supprimer les parties déjà chargées.
Avant de supprimer un compartiment de répertoires, vous devez finaliser ou annuler tous les chargements partitionnés en cours. Les compartiments de répertoires ne prennent pas en charge les configurations de cycle de vie S3. Si nécessaire, vous pouvez répertorier vos chargements partitionnés actifs, puis annuler les chargements et supprimer votre compartiment.
## Opérations de l’API de chargement partitionné et autorisations
Pour autoriser l’accès aux opérations d’API de gestion des objets sur un compartiment de répertoires, vous accordez l’autorisation `s3express:CreateSession` dans un compartiment de répertoires ou une politique basée sur l’identité Gestion des identités et des accès AWS (IAM).
Vous devez posséder les autorisations nécessaires pour utiliser les opérations de chargement partitionné. Vous pouvez utiliser des politiques de compartiment ou des politiques basées sur l’identité IAM pour accorder aux principaux IAM les autorisations nécessaires pour effectuer ces opérations. Le tableau suivant répertorie les autorisations nécessaires pour diverses opérations de chargement partitionné.
Vous pouvez identifier l’initiateur d’un chargement partitionné avec l’élément `Initiator`. Si l'initiateur est un Compte AWS, cet élément fournit les mêmes informations que l'`Owner`élément. Si l’initiateur est un utilisateur IAM, cet élément fournit l’ARN utilisateur et le nom complet.
| Action | Autorisations requises |
| --- | --- |
| Créer un chargement partitionné | Pour créer un chargement partitionné, vous devez être autorisé à effectuer l’action `s3express:CreateSession` sur le compartiment de répertoires. |
| Lancement d’un chargement partitionné | Pour lancer un chargement partitionné, vous devez être autorisé à effectuer l’action `s3express:CreateSession` sur le compartiment de répertoires. |
| Chargement d’une partie | Pour charger une partie, vous devez être autorisé à effectuer l’action `s3express:CreateSession` sur le compartiment de répertoires. Le propriétaire du compartiment doit autoriser l’initiateur à effectuer l’action `s3express:CreateSession` sur le compartiment de répertoires pour que l’initiateur charge une partie. |
| Chargement d’une partie (copie) | Pour charger une partie, vous devez être autorisé à effectuer l’action `s3express:CreateSession` sur le compartiment de répertoires. Pour que l’initiateur puisse charger une partie pour un objet, le propriétaire du compartiment doit l’autoriser à effectuer l’action `s3express:CreateSession` sur l’objet. |
| Terminer un chargement partitionné | Pour finaliser un chargement partitionné, vous devez être autorisé à effectuer l’action `s3express:CreateSession` au niveau du compartiment de répertoires. Le propriétaire du compartiment doit autoriser l’initiateur à effectuer l’action `s3express:CreateSession` sur l’objet pour que l’initiateur puisse finaliser un chargement partitionné. |
| Abandonner un chargement partitionné | Pour abandonner un chargement partitionné, vous devez être autorisé à exécuter l’action `s3express:CreateSession`. Pour annuler un chargement partitionné, son initiateur doit avoir obtenu une autorisation d’accès explicite pour effectuer l’action `s3express:CreateSession`. |
| Liste des parties | Pour répertorier les parties d’un chargement partitionné, vous devez être autorisé à effectuer l’action `s3express:CreateSession` sur le compartiment de répertoires. |
| Lister des chargements partitionnés en cours | Pour répertorier les chargements partitionnés en cours dans un compartiment, vous devez être autorisé à exécuter l’action `s3:ListBucketMultipartUploads` au niveau de ce compartiment. |
### Prise en charge des opérations d’API pour le chargement partitionné
Les sections suivantes de la Référence des API Amazon Simple Storage Service décrivent les opérations d’API REST Amazon S3 pour les chargements partitionnés.
+ [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)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## Exemples
Pour charger un objet dans S3 Express One Zone dans un compartiment de répertoires à l’aide du chargement partitionné, consultez les exemples suivants.
**Topics**
+ [Création d’un chargement partitionné](#directory-buckets-multipart-upload-examples-create)
+ [Chargement des parties d’un chargement partitionné](#directory-buckets-multipart-upload-examples-upload-part)
+ [Achèvement d’un chargement partitionné](#directory-buckets-multipart-upload-examples-complete)
+ [Interruption d’un chargement partitionné](#directory-buckets-multipart-upload-examples-abort)
+ [Création d’une opération de copie d’un chargement partitionné](#directory-buckets-multipart-upload-examples-upload-part-copy)
+ [Affichage de la liste des chargements partitionnés en cours](#directory-buckets-multipart-upload-examples-list)
+ [Affichage de la liste des parties d’un chargement partitionné](#directory-buckets-multipart-upload-examples-list-parts)
### Création d’un chargement partitionné
**Note**
Pour les compartiments de répertoires, lorsque vous effectuez une opération `CreateMultipartUpload` et une opération `UploadPartCopy`, le chiffrement par défaut du compartiment doit utiliser la configuration de chiffrement souhaitée, et les en-têtes de demande que vous fournissez dans la demande `CreateMultipartUpload` doivent correspondre à la configuration de chiffrement par défaut du compartiment de destination.
Les exemples suivants montrent comment créer un chargement partitionné.
#### À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
/**
* This method creates a multipart upload request that generates a unique upload ID that is used to track
* all the upload parts
*
* @param s3
* @param bucketName - for example, 'doc-example-bucket--use1-az4--x-s3'
* @param key
* @return
*/
private static String createMultipartUpload(S3Client s3, String bucketName, String key) {
CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder()
.bucket(bucketName)
.key(key)
.build();
String uploadId = null;
try {
CreateMultipartUploadResponse response = s3.createMultipartUpload(createMultipartUploadRequest);
uploadId = response.uploadId();
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return uploadId;
```
------
#### [ SDK for Python ]
**Example**
```
def create_multipart_upload(s3_client, bucket_name, key_name):
'''
Create a multipart upload to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: The destination bucket for the multipart upload
:param key_name: The key name for the object to be uploaded
:return: The UploadId for the multipart upload if created successfully, else None
'''
try:
mpu = s3_client.create_multipart_upload(Bucket = bucket_name, Key = key_name)
return mpu['UploadId']
except ClientError as e:
logging.error(e)
return None
```
------
#### En utilisant le AWS CLI
Cet exemple montre comment créer un chargement partitionné pour un compartiment de répertoires à l’aide de l’ AWS CLI. Cette commande lance un téléchargement partitionné vers le compartiment de répertoire *bucket-base-name* *zone-id* --x-s3 pour l'objet. *KEY\$1NAME* Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
```
aws s3api create-multipart-upload --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME
```
Pour plus d’informations, consultez [create-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-multipart-upload.html) dans le AWS Command Line Interface.
### Chargement des parties d’un chargement partitionné
Les exemples suivants montrent comment charger les parties d’un chargement partitionné.
#### À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
L’exemple suivant montre comment diviser un objet unique en plusieurs parties, puis comment les charger dans un compartiment de répertoires à l’aide du kit SDK pour Java 2.x.
**Example**
```
/**
* This method creates part requests and uploads individual parts to S3 and then returns all the completed parts
*
* @param s3
* @param bucketName
* @param key
* @param uploadId
* @throws IOException
*/
private static ListCompletedPartmultipartUpload(S3Client s3, String bucketName, String key, String uploadId, String filePath) throws IOException {
int partNumber = 1;
ListCompletedPart completedParts = new ArrayList<>();
ByteBuffer bb = ByteBuffer.allocate(1024 * 1024 * 5); // 5 MB byte buffer
// read the local file, breakdown into chunks and process
try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
long fileSize = file.length();
int position = 0;
while (position < fileSize) {
file.seek(position);
int read = file.getChannel().read(bb);
bb.flip(); // Swap position and limit before reading from the buffer.
UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
.bucket(bucketName)
.key(key)
.uploadId(uploadId)
.partNumber(partNumber)
.build();
UploadPartResponse partResponse = s3.uploadPart(
uploadPartRequest,
RequestBody.fromByteBuffer(bb));
CompletedPart part = CompletedPart.builder()
.partNumber(partNumber)
.eTag(partResponse.eTag())
.build();
completedParts.add(part);
bb.clear();
position += read;
partNumber++;
}
}
catch (IOException e) {
throw e;
}
return completedParts;
}
```
------
#### [ SDK for Python ]
L’exemple suivant montre comment diviser un objet unique en plusieurs parties, puis comment les charger dans un compartiment de répertoires à l’aide du kit SDK pour Python.
**Example**
```
def multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_size):
'''
Break up a file into multiple parts and upload those parts to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Destination bucket for the multipart upload
:param key_name: Key name for object to be uploaded and for the local file that's being uploaded
:param mpu_id: The UploadId returned from the create_multipart_upload call
:param part_size: The size parts that the object will be broken into, in bytes.
Minimum 5 MiB, Maximum 5 GiB. There is no minimum size for the last part of your multipart upload.
:return: part_list for the multipart upload if all parts are uploaded successfully, else None
'''
part_list = []
try:
with open(key_name, 'rb') as file:
part_counter = 1
while True:
file_part = file.read(part_size)
if not len(file_part):
break
upload_part = s3_client.upload_part(
Bucket = bucket_name,
Key = key_name,
UploadId = mpu_id,
Body = file_part,
PartNumber = part_counter
)
part_list.append({'PartNumber': part_counter, 'ETag': upload_part['ETag']})
part_counter += 1
except ClientError as e:
logging.error(e)
return None
return part_list
```
------
#### En utilisant le AWS CLI
Cet exemple montre comment diviser un seul objet en plusieurs parties, puis comment charger ces parties dans un compartiment de répertoires à l’aide de l’ AWS CLI. Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
```
aws s3api upload-part --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --part-number 1 --body LOCAL_FILE_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBSD0WBKMAQAAAABneY9yBVsK89iFkvWdQhRCcXohE8RbYtc9QvBOG8tNpA"
```
Pour plus d’informations, consultez [upload-part](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/upload-part.html) dans l’ AWS Command Line Interface.
### Achèvement d’un chargement partitionné
Les exemples suivants montrent comment finaliser un chargement partitionné.
#### À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
Les exemples suivants montrent comment finaliser un chargement partitionné à l’aide du kit SDK pour Java 2.x.
**Example**
```
/**
* This method completes the multipart upload request by collating all the upload parts
* @param s3
* @param bucketName - for example, 'doc-example-bucket--usw2-az1--x-s3'
* @param key
* @param uploadId
* @param uploadParts
*/
private static void completeMultipartUpload(S3Client s3, String bucketName, String key, String uploadId, ListCompletedPart uploadParts) {
CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder()
.parts(uploadParts)
.build();
CompleteMultipartUploadRequest completeMultipartUploadRequest =
CompleteMultipartUploadRequest.builder()
.bucket(bucketName)
.key(key)
.uploadId(uploadId)
.multipartUpload(completedMultipartUpload)
.build();
s3.completeMultipartUpload(completeMultipartUploadRequest);
}
public static void multipartUploadTest(S3Client s3, String bucketName, String key, String localFilePath) {
System.out.println("Starting multipart upload for: " + key);
try {
String uploadId = createMultipartUpload(s3, bucketName, key);
System.out.println(uploadId);
ListCompletedPart parts = multipartUpload(s3, bucketName, key, uploadId, localFilePath);
completeMultipartUpload(s3, bucketName, key, uploadId, parts);
System.out.println("Multipart upload completed for: " + key);
}
catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
Les exemples suivants montrent comment finaliser un chargement partitionné à l’aide du kit SDK pour Python.
**Example**
```
def complete_multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_list):
'''
Completes a multipart upload to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: The destination bucket for the multipart upload
:param key_name: The key name for the object to be uploaded
:param mpu_id: The UploadId returned from the create_multipart_upload call
:param part_list: The list of uploaded part numbers with their associated ETags
:return: True if the multipart upload was completed successfully, else False
'''
try:
s3_client.complete_multipart_upload(
Bucket = bucket_name,
Key = key_name,
UploadId = mpu_id,
MultipartUpload = {
'Parts': part_list
}
)
except ClientError as e:
logging.error(e)
return False
return True
if __name__ == '__main__':
MB = 1024 ** 2
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
key_name = 'OBJECT_NAME'
part_size = 10 * MB
s3_client = boto3.client('s3', region_name = region)
mpu_id = create_multipart_upload(s3_client, bucket_name, key_name)
if mpu_id is not None:
part_list = multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_size)
if part_list is not None:
if complete_multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_list):
print (f'{key_name} successfully uploaded through a ultipart upload to {bucket_name}')
else:
print (f'Could not upload {key_name} hrough a multipart upload to {bucket_name}')
```
------
#### En utilisant le AWS CLI
Cet exemple montre comment finaliser un chargement partitionné pour un compartiment de répertoires à l’aide de l’ AWS CLI. Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
```
aws s3api complete-multipart-upload --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBSD0WBKMAQAAAABneY9yBVsK89iFkvWdQhRCcXohE8RbYtc9QvBOG8tNpA" --multipart-upload file://parts.json
```
Cet exemple utilise une structure JSON qui décrit les parties du chargement partitionné qui doivent être réassemblées dans le fichier complet. Dans cet exemple, le préfixe `file://` est utilisé pour charger la structure JSON à partir d’un fichier du dossier local nommé `parts`.
parts.json :
```
parts.json
{
"Parts": [
{
"ETag": "6b78c4a64dd641a58dac8d9258b88147",
"PartNumber": 1
}
]
}
```
Pour plus d’informations, consultez [complete-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/complete-multipart-upload.html) dans le AWS Command Line Interface.
### Interruption d’un chargement partitionné
Les exemples suivants montrent comment abandonner un chargement partitionné.
#### À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
L’exemple suivant montre comment abandonner un chargement partitionné à l’aide du kit SDK pour Java 2.x.
**Example**
```
public static void abortMultiPartUploads( S3Client s3, String bucketName ) {
try {
ListMultipartUploadsRequest listMultipartUploadsRequest = ListMultipartUploadsRequest.builder()
.bucket(bucketName)
.build();
ListMultipartUploadsResponse response = s3.listMultipartUploads(listMultipartUploadsRequest);
ListMultipartUpload uploads = response.uploads();
AbortMultipartUploadRequest abortMultipartUploadRequest;
for (MultipartUpload upload: uploads) {
abortMultipartUploadRequest = AbortMultipartUploadRequest.builder()
.bucket(bucketName)
.key(upload.key())
.uploadId(upload.uploadId())
.build();
s3.abortMultipartUpload(abortMultipartUploadRequest);
}
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
L’exemple suivant montre comment abandonner un chargement partitionné à l’aide du kit SDK pour Python.
**Example**
```
import logging
import boto3
from botocore.exceptions import ClientError
def abort_multipart_upload(s3_client, bucket_name, key_name, upload_id):
'''
Aborts a partial multipart upload in a directory bucket.
:param s3_client: boto3 S3 client
:param bucket_name: Bucket where the multipart upload was initiated - for example, 'doc-example-bucket--usw2-az1--x-s3'
:param key_name: Name of the object for which the multipart upload needs to be aborted
:param upload_id: Multipart upload ID for the multipart upload to be aborted
:return: True if the multipart upload was successfully aborted, False if not
'''
try:
s3_client.abort_multipart_upload(
Bucket = bucket_name,
Key = key_name,
UploadId = upload_id
)
except ClientError as e:
logging.error(e)
return False
return True
if __name__ == '__main__':
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
key_name = 'KEY_NAME'
upload_id = 'UPLOAD_ID'
s3_client = boto3.client('s3', region_name = region)
if abort_multipart_upload(s3_client, bucket_name, key_name, upload_id):
print (f'Multipart upload for object {key_name} in {bucket_name} bucket has been aborted')
else:
print (f'Unable to abort multipart upload for object {key_name} in {bucket_name} bucket')
```
------
#### En utilisant le AWS CLI
Les exemples suivants montrent comment abandonner un chargement partitionné à l’aide de l’ AWS CLI. Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
```
aws s3api abort-multipart-upload --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEAX5hFw-MAQAAAAB0OxUFeA7LTbWWFS8WYwhrxDxTIDN-pdEEq_agIHqsbg"
```
Pour plus d’informations, consultez [abort-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/abort-multipart-upload.html) dans le AWS Command Line Interface.
### Création d’une opération de copie d’un chargement partitionné
**Note**
Pour chiffrer de nouvelles copies partielles d’objets dans un compartiment de répertoires avec SSE-KMS, vous devez spécifier SSE-KMS comme configuration de chiffrement par défaut de ce compartiment avec une clé KMS (plus spécifiquement, une [clé gérée par le client](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk)). La [Clé gérée par AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) (`aws/s3`) n’est pas prise en charge. Votre configuration SSE-KMS ne peut prendre en charge qu’une seule [clé gérée par le client](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) par compartiment de répertoires pendant toute la durée de vie du compartiment. Après avoir spécifié une clé gérée par le client pour SSE-KMS, vous ne pouvez pas remplacer cette clé pour la configuration SSE-KMS du compartiment. Vous ne pouvez pas spécifier de paramètres de chiffrement côté serveur pour les nouvelles copies partielles d'objets avec SSE-KMS dans les en-têtes de demande. [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html) En outre, les en-têtes de demande que vous fournissez dans la demande `CreateMultipartUpload` doivent correspondre à la configuration de chiffrement par défaut du compartiment de destination.
Les clés de compartiment S3 ne sont pas prises en charge lorsque vous copiez des objets chiffrés avec SSE-KMS depuis des compartiments à usage général vers des compartiments de répertoires, depuis des compartiments de répertoires vers des compartiments à usage général ou entre des compartiments de répertoires, par le biais de l’opération [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html). Dans ce cas, Amazon S3 effectue un appel à AWS KMS chaque fois qu'une demande de copie est faite pour un objet chiffré par KMS.
Les exemples suivants montrent comment copier des objets d’un compartiment vers un autre à l’aide du chargement partitionné.
#### À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
L’exemple suivant montre comment utiliser un chargement partitionné pour copier un objet par programmation d’un compartiment à un autre à l’aide du kit SDK pour Java 2.x.
**Example**
```
/**
* This method creates a multipart upload request that generates a unique upload ID that is used to track
* all the upload parts.
*
* @param s3
* @param bucketName
* @param key
* @return
*/
private static String createMultipartUpload(S3Client s3, String bucketName, String key) {
CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder()
.bucket(bucketName)
.key(key)
.build();
String uploadId = null;
try {
CreateMultipartUploadResponse response = s3.createMultipartUpload(createMultipartUploadRequest);
uploadId = response.uploadId();
} catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return uploadId;
}
/**
* Creates copy parts based on source object size and copies over individual parts
*
* @param s3
* @param sourceBucket
* @param sourceKey
* @param destnBucket
* @param destnKey
* @param uploadId
* @return
* @throws IOException
*/
public static ListCompletedPart multipartUploadCopy(S3Client s3, String sourceBucket, String sourceKey, String destnBucket, String destnKey, String uploadId) throws IOException {
// Get the object size to track the end of the copy operation.
HeadObjectRequest headObjectRequest = HeadObjectRequest
.builder()
.bucket(sourceBucket)
.key(sourceKey)
.build();
HeadObjectResponse response = s3.headObject(headObjectRequest);
Long objectSize = response.contentLength();
System.out.println("Source Object size: " + objectSize);
// Copy the object using 20 MB parts.
long partSize = 20 * 1024 * 1024;
long bytePosition = 0;
int partNum = 1;
ListCompletedPart completedParts = new ArrayList<>();
while (bytePosition < objectSize) {
// The last part might be smaller than partSize, so check to make sure
// that lastByte isn't beyond the end of the object.
long lastByte = Math.min(bytePosition + partSize - 1, objectSize - 1);
System.out.println("part no: " + partNum + ", bytePosition: " + bytePosition + ", lastByte: " + lastByte);
// Copy this part.
UploadPartCopyRequest req = UploadPartCopyRequest.builder()
.uploadId(uploadId)
.sourceBucket(sourceBucket)
.sourceKey(sourceKey)
.destinationBucket(destnBucket)
.destinationKey(destnKey)
.copySourceRange("bytes="+bytePosition+"-"+lastByte)
.partNumber(partNum)
.build();
UploadPartCopyResponse res = s3.uploadPartCopy(req);
CompletedPart part = CompletedPart.builder()
.partNumber(partNum)
.eTag(res.copyPartResult().eTag())
.build();
completedParts.add(part);
partNum++;
bytePosition += partSize;
}
return completedParts;
}
public static void multipartCopyUploadTest(S3Client s3, String srcBucket, String srcKey, String destnBucket, String destnKey) {
System.out.println("Starting multipart copy for: " + srcKey);
try {
String uploadId = createMultipartUpload(s3, destnBucket, destnKey);
System.out.println(uploadId);
ListCompletedPart parts = multipartUploadCopy(s3, srcBucket, srcKey,destnBucket, destnKey, uploadId);
completeMultipartUpload(s3, destnBucket, destnKey, uploadId, parts);
System.out.println("Multipart copy completed for: " + srcKey);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
L’exemple suivant montre comment utiliser un chargement partitionné pour copier un objet par programmation d’un compartiment à un autre à l’aide du kit SDK pour Python.
**Example**
```
import logging
import boto3
from botocore.exceptions import ClientError
def head_object(s3_client, bucket_name, key_name):
'''
Returns metadata for an object in a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Bucket that contains the object to query for metadata
:param key_name: Key name to query for metadata
:return: Metadata for the specified object if successful, else None
'''
try:
response = s3_client.head_object(
Bucket = bucket_name,
Key = key_name
)
return response
except ClientError as e:
logging.error(e)
return None
def create_multipart_upload(s3_client, bucket_name, key_name):
'''
Create a multipart upload to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Destination bucket for the multipart upload
:param key_name: Key name of the object to be uploaded
:return: UploadId for the multipart upload if created successfully, else None
'''
try:
mpu = s3_client.create_multipart_upload(Bucket = bucket_name, Key = key_name)
return mpu['UploadId']
except ClientError as e:
logging.error(e)
return None
def multipart_copy_upload(s3_client, source_bucket_name, key_name, target_bucket_name, mpu_id, part_size):
'''
Copy an object in a directory bucket to another bucket in multiple parts of a specified size
:param s3_client: boto3 S3 client
:param source_bucket_name: Bucket where the source object exists
:param key_name: Key name of the object to be copied
:param target_bucket_name: Destination bucket for copied object
:param mpu_id: The UploadId returned from the create_multipart_upload call
:param part_size: The size parts that the object will be broken into, in bytes.
Minimum 5 MiB, Maximum 5 GiB. There is no minimum size for the last part of your multipart upload.
:return: part_list for the multipart copy if all parts are copied successfully, else None
'''
part_list = []
copy_source = {
'Bucket': source_bucket_name,
'Key': key_name
}
try:
part_counter = 1
object_size = head_object(s3_client, source_bucket_name, key_name)
if object_size is not None:
object_size = object_size['ContentLength']
while (part_counter - 1) * part_size
L’exemple suivant montre comment utiliser un chargement partitionné pour copier par programmation un objet d’un compartiment vers un compartiment de répertoires à l’aide de l’ AWS CLI. Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
```
aws s3api upload-part-copy --bucket bucket-base-name--zone-id--x-s3 --key TARGET_KEY_NAME --copy-source SOURCE_BUCKET_NAME/SOURCE_KEY_NAME --part-number 1 --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBnJ4cxKMAQAAAABiNXpOFVZJ1tZcKWib9YKE1C565_hCkDJ_4AfCap2svg"
```
Pour plus d’informations, consultez [upload-part-copy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/upload-part-copy.html ) dans le AWS Command Line Interface.
### Affichage de la liste des chargements partitionnés en cours
Pour répertorier les téléchargements partitionnés en cours vers un bucket de répertoire, vous pouvez utiliser le AWS SDKs, ou le. AWS CLI
#### À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
Les exemples suivants montrent comment répertorier les chargements partitionnés (incomplets) en cours à l’aide du SDK pour Java 2.x.
**Example**
```
public static void listMultiPartUploads( S3Client s3, String bucketName) {
try {
ListMultipartUploadsRequest listMultipartUploadsRequest = ListMultipartUploadsRequest.builder()
.bucket(bucketName)
.build();
ListMultipartUploadsResponse response = s3.listMultipartUploads(listMultipartUploadsRequest);
List MultipartUpload uploads = response.uploads();
for (MultipartUpload upload: uploads) {
System.out.println("Upload in progress: Key = \"" + upload.key() + "\", id = " + upload.uploadId());
}
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
Les exemples suivants montrent comment répertorier les chargements partitionnés (incomplets) en cours à l’aide du SDK pour Python.
**Example**
```
import logging
import boto3
from botocore.exceptions import ClientError
def list_multipart_uploads(s3_client, bucket_name):
'''
List any incomplete multipart uploads in a directory bucket in e specified gion
:param s3_client: boto3 S3 client
:param bucket_name: Bucket to check for incomplete multipart uploads
:return: List of incomplete multipart uploads if there are any, None if not
'''
try:
response = s3_client.list_multipart_uploads(Bucket = bucket_name)
if 'Uploads' in response.keys():
return response['Uploads']
else:
return None
except ClientError as e:
logging.error(e)
if __name__ == '__main__':
bucket_name = 'BUCKET_NAME'
region = 'us-west-2'
s3_client = boto3.client('s3', region_name = region)
multipart_uploads = list_multipart_uploads(s3_client, bucket_name)
if multipart_uploads is not None:
print (f'There are {len(multipart_uploads)} ncomplete multipart uploads for {bucket_name}')
else:
print (f'There are no incomplete multipart uploads for {bucket_name}')
```
------
#### En utilisant le AWS CLI
Les exemples suivants montrent comment répertorier les chargements partitionnés (incomplets) en cours à l’aide de l’ AWS CLI. Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
```
aws s3api list-multipart-uploads --bucket bucket-base-name--zone-id--x-s3
```
Pour plus d’informations, consultez [list-multipart-uploads](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-multipart-uploads.html ) dans le AWS Command Line Interface.
### Affichage de la liste des parties d’un chargement partitionné
Les exemples suivants montrent comment répertorier les parties d’un chargement partitionné dans un compartiment de répertoires.
#### À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
Les exemples suivants montrent comment répertorier les parties d’un chargement partitionné dans un compartiment de répertoires à l’aide du kit SDK pour Java 2.x.
```
public static void listMultiPartUploadsParts( S3Client s3, String bucketName, String objKey, String uploadID) {
try {
ListPartsRequest listPartsRequest = ListPartsRequest.builder()
.bucket(bucketName)
.uploadId(uploadID)
.key(objKey)
.build();
ListPartsResponse response = s3.listParts(listPartsRequest);
ListPart parts = response.parts();
for (Part part: parts) {
System.out.println("Upload in progress: Part number = \"" + part.partNumber() + "\", etag = " + part.eTag());
}
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
Les exemples suivants montrent comment répertorier les parties d’un chargement partitionné dans un compartiment de répertoires à l’aide du kit SDK pour Python.
```
import logging
import boto3
from botocore.exceptions import ClientError
def list_parts(s3_client, bucket_name, key_name, upload_id):
'''
Lists the parts that have been uploaded for a specific multipart upload to a directory bucket.
:param s3_client: boto3 S3 client
:param bucket_name: Bucket that multipart uploads parts have been uploaded to
:param key_name: Name of the object that has parts uploaded
:param upload_id: Multipart upload ID that the parts are associated with
:return: List of parts associated with the specified multipart upload, None if there are no parts
'''
parts_list = []
next_part_marker = ''
continuation_flag = True
try:
while continuation_flag:
if next_part_marker == '':
response = s3_client.list_parts(
Bucket = bucket_name,
Key = key_name,
UploadId = upload_id
)
else:
response = s3_client.list_parts(
Bucket = bucket_name,
Key = key_name,
UploadId = upload_id,
NextPartMarker = next_part_marker
)
if 'Parts' in response:
for part in response['Parts']:
parts_list.append(part)
if response['IsTruncated']:
next_part_marker = response['NextPartNumberMarker']
else:
continuation_flag = False
else:
continuation_flag = False
return parts_list
except ClientError as e:
logging.error(e)
return None
if __name__ == '__main__':
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
key_name = 'KEY_NAME'
upload_id = 'UPLOAD_ID'
s3_client = boto3.client('s3', region_name = region)
parts_list = list_parts(s3_client, bucket_name, key_name, upload_id)
if parts_list is not None:
print (f'{key_name} has {len(parts_list)} parts uploaded to {bucket_name}')
else:
print (f'There are no multipart uploads with that upload ID for {bucket_name} bucket')
```
------
#### En utilisant le AWS CLI
Les exemples suivants montrent comment répertorier les parties d’un chargement partitionné dans un compartiment de répertoires à l’aide de l’ AWS CLI. Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
```
aws s3api list-parts --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBSD0WBKMAQAAAABneY9yBVsK89iFkvWdQhRCcXohE8RbYtc9QvBOG8tNpA"
```
Pour plus d’informations, consultez [list-parts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-parts.html) dans l’ AWS Command Line Interface.
# Copie d’objets vers ou depuis un compartiment de répertoires
L’opération de copie crée une copie d’un objet déjà stocké dans Amazon S3. Vous pouvez copier des objets entre des compartiments de répertoires et des compartiments à usage général. Vous pouvez également copier des objets au sein d’un compartiment et entre des compartiments du même type, par exemple, d’un compartiment de répertoires à un autre.
**Note**
La copie d'objets entre différents Régions AWS n'est pas prise en charge lorsque le compartiment source ou de destination se trouve dans une zone AWS locale. Les compartiments source et de destination doivent avoir la même Région AWS parent. Les compartiments source et de destination peuvent correspondre à différents types d’emplacement de compartiment (zone de disponibilité ou zone locale).
Vous pouvez créer une copie d’un objet d’une taille maximale de 5 Go dans une seule opération atomique. Toutefois, pour copier un objet supérieur à 5 Go, vous devez utiliser les opérations d’API de chargement partitionné. Pour de plus amples informations, veuillez consulter [Utilisation du chargement partitionné avec les compartiments de répertoires](s3-express-using-multipart-upload.md).
**Permissions**
Pour copier des objets, vous devez disposer des autorisations suivantes :
+ Pour copier des objets d’un compartiment de répertoires vers un autre, vous devez disposer de l’autorisation `s3express:CreateSession`.
+ Pour copier des objets à partir de compartiments de répertoires vers des compartiments à usage général, vous devez disposer de l’autorisation `s3express:CreateSession` et de l’autorisation `s3:PutObject` permettant d’écrire la copie des objets dans le compartiment de destination.
+ Pour copier des objets à partir de compartiments à usage général vers des compartiments de répertoires, vous devez disposer de l’autorisation `s3express:CreateSession` et de l’autorisation `s3:GetObject` permettant de lire l’objet source à copier.
Pour plus d’informations, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) dans la *Référence d’API Amazon Simple Storage Service*.
**Chiffrement**
Amazon S3 chiffre automatiquement tous les nouveaux objets chargés dans un compartiment S3. La configuration de chiffrement par défaut d’un compartiment S3 est toujours activée et est au minimum définie sur le chiffrement côté serveur avec les clés gérées par Amazon S3 (SSE-S3).
Pour les compartiments d'annuaire, le SSE-S3 et le chiffrement côté serveur avec des clés AWS Key Management Service (AWS KMS) (SSE-KMS) sont pris en charge. Lorsque le compartiment de destination est un compartiment de répertoires, nous recommandons que le chiffrement par défaut du compartiment de destination utilise la configuration de chiffrement souhaitée et que vous ne remplaciez pas le chiffrement par défaut du compartiment. Les nouveaux objets seront ensuite automatiquement chiffrés avec les paramètres de chiffrement souhaités. De plus, les clés de compartiment S3 ne sont pas prises en charge lorsque vous copiez des objets chiffrés avec SSE-KMS depuis des compartiments à usage général vers des compartiments de répertoires, depuis des compartiments de répertoires vers des compartiments à usage général ou entre des compartiments de répertoires, par le biais de l’opération [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html). Dans ce cas, Amazon S3 effectue un appel à AWS KMS chaque fois qu'une demande de copie est faite pour un objet chiffré par KMS. Pour plus d'informations sur les comportements de remplacement du chiffrement dans les compartiments de répertoire, voir [Spécifier le chiffrement côté serveur avec AWS KMS pour](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html) les téléchargements de nouveaux objets.
Pour les compartiments à usage général, vous pouvez utiliser le SSE-S3 (par défaut), le chiffrement côté serveur avec des clés () AWS Key Management Service (SSE-KMS AWS KMS), le chiffrement double couche côté serveur avec des clés (DSSE-KMS) ou le chiffrement côté serveur avec des AWS KMS clés fournies par le client (SSE-C).
Si vous effectuez une demande de copie qui indique d’utiliser le chiffrement DSSE-KMS ou SSE-C pour un compartiment de répertoires (compartiment source ou cible), la réponse renverra une erreur.
**Étiquettes**
Les compartiments de répertoires ne prennent pas en charge les balises. Si vous copiez un objet contenant des balises à partir d’un compartiment à usage général vers un compartiment de répertoires, vous recevez une réponse HTTP `501 (Not Implemented)`. Pour plus d’informations, consultez [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) dans la *Référence d’API Amazon Simple Storage Service*.
**ETags**
Les balises d'entité (ETags) pour S3 Express One Zone sont des chaînes alphanumériques aléatoires et ne sont pas des MD5 checksums. Pour garantir l’intégrité des objets, utilisez des sommes de contrôle supplémentaires.
**Sommes de contrôle supplémentaires**
S3 Express One Zone vous offre la possibilité de choisir l’algorithme de somme de contrôle utilisé pour valider vos données pendant le chargement ou le téléchargement. Vous pouvez sélectionner l'un des algorithmes de hachage sécurisé (SHA) ou de contrôle de redondance cyclique (CRC) suivants : CRC32 C CRC32, SHA-1 et SHA-256. MD5les checksums basés sur la base de données ne sont pas pris en charge avec la classe de stockage S3 Express One Zone.
Pour de plus amples informations, veuillez consulter [Bonnes pratiques supplémentaires en matière de somme de contrôle S3](s3-express-optimizing-performance.md#s3-express-optimizing-performance-checksums).
**Fonctionnalités prises en charge**
Pour plus d’informations sur les fonctionnalités Amazon S3 prises en charge pour S3 Express One Zone, consultez [Différences pour les compartiments de répertoires](s3-express-differences.md).
## Utilisation de la console S3 (copie vers un compartiment de répertoires)
**Note**
Voici les restrictions et limites qui s’appliquent lorsque vous copiez un objet dans un compartiment de répertoires avec la console :
L’action `Copy` s’applique à tous les objets des dossiers spécifiés (préfixes). Les objets ajoutés à ces dossiers pendant que l’action est en cours risquent d’être affectés.
Les objets chiffrés avec des clés de chiffrement fournies par le client (SSE-C) ne peuvent pas être copiés à l’aide de la console S3. Pour copier des objets chiffrés avec SSE-C, utilisez le AWS CLI AWS SDK ou l'API REST Amazon S3.
Les objets copiés ne conservent pas les paramètres de verrouillage des objets d’origine.
Si le compartiment à partir duquel vous copiez des objets utilise le paramètre imposé par le propriétaire du compartiment pour la propriété des objets S3, l'objet ne ACLs sera pas copié vers la destination spécifiée.
Si vous souhaitez copier des objets dans un compartiment qui utilise le paramètre imposé par le propriétaire du compartiment pour la propriété des objets S3, assurez-vous que le compartiment source utilise également le paramètre imposé par le propriétaire du compartiment, ou supprimez tout objet accordé par l'ACL à d'autres AWS comptes et groupes.
Les objets copiés d'un compartiment à usage général vers un compartiment de répertoire ne conserveront pas les balises d'objet ni les valeurs Etag. ACLs Les valeurs de somme de contrôle peuvent être copiées, mais ne sont pas équivalentes à une balise d’entité. La valeur d’une somme de contrôle peut changer par rapport au moment où elle a été ajoutée.
Tous les objets copiés dans un compartiment de répertoires présentent le paramètre Propriétaire du compartiment appliqué pour la propriété des objets S3.
**Pour copier un objet d’un compartiment à usage général vers un compartiment de répertoires**
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 volet de navigation gauche, sélectionnez le type de compartiment dont vous souhaitez copier des objets :
+ Pour copier des objets à partir d’un compartiment à usage général, choisissez l’onglet **Compartiments à usage général**.
+ Pour copier des objets à partir d’un compartiment de répertoires, choisissez l’onglet **Compartiments de répertoires**.
1. Choisissez le compartiment à usage général ou le compartiment de répertoires contenant les objets que vous souhaitez copier.
1. Cliquez sur l’onglet **Objets**. Sur la page **Objets**, cochez la case située à gauche du nom des objets que vous souhaitez copier.
1. Dans le menu **Actions**, choisissez **Copier**.
La page **Copier** s’affiche.
1. Sous **Destination**, choisissez **Compartiment de répertoires** pour votre type de destination. Pour spécifier le chemin de destination, choisissez **Parcourir S3**, accédez à la destination, puis cochez la case située à gauche de la destination. Choisissez **Choose destination (Choisir une destination)** en bas à droite.
Vous pouvez également saisir le chemin de destination.
1. Sous **Paramètres de copie supplémentaires**, choisissez **Copie des paramètres source**, **Aucune spécification de paramètres** ou **Spécification des paramètres**. L’option par défaut est **Copie des paramètres source**. Si vous souhaitez uniquement copier l’objet sans les attributs des paramètres source, choisissez **Aucune spécification de paramètres**. Choisissez **Spécification des paramètres** pour définir les paramètres du chiffrement côté serveur, des sommes de contrôle et des métadonnées.
1. En bas à droite, choisissez **Copy (Copier)**. Amazon S3 copie votre objet dans la destination.
## Utilisation de la console S3 (copie vers un compartiment à usage général)
**Note**
Voici les restrictions et limites qui s’appliquent lorsque vous copiez un objet dans un compartiment à usage général avec la console :
L’action `Copy` s’applique à tous les objets des dossiers spécifiés (préfixes). Les objets ajoutés à ces dossiers pendant que l’action est en cours risquent d’être affectés.
Les objets chiffrés avec des clés de chiffrement fournies par le client (SSE-C) ne peuvent pas être copiés à l’aide de la console S3. Pour copier des objets chiffrés avec SSE-C, utilisez le AWS CLI AWS SDK ou l'API REST Amazon S3.
Les objets copiés ne conservent pas les paramètres de verrouillage des objets d’origine.
Si le compartiment à partir duquel vous copiez des objets utilise le paramètre imposé par le propriétaire du compartiment pour la propriété des objets S3, l'objet ne ACLs sera pas copié vers la destination spécifiée.
Si vous souhaitez copier des objets dans un compartiment qui utilise le paramètre imposé par le propriétaire du compartiment pour la propriété des objets S3, assurez-vous que le compartiment source utilise également le paramètre imposé par le propriétaire du compartiment, ou supprimez tout objet accordé par l'ACL à d'autres AWS comptes et groupes.
**Pour copier un objet d’un compartiment de répertoires vers un compartiment à usage général**
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. Choisissez l’onglet **Compartiments de répertoires**.
1. Choisissez le compartiment de répertoires contenant les objets que vous souhaitez copier.
1. Cliquez sur l’onglet **Objets**. Sur la page **Objets**, cochez la case située à gauche du nom des objets que vous souhaitez copier.
1. Dans le menu **Actions**, choisissez **Copier**.
1. Sous **Destination**, choisissez **Compartiment à usage général** pour votre type de destination. Pour spécifier le chemin de destination, choisissez **Parcourir S3**, accédez à la destination, puis cochez la case située à gauche de la destination. Choisissez **Choose destination (Choisir une destination)** en bas à droite.
Vous pouvez également saisir le chemin de destination.
1. Sous **Paramètres de copie supplémentaires**, choisissez **Copie des paramètres source**, **Aucune spécification de paramètres** ou **Spécification des paramètres**. L’option par défaut est **Copie des paramètres source**. Si vous souhaitez uniquement copier l’objet sans les attributs des paramètres source, choisissez **Aucune spécification de paramètres**. Choisissez **Spécifier les paramètres** pour définir les paramètres de classe de stockage ACLs, les balises d'objet, les métadonnées, le chiffrement côté serveur et les sommes de contrôle supplémentaires.
1. En bas à droite, choisissez **Copy (Copier)**. Amazon S3 copie votre objet dans la destination.
## À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
public static void copyBucketObject (S3Client s3, String sourceBucket, String objectKey, String targetBucket) {
CopyObjectRequest copyReq = CopyObjectRequest.builder()
.sourceBucket(sourceBucket)
.sourceKey(objectKey)
.destinationBucket(targetBucket)
.destinationKey(objectKey)
.build();
String temp = "";
try {
CopyObjectResponse copyRes = s3.copyObject(copyReq);
System.out.println("Successfully copied " + objectKey +" from bucket " + sourceBucket +" into bucket "+targetBucket);
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
------
## En utilisant le AWS CLI
L'`copy-object`exemple de commande suivant montre comment vous pouvez utiliser le AWS CLI pour copier un objet d'un compartiment vers un autre compartiment. Vous pouvez copier des objets d’un type de compartiment à l’autre. Pour exécuter cette commande, remplacez les espaces réservés d’entrée utilisateur par vos propres informations.
```
aws s3api copy-object --copy-source SOURCE_BUCKET/SOURCE_KEY_NAME --key TARGET_KEY_NAME --bucket TARGET_BUCKET_NAME
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/copy-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/copy-object.html) dans la *Référence des commandes de l’AWS CLI *.
# Suppression d’objets à partir d’un compartiment de répertoires
Vous pouvez supprimer des objets d'un compartiment d'annuaire Amazon S3 à l'aide de la console Amazon S3, AWS Command Line Interface (AWS CLI) ou AWS SDKs. Pour plus d’informations, consultez [Utilisation des compartiments de répertoires](directory-buckets-overview.md) et [S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone).
**Avertissement**
La suppression d’un objet est irréversible.
Cette action supprime tous les objets spécifiés. Lorsque vous supprimez des dossiers, attendez la fin de l’action de suppression pour ajouter de nouveaux objets au dossier. Dans le cas contraire, de nouveaux objets pourraient également être supprimés.
**Note**
Lorsque vous supprimez plusieurs objets d’un compartiment de répertoires par programmation, notez les points suivants :
Les clés d’objet figurant dans les demandes `DeleteObjects` doivent contenir au moins un caractère autre qu’une espace. Les chaînes composées uniquement d’espaces ne sont pas prises en charge.
Les clés d’objet figurant dans les demandes `DeleteObjects` ne peuvent pas contenir de caractères de contrôle Unicode, à l’exception des sauts de ligne (`\n`), des tabulations (`\t`) et des retour chariot (`\r`).
## Utilisation de la console S3
**Pour supprimer des objets**
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 volet de navigation de gauche, choisissez **Compartiments de répertoires**.
1. Choisissez le compartiment de répertoires contenant les objets que vous souhaitez supprimer.
1. Cliquez sur l’onglet **Objets**. Dans la liste **Objets**, cochez la case en regard des objets que vous souhaitez supprimer.
1. Sélectionnez **Delete (Supprimer)**.
1. Sur la page **Supprimer des objets**, entrez **permanently delete** dans la zone de texte.
1. Choisissez **Supprimer les objets**.
## À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
L’exemple suivant illustre la suppression d’objets dans un compartiment de répertoires à l’aide du kit AWS SDK for Java 2.x.
```
static void deleteObject(S3Client s3Client, String bucketName, String objectKey) {
try {
DeleteObjectRequest del = DeleteObjectRequest.builder()
.bucket(bucketName)
.key(objectKey)
.build();
s3Client.deleteObject(del);
System.out.println("Object " + objectKey + " has been deleted");
} catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
**Example**
L’exemple suivant illustre la suppression d’objets dans un compartiment de répertoires à l’aide du kit AWS SDK pour Python (Boto3).
```
import logging
import boto3
from botocore.exceptions import ClientError
def delete_objects(s3_client, bucket_name, objects):
'''
Delete a list of objects in a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Bucket that contains objects to be deleted; for example, 'doc-example-bucket--usw2-az1--x-s3'
:param objects: List of dictionaries that specify the key names to delete
:return: Response output, else False
'''
try:
response = s3_client.delete_objects(
Bucket = bucket_name,
Delete = {
'Objects': objects
}
)
return response
except ClientError as e:
logging.error(e)
return False
if __name__ == '__main__':
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
objects = [
{
'Key': '0.txt'
},
{
'Key': '1.txt'
},
{
'Key': '2.txt'
},
{
'Key': '3.txt'
},
{
'Key': '4.txt'
}
]
s3_client = boto3.client('s3', region_name = region)
results = delete_objects(s3_client, bucket_name, objects)
if results is not None:
if 'Deleted' in results:
print (f'Deleted {len(results["Deleted"])} objects from {bucket_name}')
if 'Errors' in results:
print (f'Failed to delete {len(results["Errors"])} objects from {bucket_name}')
```
------
## En utilisant le AWS CLI
L’exemple de commande `delete-object` suivant illustre la façon d’utiliser l’ AWS CLI pour supprimer un objet d’un compartiment de répertoires. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
```
aws s3api delete-object --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-object.html) dans la *Référence des commandes de l’AWS CLI *.
L’exemple de commande `delete-objects` suivant illustre la façon d’utiliser l’ AWS CLI pour supprimer des objets d’un compartiment de répertoires. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
Le fichier `delete.json` est le suivant :
```
{
"Objects": [
{
"Key": "0.txt"
},
{
"Key": "1.txt"
},
{
"Key": "2.txt"
},
{
"Key": "3.txt"
}
]
}
```
Voici un exemple de commande `delete-objects` :
```
aws s3api delete-objects --bucket bucket-base-name--zone-id--x-s3 --delete file://delete.json
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-objects.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-objects.html) dans la *Référence des commandes de l’AWS CLI *.
# Téléchargement d’un objet à partir d’un compartiment de répertoires
Les exemples de code suivants montrent comment lire (télécharger) les données d’un objet dans un compartiment de répertoires Amazon S3 à l’aide de l’opération d’API `GetObject`.
## À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
Les exemples de code suivants montrent comment lire les données à partir d’un objet dans un compartiment de répertoires à l’aide du kit AWS SDK for Java 2.x.
```
public static void getObject(S3Client s3Client, String bucketName, String objectKey) {
try {
GetObjectRequest objectRequest = GetObjectRequest
.builder()
.key(objectKey)
.bucket(bucketName)
.build();
ResponseBytes GetObjectResponse objectBytes = s3Client.getObjectAsBytes(objectRequest);
byte[] data = objectBytes.asByteArray();
//Print object contents to console
String s = new String(data, StandardCharsets.UTF_8);
System.out.println(s);
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
**Example**
Les exemples de code suivants montrent comment lire les données à partir d’un objet dans un compartiment de répertoires à l’aide du kit AWS SDK pour Python (Boto3).
```
import boto3
from botocore.exceptions import ClientError
from botocore.response import StreamingBody
def get_object(s3_client: boto3.client, bucket_name: str, key_name: str) -> StreamingBody:
"""
Gets the object.
:param s3_client:
:param bucket_name: The bucket that contains the object.
:param key_name: The key of the object to be downloaded.
:return: The object data in bytes.
"""
try:
response = s3_client.get_object(Bucket=bucket_name, Key=key_name)
body = response['Body'].read()
print(f"Got object '{key_name}' from bucket '{bucket_name}'.")
except ClientError:
print(f"Couldn't get object '{key_name}' from bucket '{bucket_name}'.")
raise
else:
return body
def main():
s3_client = boto3.client('s3')
resp = get_object(s3_client, 'doc-example-bucket--use1-az4--x-s3', 'sample.txt')
print(resp)
if __name__ == "__main__":
main()
```
------
## En utilisant le AWS CLI
L’exemple de commande `get-object` suivant montre comment utiliser l’interface AWS CLI pour télécharger un objet depuis Amazon S3. Cette commande récupère l’objet `KEY_NAME` à partir du compartiment de répertoires `bucket-base-name--zone-id--x-s3`. L’objet sera téléchargé dans un fichier nommé `LOCAL_FILE_NAME`. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
```
aws s3api get-object --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME LOCAL_FILE_NAME
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object.html) dans la *Référence des commandes de l’AWS CLI *.
# Génération d'un bucket URLs de répertoire présigné pour partager des objets
Les exemples de code suivants montrent comment générer des objets présignés URLs pour partager à partir d'un compartiment d'annuaire Amazon S3.
## En utilisant le AWS CLI
L’exemple de commande suivant montre comment utiliser l’ AWS CLI pour générer une URL présignée pour un objet dans Amazon S3. Cette commande génère une URL présignée pour un objet `KEY_NAME` du compartiment `bucket-base-name--zone-id--x-s3` de répertoires. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
```
aws s3 presign s3://bucket-base-name--zone-id--x-s3/KEY_NAME --expires-in 7200
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/presign.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/presign.html) dans la *Référence des commandes de l’AWS CLI *.
# Récupération des métadonnées d’objets à partir de compartiments de répertoires
Les exemples de AWS SDK et de AWS CLI suivants montrent comment utiliser l'opération `HeadObject` et l'`GetObjectAttributes`API pour récupérer les métadonnées d'un objet dans un compartiment d'annuaire Amazon S3 sans renvoyer l'objet lui-même.
## À l'aide du AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
public static void headObject(S3Client s3Client, String bucketName, String objectKey) {
try {
HeadObjectRequest headObjectRequest = HeadObjectRequest
.builder()
.bucket(bucketName)
.key(objectKey)
.build();
HeadObjectResponse response = s3Client.headObject(headObjectRequest);
System.out.format("Amazon S3 object: \"%s\" found in bucket: \"%s\" with ETag: \"%s\"", objectKey, bucketName, response.eTag());
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
```
------
## En utilisant le AWS CLI
L'`head-object`exemple de commande suivant montre comment vous pouvez utiliser le AWS CLI pour récupérer les métadonnées d'un objet. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
```
aws s3api head-object --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/head-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/head-object.html) dans la *Référence des commandes de l’AWS CLI *.
L'`get-object-attributes`exemple de commande suivant montre comment vous pouvez utiliser le AWS CLI pour récupérer les métadonnées d'un objet. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
```
aws s3api get-object-attributes --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --object-attributes "StorageClass" "ETag" "ObjectSize"
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object-attributes.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object-attributes.html) dans la *Référence des commandes de l’AWS CLI *.
# Liste des objets d’un compartiment de répertoires
Les exemples de code suivants montrent comment répertorier les objets d’un compartiment de répertoires Amazon S3 à l’aide de l’opération d’API `ListObjectsV2`.
## En utilisant le AWS CLI
L’exemple de commande `list-objects-v2` suivant montre comment utiliser l’ AWS CLI pour répertorier des objets d’Amazon S3. Cette commande répertorie les objets du compartiment de répertoires `bucket-base-name--zone-id--x-s3`. Pour exécuter cette commande, remplacez `user input placeholders` par vos propres informations.
```
aws s3api list-objects-v2 --bucket bucket-base-name--zone-id--x-s3
```
Pour plus d’informations, consultez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-objects-v2.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-objects-v2.html) dans la *Référence des commandes de l’AWS CLI *.