Définition d'une configuration de cycle de vie sur un compartiment - Amazon Simple Storage Service

Définition d'une configuration de cycle de vie sur un compartiment

Cette section explique comment définir une configuration de cycle de vie S3 sur un compartiment à l'aide des kits SDK AWS, d'AWS CLI ou de la console Amazon S3. Pour de plus amples informations sur la configuration de cycle de vie S3, veuillez consulter Gestion du cycle de vie de votre stockage.

Vous pouvez utiliser des stratégies de cycle de vie pour définir les actions qu'Amazon S3 doit effectuer au cours de la durée de vie d'un objet (par exemple, transférer les objets vers une autre classe de stockage, les archiver ou les supprimer au bout d'une certaine période).

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

Retard de propagation

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é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 destinés à la suppression ou la transition 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.

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 de cycle de vie avec une action d'expiration qui fait expirer les objets avec un préfixe spécifique 30 jours après leur création, Amazon S3 met dans la file d'attente pour suppression tous les objets existants qui datent de plus de 30 jours.

Changements au niveau de la facturation

Un délai peut s'écouler entre le moment auquel les règles de la configuration du cycle de vie se vérifient et le moment auquel se produit l'action qui découle de l'application de ces règles. Néanmoins, des changements au niveau de la facturation se produisent 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, vous n'êtes pas facturé pour le stockage d'un objet après sa date d'expiration même si cet objet n'est pas immédiatement supprimé. Dans un autre exemple, 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 la transition de l'objet vers la classe de stockage S3 Glacier Flexible Retrieval n'est pas immédiate. Les transitions du cycle de vie vers la classe de stockage S3 Intelligent-Tiering (Hiérarchisation intelligente) font exception. Les modifications de facturation ne se produisent pas tant que l'objet n'est pas passé à la classe de stockage S3 Intelligent-Tiering (Hiérarchisation intelligente).

Vous pouvez définir une stratégie de cycle de vie pour tous les objets ou pour un sous-ensemble d'objets du compartiment à l'aide d'un préfixe partagé (c'est-à-dire des objets dont le nom commence par une chaîne commune) ou d'une balise. Une stratégie de cycle de vie vous permet de définir des actions propres aux versions d'objets actuelles et anciennes. Pour de plus amples informations, consultez les ressources suivantes :

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

  1. Connectez-vous à la console AWS Management Console et ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans la liste Buckets (Compartiments), choisissez le nom du compartiment pour lequel vous souhaitez créer une stratégie de cycle de vie.

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

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

  5. 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, veuillez consulter Création de noms de clés d'objet. Pour en savoir plus sur les balises d'objet, consultez Catégorisation de votre stockage à l'aide de balises.

    • Pour appliquer cette règle de cycle de vie à tous les objets du compartiment, choisissez This rule applies to all objects in the bucket. (Cette règle s'applique à tous les objets du compartiment.), et choisissez I acknowledge that this rule applies to all objects in the bucket (Je reconnais que cette règle s'applique à tous les objets du compartiment).

  6. Pour filtrer une règle par taille d'objet, vous pouvez cocher la case Specify minimum object size (Spécifier la taille minimale des objets), Specify maximum object size (Spécifier la taille maximale des objets) ou les deux.

    • Lorsque vous spécifiez les valeurs de minimum object size (taille minimale des objets) ou maximum object size (taille maximale des objets), elles doivent être comprises entre 0 octet et 5 To. Vous pouvez spécifier cette valeur en octets, Ko, Mo ou Go.

    • Si vous spécifiez les deux valeurs, la taille maximale des objets doit être supérieure à la taille minimale des objets.

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

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

  8. Pour faire la transition des versions actuelles des objets entre les classes de stockage, sous Transition current versions of objects between storage classes (Transition des versions actuelles des objets entre les classes de stockage):

    1. Dans Storage class transitions (Transitions de classe de stockage), choisissez la classe de stockage vers laquelle effectuer la transition :

      • Standard-IA (Standard - Accès peu fréquent)

      • Intelligent-Tiering (Hiérarchisation intelligente)

      • One Zone-IA (Unizone – Accès peu fréquent)

      • S3 Glacier Flexible Retrival

      • Glacier Deep Archive

    2. 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 Utilisation des classes de stockage Simple Storage Service (Amazon S3). Vous pouvez définir le transfert des versions actuelles ou précédentes des objets, ou des deux versions à la fois. Le contrôle de version vous permet de conserver plusieurs versions d'un objet au sein d'un même compartiment. Pour plus d'informations sur le contrôle de version, consultez Utiliser la console S3..

    Important

    Lorsque vous choisissez les classes de stockage 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 S3 Glacier distinct. Pour de plus amples informations, veuillez consulter Transition des objets à l'aide du cycle de vie Amazon S3.

  9. Pour faire la transition de versions non actuelles des objets entre classes de stockage, sous Transition non-current versions of objects between storage classes (Transition des versions non actuelles des objets entre classes de stockage) :

    1. Dans Storage class transitions (Transitions de classe de stockage), choisissez la classe de stockage vers laquelle effectuer la transition :

      • Standard-IA (Standard - Accès peu fréquent)

      • Intelligent-Tiering (Hiérarchisation intelligente)

      • One Zone-IA (Unizone – Accès peu fréquent)

      • S3 Glacier Flexible Retrival

      • Glacier Deep Archive

    2. Dans Days after object devient non-courant (Jours après que l'objet devienne non actuel), entrez le nombre de jours après la création pour la transition de l'objet.

  10. 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 dans Amazon S3. Pour en savoir plus sur les actions de cycle de vie, veuillez consulter Éléments pour décrire les actions du cycle de vie.

  11. 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 Number of newer versions to retain (Nombre de versions plus récentes à conserver).

  12. 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 le chargement partitionné, consultez Chargement et copie d'objets à l'aide d'un chargement partitionné.

  13. Choisissez Create rule (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).

Pour plus d'informations sur les modèles et les exemples CloudFormation, consultez les sections Utilisation des modèles AWS CloudFormation et AWS::S3::Bucket du Guide de l'utilisateur AWS CloudFormation.

Pour gérer les configurations de cycle de vie S3, vous pouvez utiliser les commandes suivantes de la AWS CLI :

  • put-bucket-lifecycle-configuration

  • get-bucket-lifecycle-configuration

  • delete-bucket-lifecycle

Pour savoir comment configurer l'AWS CLI, consultez Développement avec Amazon S3 à l'aide de la AWS CLI.

Notez que la configuration de cycle de vie Amazon S3 est un fichier XML. Mais lorsque vous utilisez l'AWS CLI, vous ne pouvez pas spécifier le XML. Vous devez spécifier le JSON à la place. Voici des exemples de configuration de cycle de vie au format XML et leurs équivalents au format JSON que vous pouvez spécifier dans une commande de l'AWS CLI.

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

Exemple 1
JSON
{
    "Rules": [
        {
            "Filter": {
                "Prefix": "documents/"
            },
            "Status": "Enabled",
            "Transitions": [
                {
                    "Days": 365,
                    "StorageClass": "GLACIER"
                }
            ],
            "Expiration": {
                "Days": 3650
            },
            "ID": "ExampleRule"
        }
    ]
        }
XML
<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>
Exemple 2
JSON
{
    "Rules": [
        {
            "ID": "id-1",
            "Filter": {
                "And": {
                    "Prefix": "myprefix", 
                    "Tags": [
                        {
                            "Value": "mytagvalue1", 
                            "Key": "mytagkey1"
                        }, 
                        {
                            "Value": "mytagvalue2", 
                            "Key": "mytagkey2"
                        }
                    ]
                }
            }, 
            "Status": "Enabled", 
            "Expiration": {
                "Days": 1
            }
        }
    ]
}
XML
<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>

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

Tester la configuration

  1. Enregistrez la configuration de cycle de vie au format JSON dans un fichier (lifecycle.json).

  2. Exécutez la commande de l'AWS CLI suivante pour définir la configuration de cycle de vie sur le compartiment.

    $ aws s3api put-bucket-lifecycle-configuration  \
--bucket bucketname  \
--lifecycle-configuration file://lifecycle.json

  3. Pour vérifier, récupérez la configuration du cycle de vie S3 grâce à la commande get-bucket-lifecycle-configuration de la AWS CLI comme suit :

    $ aws s3api get-bucket-lifecycle-configuration  \
--bucket bucketname

  4. Pour supprimer la configuration du cycle de vie S3, utilisez la commande delete-bucket-lifecycle de la AWS CLI comme suit :

    aws s3api delete-bucket-lifecycle \
--bucket bucketname
Java

Vous pouvez utiliser le kit AWS SDK for Java pour gérer la configuration du cycle de vie S3 d'un compartiment. Pour de plus amples informations sur la gestion de la configuration du cycle de vie S3, veuillez consulter Gestion du cycle de vie de votre stockage.

Note

Quand vous ajoutez une configuration de cycle de vie S3 à un compartiment, Amazon S3 remplace la configuration de 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.

L'exemple suivant montre comment utiliser le kit AWS SDK for Java pour ajouter, mettre à jour et supprimer la configuration de cycle de vie d'un compartiment. Cet exemple 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 existante.

  • Il récupère à nouveau la configuration de cycle de vie et vérifie que celle-ci comporte le bon nombre de règles en affichant ce nombre.

  • Il supprime la configuration de cycle de vie et vérifie que celle-ci a été supprimée en tentant de la récupérer à nouveau.

Pour obtenir les instructions sur la création et le test d'un exemple pratique, consultez Test des exemples de code Java Amazon S3. 


import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.BucketLifecycleConfiguration;
import com.amazonaws.services.s3.model.BucketLifecycleConfiguration.Transition;
import com.amazonaws.services.s3.model.StorageClass;
import com.amazonaws.services.s3.model.Tag;
import com.amazonaws.services.s3.model.lifecycle.LifecycleAndOperator;
import com.amazonaws.services.s3.model.lifecycle.LifecycleFilter;
import com.amazonaws.services.s3.model.lifecycle.LifecyclePrefixPredicate;
import com.amazonaws.services.s3.model.lifecycle.LifecycleTagPredicate;

import java.io.IOException;
import java.util.Arrays;

public class LifecycleConfiguration {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Bucket name ***";

        // Create a rule to archive objects with the "glacierobjects/" prefix to Glacier immediately.
        BucketLifecycleConfiguration.Rule rule1 = new BucketLifecycleConfiguration.Rule()
                .withId("Archive immediately rule")
                .withFilter(new LifecycleFilter(new LifecyclePrefixPredicate("glacierobjects/")))
                .addTransition(new Transition().withDays(0).withStorageClass(StorageClass.Glacier))
                .withStatus(BucketLifecycleConfiguration.ENABLED);

        // Create a rule to transition objects to the Standard-Infrequent Access storage class 
        // after 30 days, then to Glacier after 365 days. Amazon S3 will delete the objects after 3650 days.
        // The rule applies to all objects with the tag "archive" set to "true". 
        BucketLifecycleConfiguration.Rule rule2 = new BucketLifecycleConfiguration.Rule()
                .withId("Archive and then delete rule")
                .withFilter(new LifecycleFilter(new LifecycleTagPredicate(new Tag("archive", "true"))))
                .addTransition(new Transition().withDays(30).withStorageClass(StorageClass.StandardInfrequentAccess))
                .addTransition(new Transition().withDays(365).withStorageClass(StorageClass.Glacier))
                .withExpirationInDays(3650)
                .withStatus(BucketLifecycleConfiguration.ENABLED);

        // Add the rules to a new BucketLifecycleConfiguration.
        BucketLifecycleConfiguration configuration = new BucketLifecycleConfiguration()
                .withRules(Arrays.asList(rule1, rule2));

        try {
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withRegion(clientRegion)
                    .build();

            // Save the configuration.
            s3Client.setBucketLifecycleConfiguration(bucketName, configuration);

            // Retrieve the configuration.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);

            // Add a new rule with both a prefix predicate and a tag predicate.
            configuration.getRules().add(new BucketLifecycleConfiguration.Rule().withId("NewRule")
                    .withFilter(new LifecycleFilter(new LifecycleAndOperator(
                            Arrays.asList(new LifecyclePrefixPredicate("YearlyDocuments/"),
                                    new LifecycleTagPredicate(new Tag("expire_after", "ten_years"))))))
                    .withExpirationInDays(3650)
                    .withStatus(BucketLifecycleConfiguration.ENABLED));

            // Save the configuration.
            s3Client.setBucketLifecycleConfiguration(bucketName, configuration);

            // Retrieve the configuration.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);

            // Verify that the configuration now has three rules.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);
            System.out.println("Expected # of rules = 3; found: " + configuration.getRules().size());

            // Delete the configuration.
            s3Client.deleteBucketLifecycleConfiguration(bucketName);

            // Verify that the configuration has been deleted by attempting to retrieve it.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);
            String s = (configuration == null) ? "No configuration found." : "Configuration found.";
            System.out.println(s);
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process 
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
.NET

Vous pouvez utiliser le kit AWS SDK for .NET pour gérer la configuration du cycle de vie S3 sur un compartiment. Pour de plus amples informations sur la gestion de la configuration du cycle de vie, veuillez consulter Gestion du cycle de vie de votre stockage.

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 kit AWS SDK for .NET pour ajouter, mettre à jour et supprimer la configuration de cycle de vie d'un compartiment. 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 obtenir des instructions sur la façon de créer et de tester un exemple pratique, consultez Exécution des exemples de code .NET Amazon S3.

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 kit AWS SDK for Ruby pour gérer la configuration du cycle de vie S3 sur un compartiment à l'aide de la classe AWS::S3::BucketLifecycleConfiguration. Pour de plus amples informations sur l'utilisation du kit AWS SDK for Ruby avec Amazon S3, veuillez consulter Utilisation du kit AWS SDK for Ruby (version 3). Pour plus d'informations sur la gestion de la configuration du cycle de vie, consultez Gestion du cycle de vie de votre stockage.

Les sections suivantes de la Référence des API Amazon Simple Storage Service décrivent l'API REST associée à la configuration de cycle de vie S3.