Habilitar o versionamento em buckets

Use o S3 Versioning para manter várias versões de um objeto em um bucket. Esta seção fornece exemplos de como habilitar o versionamento em um bucket usando o console, a API REST, os AWS SDKs e a AWS Command Line Interface (AWS CLI).

nota

Se você habilitar o versionamento em um bucket pela primeira vez, poderá levar até 15 minutos para que a alteração seja totalmente propagada. Recomendamos que você aguarde 15 minutos depois de habilitar o versionamento para emitir operações de gravação (PUT ou DELETE) em objetos no bucket. As operações de gravação emitidas antes da conclusão dessa conversão podem ser aplicadas a objetos sem versões.

Para obter mais informações sobre o S3 Versioning, consulte Usando o versionamento em buckets do S3. Para obter informações sobre como trabalhar com objetos que estão em buckets habilitados para versão, consulte Trabalhar com objetos em um bucket com versionamento habilitado.

Para saber mais sobre como usar o Versionamento do S3 para proteger dados, consulte Tutorial: Protecting data on Amazon S3 against accidental deletion or application bugs using S3 Versioning, S3 Object Lock, and S3 Replication (Tutorial: Proteção de dados no Amazon S3 contra exclusão acidental ou bugs de aplicações usando o Versionamento do S3, o Bloqueio de Objeto do S3 e a Replicação do S3.

Cada bucket do S3 que você cria tem um sub-recurso de versionamento associado a ele. (Para obter mais informações, consulte Opções de configuração do bucket.) Por padrão, seu bucket não está habilitado para versionamento e o sub-recurso de versionamento armazena uma configuração vazia de versionamento, como mostrado a seguir.


<VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/"> 
</VersioningConfiguration>

Para habilitar o versionamento, você pode enviar uma solicitação ao Amazon S3 com uma configuração de versionamento que inclui um status.


<VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/"> 
  <Status>Enabled</Status> 
</VersioningConfiguration>

Para suspender o versionamento, você define o valor do status como Suspended.

O proprietário do bucket e todos os usuários autorizados podem habilitar o versionamento. O proprietário do bucket é a Conta da AWS que criou o bucket (a conta root). Para obter mais informações sobre permissões, consulte Identity and Access Management no Amazon S3.

As seções a seguir fornecem mais detalhes sobre como ativar o versionamento do S3 usando o console, a AWS CLI e os AWS SDKs.

Siga estas etapas para usar o AWS Management Console para habilitar o versionamento em um bucket do S3.

Para habilitar ou desabilitar o versionamento em um bucket do S3

Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.
Na lista Buckets, escolha o nome do bucket para o qual você deseja habilitar o versionamento.
Escolha Properties (Propriedades).
Em Bucket Versioning (Versionamento de bucket), escolha Edit (Editar).
Escolha Suspend (Suspender) ou Enable (Ativar), e selecione Save changes (Salvar alterações).

nota

Você pode usar a autenticação multifator (MFA) da AWS com versionamento. Ao usar a MFA com versionamento, você deve fornecer as chaves de acesso da sua Conta da AWS e um código válido do dispositivo MFA da conta para excluir permanentemente uma versão de objeto ou suspender ou reativar o versionamento.

Para usar a MFA com versionamento, você habilita MFA Delete. No entanto, não é possível habilitar o MFA Delete usando o AWS Management Console. É necessário usar a AWS Command Line Interface (AWS CLI) ou API. Para obter mais informações, consulte Configurando a exclusão de MFA.

O exemplo a seguir habilita o versionamento em um bucket do S3.



aws s3api put-bucket-versioning --bucket DOC-EXAMPLE-BUCKET1 --versioning-configuration Status=Enabled

O exemplo a seguir ativa o versionamento do S3 e a exclusão de autenticação multifator (MFA) em um bucket.



aws s3api put-bucket-versioning --bucket DOC-EXAMPLE-BUCKET1 --versioning-configuration Status=Enabled,MFADelete=Enabled --mfa "SERIAL 123456"

nota

O uso da exclusão de MFA requer um dispositivo de autenticação física ou virtual aprovado. Para obter mais informações sobre como usar exclusão de MFA no Amazon S3, consulte Configurando a exclusão de MFA.

Para obter mais informações sobre como ativar o versionamento usando a AWS CLI, consulte put-bucket-versioning na Referência de comandos da AWS CLI.

Os exemplos a seguir permitem o versionamento em um bucket e, em seguida, recuperam o status do versionamento usando o AWS SDK for Java e o AWS SDK for .NET. Para obter informações sobre o uso de outros AWS SDKs, consulte o Centro do Desenvolvedor da AWS.

.NET

Para obter informações sobre como criar e testar um exemplo funcional, consulte Executar os exemplos de código do Amazon S3 .NET.


using System;
using Amazon.S3;
using Amazon.S3.Model;

namespace s3.amazon.com.docsamples
{
    class BucketVersioningConfiguration
    {
        static string bucketName = "*** bucket name ***";

        public static void Main(string[] args)
        {
            using (var client = new AmazonS3Client(Amazon.RegionEndpoint.USEast1))
            {
                try
                {
                    EnableVersioningOnBucket(client);
                    string bucketVersioningStatus = RetrieveBucketVersioningConfiguration(client);
                }
                catch (AmazonS3Exception amazonS3Exception)
                {
                    if (amazonS3Exception.ErrorCode != null &&
                        (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId")
                        ||
                        amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
                    {
                        Console.WriteLine("Check the provided AWS Credentials.");
                        Console.WriteLine(
                        "To sign up for service, go to http://aws.amazon.com/s3");
                    }
                    else
                    {
                        Console.WriteLine(
                         "Error occurred. Message:'{0}' when listing objects",
                         amazonS3Exception.Message);
                    }
                }
            }

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }

        static void EnableVersioningOnBucket(IAmazonS3 client)
        {

                PutBucketVersioningRequest request = new PutBucketVersioningRequest
                {
                    BucketName = bucketName,
                    VersioningConfig = new S3BucketVersioningConfig 
                    {
                        Status = VersionStatus.Enabled
                    }
                };

                PutBucketVersioningResponse response = client.PutBucketVersioning(request);
        }


        static string RetrieveBucketVersioningConfiguration(IAmazonS3 client)
        {
                GetBucketVersioningRequest request = new GetBucketVersioningRequest
                {
                    BucketName = bucketName
                };
 
                GetBucketVersioningResponse response = client.GetBucketVersioning(request);
                return response.VersioningConfig.Status;
            }
    }
}

Java

Para obter instruções sobre como criar e testar um exemplo funcional, consulte Testar exemplos de código Java no Amazon S3.


import java.io.IOException;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.BucketVersioningConfiguration;
import com.amazonaws.services.s3.model.SetBucketVersioningConfigurationRequest;

public class BucketVersioningConfigurationExample {
    public static String bucketName = "*** bucket name ***"; 
    public static AmazonS3Client s3Client;

    public static void main(String[] args) throws IOException {
        s3Client = new AmazonS3Client(new ProfileCredentialsProvider());
        s3Client.setRegion(Region.getRegion(Regions.US_EAST_1));
        try {

            // 1. Enable versioning on the bucket.
        	BucketVersioningConfiguration configuration = 
        			new BucketVersioningConfiguration().withStatus("Enabled");
            
			SetBucketVersioningConfigurationRequest setBucketVersioningConfigurationRequest = 
					new SetBucketVersioningConfigurationRequest(bucketName,configuration);
			
			s3Client.setBucketVersioningConfiguration(setBucketVersioningConfigurationRequest);
			
			// 2. Get bucket versioning configuration information.
			BucketVersioningConfiguration conf = s3Client.getBucketVersioningConfiguration(bucketName);
			 System.out.println("bucket versioning configuration status:    " + conf.getStatus());

        } catch (AmazonS3Exception amazonS3Exception) {
            System.out.format("An Amazon S3 error occurred. Exception: %s", amazonS3Exception.toString());
        } catch (Exception ex) {
            System.out.format("Exception: %s", ex.toString());
        }        
    }
}

Python

Para obter instruções sobre como criar e testar um exemplo funcional, consulte Usar a AWS SDK for Python (Boto).

O exemplo de código Python a seguir cria um bucket do Amazon S3 bucket, habilita-o para versionamento e configura um ciclo de vida que faz com que versões não atuais de objetos expirem após 7 dias.


def create_versioned_bucket(bucket_name, prefix):
    """
    Creates an Amazon S3 bucket, enables it for versioning, and configures a lifecycle
    that expires noncurrent object versions after 7 days.

    Adding a lifecycle configuration to a versioned bucket is a best practice.
    It helps prevent objects in the bucket from accumulating a large number of
    noncurrent versions, which can slow down request performance.

    Usage is shown in the usage_demo_single_object function at the end of this module.

    :param bucket_name: The name of the bucket to create.
    :param prefix: Identifies which objects are automatically expired under the
                   configured lifecycle rules.
    :return: The newly created bucket.
    """
    try:
        bucket = s3.create_bucket(
            Bucket=bucket_name,
            CreateBucketConfiguration={
                "LocationConstraint": s3.meta.client.meta.region_name
            },
        )
        logger.info("Created bucket %s.", bucket.name)
    except ClientError as error:
        if error.response["Error"]["Code"] == "BucketAlreadyOwnedByYou":
            logger.warning("Bucket %s already exists! Using it.", bucket_name)
            bucket = s3.Bucket(bucket_name)
        else:
            logger.exception("Couldn't create bucket %s.", bucket_name)
            raise

    try:
        bucket.Versioning().enable()
        logger.info("Enabled versioning on bucket %s.", bucket.name)
    except ClientError:
        logger.exception("Couldn't enable versioning on bucket %s.", bucket.name)
        raise

    try:
        expiration = 7
        bucket.LifecycleConfiguration().put(
            LifecycleConfiguration={
                "Rules": [
                    {
                        "Status": "Enabled",
                        "Prefix": prefix,
                        "NoncurrentVersionExpiration": {"NoncurrentDays": expiration},
                    }
                ]
            }
        )
        logger.info(
            "Configured lifecycle to expire noncurrent versions after %s days "
            "on bucket %s.",
            expiration,
            bucket.name,
        )
    except ClientError as error:
        logger.warning(
            "Couldn't configure lifecycle on bucket %s because %s. "
            "Continuing anyway.",
            bucket.name,
            error,
        )

    return bucket

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Versionamento do S3

Configurando a exclusão de MFA