As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Exemplos de código do Amazon S3 usando o AWS SDK para C\$1\$1
<a name="examples-s3"></a>

O [Amazon S3](https://aws.amazon.com/s3) é um armazenamento de objetos para armazenar e recuperar qualquer volume de dados de qualquer local. Há várias classes fornecidas pela interface AWS SDK para C\$1\$1 to com o Amazon S3. 

**nota**  
Somente o código necessário para demonstrar determinadas técnicas é fornecido neste Guia, mas o [código de exemplo completo está disponível em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). Em GitHub você pode baixar um único arquivo de origem ou clonar o repositório localmente para obter, criar e executar todos os exemplos.
+ Classe [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_client.html) 

  A biblioteca `S3Client` é uma interface completa do Amazon S3.

  O `list_buckets_disabling_dns_cache.cpp` exemplo neste conjunto foi criado especificamente para trabalhar com o CURL ativado Linux/Mac (embora possa ser modificado para funcionar no Windows). Se você estiver no Windows, exclua o arquivo `list_buckets_disabling_dns_cache.cpp` antes de criar o projeto, pois ele depende do curl HttpClient do Linux.

  O código de exemplo utilizando o `S3Client` está na [pasta `s3`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3) no Github. Consulte o [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/README.md) no Github para ver uma lista completa das funções demonstradas por esse conjunto de exemplos.

  Partes do conjunto de exemplos do `s3` são abordadas com mais detalhes neste guia:
  + [Criar, listar e excluir buckets](examples-s3-buckets.md)
  + [Operações em objetos](examples-s3-objects.md): fazer upload e baixar objetos de dados
  + [Gerenciar permissões de acesso do Amazon S3](examples-s3-access-permissions.md)
  + [Gerenciar o acesso a buckets do Amazon S3 usando políticas de bucket](examples-s3-bucket-policies.md)
  + [Configurar um bucket do Amazon S3 como um site](examples-s3-website-configuration.md)
+ Classe [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html) 

  O `S3CrtClient` foi adicionado na versão 1.9 do SDK. O `S3CrtClient` fornece alto throughput para operações GET (download) e PUT (upload) do Amazon S3. O `S3CrtClient` é implementado na parte superior das bibliotecas do AWS Common Runtime (CRT). 

  O código de exemplo utilizando o `S3CrtClient` está na [pasta `s3-crt`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt) no Github. Consulte o [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/README.md) no Github para ver uma lista completa das funções demonstradas por esse conjunto de exemplos.
  + [Usar o `S3CrtClient` para operações do Amazon S3](examples-s3-crt.md)
+ Classe [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html) 

  O `TransferManager` É um serviço totalmente gerenciado que permite a transferência de arquivos usando File Transfer Protocol (FTP), File Transfer Protocol over SSL (FTPS), or Secure Shell (SSH) File Transfer Protocol (SFTP) diretamente para dentro e para fora do Amazon S3.

  O código de exemplo utilizando o `TransferManager` está na [pasta `transfer-manager`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager) no Github. Consulte o [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/README.md) no Github para ver uma lista completa das funções demonstradas por esse conjunto de exemplos.
  + [Usando TransferManager para operações do Amazon S3](examples-s3-transfermanager.md)

# Criar, listar e excluir buckets
<a name="examples-s3-buckets"></a>

Cada *objeto* ou arquivo no Amazon Simple Storage Service (Amazon S3) está contido em um *bucket*, que representa uma pasta de objetos. Cada bucket tem um nome globalmente exclusivo na AWS. Para acessar mais informações, consulte [Trabalhar com buckets do S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) no Guia do usuário do Amazon Simple Storage Service.

## Pré-requisitos
<a name="codeExamplePrereq"></a>

Antes de começar, recomendamos que você leia [Getting started using the AWS SDK para C\$1\$1](getting-started.md). 

Baixe o exemplo código de código e crie a solução conforme descrito em [Conceitos básicos dos exemplos de código](getting-started-code-examples.md). 

Para executar os exemplos, o perfil de usuário que seu código usa para fazer as solicitações deve ter as permissões adequadas na AWS (para o serviço e a ação). Para acessar mais informações, consulte [Fornecer credenciais da AWS](credentials.md).

## Listar buckets
<a name="list-buckets"></a>

Para executar o exemplo de `list_buckets`, em um prompt de comando, navegue até a pasta onde seu sistema cria seus executáveis de compilação. Utilize o executável da mesma forma que `run_list_buckets` (o nome completo do arquivo executável será diferente com base no seu sistema operacional). O resultado listará os buckets da sua conta, se você tiver algum, ou exibirá uma lista vazia se você não tiver nenhum bucket.

Em `list_buckets.cpp`, há dois métodos.
+ `main()` chama `ListBuckets()`. 
+ `ListBuckets()` usa o SDK para consultar seus buckets.

O objeto `S3Client` chama o método `ListBuckets()` do SDK. Se for bem-sucedido, o método exibirá um objeto `ListBucketOutcome` que contém um objeto `ListBucketResult`. O objeto `ListBucketResult` chama o método `GetBuckets()` para acessar uma lista de objetos `Bucket` que contêm informações sobre cada bucket do Amazon S3 em sua conta.

 **Código da** 

```
bool AwsDoc::S3::listBuckets(const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    auto outcome = client.ListBuckets();

    bool result = true;
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed with error: " << outcome.GetError() << std::endl;
        result = false;
    } else {
        std::cout << "Found " << outcome.GetResult().GetBuckets().size() << " buckets\n";
        for (auto &&b: outcome.GetResult().GetBuckets()) {
            std::cout << b.GetName() << std::endl;
        }
    }

    return result;
}
```

Veja o [exemplo list\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_buckets.cpp) completo no Github.

## Criar um bucket
<a name="create-bucket"></a>



Para executar o exemplo de `create_bucket`, em um prompt de comando, navegue até a pasta onde seu sistema cria seus executáveis de compilação. Utilize o executável da mesma forma que `run_create_bucket` (o nome completo do arquivo executável será diferente com base no seu sistema operacional). O código cria um bucket vazio em sua conta e, depois, exibe êxito ou a falha da solicitação.

Em `create_bucket.cpp`, há dois métodos. 
+ `main()` chama `CreateBucket()`. Em `main()`, você precisa alterar a Região da AWS para a região da sua conta usando o `enum`. Você pode ver a região da sua conta fazendo login no [Console de gerenciamento da AWS](https://console.aws.amazon.com/) e localizando a região no canto superior direito. 
+ `CreateBucket()` usa o SDK para criar um bucket. 



O objeto `S3Client` chama o método `CreateBucket()` do SDK, transmitindo uma `CreateBucketRequest` com o nome do bucket. Por padrão, os buckets são criados na região *us-east-1* (Norte da Virgínia). Se sua região não for *us-east-1*, o código vai configurar uma restrição de bucket a fim de garantir que ele seja criado em sua região.

 **Código da** 

```
bool AwsDoc::S3::createBucket(const Aws::String &bucketName,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::CreateBucketRequest request;
    request.SetBucket(bucketName);

    if (clientConfig.region != "us-east-1") {
        Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
        createBucketConfig.SetLocationConstraint(
                Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
                        clientConfig.region));
        request.SetCreateBucketConfiguration(createBucketConfig);
    }

    Aws::S3::Model::CreateBucketOutcome outcome = client.CreateBucket(request);
    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: createBucket: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Created bucket " << bucketName <<
                  " in the specified AWS Region." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo [create\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/create_bucket.cpp) completo no Github.

## Excluir um bucket
<a name="delete-bucket"></a>



Para executar o exemplo de `delete_bucket`, em um prompt de comando, navegue até a pasta onde seu sistema cria seus executáveis de compilação. Utilize o executável da mesma forma que `run_delete_bucket` (o nome completo do arquivo executável será diferente com base no seu sistema operacional). O código exclui o bucket especificado em sua conta e, depois, exibe êxito ou a falha da solicitação.

Em `delete_bucket.cpp` há dois métodos. 
+ `main()` chama `DeleteBucket()`. Em `main()`, você precisa alterar a Região da AWS para a região da sua conta usando o `enum`. Você também precisa alterar o `bucket_name` para o nome do bucket a ser excluído. 
+ O `DeleteBucket()` usa o SDK para excluir o bucket. 



O objeto `S3Client` usa o método `DeleteBucket()` do SDK, transmitindo um objeto `DeleteBucketRequest` com o nome do bucket a ser excluído. O bucket deve estar vazio para ser bem-sucedido.

 **Código da**

```
bool AwsDoc::S3::deleteBucket(const Aws::String &bucketName,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {

    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::DeleteBucketRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::DeleteBucketOutcome outcome =
            client.DeleteBucket(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: deleteBucket: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "The bucket was deleted" << std::endl;
    }

    return outcome.IsSuccess();
}
```

Veja o [exemplo delete\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket.cpp) completo no Github.

# Operações em objetos
<a name="examples-s3-objects"></a>

Um objeto do Amazon S3 representa um *arquivo*, que é uma coleção de dados. Cada objeto deve residir em um [bucket](examples-s3-buckets.md).

## Pré-requisitos
<a name="codeExamplePrereq"></a>

Antes de começar, recomendamos que você leia [Getting started using the AWS SDK para C\$1\$1](getting-started.md). 

Baixe o exemplo código de código e crie a solução conforme descrito em [Conceitos básicos dos exemplos de código](getting-started-code-examples.md). 

Para executar os exemplos, o perfil de usuário que seu código usa para fazer as solicitações deve ter as permissões adequadas AWS (para o serviço e a ação). Para obter mais informações, consulte [Fornecimento de AWS credenciais.](credentials.md)

## Fazer upload de um arquivo para um bucket
<a name="upload-object"></a>

Use a função `PutObject` do `S3Client` fornecendo um nome de bucket, um nome de chave e um arquivo para upload. `Aws::FStream` é usado para fazer upload do conteúdo do arquivo local para o bucket. O bucket deve existir ou isso causará um erro.

Para ver um exemplo de como fazer upload de objetos de forma assíncrona, consulte [Programação assíncrona usando o AWS SDK para C\$1\$1](async-methods.md).

 **Código** 

```
bool AwsDoc::S3::putObject(const Aws::String &bucketName,
                           const Aws::String &fileName,
                           const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::PutObjectRequest request;
    request.SetBucket(bucketName);
    //We are using the name of the file as the key for the object in the bucket.
    //However, this is just a string and can be set according to your retrieval needs.
    request.SetKey(fileName);

    std::shared_ptr<Aws::IOStream> inputData =
            Aws::MakeShared<Aws::FStream>("SampleAllocationTag",
                                          fileName.c_str(),
                                          std::ios_base::in | std::ios_base::binary);

    if (!*inputData) {
        std::cerr << "Error unable to read file " << fileName << std::endl;
        return false;
    }

    request.SetBody(inputData);

    Aws::S3::Model::PutObjectOutcome outcome =
            s3Client.PutObject(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: putObject: " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Added object '" << fileName << "' to bucket '"
                  << bucketName << "'.";
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object.cpp).

## Fazer upload de uma string para um bucket
<a name="upload-object-string"></a>

Use a função `PutObject` do objeto do `S3Client` fornecendo um nome de bucket, um nome de chave e um arquivo para upload. O bucket deve existir ou isso causará um erro. Esse exemplo difere do anterior, pois usa `Aws::StringStream` para fazer upload de um objeto de dados de string na memória diretamente para um bucket.

Para ver um exemplo de como fazer upload de objetos de forma assíncrona, consulte [Programação assíncrona usando o AWS SDK para C\$1\$1](async-methods.md).

 **Código** 

```
bool AwsDoc::S3::putObjectBuffer(const Aws::String &bucketName,
                                 const Aws::String &objectName,
                                 const std::string &objectContent,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::PutObjectRequest request;
    request.SetBucket(bucketName);
    request.SetKey(objectName);

    const std::shared_ptr<Aws::IOStream> inputData =
            Aws::MakeShared<Aws::StringStream>("");
    *inputData << objectContent.c_str();

    request.SetBody(inputData);

    Aws::S3::Model::PutObjectOutcome outcome = s3Client.PutObject(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: putObjectBuffer: " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Success: Object '" << objectName << "' with content '"
                  << objectContent << "' uploaded to bucket '" << bucketName << "'.";
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_buffer.cpp).

## Listar objetos
<a name="list-objects"></a>

Para ver uma lista de objetos em um bucket, use a função `S3Client` do objeto do `ListObjects`. Forneça uma `ListObjectsRequest` definida com o nome de um bucket para listar o conteúdo.

A função `ListObjects` exibe um objeto `ListObjectsOutcome` que você pode usar para ver uma lista de objetos na forma de instâncias do `Object`.

 **Código** 

```
bool AwsDoc::S3::listObjects(const Aws::String &bucketName,
                             Aws::Vector<Aws::String> &keysResult,
                             const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::ListObjectsV2Request request;
    request.WithBucket(bucketName);

    Aws::String continuationToken; // Used for pagination.
    Aws::Vector<Aws::S3::Model::Object> allObjects;

    do {
        if (!continuationToken.empty()) {
            request.SetContinuationToken(continuationToken);
        }

        auto outcome = s3Client.ListObjectsV2(request);

        if (!outcome.IsSuccess()) {
            std::cerr << "Error: listObjects: " <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        } else {
            Aws::Vector<Aws::S3::Model::Object> objects =
                    outcome.GetResult().GetContents();

            allObjects.insert(allObjects.end(), objects.begin(), objects.end());
            continuationToken = outcome.GetResult().GetNextContinuationToken();
        }
    } while (!continuationToken.empty());

    std::cout << allObjects.size() << " object(s) found:" << std::endl;

    for (const auto &object: allObjects) {
        std::cout << "  " << object.GetKey() << std::endl;
        keysResult.push_back(object.GetKey());
    }

    return true;
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_objects.cpp).

## Fazer download de um objeto
<a name="download-object"></a>

Use a função `S3Client` do objeto do `GetObject`, transmitindo a ela uma `GetObjectRequest` definida com o nome de um bucket e a chave do objeto a ser baixada. `GetObject` exibe um objeto [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/namespace_aws_1_1_s3_1_1_model.html#a6e16a7b25e8c7547934968a538a15272](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/namespace_aws_1_1_s3_1_1_model.html#a6e16a7b25e8c7547934968a538a15272) que consiste em um [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_object_result.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_object_result.html) e um [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_error.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_s3_error.html). `GetObjectResult` pode ser usado para acessar os dados do objeto do S3.

O seguinte exemplo baixa um objeto do Amazon S3: O conteúdo do objeto é armazenado em uma variável local e a primeira linha do conteúdo é enviada ao console.

 **Código** 

```
bool AwsDoc::S3::getObject(const Aws::String &objectKey,
                           const Aws::String &fromBucket,
                           const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::GetObjectRequest request;
    request.SetBucket(fromBucket);
    request.SetKey(objectKey);

    Aws::S3::Model::GetObjectOutcome outcome =
            client.GetObject(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getObject: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully retrieved '" << objectKey << "' from '"
                  << fromBucket << "'." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_object.cpp).

## Excluir um objeto
<a name="delete-object"></a>

Use a função do `DeleteObject` do objeto do `S3Client`, transmitindo a ela uma `DeleteObjectRequest` definida com o nome de um bucket e o objeto para baixar. *O bucket especificado e a chave de objeto devem existir ou isso causará um erro*.

 **Código** 

```
bool AwsDoc::S3::deleteObject(const Aws::String &objectKey,
                              const Aws::String &fromBucket,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::DeleteObjectRequest request;

    request.WithKey(objectKey)
            .WithBucket(fromBucket);

    Aws::S3::Model::DeleteObjectOutcome outcome =
            client.DeleteObject(request);

    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: deleteObject: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully deleted the object." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_object.cpp).

# Gerenciar permissões de acesso do Amazon S3
<a name="examples-s3-access-permissions"></a>

As permissões de acesso para um bucket ou objeto do Amazon S3 são definidas em uma lista de controle de acesso (ACL). A ACL especifica o proprietário do bucket/object e uma lista de concessões. Cada concessão especifica um usuário (ou beneficiário) e as permissões do usuário para acessar o bucket/objeto, como acesso READ ou WRITE.

## Pré-requisitos
<a name="codeExamplePrereq"></a>

Antes de começar, recomendamos que você leia [Getting started using the AWS SDK para C\$1\$1](getting-started.md). 

Baixe o exemplo código de código e crie a solução conforme descrito em [Conceitos básicos dos exemplos de código](getting-started-code-examples.md). 

Para executar os exemplos, o perfil de usuário que seu código usa para fazer as solicitações deve ter as permissões adequadas AWS (para o serviço e a ação). Para obter mais informações, consulte [Fornecimento de AWS credenciais.](credentials.md)

## Gerenciar a lista de controle de acesso de um objeto
<a name="manage-an-object-s-access-control-list"></a>

A lista de controle de acesso de um objeto pode ser recuperada chamando o método `GetObjectAcl` do `S3Client`. O método aceita os nomes do objeto e do respectivo bucket. O valor de retorno inclui o `Owner` da ACL e a lista de `Grants`.

```
bool AwsDoc::S3::getObjectAcl(const Aws::String &bucketName,
                              const Aws::String &objectKey,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetObjectAclRequest request;
    request.SetBucket(bucketName);
    request.SetKey(objectKey);

    Aws::S3::Model::GetObjectAclOutcome outcome =
            s3Client.GetObjectAcl(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getObjectAcl: "
                  << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        Aws::Vector<Aws::S3::Model::Grant> grants =
                outcome.GetResult().GetGrants();

        for (auto it = grants.begin(); it != grants.end(); it++) {
            std::cout << "For object " << objectKey << ": "
                      << std::endl << std::endl;

            Aws::S3::Model::Grant grant = *it;
            Aws::S3::Model::Grantee grantee = grant.GetGrantee();

            if (grantee.TypeHasBeenSet()) {
                std::cout << "Type:          "
                          << getGranteeTypeString(grantee.GetType()) << std::endl;
            }

            if (grantee.DisplayNameHasBeenSet()) {
                std::cout << "Display name:  "
                          << grantee.GetDisplayName() << std::endl;
            }

            if (grantee.EmailAddressHasBeenSet()) {
                std::cout << "Email address: "
                          << grantee.GetEmailAddress() << std::endl;
            }

            if (grantee.IDHasBeenSet()) {
                std::cout << "ID:            "
                          << grantee.GetID() << std::endl;
            }

            if (grantee.URIHasBeenSet()) {
                std::cout << "URI:           "
                          << grantee.GetURI() << std::endl;
            }

            std::cout << "Permission:    " <<
                      getPermissionString(grant.GetPermission()) <<
                      std::endl << std::endl;
        }
    }

    return outcome.IsSuccess();
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param type: Type enumeration.
 \return String: Human-readable string
*/
Aws::String getGranteeTypeString(const Aws::S3::Model::Type &type) {
    switch (type) {
        case Aws::S3::Model::Type::AmazonCustomerByEmail:
            return "Email address of an AWS account";
        case Aws::S3::Model::Type::CanonicalUser:
            return "Canonical user ID of an AWS account";
        case Aws::S3::Model::Type::Group:
            return "Predefined Amazon S3 group";
        case Aws::S3::Model::Type::NOT_SET:
            return "Not set";
        default:
            return "Type unknown";
    }
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param permission: Permission enumeration.
 \return String: Human-readable string
*/
Aws::String getPermissionString(const Aws::S3::Model::Permission &permission) {
    switch (permission) {
        case Aws::S3::Model::Permission::FULL_CONTROL:
            return "Can read this object's data and its metadata, "
                   "and read/write this object's permissions";
        case Aws::S3::Model::Permission::NOT_SET:
            return "Permission not set";
        case Aws::S3::Model::Permission::READ:
            return "Can read this object's data and its metadata";
        case Aws::S3::Model::Permission::READ_ACP:
            return "Can read this object's permissions";
            // case Aws::S3::Model::Permission::WRITE // Not applicable.
        case Aws::S3::Model::Permission::WRITE_ACP:
            return "Can write this object's permissions";
        default:
            return "Permission unknown";
    }
}
```

A ACL pode ser modificada criando outra ACL ou alterando as concessões especificadas na ACL atual. A ACL atualizada se torna a nova ACL atual transmitindo-a para o método `PutObjectAcl`.

O código a seguir usa a ACL recuperada por `GetObjectAcl` e adiciona uma nova concessão a ela. O usuário ou o beneficiário recebe a permissão READ para o objeto. A ACL modificada é transmitida ao `PutObjectAcl`, tornando-se a nova ACL atual. 

```
bool AwsDoc::S3::putObjectAcl(const Aws::String &bucketName, const Aws::String &objectKey, const Aws::String &ownerID,
                              const Aws::String &granteePermission, const Aws::String &granteeType,
                              const Aws::String &granteeID, const Aws::String &granteeEmailAddress,
                              const Aws::String &granteeURI, const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::Owner owner;
    owner.SetID(ownerID);

    Aws::S3::Model::Grantee grantee;
    grantee.SetType(setGranteeType(granteeType));

    if (!granteeEmailAddress.empty()) {
        grantee.SetEmailAddress(granteeEmailAddress);
    }

    if (!granteeID.empty()) {
        grantee.SetID(granteeID);
    }

    if (!granteeURI.empty()) {
        grantee.SetURI(granteeURI);
    }

    Aws::S3::Model::Grant grant;
    grant.SetGrantee(grantee);
    grant.SetPermission(setGranteePermission(granteePermission));

    Aws::Vector<Aws::S3::Model::Grant> grants;
    grants.push_back(grant);

    Aws::S3::Model::AccessControlPolicy acp;
    acp.SetOwner(owner);
    acp.SetGrants(grants);

    Aws::S3::Model::PutObjectAclRequest request;
    request.SetAccessControlPolicy(acp);
    request.SetBucket(bucketName);
    request.SetKey(objectKey);

    Aws::S3::Model::PutObjectAclOutcome outcome =
            s3Client.PutObjectAcl(request);

    if (!outcome.IsSuccess()) {
        auto error = outcome.GetError();
        std::cerr << "Error: putObjectAcl: " << error.GetExceptionName()
                  << " - " << error.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully added an ACL to the object '" << objectKey
                  << "' in the bucket '" << bucketName << "'." << std::endl;
    }

    return outcome.IsSuccess();
}

//! Routine which converts a human-readable string to a built-in type enumeration.
/*!
 \param access: Human readable string.
 \return Permission: Permission enumeration.
*/
Aws::S3::Model::Permission setGranteePermission(const Aws::String &access) {
    if (access == "FULL_CONTROL")
        return Aws::S3::Model::Permission::FULL_CONTROL;
    if (access == "WRITE")
        return Aws::S3::Model::Permission::WRITE;
    if (access == "READ")
        return Aws::S3::Model::Permission::READ;
    if (access == "WRITE_ACP")
        return Aws::S3::Model::Permission::WRITE_ACP;
    if (access == "READ_ACP")
        return Aws::S3::Model::Permission::READ_ACP;
    return Aws::S3::Model::Permission::NOT_SET;
}

//! Routine which converts a human-readable string to a built-in type enumeration.
/*!
 \param type: Human readable string.
 \return Type: Type enumeration.
*/
Aws::S3::Model::Type setGranteeType(const Aws::String &type) {
    if (type == "Amazon customer by email")
        return Aws::S3::Model::Type::AmazonCustomerByEmail;
    if (type == "Canonical user")
        return Aws::S3::Model::Type::CanonicalUser;
    if (type == "Group")
        return Aws::S3::Model::Type::Group;
    return Aws::S3::Model::Type::NOT_SET;
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_object_acl.cpp).

## Gerenciar a lista de controle de acesso de um bucket
<a name="manage-a-bucket-s-access-control-list"></a>

Na maioria dos casos, o método preferido para definir as permissões de acesso de um bucket é definir uma política de bucket. No entanto, os buckets também comportam listas de controle de acesso para usuários que desejam usá-las.

O gerenciamento de uma lista de controle de acesso para um bucket é idêntico ao usado para um objeto. O método `GetBucketAcl` recupera a ACL atual de um bucket e o `PutBucketAcl` aplica uma nova ACL a ele.

O código a seguir demonstra como recuperar e definir uma ACL de bucket.

```
//! Routine which demonstrates setting the ACL for an S3 bucket.
/*!
  \param bucketName: Name of a bucket.
  \param ownerID: The canonical ID of the bucket owner.
   See https://docs.aws.amazon.com/AmazonS3/latest/userguide/finding-canonical-user-id.html for more information.
  \param granteePermission: The access level to enable for the grantee.
  \param granteeType: The type of grantee.
  \param granteeID: The canonical ID of the grantee.
  \param granteeEmailAddress: The email address associated with the grantee's AWS account.
  \param granteeURI: The URI of a built-in access group.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
*/

bool AwsDoc::S3::getPutBucketAcl(const Aws::String &bucketName,
                                 const Aws::String &ownerID,
                                 const Aws::String &granteePermission,
                                 const Aws::String &granteeType,
                                 const Aws::String &granteeID,
                                 const Aws::String &granteeEmailAddress,
                                 const Aws::String &granteeURI,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    bool result = ::putBucketAcl(bucketName, ownerID, granteePermission, granteeType,
                                 granteeID,
                                 granteeEmailAddress,
                                 granteeURI,
                                 clientConfig);
    if (result) {
        result = ::getBucketAcl(bucketName, clientConfig);
    }

    return result;
}

//! Routine which demonstrates setting the ACL for an S3 bucket.
/*!
  \param bucketName: Name of from bucket.
  \param ownerID: The canonical ID of the bucket owner.
   See https://docs.aws.amazon.com/AmazonS3/latest/userguide/finding-canonical-user-id.html for more information.
  \param granteePermission: The access level to enable for the grantee.
  \param granteeType: The type of grantee.
  \param granteeID: The canonical ID of the grantee.
  \param granteeEmailAddress: The email address associated with the grantee's AWS account.
  \param granteeURI: The URI of a built-in access group.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
*/

bool putBucketAcl(const Aws::String &bucketName,
                  const Aws::String &ownerID,
                  const Aws::String &granteePermission,
                  const Aws::String &granteeType,
                  const Aws::String &granteeID,
                  const Aws::String &granteeEmailAddress,
                  const Aws::String &granteeURI,
                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::Owner owner;
    owner.SetID(ownerID);

    Aws::S3::Model::Grantee grantee;
    grantee.SetType(setGranteeType(granteeType));

    if (!granteeEmailAddress.empty()) {
        grantee.SetEmailAddress(granteeEmailAddress);
    }

    if (!granteeID.empty()) {
        grantee.SetID(granteeID);
    }

    if (!granteeURI.empty()) {
        grantee.SetURI(granteeURI);
    }

    Aws::S3::Model::Grant grant;
    grant.SetGrantee(grantee);
    grant.SetPermission(setGranteePermission(granteePermission));

    Aws::Vector<Aws::S3::Model::Grant> grants;
    grants.push_back(grant);

    Aws::S3::Model::AccessControlPolicy acp;
    acp.SetOwner(owner);
    acp.SetGrants(grants);

    Aws::S3::Model::PutBucketAclRequest request;
    request.SetAccessControlPolicy(acp);
    request.SetBucket(bucketName);

    Aws::S3::Model::PutBucketAclOutcome outcome =
            s3Client.PutBucketAcl(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &error = outcome.GetError();

        std::cerr << "Error: putBucketAcl: " << error.GetExceptionName()
                  << " - " << error.GetMessage() << std::endl;
    } else {
        std::cout << "Successfully added an ACL to the bucket '" << bucketName
                  << "'." << std::endl;
    }

    return outcome.IsSuccess();
}

//! Routine which demonstrates getting the ACL for an S3 bucket.
/*!
  \param bucketName: Name of the s3 bucket.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
*/
bool getBucketAcl(const Aws::String &bucketName,
                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetBucketAclRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::GetBucketAclOutcome outcome =
            s3Client.GetBucketAcl(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getBucketAcl: "
                  << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        const Aws::Vector<Aws::S3::Model::Grant> &grants =
                outcome.GetResult().GetGrants();

        for (const Aws::S3::Model::Grant &grant: grants) {
            const Aws::S3::Model::Grantee &grantee = grant.GetGrantee();

            std::cout << "For bucket " << bucketName << ": "
                      << std::endl << std::endl;

            if (grantee.TypeHasBeenSet()) {
                std::cout << "Type:          "
                          << getGranteeTypeString(grantee.GetType()) << std::endl;
            }

            if (grantee.DisplayNameHasBeenSet()) {
                std::cout << "Display name:  "
                          << grantee.GetDisplayName() << std::endl;
            }

            if (grantee.EmailAddressHasBeenSet()) {
                std::cout << "Email address: "
                          << grantee.GetEmailAddress() << std::endl;
            }

            if (grantee.IDHasBeenSet()) {
                std::cout << "ID:            "
                          << grantee.GetID() << std::endl;
            }

            if (grantee.URIHasBeenSet()) {
                std::cout << "URI:           "
                          << grantee.GetURI() << std::endl;
            }

            std::cout << "Permission:    " <<
                      getPermissionString(grant.GetPermission()) <<
                      std::endl << std::endl;
        }
    }

    return outcome.IsSuccess();
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param permission: Permission enumeration.
 \return String: Human-readable string.
*/

Aws::String getPermissionString(const Aws::S3::Model::Permission &permission) {
    switch (permission) {
        case Aws::S3::Model::Permission::FULL_CONTROL:
            return "Can list objects in this bucket, create/overwrite/delete "
                   "objects in this bucket, and read/write this "
                   "bucket's permissions";
        case Aws::S3::Model::Permission::NOT_SET:
            return "Permission not set";
        case Aws::S3::Model::Permission::READ:
            return "Can list objects in this bucket";
        case Aws::S3::Model::Permission::READ_ACP:
            return "Can read this bucket's permissions";
        case Aws::S3::Model::Permission::WRITE:
            return "Can create, overwrite, and delete objects in this bucket";
        case Aws::S3::Model::Permission::WRITE_ACP:
            return "Can write this bucket's permissions";
        default:
            return "Permission unknown";
    }
}

//! Routine which converts a human-readable string to a built-in type enumeration
/*!
 \param access: Human readable string.
 \return Permission: Permission enumeration.
*/
Aws::S3::Model::Permission setGranteePermission(const Aws::String &access) {
    if (access == "FULL_CONTROL")
        return Aws::S3::Model::Permission::FULL_CONTROL;
    if (access == "WRITE")
        return Aws::S3::Model::Permission::WRITE;
    if (access == "READ")
        return Aws::S3::Model::Permission::READ;
    if (access == "WRITE_ACP")
        return Aws::S3::Model::Permission::WRITE_ACP;
    if (access == "READ_ACP")
        return Aws::S3::Model::Permission::READ_ACP;
    return Aws::S3::Model::Permission::NOT_SET;
}

//! Routine which converts a built-in type enumeration to a human-readable string.
/*!
 \param type: Type enumeration.
 \return bool: Human-readable string.
*/
Aws::String getGranteeTypeString(const Aws::S3::Model::Type &type) {
    switch (type) {
        case Aws::S3::Model::Type::AmazonCustomerByEmail:
            return "Email address of an AWS account";
        case Aws::S3::Model::Type::CanonicalUser:
            return "Canonical user ID of an AWS account";
        case Aws::S3::Model::Type::Group:
            return "Predefined Amazon S3 group";
        case Aws::S3::Model::Type::NOT_SET:
            return "Not set";
        default:
            return "Type unknown";
    }
}

Aws::S3::Model::Type setGranteeType(const Aws::String &type) {
    if (type == "Amazon customer by email")
        return Aws::S3::Model::Type::AmazonCustomerByEmail;
    if (type == "Canonical user")
        return Aws::S3::Model::Type::CanonicalUser;
    if (type == "Group")
        return Aws::S3::Model::Type::Group;
    return Aws::S3::Model::Type::NOT_SET;
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_bucket_acl.cpp).

# Gerenciar o acesso a buckets do Amazon S3 usando políticas de bucket
<a name="examples-s3-bucket-policies"></a>

Você pode definir, acessar ou excluir uma *política de bucket* para gerenciar o acesso aos buckets do Amazon S3.

## Pré-requisitos
<a name="codeExamplePrereq"></a>

Antes de começar, recomendamos que você leia [Getting started using the AWS SDK para C\$1\$1](getting-started.md). 

Baixe o exemplo código de código e crie a solução conforme descrito em [Conceitos básicos dos exemplos de código](getting-started-code-examples.md). 

Para executar os exemplos, o perfil de usuário que seu código usa para fazer as solicitações deve ter as permissões adequadas AWS (para o serviço e a ação). Para obter mais informações, consulte [Fornecimento de AWS credenciais.](credentials.md)

## Definir uma política de bucket
<a name="set-s3-bucket-policy"></a>

Você pode definir a política de bucket para um determinado bucket do S3 chamando a `PutBucketPolicy` função `S3Client`'s e fornecendo a ela o nome do bucket e a representação JSON da política em a. [PutBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_put_bucket_policy_request.html)

 **Código** 

```
//! Build a policy JSON string.
/*!
  \param userArn: Aws user Amazon Resource Name (ARN).
      For more information, see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns.
  \param bucketName: Name of a bucket.
  \return String: Policy as JSON string.
*/

Aws::String getPolicyString(const Aws::String &userArn,
                            const Aws::String &bucketName) {
    return
            "{\n"
            "   \"Version\":\"2012-10-17\",\n"
            "   \"Statement\":[\n"
            "       {\n"
            "           \"Sid\": \"1\",\n"
            "           \"Effect\": \"Allow\",\n"
            "           \"Principal\": {\n"
            "               \"AWS\": \""
            + userArn +
            "\"\n""           },\n"
            "           \"Action\": [ \"s3:getObject\" ],\n"
            "           \"Resource\": [ \"arn:aws:s3:::"
            + bucketName +
            "/*\" ]\n"
            "       }\n"
            "   ]\n"
            "}";
}
```

```
bool AwsDoc::S3::putBucketPolicy(const Aws::String &bucketName,
                                 const Aws::String &policyBody,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    std::shared_ptr<Aws::StringStream> request_body =
            Aws::MakeShared<Aws::StringStream>("");
    *request_body << policyBody;

    Aws::S3::Model::PutBucketPolicyRequest request;
    request.SetBucket(bucketName);
    request.SetBody(request_body);

    Aws::S3::Model::PutBucketPolicyOutcome outcome =
            s3Client.PutBucketPolicy(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: putBucketPolicy: "
                  << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Set the following policy body for the bucket '" <<
                  bucketName << "':" << std::endl << std::endl;
        std::cout << policyBody << std::endl;
    }

    return outcome.IsSuccess();
}
```

**nota**  
A classe de [utilitário Aws: :Utils: :Json:: JsonValue](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_json_1_1_json_value.html) pode ser usada para ajudar você a construir objetos JSON válidos para os quais passar. `PutBucketPolicy`

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_bucket_policy.cpp).

## Obter uma política de bucket
<a name="get-s3-bucket-policy"></a>

Para recuperar a política de um bucket do Amazon S3, chame `S3Client` a função `GetBucketPolicy`'s, passando o nome do bucket em a. [GetBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_bucket_policy_request.html)

 **Código** 

```
bool AwsDoc::S3::getBucketPolicy(const Aws::String &bucketName,
                                 const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetBucketPolicyRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::GetBucketPolicyOutcome outcome =
            s3Client.GetBucketPolicy(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: getBucketPolicy: "
                  << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        Aws::StringStream policy_stream;
        Aws::String line;

        outcome.GetResult().GetPolicy() >> line;
        policy_stream << line;

        std::cout << "Retrieve the policy for bucket '" << bucketName << "':\n\n" <<
                  policy_stream.str() << std::endl;
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_bucket_policy.cpp).

## Excluir uma política de bucket
<a name="delete-s3-bucket-policy"></a>

Para excluir uma política de bucket, chame a `DeleteBucketPolicy` função `S3Client`'s, fornecendo o nome do bucket em [DeleteBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_delete_bucket_policy_request.html)a.

 **Código** 

```
bool AwsDoc::S3::deleteBucketPolicy(const Aws::String &bucketName,
                                    const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::DeleteBucketPolicyRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::DeleteBucketPolicyOutcome outcome = client.DeleteBucketPolicy(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();
        std::cerr << "Error: deleteBucketPolicy: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Policy was deleted from the bucket." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Essa função será bem-sucedida, mesmo se o bucket ainda não tiver uma política. Se você especificar um nome de bucket não existente ou se não tiver acesso ao bucket, um `AmazonServiceException` será lançado.

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket_policy.cpp).

## Mais informações
<a name="more-info"></a>
+  [PutBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/PutBucketPolicy.html)na referência de API do Amazon Simple Storage Service
+  [GetBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/GetBucketPolicy.html)na referência de API do Amazon Simple Storage Service
+  [DeleteBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/DeleteBucketPolicy.html)na referência de API do Amazon Simple Storage Service
+  [Visão geral da linguagem de políticas de acesso](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) no Guia do usuário do Amazon Simple Storage Service
+  [Exemplos de políticas de bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) no Guia do usuário do Amazon Simple Storage Service.

# Configurar um bucket do Amazon S3 como um site
<a name="examples-s3-website-configuration"></a>

É possível configurar um bucket do Amazon S3 para se comportar como um site. Para isso, você precisa definir a configuração do site.

## Pré-requisitos
<a name="codeExamplePrereq"></a>

Antes de começar, recomendamos que você leia [Getting started using the AWS SDK para C\$1\$1](getting-started.md). 

Baixe o exemplo código de código e crie a solução conforme descrito em [Conceitos básicos dos exemplos de código](getting-started-code-examples.md). 

Para executar os exemplos, o perfil de usuário que seu código usa para fazer as solicitações deve ter as permissões adequadas AWS (para o serviço e a ação). Para obter mais informações, consulte [Fornecimento de AWS credenciais.](credentials.md)

## Definir uma configuração do site de um bucket
<a name="set-a-bucket-s-website-configuration"></a>

Para definir a configuração do site de um bucket do Amazon S3, chame a `PutBucketWebsite` função `S3Client`'s com um [PutBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_put_bucket_website_request.html)objeto contendo o nome do bucket e a configuração do site, fornecidos em um [WebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_website_configuration.html)objeto.

Configurar um documento de índice é *obrigatório*; todos os outros parâmetros são opcionais.

 **Código** 

```
bool AwsDoc::S3::putWebsiteConfig(const Aws::String &bucketName,
                                  const Aws::String &indexPage, const Aws::String &errorPage,
                                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);

    Aws::S3::Model::IndexDocument indexDocument;
    indexDocument.SetSuffix(indexPage);

    Aws::S3::Model::ErrorDocument errorDocument;
    errorDocument.SetKey(errorPage);

    Aws::S3::Model::WebsiteConfiguration websiteConfiguration;
    websiteConfiguration.SetIndexDocument(indexDocument);
    websiteConfiguration.SetErrorDocument(errorDocument);

    Aws::S3::Model::PutBucketWebsiteRequest request;
    request.SetBucket(bucketName);
    request.SetWebsiteConfiguration(websiteConfiguration);

    Aws::S3::Model::PutBucketWebsiteOutcome outcome =
            client.PutBucketWebsite(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Error: PutBucketWebsite: "
                  << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Success: Set website configuration for bucket '"
                  << bucketName << "'." << std::endl;
    }

    return outcome.IsSuccess();
}
```

**nota**  
Definir a configuração de um site não modifica as permissões de acesso do bucket. Para tornar os arquivos visíveis na web, você também precisa definir uma *política de bucket* que permite acesso de leitura público aos arquivos no bucket. Para obter mais informações, consulte [Gerenciar acesso aos buckets do Amazon S3 usando políticas de bucket](examples-s3-bucket-policies.md).

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_website_config.cpp).

## Obter uma configuração do site de um bucket
<a name="get-a-bucket-s-website-configuration"></a>

Para obter a configuração do site de um bucket do Amazon S3, chame a `GetBucketWebsite` função `S3Client`'s [GetBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_bucket_website_request.html)contendo o nome do bucket para o qual recuperar a configuração.

A configuração será retornada como um [GetBucketWebsiteResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_get_bucket_website_result.html)objeto dentro do objeto de resultado. Se não houver configuração de site para o bucket, `null` será retornado.

 **Código** 

```
bool AwsDoc::S3::getWebsiteConfig(const Aws::String &bucketName,
                                  const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client s3Client(clientConfig);

    Aws::S3::Model::GetBucketWebsiteRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::GetBucketWebsiteOutcome outcome =
            s3Client.GetBucketWebsite(request);

    if (!outcome.IsSuccess()) {
        const Aws::S3::S3Error &err = outcome.GetError();

        std::cerr << "Error: GetBucketWebsite: "
                  << err.GetMessage() << std::endl;
    } else {
        Aws::S3::Model::GetBucketWebsiteResult websiteResult = outcome.GetResult();

        std::cout << "Success: GetBucketWebsite: "
                  << std::endl << std::endl
                  << "For bucket '" << bucketName << "':"
                  << std::endl
                  << "Index page : "
                  << websiteResult.GetIndexDocument().GetSuffix()
                  << std::endl
                  << "Error page: "
                  << websiteResult.GetErrorDocument().GetKey()
                  << std::endl;
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_website_config.cpp).

## Excluir uma configuração do site de um bucket
<a name="delete-a-bucket-s-website-configuration"></a>

Para excluir a configuração do site de um bucket do Amazon S3, chame a `DeleteBucketWebsite` função `S3Client`'s com um [DeleteBucketWebsiteRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3/html/class_aws_1_1_s3_1_1_model_1_1_delete_bucket_website_request.html): contendo o nome do bucket do qual excluir a configuração.

 **Código** 

```
bool AwsDoc::S3::deleteBucketWebsite(const Aws::String &bucketName,
                                     const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::DeleteBucketWebsiteRequest request;
    request.SetBucket(bucketName);

    Aws::S3::Model::DeleteBucketWebsiteOutcome outcome =
            client.DeleteBucketWebsite(request);

    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: deleteBucketWebsite: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Website configuration was removed." << std::endl;
    }

    return outcome.IsSuccess();
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_website_config.cpp).

## Mais informações
<a name="more-information"></a>
+  [PUT Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) na Referência de API do Amazon Simple Storage Service.
+  [GET Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) na Referência de API do Amazon Simple Storage Service.
+  [DELETE Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) na Referência de API do Amazon Simple Storage Service.

# Usando TransferManager para operações do Amazon S3
<a name="examples-s3-transfermanager"></a>

Você pode usar a AWS SDK para C\$1\$1 `TransferManager` classe para transferir arquivos de forma confiável do ambiente local para o Amazon S3 e copiar objetos de um local do Amazon S3 para outro. `TransferManager`pode obter o progresso de uma transferência e pausar ou retomar carregamentos e downloads.

**nota**  
Para evitar a cobrança por uploads incompletos ou parciais, recomendamos que você habilite a regra de [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo de vida em seus buckets do Amazon S3.  
Essa regra faz com que o Amazon S3 anule multipart uploads que não sejam concluídos em um número específico de dias depois de serem iniciados. Quando o limite de tempo definido é excedido, o Amazon S3 anula o upload e exclui os dados de uploads incompletos.   
Para acessar mais informações, consulte [Definir configuração do ciclo de vida em bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) no Guia do usuário do Amazon S3.

## Pré-requisitos
<a name="codeExamplePrereq"></a>

Antes de começar, recomendamos que você leia [Getting started using the AWS SDK para C\$1\$1](getting-started.md). 

Baixe o exemplo código de código e crie a solução conforme descrito em [Conceitos básicos dos exemplos de código](getting-started-code-examples.md). 

Para executar os exemplos, o perfil de usuário que seu código usa para fazer as solicitações deve ter as permissões adequadas AWS (para o serviço e a ação). Para obter mais informações, consulte [Fornecimento de AWS credenciais.](credentials.md)

## Upload e download de um objeto usando `TransferManager`
<a name="stream"></a>

Este exemplo demonstra como o [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/class_aws_1_1_transfer_1_1_transfer_manager.html) transfere objetos grandes na memória. Os métodos `UploadFile` e `DownloadFile` são chamados de forma assíncrona e exibem o `TransferHandle` para gerenciar o status da sua solicitação. Se o objeto do qual foi feito upload for maior que `bufferSize`, será realizado um multipart upload. O `bufferSize` tem como padrão 5 MB, mas isso pode ser configurado por [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/struct_aws_1_1_transfer_1_1_transfer_manager_configuration.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-transfer/html/struct_aws_1_1_transfer_1_1_transfer_manager_configuration.html). 

```
        auto s3_client = Aws::MakeShared<Aws::S3::S3Client>("S3Client");
        auto executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 25);
        Aws::Transfer::TransferManagerConfiguration transfer_config(executor.get());
        transfer_config.s3Client = s3_client;

        // Create buffer to hold data received by the data stream.
        Aws::Utils::Array<unsigned char> buffer(BUFFER_SIZE);

        // The local variable 'streamBuffer' is captured by reference in a lambda.
        // It must persist until all downloading by the 'transfer_manager' is complete.
        Stream::PreallocatedStreamBuf streamBuffer(buffer.GetUnderlyingData(), buffer.GetLength());

        auto transfer_manager = Aws::Transfer::TransferManager::Create(transfer_config);

        auto uploadHandle = transfer_manager->UploadFile(LOCAL_FILE, BUCKET, KEY, "text/plain", Aws::Map<Aws::String, Aws::String>());
        uploadHandle->WaitUntilFinished();
        bool success = uploadHandle->GetStatus() == Transfer::TransferStatus::COMPLETED; 
      
        if (!success)
        {
            auto err = uploadHandle->GetLastError();           
            std::cout << "File upload failed:  "<< err.GetMessage() << std::endl;
        }
        else
        {
            std::cout << "File upload finished." << std::endl;

            auto downloadHandle = transfer_manager->DownloadFile(BUCKET,
                KEY,
                [&]() { //Define a lambda expression for the callback method parameter to stream back the data.
                    return Aws::New<MyUnderlyingStream>("TestTag", &streamBuffer);
                });
            downloadHandle->WaitUntilFinished();// Block calling thread until download is complete.
            auto downStat = downloadHandle->GetStatus();
            if (downStat != Transfer::TransferStatus::COMPLETED)
            {
                auto err = downloadHandle->GetLastError();
                std::cout << "File download failed:  " << err.GetMessage() << std::endl;
            }
            std::cout << "File download to memory finished."  << std::endl;
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/transferOnStream.cpp).

# Usar o `S3CrtClient` para operações do Amazon S3
<a name="examples-s3-crt"></a>

A `S3CrtClient` classe está disponível na versão 1.9 do AWS SDK para C\$1\$1 e melhora a taxa de transferência de upload e download de grandes arquivos de dados de e para o Amazon S3. Para obter mais informações sobre as melhorias desta versão, consulte [Melhorando a taxa de transferência do Amazon S3](https://github.com/aws/aws-sdk-cpp/wiki/Improving-S3-Throughput-with-AWS-SDK-for-CPP-v1.9) com a versão 1.9 AWS SDK para C\$1\$1 

O `S3CrtClient` é implementado na parte superior das [bibliotecas do AWS Common Runtime (CRT)](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html).

**nota**  
Para evitar a cobrança por uploads incompletos ou parciais, recomendamos que você habilite a regra de [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo de vida em seus buckets do Amazon S3.  
Essa regra faz com que o Amazon S3 anule multipart uploads que não sejam concluídos em um número específico de dias depois de serem iniciados. Quando o limite de tempo definido é excedido, o Amazon S3 anula o upload e exclui os dados de uploads incompletos.   
Para acessar mais informações, consulte [Definir configuração do ciclo de vida em bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) no Guia do usuário do Amazon S3.

## Pré-requisitos
<a name="codeExamplePrereq"></a>

Antes de começar, recomendamos que você leia [Getting started using the AWS SDK para C\$1\$1](getting-started.md). 

Baixe o exemplo código de código e crie a solução conforme descrito em [Conceitos básicos dos exemplos de código](getting-started-code-examples.md). 

Para executar os exemplos, o perfil de usuário que seu código usa para fazer as solicitações deve ter as permissões adequadas AWS (para o serviço e a ação). Para obter mais informações, consulte [Fornecimento de AWS credenciais.](credentials.md)

## Upload e download de um objeto usando `S3CrtClient`
<a name="stream"></a>

Este exemplo demonstra como usar o [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-s3-crt/html/class_aws_1_1_s3_crt_1_1_s3_crt_client.html). O exemplo cria um bucket, faz upload de um objeto, baixa o objeto e, depois, exclui o arquivo e o bucket. Uma operação PUT se transforma em um multipart upload. Uma operação GET se transforma em várias solicitações GET “no intervalo”. Para acessar mais informações sobre multipart uploads, consulte [Carregar e copiar objetos usando upload fracionado](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) no Guia do usuário do Amazon S3. 

É feito upload do arquivo de dados fornecido, `ny.json`, como um multipart upload neste exemplo. Isso pode ser confirmado visualizando os logs de depuração após uma execução bem-sucedida do programa.

Se o upload falhar, um `AbortMultipartUpload` será emitido na biblioteca CRT subjacente para limpar todas as partes das quais já foi feito upload. No entanto, nem todas as falhas podem ser tratadas internamente (como um cabo de rede que foi desconectado). É recomendável criar uma regra de ciclo de vida em seu bucket do Amazon S3 para garantir que os dados cujo upload foi feito parcialmente não permaneçam na sua conta (esses dados ainda podem ser faturados). Para saber mais sobre como configurar uma regra de ciclo de vida, consulte [Descobrir e excluir multipart uploads incompletos para reduzir os custos do Amazon S3](https://aws.amazon.com/blogs/aws-cost-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/ ). 

**Usar o log de depuração para explorar detalhes de multipart upload**

1. Em `main()`, observe que há comentários “TODO“ com instruções para atualizar o código.

   1. Para `file_name`: no link fornecido no comentário do código, baixe o arquivo de dados de exemplo `ny.json` ou use seu próprio arquivo de dados grande.

   1. Para`region`: Atualize a `region` variável, usando a enumeração, para a Região da AWS da sua conta. Para encontrar a região da sua conta, faça login no Console de gerenciamento da AWS e localize a região no canto superior direito.

1. Compile o exemplo.

1. Copie o arquivo especificado pela variável `file_name` na sua pasta do executável e utilize o executável `s3-crt-demo`.

1. Na sua pasta do executável, encontre o arquivo `.log` mais recente.

1. Abra o arquivo de log, selecione **pesquisar** e digite **partNumber**.

1. O log contém entradas semelhantes às seguintes, nas quais `partNumber` e `uploadId` são especificadas para cada parte do arquivo do qual foi feito upload:

    `PUT /my-object partNumber=1&uploadId=gsk8vDbmnlA5EseDo._LDEgq22Qmt0SeuszYxMsZ9ABt503VqDIFOP8xzZI1P0zp.ToS.qo5kK16HNWogZF3KpRo.Dc7QnLZIK0BTmzCWwWoPax4T21hvP6nPdz9591F content-length:8388608 host:my-bucketasdfasdf.s3.us-east-2.amazonaws.com x-amz-content-sha256:UNSIGNED-PAYLOAD`

    and 

    `PUT /my-object partNumber=2&uploadId=gsk8vDbmnlA5EseDo._LDEgq22Qmt0SeuszYxMsZ9ABt503VqDIFOP8xzZI1P0zp.ToS.qo5kK16HNWogZF3KpRo.Dc7QnLZIK0BTmzCWwWoPax4T21hvP6nPdz9591F content-length:8388608 host:my-bucketasdfasdf.s3.us-east-2.amazonaws.com x-amz-content-sha256:UNSIGNED-PAYLOAD `

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/s3-crt-demo.cpp).