Definir uma configuração do Ciclo de Vida do S3 em um bucket - Amazon Simple Storage Service
Considerações sobre o Ciclo de Vida do S3Como definir uma configuração do Ciclo de Vida do S3Solução de problemas de ciclo de vida do S3

Definir uma configuração do Ciclo de Vida do S3 em um bucket

É possível definir uma configuração do Ciclo de Vida do Amazon S3 em um bucket usando o console do Amazon S3, a AWS Command Line Interface (AWS CLI), os SDKs da AWS ou a API REST do Amazon S3. Para obter informações sobre a configuração do S3 Lifecycle, consulte Gerenciar o ciclo de vida dos objetos.

Na configuração do Ciclo de Vida do S3, você usa regras de ciclo de vida para definir ações que você deseja que o Amazon S3 realize durante a vida útil de um objeto. Por exemplo, é possível definir regras para fazer a transição de objetos a outra classe de armazenamento, arquivá-los ou expirá-los (excluí-los) após um período especificado.

Considerações sobre o Ciclo de Vida do S3

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

Atraso de propagação da configuração do ciclo de vida

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.

Atraso na transição ou na expiração

Há um atraso entre quando uma regra do ciclo de vida é cumprida e quando a ação para a regra é concluída. Por exemplo, suponha que um conjunto de objetos tenha expirado por uma regra de ciclo de vida em 1.º de janeiro. Mesmo que a regra de expiração tenha sido cumprida em 1º de janeiro, o Amazon S3 pode não excluir esses objetos até dias ou até semanas depois. Esse atraso ocorre porque o ciclo de vida do S3 enfileira objetos para transições ou expirações de forma assíncrona. No entanto, as alterações no faturamento geralmente são aplicadas quando a regra do ciclo de vida é cumprida, mesmo que a ação não seja concluída. Consulte mais informações em Alterações no faturamento. Para monitorar o efeito das atualizações feitas pelas regras de ciclo de vida ativas, consulte Como monitorar as ações realizadas pelas minhas regras de ciclo de vida?

Atualizar, desabilitar ou excluir regras de ciclo de vida

Quando você desabilita ou exclui regras de ciclo de vida, o Amazon S3 para de programar a exclusão ou transição de novos objetos depois de um pequeno atraso. 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 regras de ciclo de vida, use as operações de API LIST (como ListObjectsV2, ListObjectVersions e ListMultipartUploads) ou Catalogar e analisar seus dados com o Inventário S3 para verificar se o Amazon S3 fez a transição e descontinuou 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 de ciclo de vida, consulte Solucionar problemas de 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 da funcionalidade 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 o prefixo especificado e com mais de 30 dias.

Monitorar o efeito de regras de ciclo de vida

Para monitorar o efeito das atualizações feitas pelas regras de ciclo de vida ativas, consulte Como monitorar as ações realizadas pelas minhas regras de ciclo de vida?

Alterações no faturamento

Pode haver um atraso entre o momento em que as regras de configuração da funcionalidade 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 da funcionalidade Ciclo de Vida é satisfeita, mesmo que a ação ainda não tenha sido tomada.

Por exemplo, não haverá cobrança pelo armazenamento após o tempo de expiração do objeto, mesmo que o objeto não seja excluído imediatamente. Da mesma maneira, assim que o tempo de transição do objeto terminar, você receberá cobrança segundo as taxas de armazenamento da classe S3 Glacier Flexible Retrieval, mesmo que a transição do objeto para a classe de armazenamento S3 Glacier Flexible Retrieval não seja feita imediatamente.

No entanto, 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 só acontecerão depois da transição do objeto para a classe de armazenamento S3 Intelligent-Tiering.

Regras múltiplas ou conflitantes

Quando você tem várias regras em uma configuração do ciclo de vida do S3, um objeto pode se tornar elegível para várias ações do ciclo de vida do S3 no mesmo dia. Nesses casos, o Amazon S3 segue estas regras gerais:

  • A exclusão permanente tem precedência sobre a transição.

  • A transição tem precedência sobre a criação de marcadores de exclusão.

  • Quando um objeto é elegível para transição às classes S3 Glacier Flexible Retrieval e S3 Standard-IA (ou S3 One Zone-IA), o Amazon S3 escolhe a transição para a classe S3 Glacier Flexible Retrieval.

Para ver exemplos, consulte Exemplos de filtros sobrepostos e ações de ciclo de vida conflitantes.

Como definir uma configuração do Ciclo de Vida do S3

É possível definir uma configuração do Ciclo de Vida do Amazon S3 em um bucket usando o console do Amazon S3, a AWS Command Line Interface (AWS CLI), os SDKs da AWS ou a API REST do Amazon S3.

Consulte informações sobre modelos e exemplos do AWS CloudFormation em Trabalhar com modelos do AWS CloudFormation e AWS::S3::Bucket no Guia do usuário do AWS CloudFormation.

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

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 Nomear objetos do Amazon S3. Para obter mais informações sobre tags de objeto, consulte Categorizar seu armazenamento usando tags.

    • Para aplicar essa regra de ciclo de vida a todos os objetos no bucket, escolha Esta regra se aplica a todos os objetos no bucket e Eu reconheço que esta regra se aplica a todos os objetos no bucket.

  6. Para filtrar uma regra por tamanho de objeto, selecione Especificar o tamanho mínimo do objeto, Especificar o tamanho máximo do objeto ou as duas opções.

    • Ao especificar um valor para Tamanho mínimo do objeto ou Tamanho máximo do objeto, o valor deverá ser maior que 0 byte e no máximo 5 TB. É possível especificar esse valor em bytes, KB, MB ou GB.

    • Ao especificar ambos os valores, o tamanho máximo do objeto deverá ser maior que o tamanho mínimo do objeto.

      nota

      Os filtros Tamanho mínimo do objeto e Tamanho máximo do objeto excluem os valores especificados. Por exemplo, se você definir um filtro para expirar objetos que tenham um Tamanho mínimo do objeto de 128 KB, os objetos com exatamente 128 KB não expirarão. Em vez disso, a regra se aplica somente a objetos com tamanho maior que 128 KB.

  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

      nota

      Para buckets que não têm o versionamento do S3 habilitado, a expiração das versões atuais faz com que o Amazon S3 exclua permanentemente os objetos. Para ter mais informações, consulte Ações de ciclo de vida e estado de versionamento do bucket.

    • 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 Transição de versões atuais de objetos entre classes de armazenamento, faça o seguinte:

    1. Em Transições de classe de armazenamento, escolha a classe de armazenamento para a qual fazer a transição. Consulte uma lista de possíveis transições em Transições de ciclo de vida com suporte. É possível escolher entre as seguintes classes de armazenamento:

      • S3 Standard – IA

      • S3 Intelligent-Tiering

      • S3 One Zone-IA

      • S3 Glacier Instant Retrieval

      • S3 Glacier Flexible Retrieval

      • S3 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 Compreender e gerenciar 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 Instant Retrieval, 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 ter 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 Transição de versões não atuais de objetos entre classes de armazenamento, faça o seguinte:

    1. Em Transições de classe de armazenamento, escolha a classe de armazenamento para a qual fazer a transição. Consulte uma lista de possíveis transições em Transições de ciclo de vida com suporte. É possível escolher entre as seguintes classes de armazenamento:

      • S3 Standard – IA

      • S3 Intelligent-Tiering

      • S3 One Zone-IA

      • S3 Glacier Instant Retrieval

      • S3 Glacier Flexible Retrieval

      • S3 Glacier Deep Archive

    2. Em Dias após o objeto ficar desatualizado, 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 permanentemente 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).

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

Consulte instruções sobre como configurar a AWS CLI em Developing with Amazon S3 using the AWS CLI na Referência de API do Amazon S3.

A configuração do ciclo de vida do Amazon S3 é um arquivo XML. Porém, ao usar a AWS CLI, você não pode especificar o formado XML. Em vez disso, você deve especificar o formato JSON. Veja a seguir exemplos de configurações de ciclo de vida em XML e as configurações JSON equivalentes que podem ser especificadas em um comando da AWS CLI.

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

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

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

Como testar a configuração

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

  2. Execute o comando da AWS CLI a seguir para definir a configuração do ciclo de vida no bucket. Substitua os user input placeholders por suas próprias informações.

    $ aws s3api put-bucket-lifecycle-configuration  \
--bucket amzn-s3-demo-bucket  \
--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 amzn-s3-demo-bucket

  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 amzn-s3-demo-bucket
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 Gerenciar o ciclo de vida dos objetos.

nota

Quando você adiciona uma configuração do Ciclo de Vida do S3 a 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 imprimindo o número de regras.

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

Consulte instruções sobre como criar e testar uma amostra funcional em Getting Started no Guia do desenvolvedor do AWS SDK for Java.


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 Gerenciar o ciclo de vida dos objetos.

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.

Consulte informações sobre como configurar e executar exemplos de código, em Getting Started with the AWS SDK for .NET no Guia do desenvolvedor do AWS SDK for .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

É possível usar o AWS SDK for Ruby para gerenciar uma configuração do Ciclo de Vida do S3 em um bucket usando a classe AWS::S3::BucketLifecycleConfiguration. Para obter mais informações sobre o gerenciamento da configuração do ciclo de vida do S3, consulte Gerenciar o ciclo de vida dos objetos.

Os tópicos a seguir na Referência da API do Amazon Simple Storage Service descrevem as operações da API REST relacionada à configuração do Ciclo de Vida do S3:

Solução de problemas de ciclo de vida do S3

Consulte problemas comuns que podem ocorrer ao trabalhar com o ciclo de vida do S3 em Solucionar problemas de ciclo de vida do Amazon S3.