

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.

# Définition d’une configuration du cycle de vie S3 sur un compartiment
<a name="how-to-set-lifecycle-configuration-intro"></a>

Vous pouvez définir une configuration du cycle de vie Amazon S3 sur un compartiment à l'aide de la console Amazon S3, de l'API REST AWS Command Line Interface (AWS CLI) ou de l'API REST Amazon S3. AWS SDKs Pour plus d’informations sur la configuration de cycle de vie S3, consultez [Gestion du cycle de vie des objets](object-lifecycle-mgmt.md).

**Note**  
Pour consulter ou modifier la configuration du cycle de vie d'un compartiment de répertoire AWS CLI AWS SDKs, utilisez l'API REST, ou Amazon S3. Pour de plus amples informations, veuillez consulter [Utilisation du cycle de vie S3 pour les compartiments de répertoires](directory-buckets-objects-lifecycle.md).

Dans votre configuration du cycle de vie S3, vous utilisez des *règles de cycle de vie* pour définir les actions que vous souhaitez qu’Amazon S3 entreprenne au cours de la durée de vie d’un objet. Par exemple, vous pouvez définir des règles pour transférer les objets vers une autre classe de stockage, archiver les objets ou les faire expirer (supprimer) après une période spécifiée.

## Considérations de cycle de vie S3
<a name="lifecycle-considerations"></a>

Avant de définir une configuration de cycle de vie, veuillez noter ce qui suit :

**Délai de propagation d’une configuration du cycle de vie**  
Quand vous ajoutez une configuration de cycle de vie S3 à un compartiment, il y a habituellement un certain délai avant que la nouvelle configuration de cycle de vie ou celle qui a été mise à jour ne soit totalement appliquée à tous les systèmes Amazon S3. Il faut attendre quelques minutes avant que la configuration ne prenne effet. Ce décalage peut également se produire lors de la suppression d’une configuration de cycle de vie S3.

**Délai de transition ou d’expiration**  
Il y a un délai entre le moment où une règle de cycle de vie est satisfaite et le moment où l’action correspondant à la règle se termine. Supposons, par exemple, qu’une règle de cycle de vie entraîne l’expiration d’un ensemble d’objets le 1er janvier. Même si la règle d’expiration a été respectée le 1er janvier, Amazon S3 ne supprimera peut-être ces objets que des jours, voire des semaines plus tard. Ce délai est dû au fait que le cycle de vie S3 met en file d’attente les objets à transférer ou à faire expirer de manière asynchrone. Lorsque vous ajoutez ou modifiez une règle de cycle de vie, S3 Lifecycle peut commencer à traiter les objets éligibles immédiatement ou avec un certain retard. Lorsque S3 Lifecycle crée un marqueur de suppression ou effectue la transition d'un objet, l'horodatage est défini sur minuit UTC le jour où l'action s'est produite, quelle que soit l'heure réelle à laquelle l'action a été effectuée. Toutefois, les changements de tarification sont généralement appliqués quand la règle de cycle de vie est satisfaite, même si l’action n’est pas terminée. Pour plus d’informations, consultez [Changements au niveau de la facturation](#lifecycle-billing). Pour surveiller l’effet des mises à jour effectuées par les règles de cycle de vie actives, consultez [Comment puis-je surveiller les actions prises conformément à mes règles de cycle de vie ?](troubleshoot-lifecycle.md#troubleshoot-lifecycle-2)

**Note**  
Lorsqu'une règle de cycle de vie est créée ou modifiée, les objets qui répondent déjà aux critères d'éligibilité peuvent être traités immédiatement.

**Mise à jour, désactivation ou suppression des règles de cycle de vie**  
Lorsque vous désactivez ou supprimez des règles de cycle de vie, Amazon S3 interrompt la planification des nouveaux objets à supprimer ou transférer après un court délai. Tous les objets déjà planifiés sont déprogrammés et ne sont ni supprimés ni transférés.

**Note**  
Avant de mettre à jour, de désactiver ou de supprimer les règles de cycle de vie, utilisez les opérations d’API `LIST` (telles que [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html), [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectVersions.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectVersions.html) et [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)) ou [Catalogage et analyse de vos données avec S3 Inventory](storage-inventory.md) pour vérifier qu’Amazon S3 a transféré et fait expirer les objets éligibles en fonction de vos cas d’utilisation. Si vous rencontrez des problèmes lors de la mise à jour, de la désactivation ou de la suppression des règles de cycle de vie, consultez [Résolution des problèmes du cycle de vie Amazon S3](troubleshoot-lifecycle.md).

**Objets existants et nouveaux**  
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 d’expiration qui entraîne l’expiration des objets dotés d’un préfixe spécifique 30 jours après leur création, Amazon S3 met en file d’attente de suppression tous les objets de plus de 30 jours qui incluent le préfixe spécifié.

**Surveillance de l’effet des règles de cycle de vie**  
Pour surveiller l’effet des mises à jour effectuées par les règles de cycle de vie actives, consultez [Comment puis-je surveiller les actions prises conformément à mes règles de cycle de vie ?](troubleshoot-lifecycle.md#troubleshoot-lifecycle-2)

**Changements au niveau de la facturation**  
Un délai peut s’écouler entre le moment où les règles de configuration du cycle de vie sont satisfaites et le moment où se déroule l’action déclenchée par la satisfaction de ces règles. Toutefois, des modifications de facturation interviennent dès que la règle de configuration du cycle de vie est satisfaite, même si l’action n’est pas encore entreprise.

Par exemple, après l’expiration d’un objet, son stockage ne vous est plus facturé, même si l’objet n’est pas supprimé immédiatement. De même, dès que le délai de transition d’un objet s’est écoulé, les frais de stockage S3 Glacier Flexible Retrieval vous sont facturés, même si l’objet n’est pas immédiatement transféré vers la classe de stockage S3 Glacier Flexible Retrieval. 

Toutefois, les transitions du cycle de vie vers la classe de stockage S3 Intelligent-Tiering font exception. Les modifications de facturation n’interviennent qu’après le passage de l’objet dans la classe de stockage S3 Intelligent-Tiering. 

**Règles multiples ou contradictoires**  
Si vous avez plusieurs règles dans une configuration du cycle de vie S3, un objet peut devenir éligible pour plusieurs actions du cycle de vie S3 le même jour. Dans de tels cas, Amazon S3 suit les règles générales suivantes :
+ La suppression permanente a priorité sur la transition.
+ La transition a priorité sur la création de [marqueurs de suppression](DeleteMarker.md).
+ Si un objet est éligible pour les transitions vers S3 Glacier Flexible Retrieval et S3 Standard-IA (ou S3 One Zone-IA), Amazon S3 choisit la transition vers S3 Glacier Flexible Retrieval.

 Pour obtenir des exemples, consultez [Exemples de chevauchement de filtres et d’actions de cycle de vie contradictoires](lifecycle-conflicts.md#lifecycle-config-conceptual-ex5). 

## Comment définir une configuration du cycle de vie S3
<a name="how-to-set-lifecycle-configuration"></a>

Vous pouvez définir une configuration du cycle de vie Amazon S3 sur un compartiment à usage général à l'aide de la console Amazon S3, de l'API REST AWS Command Line Interface (AWS CLI) ou de l'API REST Amazon S3. AWS SDKs 

Pour plus d'informations sur les AWS CloudFormation modèles et les exemples, voir [Utilisation des AWS CloudFormation modèles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) et [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3-bucket.html#aws-resource-s3-bucket--examples](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3-bucket.html#aws-resource-s3-bucket--examples)dans le *Guide de CloudFormation l'utilisateur*.

### Utilisation de la console S3
<a name="create-lifecycle"></a>

Vous pouvez définir des règles de cycle de vie pour tous les objets ou un sous-ensemble d’objets dans un compartiment en utilisant un préfixe partagé (noms d’objets commençant par une chaîne commune) ou une balise. Dans votre règle de cycle de vie, vous pouvez définir des actions spécifiques aux versions actuelles et non actuelles des objets. Pour plus d’informations, consultez les ressources suivantes :
+ [Gestion du cycle de vie des objets](object-lifecycle-mgmt.md)
+ [Conservation de plusieurs versions d’objets grâce à la gestion des versions S3](Versioning.md)

**Pour créer une stratégie de cycle de vie**

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 à usage général**.

1. Dans la liste des compartiments, choisissez le nom du compartiment pour lequel vous souhaitez créer une règle de cycle de vie.

1. Choisissez l’onglet **Management (Gestion)**, puis choisissez **Create lifecycle rule (Créer une règle de cycle de vie)**.

1. Dans **Lifecycle rule name (Nom de la règle du cycle de vie)**, saisissez un nom pour votre règle. 

   Ce nom doit être unique dans le compartiment. 

1. Choisissez l'étendue de la règle de cycle de vie : 
   + Pour appliquer cette règle de cycle de vie à *tous les objets avec un préfixe ou une balise spécifique*, choisissez **Limiter la portée à des préfixes ou balises spécifiques**. 
     + Pour limiter l’étendue par préfixe, saisissez le préfixe dans **Prefix (Préfixe)**. 
     + Pour limiter l’étendue par balise, choisissez **Add tag (Ajouter une balise)**, puis saisissez la clé et la valeur de la balise.

     Pour en savoir plus sur les préfixes de nom d’objet, consultez [Attribution d’un nom aux objets Amazon S3](object-keys.md). Pour en savoir plus sur les balises d'objet, consultez [Catégorisation de vos objets à l’aide de balises](object-tagging.md). 
   + Pour appliquer cette règle de cycle de vie à *tous les objets du compartiment*, choisissez **Cette règle s’applique à *tous* les objets du compartiment**, puis **Je reconnais que cette règle s’applique à tous les objets du compartiment**.

1. Pour filtrer une règle par taille d’objet, vous pouvez sélectionner **Spécifier la taille minimale d’objet**, **Spécifier la taille maximale d’objet** ou les deux options.
   + Lorsque vous spécifiez une valeur pour la **taille minimale de l'objet** ou la **taille maximale de l'objet**, la valeur doit être supérieure à 0 octet et maximale de 50 To. Vous pouvez spécifier cette valeur en octets, Ko, Mo ou Go.
   + Si vous spécifiez les deux valeurs, la taille maximale d’objet doit être supérieure à la taille minimale d’objet.
**Note**  
Les filtres **Taille minimale d’objet** et **Taille maximale d’objet** excluent les valeurs spécifiées. Par exemple, si vous définissez un filtre pour faire expirer les objets ayant une **Taille minimale d’objet** de 128 Ko, les objets dont la taille est exactement de 128 Ko n’expirent pas. À la place, la règle s’applique uniquement aux objets d’une talle supérieure à 128 Ko.

1. Sous **Lifecycle rule actions (Actions de règle de cycle de vie)**, choisissez les actions que votre règle de cycle de vie doit effectuer :
   + Transition *current* versions of objects between storage classes (Transition des versions actuelles des objets entre les classes de stockage)
   + Transition *previous* versions of objects between storage classes (Transition des versions précédentes des objets entre les classes de stockage)
   + Expire *current* versions of objects (Faire expirer les versions actuelles des objets)
**Note**  
Pour les compartiments pour lesquels l’option [Gestion des versions S3](Versioning.md) n’est pas activée, l’expiration des versions actuelles entraîne la suppression définitive des objets par Amazon S3. Pour de plus amples informations, veuillez consulter [Actions du cycle de vie et état de la gestion des versions du compartiment](intro-lifecycle-rules.md#lifecycle-actions-bucket-versioning-state).
   + Permanently delete *previous* versions of objects (Supprimer définitivement les versions précédentes des objets)
   + Delete expired delete markers or incomplete multipart uploads (Supprimer les marqueurs de suppression expirés ou les chargements partitionnés non terminés) 

   Selon les actions que vous choisissez, différentes options apparaissent.

1. Pour transférer les versions *actuelles* des objets entre les classes de stockage, sous **Transition des versions actuelles des objets entre les classes de stockage**, procédez comme suit :

   1. Dans **Transitions des classes de stockage**, choisissez la classe de stockage vers laquelle effectuer la transition. Pour obtenir la liste des transitions possibles, consultez [Transitions de cycle de vie prises en charge](lifecycle-transition-general-considerations.md#supported-lifecycle-transitions). Vous pouvez choisir parmi les classes de stockage suivantes :
      + S3 standard – Accès peu fréquent
      + S3 Intelligent-Tiering
      + S3 One Zone-IA
      + S3 Glacier Instant Retrieval
      + S3 Glacier Flexible Retrieval
      + S3 Glacier Deep Archive

   1. Dans **Days after object creation (Jours après la création de l’objet)**, entrez le nombre de jours après la création pour la transition de l’objet.

   Pour plus d'informations sur les classes de stockage, consultez [Bien comprendre et gérer les classes de stockage Amazon S3](storage-class-intro.md). Vous pouvez définir le transfert des versions actuelles ou précédentes des objets, ou des deux versions à la fois. La gestion des versions vous permet de conserver plusieurs versions d’un objet au sein d’un même compartiment. Pour plus d’informations sur la gestion des versions, consultez [Utilisation de la console S3](manage-versioning-examples.md#enable-versioning).
**Important**  
Lorsque vous choisissez la classe de stockage S3 Glacier Instant Retrieval, S3 Glacier Flexible Retrieval ou Glacier Deep Archive, vos objets restent dans Amazon S3. Vous ne pouvez pas y accéder directement via le service Amazon Glacier distinct. Pour de plus amples informations, veuillez consulter [Transition des objets à l’aide du cycle de vie Amazon S3](lifecycle-transition-general-considerations.md). 

1. Pour transférer les versions *non actuelles* des objets entre les classes de stockage, sous **Transition des versions non actuelles des objets entre les classes de stockage**, procédez comme suit :

   1. Dans **Transitions des classes de stockage**, choisissez la classe de stockage vers laquelle effectuer la transition. Pour obtenir la liste des transitions possibles, consultez [Transitions de cycle de vie prises en charge](lifecycle-transition-general-considerations.md#supported-lifecycle-transitions). Vous pouvez choisir parmi les classes de stockage suivantes :
      + S3 standard – Accès peu fréquent
      + S3 Intelligent-Tiering
      + S3 One Zone-IA
      + S3 Glacier Instant Retrieval
      + S3 Glacier Flexible Retrieval
      + S3 Glacier Deep Archive

   1. Dans **Jours après lesquels les objets deviennent anciens**, entrez le nombre de jours après la création pour effectuer la transition de l’objet.

1. Pour faire expirer les versions *actuelles* des objets, sous **Expire current versions of objects (Faire expirer des versions actuelles des objets)**, dans **Number of days after object creation (Nombre de jours après la création de l’objet)**, entrez le nombre de jours.
**Important**  
Dans un compartiment sans gestion des versions, l’action d’expiration a pour résultat la suppression permanente de l’objet par Amazon S3. Pour en savoir plus sur les actions de cycle de vie, consultez [Éléments pour décrire les actions du cycle de vie](intro-lifecycle-rules.md#intro-lifecycle-rules-actions).

1. Pour supprimer définitivement les versions précédentes d’objets, sous **Permanently delete noncurrent versions of objects** (Supprimer définitivement les versions précédentes des objets), dans **Days after objects become previous versions** (Jours après que les objets deviennent des versions précédentes), entrez le nombre de jours. Vous pouvez éventuellement spécifier le nombre de versions plus récentes à conserver en saisissant une valeur sous **Nombre de versions plus récentes à conserver**.

1. Sous **Delete expired delete markers or incomplete multipart uploads (Supprimer les marqueurs de suppression expirés ou les chargements en plusieurs parties incomplets)**, choisissez **Delete expired object delete markers (Supprimer les marqueurs de suppression d’objet arrivés à expiration)** et **Delete incomplete multipart uploads (Supprimer les chargements partitionnés non terminés)**. Entrez ensuite le nombre de jours après le début du chargement partitionné que vous souhaitez arrêter et nettoyez les chargements en plusieurs parties incomplets.

   Pour en savoir plus sur les chargements partitionnés, consultez [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md).

1. Choisissez **Créer une règle**.

   Si la règle ne contient aucune erreur, Amazon S3 l’active et vous pouvez la voir dans l’onglet **Management (Gestion)** sous **Lifecycle rules (Règles de cycle de vie)**.

### En utilisant le AWS CLI
<a name="set-lifecycle-cli"></a>

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.

Prenez l’exemple suivant de configuration de cycle de vie S3.

**Example Exemple 1**  

**Example**  

```
<LifecycleConfiguration>
    <Rule>
        <ID>ExampleRule</ID>
        <Filter>
           <Prefix>documents/</Prefix>
        </Filter>
        <Status>Enabled</Status>
        <Transition>        
           <Days>365</Days>        
           <StorageClass>GLACIER</StorageClass>
        </Transition>    
        <Expiration>
             <Days>3650</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>
```

```
{
    "Rules": [
        {
            "Filter": {
                "Prefix": "documents/"
            },
            "Status": "Enabled",
            "Transitions": [
                {
                    "Days": 365,
                    "StorageClass": "GLACIER"
                }
            ],
            "Expiration": {
                "Days": 3650
            },
            "ID": "ExampleRule"
        }
    ]
}
```

**Example Exemple 2**  

**Example**  

```
<LifecycleConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
    <Rule>
        <ID>id-1</ID>
        <Expiration>
            <Days>1</Days>
        </Expiration>
        <Filter>
            <And>
                <Prefix>myprefix</Prefix>
                <Tag>
                    <Key>mytagkey1</Key>
                    <Value>mytagvalue1</Value>
                </Tag>
                <Tag>
                    <Key>mytagkey2</Key>
                    <Value>mytagvalue2</Value>
                </Tag>
            </And>
        </Filter>
        <Status>Enabled</Status>    
    </Rule>
</LifecycleConfiguration>
```

```
{
    "Rules": [
        {
            "ID": "id-1",
            "Filter": {
                "And": {
                    "Prefix": "myprefix", 
                    "Tags": [
                        {
                            "Value": "mytagvalue1", 
                            "Key": "mytagkey1"
                        }, 
                        {
                            "Value": "mytagvalue2", 
                            "Key": "mytagkey2"
                        }
                    ]
                }
            }, 
            "Status": "Enabled", 
            "Expiration": {
                "Days": 1
            }
        }
    ]
}
```

Vous pouvez tester la commande `put-bucket-lifecycle-configuration` comme suit.

**Tester la configuration**

1. Enregistrez la configuration du cycle de vie au format JSON dans un fichier (par exemple, *`lifecycle.json`*). 

1. Exécutez la AWS CLI commande suivante pour définir la configuration du cycle de vie de votre bucket. Remplacez les `user input placeholders` par vos propres informations.

   ```
   $ aws s3api put-bucket-lifecycle-configuration  \
   --bucket amzn-s3-demo-bucket  \
   --lifecycle-configuration file://lifecycle.json
   ```

1. Pour vérifier, récupérez la configuration du cycle de vie S3 à l'aide de la `get-bucket-lifecycle-configuration` AWS CLI commande suivante :

   ```
   $ aws s3api get-bucket-lifecycle-configuration  \
   --bucket amzn-s3-demo-bucket
   ```

1. Pour supprimer la configuration du cycle de vie S3, utilisez la `delete-bucket-lifecycle` AWS CLI commande suivante :

   ```
   aws s3api delete-bucket-lifecycle \
   --bucket amzn-s3-demo-bucket
   ```

### En utilisant le AWS SDKs
<a name="manage-lifecycle-using-sdk"></a>

------
#### [ Java ]

Vous pouvez utiliser le AWS SDK for Java pour gérer la configuration du cycle de vie S3 d'un bucket. Pour plus d’informations sur la gestion de la configuration du cycle de vie S3, consultez [Gestion du cycle de vie des objets](object-lifecycle-mgmt.md).

**Note**  
Quand vous ajoutez une configuration du cycle de vie S3 à un compartiment, Amazon S3 remplace la configuration du cycle de vie actuelle du compartiment, s’il en existe une. Pour mettre à jour une configuration, vous devez la récupérer, effectuer les modifications souhaitées, puis ajouter la configuration révisée dans le compartiment.

Pour gérer la configuration du cycle de vie à l'aide du AWS SDK for Java, vous pouvez :
+ Ajouter une configuration de cycle de vie à un compartiment.
+ Récupérer la configuration de cycle de vie et la mettre à jour en ajoutant une autre règle.
+ Ajouter la configuration de cycle de vie modifiée au compartiment. Amazon S3 remplace la configuration existante.
+ Récupérer à nouveau la configuration et vérifier que celle-ci comporte le nombre approprié de règles en affichant ce nombre.
+ Supprimer la configuration de cycle de vie et vérifier que celle-ci a été supprimée en tentant de la récupérer à nouveau.

Pour des exemples expliquant comment définir la configuration du cycle de vie d'un bucket avec le AWS SDK for Java, [consultez la section Définir la configuration du cycle de vie d'un](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_PutBucketLifecycleConfiguration_section.html) bucket dans *le manuel Amazon S3 API Reference*.

------
#### [ .NET ]

Vous pouvez utiliser le AWS SDK pour .NET pour gérer la configuration du cycle de vie S3 sur un bucket. Pour plus d’informations sur la gestion de la configuration du cycle de vie, consultez [Gestion du cycle de vie des objets](object-lifecycle-mgmt.md). 

**Note**  
Quand vous ajoutez une configuration de cycle de vie, Amazon S3 remplace la configuration existante sur le compartiment spécifié. Pour mettre à jour une configuration, vous devez d’abord récupérer la configuration de cycle de vie, effectuer les modifications, puis ajouter la configuration modifiée dans le compartiment.

L'exemple suivant montre comment utiliser le pour ajouter, mettre AWS SDK pour .NET à jour et supprimer la configuration du cycle de vie d'un bucket. L’exemple de code effectue les opérations suivantes :
+ Il ajoute une configuration de cycle de vie à un compartiment. 
+ Il récupère la configuration de cycle de vie et la met à jour en ajoutant une autre règle. 
+ Il ajoute la configuration de cycle de vie modifiée au compartiment. Amazon S3 remplace la configuration de cycle de vie existante.
+ Il récupère à nouveau la configuration de cycle de vie et la vérifie en affichant le nombre de règles qu’elle contient.
+ Il supprime la configuration de cycle de vie et vérifie qu’elle a été supprimée.

Pour plus d’informations sur la configuration et l’exécution des exemples de code, consultez [Premiers pas avec le kit AWS SDK pour .NET](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config.html) dans le *Guide du développeur AWS SDK pour .NET *. 

```
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 = "*** bucket name ***";
        // 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<LifecycleRule>
                        {
                            new LifecycleRule
                            {
                                 Id = "Archive immediately rule",
                                 Filter = new LifecycleFilter()
                                 {
                                     LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                                     {
                                         Prefix = "glacierobjects/"
                                     }
                                 },
                                 Status = LifecycleRuleStatus.Enabled,
                                 Transitions = new List<LifecycleTransition>
                                 {
                                      new LifecycleTransition
                                      {
                                           Days = 0,
                                           StorageClass = S3StorageClass.Glacier
                                      }
                                  },
                            },
                            new LifecycleRule
                            {
                                 Id = "Archive and then delete rule",
                                  Filter = new LifecycleFilter()
                                 {
                                     LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                                     {
                                         Prefix = "projectdocs/"
                                     }
                                 },
                                 Status = LifecycleRuleStatus.Enabled,
                                 Transitions = new List<LifecycleTransition>
                                 {
                                      new LifecycleTransition
                                      {
                                           Days = 30,
                                           StorageClass = S3StorageClass.StandardInfrequentAccess
                                      },
                                      new LifecycleTransition
                                      {
                                        Days = 365,
                                        StorageClass = S3StorageClass.Glacier
                                      }
                                 },
                                 Expiration = new LifecycleRuleExpiration()
                                 {
                                       Days = 3650
                                 }
                            }
                        }
                };

                // 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 = "NewRule",
                    Filter = new LifecycleFilter()
                    {
                        LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                        {
                            Prefix = "YearlyDocuments/"
                        }
                    },
                    Expiration = new LifecycleRuleExpiration()
                    {
                        Days = 3650
                    }
                });

                // Add the configuration to the bucket. 
                await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);

                // Verify that there are now three rules.
                lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
                Console.WriteLine("Expected # of rulest=3; 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<LifecycleConfiguration> 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);
        }
    }
}
```

------
#### [ Ruby ]

Vous pouvez utiliser le AWS SDK pour Ruby pour gérer une configuration S3 Lifecycle sur un bucket à l'aide de la classe [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/BucketLifecycle.html](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/BucketLifecycle.html). Pour plus d’informations sur la gestion de la configuration du cycle de vie S3, consultez [Gestion du cycle de vie des objets](object-lifecycle-mgmt.md). 

------

### Utilisation de l'API REST
<a name="manage-lifecycle-using-rest"></a>

Les rubriques suivantes de la *Référence d’API Amazon Simple Storage Service* décrivent les opérations d’API REST associées à la configuration du cycle de vie S3 : 
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketLifecycle.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketLifecycle.html)

## Résolution des problèmes liés au cycle de vie S3
<a name="lifecycle-troubleshoot"></a>

Pour découvrir les problèmes courants susceptibles de se produire lors de l’utilisation du cycle de vie S3, consultez [Résolution des problèmes du cycle de vie Amazon S3](troubleshoot-lifecycle.md).