Definir a configuração do ciclo de vida em um bucket

Esta seção explica como você pode definir uma configuração do S3 Lifecycle em um bucket usando AWS SDKs, a AWS CLI ou o console do Amazon S3. Para obter informações sobre a configuração do S3 Lifecycle, consulte Gerenciando seu ciclo de vida de armazenamento.

É possível usar regras de ciclo de vida para definir ações que você deseja que o Amazon S3 realize durante o ciclo de vida de um objeto (por exemplo, fazer a transição de objetos para outra classe de armazenamento, arquivá-los, ou excluí-los após um período especificado).

Antes de definir uma configuração de ciclo de vida, observe o seguinte:

Atraso de propagação

Quando você adiciona uma configuração do S3 Lifecycle a um bucket, costuma haver algum atraso antes que uma configuração nova ou atualizada do ciclo de vida seja totalmente propagada para todos os sistemas do Amazon S3. Considere um atraso de alguns minutos antes que a configuração entre totalmente em vigor. Esse atraso também pode ocorrer quando você exclui uma configuração do S3 Lifecycle.

Desabilitando ou excluindo regras de ciclo de vida

Quando você desabilita ou exclui regras do ciclo de vida, depois de um pequeno atraso o Amazon S3 para de agendar a exclusão ou transição de novos objetos. Todos os objetos que já foram agendados não são agendados e não são excluídos ou transicionados.

nota

Antes de atualizar, desabilitar ou excluir as regras da funcionalidade Ciclo de Vida, use as operações da API LIST (como ListObjectsV2, ListObjectVersions e ListMultipartUploads) ou Inventário do Amazon S3 para verificar se o Amazon S3 fez a transição e expirou os objetos elegíveis com base em seus casos de uso. Se você estiver enfrentando problemas com a atualização, a desabilitação ou a exclusão de regras da funcionalidade Ciclo de Vida, consulte Solução de problemas do ciclo de vida do Amazon S3.

Objetos existentes e novos

Quando você adiciona uma configuração do ciclo de vida a um bucket, as regras de configuração se aplicam aos objetos existentes e aos objetos que serão adicionados no futuro. Por exemplo, se você adicionar uma regra de configuração do ciclo de vida hoje com uma ação de expiração que faz com que os objetos com um prefixo específico expirem 30 dias após sua criação, o Amazon S3 organizará para exclusão todos os objetos existentes com mais de 30 dias.

Alterações no faturamento

Pode haver um atraso entre o momento em que as regras de configuração do ciclo de vida são satisfeitas e o momento em que a ação, ativada pela satisfação da regra, é tomada. No entanto, as alterações na cobrança acontecem assim que a regra de configuração do ciclo de vida é satisfeita, mesmo que a ação ainda não tenha sido tomada.

Por exemplo, você não será cobrado pelo armazenamento após o tempo de expiração do objeto, mesmo que o objeto não seja excluído imediatamente. Outro exemplo é a cobrança das taxas de armazenamento do S3 Glacier Flexible Retrieval assim que o tempo de transição do objeto termina, mesmo que não seja feita a transição do objeto para a classe de armazenamento S3 Glacier Flexible Retrieval imediatamente. As transições do ciclo de vida para a classe de armazenamento S3 Intelligent-Tiering são a exceção. As alterações no faturamento não acontecem até que o objeto tenha transitado para a classe de armazenamento S3 Intelligent-Tiering.

Uso do console do S3

É possível definir uma regra de ciclo de vida para todos os objetos ou para um subconjunto de objetos no bucket usando um prefixo compartilhado (nomes de objetos que começam com uma string comum) ou uma tag. Usando uma regra de ciclo de vida, é possível definir ações específicas para versões atuais e anteriores do objeto. Para obter mais informações, consulte:

• Gerenciando seu ciclo de vida de armazenamento

• Usando o versionamento em buckets do S3

Como criar uma regra de ciclo de vida

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

2. Na lista Buckets, escolha o nome do bucket para o qual você deseja criar uma regra de ciclo de vida.

3. Escolha a guia Management (Gerenciamento) e escolha Create lifecycle rule (Criar regra de ciclo de vida).

4. Em Lifecycle rule name (Nome da regra do ciclo de vida), insira um nome para sua regra.

   O nome deve ser exclusivo dentro do bucket.

5. Escolha o escopo da regra do ciclo de vida:

   • Para aplicar essa regra de ciclo de vida a todos os objetos com um prefixo ou uma tag específica, escolha Limitar o escopo a prefixos ou tags específicos.

     • Para limitar o escopo por prefixo, em Prefix (Prefixo), insira o prefixo.

     • Para limitar o escopo por tag, escolha Add tag (Adicionar tag) e insira a chave e o valor da tag.

     Para obter mais informações sobre prefixos de nome de objeto, consulte Criar nomes de chave de objeto. Para obter mais informações sobre tags de objeto, consulte Categorizando seu armazenamento usando tags.

   • Para aplicar essa regra de ciclo de vida a todos os objetos no bucket, escolha This rule applies to all objects in the bucket e escolha I acknowledge that this rule applies to all objects in the bucket (Eu reconheço que essa regra se aplica a todos os objetos no bucket).

6. Para filtrar uma regra por tamanho de objeto, você pode marcar Specify minimum object size (Especificar o tamanho mínimo de objeto), Specify maximum object size (Especificar o tamanho máximo do objeto) ou as duas opções.

   • Quando você especificar um tamanho mínimo do objeto ou tamanho máximo do objeto, o valor deverá ser maior que 0 byte e até 5 TB. É possível especificar esse valor em bytes, KB, MB ou GB.

   • Quando você especificar ambos, o tamanho máximo do objeto deverá ser maior que o tamanho mínimo do objeto.

7. Em Lifecycle rule actions (Ações de regra do ciclo de vida), escolha as ações que você deseja que sua regra de ciclo de vida execute:

   • Transição de versões atuais de objetos entre classes de armazenamento

   • Transição de versões anteriores de objetos entre classes de armazenamento

   • Expirar as versões atuais dos objetos

   • Excluir permanentemente versões anteriores de objetos

   • Excluir marcadores de exclusão expirados ou multipart uploads incompletos

   Dependendo das ações que você escolher, diferentes opções serão exibidas.

8. Para fazer a transição de versões atuais de objetos entre classes de armazenamento, em Transition current versions of objects between storage classes (Transição de versões atuais de objetos entre classes de armazenamento):

   1. Em Storage class transitions (Transições de classe de armazenamento), escolha a classe de armazenamento para a qual fazer a transição:

      • Standard-IA

      • Intelligent-Tiering

      • One Zone-IA

      • S3 Glacier Flexible Retrieval

      • Glacier Deep Archive

   2. Em Days after object creation (Dias após a criação do objeto), insira o número de dias após a criação para fazer a transição do objeto.

   Para obter mais informações sobre classes de armazenamento, consulte Uso de classes de armazenamento do Amazon S3. É possível definir transições para a versão atual ou as versões anteriores do objeto, ou para ambas. O versionamento permite que você mantenha várias versões de um objeto em um bucket. Para obter mais informações sobre versionamento, consulte Uso do console do S3.

   Importante

   Quando você escolhe a classe de armazenamento S3 Glacier Flexible Retrieval ou Glacier Deep Archive, os objetos permanecem no Amazon S3. Não será possível acessá-los diretamente por meio do serviço separado do Amazon S3 Glacier. Para obter mais informações, consulte Transição de objetos usando o Amazon S3 Lifecycle.

9. Para fazer a transição de versões não atuais de objetos entre classes de armazenamento, em Transition non-current versions of objects between storage classes (Transição de versões não atuais de objetos entre classes de armazenamento):

   1. Em Storage class transitions (Transições de classe de armazenamento), escolha a classe de armazenamento para a qual fazer a transição:

      • Standard-IA

      • Intelligent-Tiering

      • One Zone-IA

      • S3 Glacier Flexible Retrieval

      • Glacier Deep Archive

   2. Em Days after object becomes non-current (Dias após o objeto se tornar não atual), insira o número de dias após a criação para fazer a transição do objeto.

10. Para expirar as versões atuais dos objetos, em Expire current versions of objects (Expirar versões atuais de objetos), em Number of days after object creation (Número de dias após a criação do objeto), insira o número de dias.

    Importante

    Em um bucket sem versionamento, a ação de expiração faz com que o Amazon S3 remova permanente o objeto. Para obter mais informações sobre ações de ciclo de vida, consulte Elementos para descrever ações de ciclo de vida.

11. Para excluir permanentemente versões anteriores de objetos, em Permanently delete previous versions of objects (Excluir permanentemente versões desatualizadas de objetos), em Days after objects become noncurrent (Dias após os objetos ficarem desatualizados), insira o número de dias. Opcionalmente, você pode especificar o número de versões mais recentes a serem retidas inserindo um valor em Number of newer versions to retain (Número de versões mais novas a serem mantidas).

12. Em Delete expired delete markers or incomplete multipart uploads (Excluir marcadores de exclusão expirados ou multipart uploads incompletos), escolha Delete expired object delete markers (Excluir marcadores de exclusão de objetos expirados) e Delete incomplete multipart uploads (Excluir multipart uploads incompletos). Depois, insira o número de dias após o início do multipart upload que você deseja encerrar e limpar multipart uploads incompletos.

    Para obter mais informações sobre multipart uploads, consulte Carregar e copiar objetos usando multipart upload.

13. Selecione Criar regra.

    Se a regra não contiver erros, o Amazon S3 a habilitará e você poderá vê-la na guia Management (Gerenciamento) em Lifecycle rules (Regras de ciclo de vida).

Para obter informações sobre modelos e exemplos do CloudFormation, consulte Como trabalhar com modelos do AWS CloudFormation e AWS::S3::Bucket no Guia do usuário do AWS CloudFormation.

Usar a AWS CLI

Use os comandos da AWS CLI a seguir para gerenciar as configurações do S3 Lifecycle:

• put-bucket-lifecycle-configuration

• get-bucket-lifecycle-configuration

• delete-bucket-lifecycle

Para obter instruções de configuração da AWS CLI, consulte Desenvolvimento com o Amazon S3 usando a AWS CLI.

A configuração do ciclo de vida do Amazon S3 é um arquivo XML. Mas ao usar a AWS CLI, você não pode especificar o XML. Você deve especificar o JSON em vez disso. Veja a seguir exemplos de configurações do ciclo de vida em XML e o JSON equivalente que pode ser especificado em um comando da AWS CLI.

Considere o seguinte exemplo de configuração do S3 Lifecycle.

exemplo Exemplo 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>

exemplo Exemplo 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>

Teste o comando put-bucket-lifecycle-configuration da seguinte forma.

Como testar a configuração

1. Salve a configuração do ciclo de vida JSON em um arquivo (lifecycle.json).

2. Execute o comando da AWS CLI a seguir para definir a configuração do ciclo de vida no bucket.

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

3. Para verificar, recupere a configuração do S3 Lifecycle usando o comando get-bucket-lifecycle-configuration da AWS CLI da seguinte maneira:

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

4. Para excluir a configuração do S3 Lifecycle, use o comando delete-bucket-lifecycle da AWS CLI da seguinte maneira:

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

Uso da SDKs AWS

Java

Use o AWS SDK for Java para gerenciar a configuração do S3 Lifecycle de um bucket. Para obter mais informações sobre o gerenciamento da configuração do ciclo de vida do S3, consulte Gerenciando seu ciclo de vida de armazenamento.

nota

Quando você adiciona uma configuração do S3 Lifecycle em um bucket, o Amazon S3 substitui a configuração do ciclo de vida atual do bucket, se houver. Para atualizar uma configuração, recupere a configuração, faça as alterações desejadas e adicione a configuração revisada ao bucket.

O exemplo a seguir mostra como usar o AWS SDK for Java para adicionar, atualizar e excluir a configuração do ciclo de vida de um bucket. O exemplo faz o seguinte:

• Adiciona a configuração do ciclo de vida a um bucket.

• Recupera a configuração do ciclo de vida e a atualiza adicionando outra regra.

• Adiciona a configuração do ciclo de vida modificada ao bucket. O Amazon S3 substitui a configuração existente.

• Recupera a configuração novamente e verifica se ela tem o número certo de regras pela impressão do número de regras.

• Exclui a configuração do ciclo de vida e verifica se ela foi excluída ao tentar recuperá-la novamente.

Para obter instruções sobre criar e testar um exemplo funcional, consulte Testar exemplos de código Java no 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

Use o AWS SDK for .NET para gerenciar a configuração do S3 Lifecycle em um bucket. Para obter mais informações sobre o gerenciamento da configuração do ciclo de vida, consulte Gerenciando seu ciclo de vida de armazenamento.

nota

Quando você adiciona uma configuração do ciclo de vida, o Amazon S3 substitui a configuração existente no bucket especificado. Para atualizar uma configuração, recupere a configuração do ciclo de vida, faça as alterações e, depois, adicione a configuração revisada ao bucket.

O exemplo a seguir mostra como usar o AWS SDK for .NET para adicionar, atualizar e excluir uma configuração do ciclo de vida de um bucket. O exemplo de código faz o seguinte:

• Adiciona a configuração do ciclo de vida a um bucket.

• Recupera a configuração do ciclo de vida e a atualiza adicionando outra regra.

• Adiciona a configuração do ciclo de vida modificada ao bucket. O Amazon S3 substitui a configuração do ciclo de vida existente.

• Recupera a configuração novamente e a verifica imprimindo o número de regras na configuração.

• Exclui a configuração do Lifecycle e verifica a exclusão.

Para obter instruções sobre como criar e testar um exemplo funcional, consulte Executar os exemplos de código do Amazon S3 .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

Você pode usar o AWS SDK for Ruby para gerenciar a configuração do S3 Lifecycle em um bucket com a classe AWS::S3::BucketLifecycleConfiguration. Para obter mais informações sobre como usar o AWS SDK for Ruby com o Amazon S3, consulte Usar o AWS SDK for Ruby - versão 3. Para obter mais informações sobre o gerenciamento da configuração do ciclo de vida, consulte Gerenciando seu ciclo de vida de armazenamento.

Uso dos REST API

As seções a seguir na Referência da API do Amazon Simple Storage Service descrevem a API REST relacionada à configuração do S3 Lifecycle.

• Ciclo de vida de PUT Bucket

• Ciclo de vida de GET Bucket

• DELETE Bucket lifecycle