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 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).