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 guiados para chamadas Serviços da AWS usando o AWS SDK para C\$1\$1
<a name="programming-services"></a>

Se você não conhece AWS ou conhece os exemplos de AWS código, recomendamos que comece com[Conceitos básicos dos exemplos de código](getting-started-code-examples.md).

O código-fonte que mostra como trabalhar com AWS serviços usando o AWS SDK para C\$1\$1 está disponível no [Exemplos de código](cpp_code_examples.md) capítulo deste guia ou diretamente no [Repositório de exemplos de AWS código](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) em GitHub. 

Esta seção seleciona vários AWS serviços e orienta você pelos exemplos de uso deles. Os exemplos guiados a seguir são um subconjunto do que está disponível no Github.


**Exemplos de serviços com explicação adicional (consulte o [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) para ver a lista completa)**  

| Serviço | Resumo do que o serviço fornece ao seu programa | 
| --- | --- | 
| [Amazon CloudWatch](examples-cloudwatch.md) | Coleta e monitora métricas AWS dos recursos que você está usando | 
| [Amazon DynamoDB](examples-dynamodb.md) | Serviço de banco de dados NoSQL | 
| [Amazon Elastic Compute Cloud (Amazon EC2)](examples-ec2.md) | Capacidade computacional segura e redimensionável. | 
| [Amazon Simple Storage Service (Amazon S3)](examples-s3.md) | Armazenamento e recuperação de dados (objetos em buckets). | 
| [Amazon Simple Queue Service (Amazon SQS)](examples-sqs.md) | Serviço de enfileiramento de mensagens para enviar, armazenar e receber mensagens entre componentes de software. | 

Também há exemplos que mostram como usar [métodos assíncronos](async-methods.md).

Para propor um novo exemplo de código para a equipe de AWS documentação, consulte [Diretrizes de contribuição](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/CONTRIBUTING.md) GitHub para criar uma nova solicitação. A equipe prefere criar exemplos de código que mostrem cenários amplos em vez de chamadas de API individuais.

**Usar os exemplos de código no Windows**

Se você estiver criando os exemplos no Windows com o SDK versão 1.9, consulte [Solução de problemas de compilação do AWS SDK for C\$1\$1](troubleshooting-cmake.md).

# CloudWatch Exemplos da Amazon usando o AWS SDK para C\$1\$1
<a name="examples-cloudwatch"></a>

A Amazon CloudWatch (CloudWatch) é um serviço de monitoramento dos recursos da AWS nuvem e dos aplicativos em que você executa AWS. Você pode usar os exemplos a seguir para programar [CloudWatch](https://aws.amazon.com/cloudwatch)usando AWS SDK para C\$1\$1 o.

A Amazon CloudWatch monitora seus AWS recursos e os aplicativos em que você executa AWS em tempo real. Você pode usar CloudWatch para coletar e monitorar métricas, que são variáveis que você pode medir para seus recursos e aplicativos. CloudWatchos alarmes enviam notificações ou fazem alterações automaticamente nos recursos que você está monitorando com base nas regras definidas por você.

Para obter mais informações sobre CloudWatch, consulte o [Guia CloudWatch do usuário da Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/).

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

**Topics**
+ [Obtendo métricas de CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Publicar dados de métrica personalizada](examples-cloudwatch-publish-custom-metrics.md)
+ [Trabalhando com CloudWatch alarmes](examples-cloudwatch-create-alarms.md)
+ [Usando ações de alarme em CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Enviando eventos para CloudWatch](examples-cloudwatch-send-events.md)

# Obtendo métricas de CloudWatch
<a name="examples-cloudwatch-get-metrics"></a>

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

## Listar métricas
<a name="listing-metrics"></a>

Para listar CloudWatch as métricas, crie uma `ListMetrics` função [ListMetricsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_list_metrics_request.html)e chame a CloudWatchClient. Você pode usar o `ListMetricsRequest` para filtrar as métricas retornadas por namespace, nome da métrica ou dimensões.

**nota**  
Uma lista de métricas e dimensões publicadas por AWS serviços pode ser encontrada na [Referência de CloudWatch métricas e dimensões da Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CW_Support_For_AWS.html) no Guia do CloudWatch usuário da Amazon.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/ListMetricsRequest.h>
#include <aws/monitoring/model/ListMetricsResult.h>
#include <iomanip>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::ListMetricsRequest request;

        if (argc > 1)
        {
            request.SetMetricName(argv[1]);
        }

        if (argc > 2)
        {
            request.SetNamespace(argv[2]);
        }

        bool done = false;
        bool header = false;
        while (!done)
        {
            auto outcome = cw.ListMetrics(request);
            if (!outcome.IsSuccess())
            {
                std::cout << "Failed to list CloudWatch metrics:" <<
                    outcome.GetError().GetMessage() << std::endl;
                break;
            }

            if (!header)
            {
                std::cout << std::left << std::setw(48) << "MetricName" <<
                    std::setw(32) << "Namespace" << "DimensionNameValuePairs" <<
                    std::endl;
                header = true;
            }

            const auto &metrics = outcome.GetResult().GetMetrics();
            for (const auto &metric : metrics)
            {
                std::cout << std::left << std::setw(48) <<
                    metric.GetMetricName() << std::setw(32) <<
                    metric.GetNamespace();
                const auto &dimensions = metric.GetDimensions();
                for (auto iter = dimensions.cbegin();
                    iter != dimensions.cend(); ++iter)
                {
                    const auto &dimkv = *iter;
                    std::cout << dimkv.GetName() << " = " << dimkv.GetValue();
                    if (iter + 1 != dimensions.cend())
                    {
                        std::cout << ", ";
                    }
                }
                std::cout << std::endl;
            }

            const auto &next_token = outcome.GetResult().GetNextToken();
            request.SetNextToken(next_token);
            done = next_token.empty();
        }
```

As métricas são retornadas em a [ListMetricsResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_list_metrics_result.html)chamando sua `GetMetrics` função. Os resultados podem ser *paginados*. Para recuperar o próximo lote de resultados, chame `SetNextToken` no objeto de solicitação original com o valor de retorno da função `GetNextToken` do objeto `ListMetricsResult` e transmita o objeto de solicitação modificado para outra chamada de `ListMetrics`.

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/list_metrics.cpp).

## Mais informações
<a name="more-information"></a>
+  [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/ListMetrics.html)na Amazon CloudWatch API Reference.

# Publicar dados de métrica personalizada
<a name="examples-cloudwatch-publish-custom-metrics"></a>

Vários AWS serviços [publicam suas próprias métricas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) em namespaces começando com `AWS/` Você também pode publicar dados métricos personalizados usando seu próprio namespace (desde que não comece com). `AWS/`

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

## Publicar dados de métrica personalizada
<a name="publish-custom-metric-data"></a>

Para publicar seus próprios dados métricos, chame a `PutMetricData` função CloudWatchClient's com [PutMetricDataRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_put_metric_data_request.html)a. Eles `PutMetricDataRequest` devem incluir o namespace personalizado a ser usado para os dados e informações sobre o próprio ponto de dados em um [MetricDatum](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_metric_datum.html)objeto.

**nota**  
Você não pode especificar um namespace que comece com. `AWS/` Namespaces que começam com `AWS/` são reservados para serem usados por produtos da Amazon Web Services.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/PutMetricDataRequest.h>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatch::CloudWatchClient cw;

        Aws::CloudWatch::Model::Dimension dimension;
        dimension.SetName("UNIQUE_PAGES");
        dimension.SetValue("URLS");

        Aws::CloudWatch::Model::MetricDatum datum;
        datum.SetMetricName("PAGES_VISITED");
        datum.SetUnit(Aws::CloudWatch::Model::StandardUnit::None);
        datum.SetValue(data_point);
        datum.AddDimensions(dimension);

        Aws::CloudWatch::Model::PutMetricDataRequest request;
        request.SetNamespace("SITE/TRAFFIC");
        request.AddMetricData(datum);

        auto outcome = cw.PutMetricData(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to put sample metric data:" <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully put sample metric data" << std::endl;
        }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/put_metric_data.cpp).

## Mais informações
<a name="more-information"></a>
+  [Usando o Amazon CloudWatch Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) no Guia CloudWatch do usuário da Amazon.
+  [AWS Namespaces](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) no Guia do CloudWatch usuário da Amazon.
+  [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricData.html)na Amazon CloudWatch API Reference.

# Trabalhando com CloudWatch alarmes
<a name="examples-cloudwatch-create-alarms"></a>

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

## Criar um alarme
<a name="create-an-alarm"></a>

Para criar um alarme com base em uma CloudWatch métrica, chame a `PutMetricAlarm` função CloudWatchClient's [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_put_metric_alarm_request.html)preenchendo as condições do alarme.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/PutMetricAlarmRequest.h>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::PutMetricAlarmRequest request;
        request.SetAlarmName(alarm_name);
        request.SetComparisonOperator(
            Aws::CloudWatch::Model::ComparisonOperator::GreaterThanThreshold);
        request.SetEvaluationPeriods(1);
        request.SetMetricName("CPUUtilization");
        request.SetNamespace("AWS/EC2");
        request.SetPeriod(60);
        request.SetStatistic(Aws::CloudWatch::Model::Statistic::Average);
        request.SetThreshold(70.0);
        request.SetActionsEnabled(false);
        request.SetAlarmDescription("Alarm when server CPU exceeds 70%");
        request.SetUnit(Aws::CloudWatch::Model::StandardUnit::Seconds);

        Aws::CloudWatch::Model::Dimension dimension;
        dimension.SetName("InstanceId");
        dimension.SetValue(instanceId);

        request.AddDimensions(dimension);

        auto outcome = cw.PutMetricAlarm(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to create CloudWatch alarm:" <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully created CloudWatch alarm " << alarm_name
                << std::endl;
        }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/put_metric_alarm.cpp).

## Listar alarmes
<a name="list-alarms"></a>

Para listar os CloudWatch alarmes que você criou, chame a `DescribeAlarms` função CloudWatchClient's com uma [DescribeAlarmsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_describe_alarms_request.html)que você pode usar para definir opções para o resultado.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/DescribeAlarmsRequest.h>
#include <aws/monitoring/model/DescribeAlarmsResult.h>
#include <iomanip>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::DescribeAlarmsRequest request;
        request.SetMaxRecords(1);

        bool done = false;
        bool header = false;
        while (!done)
        {
            auto outcome = cw.DescribeAlarms(request);
            if (!outcome.IsSuccess())
            {
                std::cout << "Failed to describe CloudWatch alarms:" <<
                    outcome.GetError().GetMessage() << std::endl;
                break;
            }

            if (!header)
            {
                std::cout << std::left <<
                    std::setw(32) << "Name" <<
                    std::setw(64) << "Arn" <<
                    std::setw(64) << "Description" <<
                    std::setw(20) << "LastUpdated" <<
                    std::endl;
                header = true;
            }

            const auto &alarms = outcome.GetResult().GetMetricAlarms();
            for (const auto &alarm : alarms)
            {
                std::cout << std::left <<
                    std::setw(32) << alarm.GetAlarmName() <<
                    std::setw(64) << alarm.GetAlarmArn() <<
                    std::setw(64) << alarm.GetAlarmDescription() <<
                    std::setw(20) <<
                    alarm.GetAlarmConfigurationUpdatedTimestamp().ToGmtString(
                        SIMPLE_DATE_FORMAT_STR) <<
                    std::endl;
            }

            const auto &next_token = outcome.GetResult().GetNextToken();
            request.SetNextToken(next_token);
            done = next_token.empty();
        }
```

A lista de alarmes pode ser obtida `getMetricAlarms` chamando o [DescribeAlarmsResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_describe_alarms_result.html)que é retornado por`DescribeAlarms`.

Os resultados podem ser *paginados*. Para recuperar o próximo lote de resultados, chame `SetNextToken` no objeto de solicitação original com o valor de retorno da função `GetNextToken` do objeto `DescribeAlarmsResult` e transmita o objeto de solicitação modificado para outra chamada de `DescribeAlarms`.

**nota**  
Você também pode recuperar alarmes para uma métrica específica usando a função CloudWatchClient's`DescribeAlarmsForMetric`. O uso é semelhante a `DescribeAlarms`.

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/describe_alarms.cpp).

## Excluir alarmes
<a name="delete-alarms"></a>

Para excluir CloudWatch alarmes, chame a `DeleteAlarms` função CloudWatchClient's [DeleteAlarmsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_delete_alarms_request.html)contendo um ou mais nomes de alarmes que você deseja excluir.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/DeleteAlarmsRequest.h>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatch::CloudWatchClient cw;
        Aws::CloudWatch::Model::DeleteAlarmsRequest request;
        request.AddAlarmNames(alarm_name);

        auto outcome = cw.DeleteAlarms(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to delete CloudWatch alarm:" <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully deleted CloudWatch alarm " << alarm_name
                << std::endl;
        }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/delete_alarm.cpp).

## Mais informações
<a name="more-information"></a>
+  [Criação de CloudWatch alarmes da Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) no Guia do CloudWatch usuário da Amazon
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)na Amazon CloudWatch API Reference
+  [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DescribeAlarms.html)na Amazon CloudWatch API Reference
+  [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DeleteAlarms.html)na Amazon CloudWatch API Reference

# Usando ações de alarme em CloudWatch
<a name="examples-cloudwatch-use-alarm-actions"></a>

Usando ações de CloudWatch alarme, você pode criar alarmes que executam ações como parar, encerrar, reiniciar ou recuperar automaticamente instâncias do Amazon EC2.

As ações de alarme podem ser adicionadas a um alarme usando a `SetAlarmActions` função [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_put_metric_alarm_request.html)'s ao [criar um alarme](examples-cloudwatch-create-alarms.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)

## Habilitar ações de alarme
<a name="enable-alarm-actions"></a>

Para habilitar ações de CloudWatch alarme para um alarme, chame o CloudWatchClient s [EnableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_enable_alarm_actions_request.html)contendo um ou mais nomes de alarmes cujas ações você deseja ativar. `EnableAlarmActions`

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/EnableAlarmActionsRequest.h>
#include <aws/monitoring/model/PutMetricAlarmRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::CloudWatch::CloudWatchClient cw;
    Aws::CloudWatch::Model::PutMetricAlarmRequest request;
    request.SetAlarmName(alarm_name);
    request.SetComparisonOperator(
        Aws::CloudWatch::Model::ComparisonOperator::GreaterThanThreshold);
    request.SetEvaluationPeriods(1);
    request.SetMetricName("CPUUtilization");
    request.SetNamespace("AWS/EC2");
    request.SetPeriod(60);
    request.SetStatistic(Aws::CloudWatch::Model::Statistic::Average);
    request.SetThreshold(70.0);
    request.SetActionsEnabled(false);
    request.SetAlarmDescription("Alarm when server CPU exceeds 70%");
    request.SetUnit(Aws::CloudWatch::Model::StandardUnit::Seconds);
    request.AddAlarmActions(actionArn);

    Aws::CloudWatch::Model::Dimension dimension;
    dimension.SetName("InstanceId");
    dimension.SetValue(instanceId);
    request.AddDimensions(dimension);

    auto outcome = cw.PutMetricAlarm(request);
    if (!outcome.IsSuccess())
    {
        std::cout << "Failed to create CloudWatch alarm:" <<
            outcome.GetError().GetMessage() << std::endl;
        return;
    }

    Aws::CloudWatch::Model::EnableAlarmActionsRequest enable_request;
    enable_request.AddAlarmNames(alarm_name);

    auto enable_outcome = cw.EnableAlarmActions(enable_request);
    if (!enable_outcome.IsSuccess())
    {
        std::cout << "Failed to enable alarm actions:" <<
            enable_outcome.GetError().GetMessage() << std::endl;
        return;
    }

    std::cout << "Successfully created alarm " << alarm_name <<
        " and enabled actions on it." << std::endl;
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/enable_alarm_actions.cpp).

## Desabilitar ações de alarme
<a name="disable-alarm-actions"></a>

Para desativar as ações de CloudWatch alarme de um alarme, chame o CloudWatchClient s [DisableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-monitoring/html/class_aws_1_1_cloud_watch_1_1_model_1_1_disable_alarm_actions_request.html)contendo um ou mais nomes de alarmes cujas ações você deseja desativar. `DisableAlarmActions`

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/monitoring/CloudWatchClient.h>
#include <aws/monitoring/model/DisableAlarmActionsRequest.h>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatch::CloudWatchClient cw;

        Aws::CloudWatch::Model::DisableAlarmActionsRequest disableAlarmActionsRequest;
        disableAlarmActionsRequest.AddAlarmNames(alarm_name);

        auto disableAlarmActionsOutcome = cw.DisableAlarmActions(disableAlarmActionsRequest);
        if (!disableAlarmActionsOutcome.IsSuccess())
        {
            std::cout << "Failed to disable actions for alarm " << alarm_name <<
                ": " << disableAlarmActionsOutcome.GetError().GetMessage() <<
                std::endl;
        }
        else
        {
            std::cout << "Successfully disabled actions for alarm " <<
                alarm_name << std::endl;
        }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/disable_alarm_actions.cpp).

## Mais informações
<a name="more-information"></a>
+  [Crie alarmes para parar, encerrar, reinicializar ou recuperar uma instância no Guia do usuário](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) da Amazon CloudWatch 
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)na Amazon CloudWatch API Reference
+  [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/EnableAlarmActions.html)na Amazon CloudWatch API Reference
+  [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DisableAlarmActions.html)na Amazon CloudWatch API Reference

# Enviando eventos para CloudWatch
<a name="examples-cloudwatch-send-events"></a>

CloudWatch O Events fornece um fluxo quase em tempo real de eventos do sistema que descrevem mudanças nos AWS recursos das instâncias do Amazon EC2, funções Lambda, streams do Kinesis, tarefas do Amazon ECS, máquinas de estado do Step Functions, tópicos do Amazon SNS, filas do Amazon SQS ou destinos integrados. Você pode comparar eventos e roteá-los para um ou mais fluxos ou funções de destino usando regras simples.

**nota**  
[Esses trechos de código pressupõem que você compreenda o material em [Introdução ao uso do AWS SDK para C\$1\$1 e tenha configurado as](getting-started.md)AWS credenciais padrão usando as informações em Fornecimento de credenciais. AWS](credentials.md)

## Adicionar eventos
<a name="add-events"></a>

Para adicionar CloudWatch eventos personalizados, chame a `PutEvents` função CloudWatchEventsClient's com um [PutEventsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_events_request.html)objeto que contém um ou mais [PutEventsRequestEntry](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_events_request_entry.html)objetos que fornecem detalhes sobre cada evento. Você pode especificar vários parâmetros para a entrada, como a origem e o tipo do evento, recursos associados ao evento e assim por diante.

**nota**  
Você pode especificar um máximo de dez eventos por chamada para `putEvents`.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/events/EventBridgeClient.h>
#include <aws/events/model/PutEventsRequest.h>
#include <aws/events/model/PutEventsResult.h>
#include <aws/core/utils/Outcome.h>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatchEvents::EventBridgeClient cwe;

        Aws::CloudWatchEvents::Model::PutEventsRequestEntry event_entry;
        event_entry.SetDetail(MakeDetails(event_key, event_value));
        event_entry.SetDetailType("sampleSubmitted");
        event_entry.AddResources(resource_arn);
        event_entry.SetSource("aws-sdk-cpp-cloudwatch-example");

        Aws::CloudWatchEvents::Model::PutEventsRequest request;
        request.AddEntries(event_entry);

        auto outcome = cwe.PutEvents(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to post CloudWatch event: " <<
                outcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout << "Successfully posted CloudWatch event" << std::endl;
        }
```

## Adicionar regras
<a name="add-rules"></a>

Para criar ou atualizar uma regra, chame a `PutRule` função CloudWatchEventsClient's com a [PutRuleRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_rule_request.html)com o nome da regra e parâmetros opcionais, como o [padrão do evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), a função do IAM a ser associada à regra e uma [expressão de agendamento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) que descreva a frequência com que a regra é executada.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/events/EventBridgeClient.h>
#include <aws/events/model/PutRuleRequest.h>
#include <aws/events/model/PutRuleResult.h>
#include <aws/core/utils/Outcome.h>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatchEvents::EventBridgeClient cwe;
        Aws::CloudWatchEvents::Model::PutRuleRequest request;
        request.SetName(rule_name);
        request.SetRoleArn(role_arn);
        request.SetScheduleExpression("rate(5 minutes)");
        request.SetState(Aws::CloudWatchEvents::Model::RuleState::ENABLED);

        auto outcome = cwe.PutRule(request);
        if (!outcome.IsSuccess())
        {
            std::cout << "Failed to create CloudWatch events rule " <<
                rule_name << ": " << outcome.GetError().GetMessage() <<
                std::endl;
        }
        else
        {
            std::cout << "Successfully created CloudWatch events rule " <<
                rule_name << " with resulting Arn " <<
                outcome.GetResult().GetRuleArn() << std::endl;
        }
```

## Adicionar destinos
<a name="add-targets"></a>

Destinos são os recursos invocados quando uma regra é disparada. Os exemplos de destino incluem instâncias do Amazon EC2, funções do Lambda, fluxos do Kinesis, tarefas do Amazon ECS, máquinas de estado do Step Functions e destinos integrados.

Para adicionar um alvo a uma regra, chame a `PutTargets` função CloudWatchEventsClient's [PutTargetsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-eventbridge/html/class_aws_1_1_event_bridge_1_1_model_1_1_put_targets_request.html)contendo a regra a ser atualizada e uma lista de destinos a serem adicionados à regra.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/events/EventBridgeClient.h>
#include <aws/events/model/PutTargetsRequest.h>
#include <aws/events/model/PutTargetsResult.h>
#include <aws/core/utils/Outcome.h>
#include <iostream>
```

 **Código** 

```
        Aws::CloudWatchEvents::EventBridgeClient cwe;

        Aws::CloudWatchEvents::Model::Target target;
        target.SetArn(lambda_arn);
        target.SetId(target_id);

        Aws::CloudWatchEvents::Model::PutTargetsRequest request;
        request.SetRule(rule_name);
        request.AddTargets(target);

        auto putTargetsOutcome = cwe.PutTargets(request);
        if (!putTargetsOutcome.IsSuccess())
        {
            std::cout << "Failed to create CloudWatch events target for rule "
                << rule_name << ": " <<
                putTargetsOutcome.GetError().GetMessage() << std::endl;
        }
        else
        {
            std::cout <<
                "Successfully created CloudWatch events target for rule "
                << rule_name << std::endl;
        }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/eventbridge/put_targets.cpp).

## Mais informações
<a name="more-information"></a>
+  [Adicionar eventos ao](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) Guia PutEvents do usuário do Amazon CloudWatch Events
+  [Agende expressões para regras](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) no Guia do usuário do Amazon CloudWatch Events
+  [Tipos de CloudWatch eventos para eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) no Guia do usuário do Amazon CloudWatch Events
+  [Eventos e padrões de eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) no Guia do usuário do Amazon CloudWatch Events
+  [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutEvents.html)na referência da API de CloudWatch eventos da Amazon
+  [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutTargets.html)na referência da API de CloudWatch eventos da Amazon
+  [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutRule.html)na referência da API de CloudWatch eventos da Amazon

# Exemplos do Amazon DynamoDB usando o AWS SDK para C\$1\$1
<a name="examples-dynamodb"></a>

O Amazon DynamoDB é um serviço de banco de dados NoSQL totalmente gerenciado que fornece uma performance rápida e previsível com escalabilidade integrada. Os exemplos a seguir mostram como programar o [Amazon DynamoDB](https://aws.amazon.com/dynamodb) usando o AWS SDK para C\$1\$1.

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

**Topics**
+ [Trabalhar com tabelas no DynamoDB](examples-dynamodb-tables.md)
+ [Trabalhar com itens no DynamoDB](examples-dynamodb-items.md)

# Trabalhar com tabelas no DynamoDB
<a name="examples-dynamodb-tables"></a>

Tabelas são os contêineres de todos os itens em um banco de dados do DynamoDB. Para adicionar ou remover dados do DynamoDB, você deve criar uma tabela.

Para cada tabela, você deve definir:
+ Um *nome* de tabela exclusivo para seu Conta da AWS Região da AWS e.
+ Uma *chave primária* para a qual cada valor deve ser exclusivo. Nenhum item de sua tabela não pode ter o mesmo valor de chave primária de outro.

  Uma chave primária pode ser *simples*, consistindo em uma única chave de partição (HASH) ou *composta*, que consiste em uma partição e uma chave de classificação (RANGE).

  Cada valor de chave tem um *tipo de dados* associado, enumerado pela classe [ScalarAttributeType](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/namespace_aws_1_1_dynamo_d_b_1_1_model.html#a4b39ae66214e022d3737079d071e4bcb.html). O valor da chave pode ser binário (B), numérico (N) ou uma string (S). Para acessar mais informações, consulte [Regras de nomenclatura e tipos de dados](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) no Guia do desenvolvedor do Amazon DynamoDB.
+  Valores de taxa de *transferência provisionados* que definem o número de unidades de read/write capacidade reservadas para a tabela.
**nota**  
 A [definição de preço do Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) se baseia nos valores de taxa de transferência provisionada definidas por você nas tabelas. Dessa forma, reserve somente a capacidade máxima de que você imagina precisar para a tabela.  
O throughput provisionado para uma tabela pode ser modificado a qualquer momento. Dessa forma, você poderá ajustar a capacidade se as necessidades mudarem.

## Criar uma tabela
<a name="dynamodb-create-table"></a>

Use o método `CreateTable` [cliente do DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html) para criar uma tabela do DynamoDB. Você precisa construir atributos de tabela e um esquema de tabela, ambos usados para identificar a chave primária da tabela. Você também deve fornecer valores iniciais do throughput provisionado e um nome de tabela. `CreateTable` é uma operação assíncrona. `GetTableStatus` exibirá CREATING até que a tabela esteja ativa (ACTIVE) e pronta para uso.

### Criar uma tabela com uma chave primária simples
<a name="dynamodb-create-table-simple"></a>

Esse código cria uma tabela com uma chave primária simples ("Name").

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/CreateTableRequest.h>
#include <aws/dynamodb/model/KeySchemaElement.h>
#include <aws/dynamodb/model/ProvisionedThroughput.h>
#include <aws/dynamodb/model/ScalarAttributeType.h>
#include <iostream>
```

 **Código** 

```
//! Create an Amazon DynamoDB table.
/*!
  \sa createTable()
  \param tableName: Name for the DynamoDB table.
  \param primaryKey: Primary key for the DynamoDB table.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::createTable(const Aws::String &tableName,
                                   const Aws::String &primaryKey,
                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    std::cout << "Creating table " << tableName <<
              " with a simple primary key: \"" << primaryKey << "\"." << std::endl;

    Aws::DynamoDB::Model::CreateTableRequest request;

    Aws::DynamoDB::Model::AttributeDefinition hashKey;
    hashKey.SetAttributeName(primaryKey);
    hashKey.SetAttributeType(Aws::DynamoDB::Model::ScalarAttributeType::S);
    request.AddAttributeDefinitions(hashKey);

    Aws::DynamoDB::Model::KeySchemaElement keySchemaElement;
    keySchemaElement.WithAttributeName(primaryKey).WithKeyType(
            Aws::DynamoDB::Model::KeyType::HASH);
    request.AddKeySchema(keySchemaElement);

    Aws::DynamoDB::Model::ProvisionedThroughput throughput;
    throughput.WithReadCapacityUnits(5).WithWriteCapacityUnits(5);
    request.SetProvisionedThroughput(throughput);
    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::CreateTableOutcome &outcome = dynamoClient.CreateTable(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Table \""
                  << outcome.GetResult().GetTableDescription().GetTableName() <<
                  " created!" << std::endl;
    }
    else {
        std::cerr << "Failed to create table: " << outcome.GetError().GetMessage()
                  << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/create_table.cpp).

### Criar uma tabela com uma chave primária composta
<a name="dynamodb-create-table-composite"></a>

Adicione outro [AttributeDefinition](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_attribute_definition.html)e [KeySchemaElement](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_key_schema_element.html)para [CreateTableRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_create_table_request.html).

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/CreateTableRequest.h>
#include <aws/dynamodb/model/KeySchemaElement.h>
#include <aws/dynamodb/model/ProvisionedThroughput.h>
#include <aws/dynamodb/model/ScalarAttributeType.h>
#include <iostream>
```

 **Código** 

```
//! Create an Amazon DynamoDB table with a composite key.
/*!
  \sa createTableWithCompositeKey()
  \param tableName: Name for the DynamoDB table.
  \param partitionKey: Name for the partition (hash) key.
  \param sortKey: Name for the sort (range) key.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::createTableWithCompositeKey(const Aws::String &tableName,
                                                   const Aws::String &partitionKey,
                                                   const Aws::String &sortKey,
                                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    std::cout << "Creating table " << tableName <<
              " with a composite primary key:\n" \
            "* " << partitionKey << " - partition key\n" \
            "* " << sortKey << " - sort key\n";

    Aws::DynamoDB::Model::CreateTableRequest request;

    Aws::DynamoDB::Model::AttributeDefinition hashKey1, hashKey2;
    hashKey1.WithAttributeName(partitionKey).WithAttributeType(
            Aws::DynamoDB::Model::ScalarAttributeType::S);
    request.AddAttributeDefinitions(hashKey1);
    hashKey2.WithAttributeName(sortKey).WithAttributeType(
            Aws::DynamoDB::Model::ScalarAttributeType::S);
    request.AddAttributeDefinitions(hashKey2);

    Aws::DynamoDB::Model::KeySchemaElement keySchemaElement1, keySchemaElement2;
    keySchemaElement1.WithAttributeName(partitionKey).WithKeyType(
            Aws::DynamoDB::Model::KeyType::HASH);
    request.AddKeySchema(keySchemaElement1);
    keySchemaElement2.WithAttributeName(sortKey).WithKeyType(
            Aws::DynamoDB::Model::KeyType::RANGE);
    request.AddKeySchema(keySchemaElement2);

    Aws::DynamoDB::Model::ProvisionedThroughput throughput;
    throughput.WithReadCapacityUnits(5).WithWriteCapacityUnits(5);
    request.SetProvisionedThroughput(throughput);

    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::CreateTableOutcome &outcome = dynamoClient.CreateTable(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Table \""
                  << outcome.GetResult().GetTableDescription().GetTableName() <<
                  "\" was created!" << std::endl;
    }
    else {
        std::cerr << "Failed to create table:" << outcome.GetError().GetMessage()
                  << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

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

## Listar tabelas
<a name="dynamodb-list-tables"></a>

Você pode listar as tabelas em determinada região chamando o método `ListTables` do [cliente do DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html).

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/core/utils/Outcome.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/ListTablesRequest.h>
#include <aws/dynamodb/model/ListTablesResult.h>
#include <iostream>
```

 **Código** 

```
//! List the Amazon DynamoDB tables for the current AWS account.
/*!
  \sa listTables()
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */

bool AwsDoc::DynamoDB::listTables(
        const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::ListTablesRequest listTablesRequest;
    listTablesRequest.SetLimit(50);
    do {
        const Aws::DynamoDB::Model::ListTablesOutcome &outcome = dynamoClient.ListTables(
                listTablesRequest);
        if (!outcome.IsSuccess()) {
            std::cout << "Error: " << outcome.GetError().GetMessage() << std::endl;
            return false;
        }

        for (const auto &tableName: outcome.GetResult().GetTableNames())
            std::cout << tableName << std::endl;
        listTablesRequest.SetExclusiveStartTableName(
                outcome.GetResult().GetLastEvaluatedTableName());

    } while (!listTablesRequest.GetExclusiveStartTableName().empty());

    return true;
}
```

Por padrão, até cem tabelas são exibidas por chamada. Use `GetExclusiveStartTableName` no [ListTablesOutcome](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html)objeto retornado para obter a última tabela que foi avaliada. Você pode usar esse valor para iniciar a listagem depois do último valor retornado da listagem anterior.

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/list_tables.cpp).

## Recuperar informações sobre uma tabela
<a name="dynamodb-describe-table"></a>

Você pode descobrir mais sobre uma tabela chamando o método `DescribeTable` do [cliente do DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html).

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/DescribeTableRequest.h>
#include <iostream>
```

 **Código** 

```
//! Describe an Amazon DynamoDB table.
/*!
  \sa describeTable()
  \param tableName: The DynamoDB table name.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::describeTable(const Aws::String &tableName,
                                     const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::DescribeTableRequest request;
    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::DescribeTableOutcome &outcome = dynamoClient.DescribeTable(
            request);

    if (outcome.IsSuccess()) {
        const Aws::DynamoDB::Model::TableDescription &td = outcome.GetResult().GetTable();
        std::cout << "Table name  : " << td.GetTableName() << std::endl;
        std::cout << "Table ARN   : " << td.GetTableArn() << std::endl;
        std::cout << "Status      : "
                  << Aws::DynamoDB::Model::TableStatusMapper::GetNameForTableStatus(
                          td.GetTableStatus()) << std::endl;
        std::cout << "Item count  : " << td.GetItemCount() << std::endl;
        std::cout << "Size (bytes): " << td.GetTableSizeBytes() << std::endl;

        const Aws::DynamoDB::Model::ProvisionedThroughputDescription &ptd = td.GetProvisionedThroughput();
        std::cout << "Throughput" << std::endl;
        std::cout << "  Read Capacity : " << ptd.GetReadCapacityUnits() << std::endl;
        std::cout << "  Write Capacity: " << ptd.GetWriteCapacityUnits() << std::endl;

        const Aws::Vector<Aws::DynamoDB::Model::AttributeDefinition> &ad = td.GetAttributeDefinitions();
        std::cout << "Attributes" << std::endl;
        for (const auto &a: ad)
            std::cout << "  " << a.GetAttributeName() << " (" <<
                      Aws::DynamoDB::Model::ScalarAttributeTypeMapper::GetNameForScalarAttributeType(
                              a.GetAttributeType()) <<
                      ")" << std::endl;
    }
    else {
        std::cerr << "Failed to describe table: " << outcome.GetError().GetMessage();
    }

    return outcome.IsSuccess();
}
```

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

## Modificar uma tabela
<a name="dynamodb-update-table"></a>

Você pode modificar os valores de throughput provisionado da tabela a qualquer momento chamando o método `UpdateTable` do [cliente do DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html).

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/core/utils/Outcome.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/ProvisionedThroughput.h>
#include <aws/dynamodb/model/UpdateTableRequest.h>
#include <iostream>
```

 **Código** 

```
//! Update a DynamoDB table.
/*!
  \sa updateTable()
  \param tableName: Name for the DynamoDB table.
  \param readCapacity: Provisioned read capacity.
  \param writeCapacity: Provisioned write capacity.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::updateTable(const Aws::String &tableName,
                                   long long readCapacity, long long writeCapacity,
                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    std::cout << "Updating " << tableName << " with new provisioned throughput values"
              << std::endl;
    std::cout << "Read capacity : " << readCapacity << std::endl;
    std::cout << "Write capacity: " << writeCapacity << std::endl;

    Aws::DynamoDB::Model::UpdateTableRequest request;
    Aws::DynamoDB::Model::ProvisionedThroughput provisionedThroughput;
    provisionedThroughput.WithReadCapacityUnits(readCapacity).WithWriteCapacityUnits(
            writeCapacity);
    request.WithProvisionedThroughput(provisionedThroughput).WithTableName(tableName);

    const Aws::DynamoDB::Model::UpdateTableOutcome &outcome = dynamoClient.UpdateTable(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully updated the table." << std::endl;
    } else {
        const Aws::DynamoDB::DynamoDBError &error = outcome.GetError();
        if (error.GetErrorType() == Aws::DynamoDB::DynamoDBErrors::VALIDATION &&
            error.GetMessage().find("The provisioned throughput for the table will not change") != std::string::npos) {
            std::cout << "The provisioned throughput for the table will not change." << std::endl;
        } else {
            std::cerr << outcome.GetError().GetMessage() << std::endl;
            return false;
        }
    }

    return waitTableActive(tableName, dynamoClient);
}
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/update_table.cpp).

## Excluir uma tabela
<a name="dynamodb-delete-table"></a>

Chame o método `DeleteTable` do [cliente do DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html) e transmita para ele o nome da tabela.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/DeleteTableRequest.h>
#include <iostream>
```

 **Código** 

```
//! Delete an Amazon DynamoDB table.
/*!
  \sa deleteTable()
  \param tableName: The DynamoDB table name.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::deleteTable(const Aws::String &tableName,
                                   const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::DeleteTableRequest request;
    request.SetTableName(tableName);

    const Aws::DynamoDB::Model::DeleteTableOutcome &result = dynamoClient.DeleteTable(
            request);
    if (result.IsSuccess()) {
        std::cout << "Your table \""
                  << result.GetResult().GetTableDescription().GetTableName()
                  << " was deleted.\n";
    }
    else {
        std::cerr << "Failed to delete table: " << result.GetError().GetMessage()
                  << std::endl;
    }

    return result.IsSuccess();
}
```

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

## Mais informações
<a name="more-info"></a>
+  [Diretrizes para trabalhar com tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) no Guia do desenvolvedor do Amazon DynamoDB
+  [Trabalhar com tabelas no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) no Guia do desenvolvedor do Amazon DynamoDB.

# Trabalhar com itens no DynamoDB
<a name="examples-dynamodb-items"></a>

No DynamoDB, um item é um conjunto de *atributos*, e cada um tem um *nome* e um *valor*. Um valor de atributo pode ser uma escalar, um conjunto ou um tipo de documento. Para acessar mais informações, consulte [Regras de nomenclatura e tipos de dados](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) no Guia do desenvolvedor do Amazon DynamoDB.

## Recuperar um item de uma tabela
<a name="dynamodb-get-item"></a>

Chame o método `GetItem` do [cliente do DynamoDB](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_dynamo_d_b_client.html). Passe a ele um [GetItemRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_get_item_request.html)objeto com o nome da tabela e o valor da chave primária do item que você deseja. Ele retorna um [GetItemResult](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_get_item_result.html)objeto.

Você pode usar o `GetItem()` método do `GetItemResult` objeto retornado para recuperar um `Aws::Map` dos [AttributeValue](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_attribute_value.html)pares de chaves `Aws::String` e valores associados ao item.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/GetItemRequest.h>
#include <iostream>
```

 **Código** 

```
//! Get an item from an Amazon DynamoDB table.
/*!
  \sa getItem()
  \param tableName: The table name.
  \param partitionKey: The partition key.
  \param partitionValue: The value for the partition key.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */

bool AwsDoc::DynamoDB::getItem(const Aws::String &tableName,
                               const Aws::String &partitionKey,
                               const Aws::String &partitionValue,
                               const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
    Aws::DynamoDB::Model::GetItemRequest request;

    // Set up the request.
    request.SetTableName(tableName);
    request.AddKey(partitionKey,
                   Aws::DynamoDB::Model::AttributeValue().SetS(partitionValue));

    // Retrieve the item's fields and values.
    const Aws::DynamoDB::Model::GetItemOutcome &outcome = dynamoClient.GetItem(request);
    if (outcome.IsSuccess()) {
        // Reference the retrieved fields/values.
        const Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> &item = outcome.GetResult().GetItem();
        if (!item.empty()) {
            // Output each retrieved field and its value.
            for (const auto &i: item)
                std::cout << "Values: " << i.first << ": " << i.second.GetS()
                          << std::endl;
        }
        else {
            std::cout << "No item found with the key " << partitionKey << std::endl;
        }
    }
    else {
        std::cerr << "Failed to get item: " << outcome.GetError().GetMessage();
    }

    return outcome.IsSuccess();
}
```

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

## Adicionar um item a uma tabela
<a name="dynamodb-add-item"></a>

Crie [AttributeValue](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_attribute_value.html)pares de chaves `Aws::String` e valores que representem cada item. Eles devem incluir valores para os campos de chave primária da tabela. Se o item identificado pela chave primária já existir, os campos serão *atualizados* pela requisição. Adicione-os ao [PutItemRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-dynamodb/html/class_aws_1_1_dynamo_d_b_1_1_model_1_1_put_item_request.html)usando o `AddItem` método.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/PutItemRequest.h>
#include <aws/dynamodb/model/PutItemResult.h>
#include <iostream>
```

 **Código** 

```
//! Put an item in an Amazon DynamoDB table.
/*!
  \sa putItem()
  \param tableName: The table name.
  \param artistKey: The artist key. This is the partition key for the table.
  \param artistValue: The artist value.
  \param albumTitleKey: The album title key.
  \param albumTitleValue: The album title value.
  \param awardsKey: The awards key.
  \param awardsValue: The awards value.
  \param songTitleKey: The song title key.
  \param songTitleValue: The song title value.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::DynamoDB::putItem(const Aws::String &tableName,
                               const Aws::String &artistKey,
                               const Aws::String &artistValue,
                               const Aws::String &albumTitleKey,
                               const Aws::String &albumTitleValue,
                               const Aws::String &awardsKey,
                               const Aws::String &awardsValue,
                               const Aws::String &songTitleKey,
                               const Aws::String &songTitleValue,
                               const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    Aws::DynamoDB::Model::PutItemRequest putItemRequest;
    putItemRequest.SetTableName(tableName);

    putItemRequest.AddItem(artistKey, Aws::DynamoDB::Model::AttributeValue().SetS(
            artistValue)); // This is the hash key.
    putItemRequest.AddItem(albumTitleKey, Aws::DynamoDB::Model::AttributeValue().SetS(
            albumTitleValue));
    putItemRequest.AddItem(awardsKey,
                           Aws::DynamoDB::Model::AttributeValue().SetS(awardsValue));
    putItemRequest.AddItem(songTitleKey,
                           Aws::DynamoDB::Model::AttributeValue().SetS(songTitleValue));

    const Aws::DynamoDB::Model::PutItemOutcome outcome = dynamoClient.PutItem(
            putItemRequest);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully added Item!" << std::endl;
    }
    else {
        std::cerr << outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

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

## Atualizar um item existente em uma tabela
<a name="dynamodb-update-item"></a>

Você pode atualizar um atributo de um item que já existe em uma tabela usando o `UpdateItem` método DBClient do Dynamo, fornecendo um nome de tabela, valor de chave primária e campos a serem atualizados e o valor correspondente.

 **Importações** 

```
#include <aws/core/Aws.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/UpdateItemRequest.h>
#include <aws/dynamodb/model/UpdateItemResult.h>
#include <iostream>
```

 **Código** 

```
//! Update an Amazon DynamoDB table item.
/*!
  \sa updateItem()
  \param tableName: The table name.
  \param partitionKey: The partition key.
  \param partitionValue: The value for the partition key.
  \param attributeKey: The key for the attribute to be updated.
  \param attributeValue: The value for the attribute to be updated.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
  */

/*
 *  The example code only sets/updates an attribute value. It processes
 *  the attribute value as a string, even if the value could be interpreted
 *  as a number. Also, the example code does not remove an existing attribute
 *  from the key value.
 */

bool AwsDoc::DynamoDB::updateItem(const Aws::String &tableName,
                                  const Aws::String &partitionKey,
                                  const Aws::String &partitionValue,
                                  const Aws::String &attributeKey,
                                  const Aws::String &attributeValue,
                                  const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);

    // *** Define UpdateItem request arguments.
    // Define TableName argument.
    Aws::DynamoDB::Model::UpdateItemRequest request;
    request.SetTableName(tableName);

    // Define KeyName argument.
    Aws::DynamoDB::Model::AttributeValue attribValue;
    attribValue.SetS(partitionValue);
    request.AddKey(partitionKey, attribValue);

    // Construct the SET update expression argument.
    Aws::String update_expression("SET #a = :valueA");
    request.SetUpdateExpression(update_expression);

    // Construct attribute name argument.
    Aws::Map<Aws::String, Aws::String> expressionAttributeNames;
    expressionAttributeNames["#a"] = attributeKey;
    request.SetExpressionAttributeNames(expressionAttributeNames);

    // Construct attribute value argument.
    Aws::DynamoDB::Model::AttributeValue attributeUpdatedValue;
    attributeUpdatedValue.SetS(attributeValue);
    Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue> expressionAttributeValues;
    expressionAttributeValues[":valueA"] = attributeUpdatedValue;
    request.SetExpressionAttributeValues(expressionAttributeValues);

    // Update the item.
    const Aws::DynamoDB::Model::UpdateItemOutcome &outcome = dynamoClient.UpdateItem(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Item was updated" << std::endl;
    } else {
        std::cerr << outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    return waitTableActive(tableName, dynamoClient);
}
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/update_item.cpp).

## Mais informações
<a name="more-info"></a>
+  [Diretrizes para trabalhar com itens](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) no Guia do desenvolvedor do Amazon DynamoDB
+  [Trabalhar com itens no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) no Guia do desenvolvedor do Amazon DynamoDB.

# Exemplos do Amazon EC2 usando o AWS SDK para C\$1\$1
<a name="examples-ec2"></a>

O Amazon Elastic Compute Cloud (Amazon EC2) é um serviço da Web que fornece capacidade de computação escalável (literalmente, servidores nos data centers da Amazon) que você utiliza para construir e hospedar seus sistemas de software. É possível usar os exemplos a seguir para programar o [Amazon EC2](https://aws.amazon.com/ec2) usando o AWS SDK para C\$1\$1.

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

**Topics**
+ [Gerenciar instâncias do Amazon EC2](examples-ec2-instances.md)
+ [Usar endereços IP elásticos no Amazon EC2](examples-ec2-elastic-ip.md)
+ [Uso de regiões e zonas de disponibilidade para o Amazon EC2](examples-ec2-regions-zones.md)
+ [Trabalhar com pares de chaves do Amazon EC2](examples-ec2-key-pairs.md)
+ [Trabalhar com grupos de segurança no Amazon EC2](examples-ec2-security-groups.md)

# Gerenciar instâncias do Amazon EC2
<a name="examples-ec2-instances"></a>

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

## Criar uma instância do
<a name="create-an-instance"></a>

Crie uma nova instância do Amazon EC2 chamando a `RunInstances` função do EC2 cliente, fornecendo a ela uma imagem de máquina da Amazon (AMI) [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_run_instances_request.html)contendo a [imagem de máquina da Amazon (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) a ser usada e um tipo de [instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/RunInstancesRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::RunInstancesRequest runRequest;
    runRequest.SetImageId(amiId);
    runRequest.SetInstanceType(Aws::EC2::Model::InstanceType::t1_micro);
    runRequest.SetMinCount(1);
    runRequest.SetMaxCount(1);

    Aws::EC2::Model::RunInstancesOutcome runOutcome = ec2Client.RunInstances(
            runRequest);
    if (!runOutcome.IsSuccess()) {
        std::cerr << "Failed to launch EC2 instance " << instanceName <<
                  " based on ami " << amiId << ":" <<
                  runOutcome.GetError().GetMessage() << std::endl;
        return false;
    }

    const Aws::Vector<Aws::EC2::Model::Instance> &instances = runOutcome.GetResult().GetInstances();
    if (instances.empty()) {
        std::cerr << "Failed to launch EC2 instance " << instanceName <<
                  " based on ami " << amiId << ":" <<
                  runOutcome.GetError().GetMessage() << std::endl;
        return false;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/run_instances.cpp).

## Iniciar uma instância
<a name="start-an-instance"></a>

Para iniciar uma instância do Amazon EC2, chame a `StartInstances` função do EC2 cliente, fornecendo a ela um [StartInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_start_instances_request.html)contendo o ID da instância a ser iniciada.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/StartInstancesRequest.h>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::StartInstancesRequest startRequest;
    startRequest.AddInstanceIds(instanceId);
    startRequest.SetDryRun(true);

    Aws::EC2::Model::StartInstancesOutcome dryRunOutcome = ec2Client.StartInstances(startRequest);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to start instance. A dry run should trigger an error."
                << std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType() !=
               Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to start instance " << instanceId << ": "
                  << dryRunOutcome.GetError().GetMessage() << std::endl;
        return false;
    }

    startRequest.SetDryRun(false);
    Aws::EC2::Model::StartInstancesOutcome startInstancesOutcome = ec2Client.StartInstances(startRequest);

    if (!startInstancesOutcome.IsSuccess()) {
        std::cout << "Failed to start instance " << instanceId << ": " <<
                  startInstancesOutcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully started instance " << instanceId <<
                  std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/start_stop_instance.cpp).

## Interromper uma instância
<a name="stop-an-instance"></a>

Para interromper uma instância do Amazon EC2, chame a `StopInstances` função do EC2 cliente, fornecendo a ela um [StopInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_stop_instances_request.html)contendo o ID da instância a ser interrompida.

 **Inclui** 

```
#include <aws/ec2/model/StopInstancesRequest.h>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::StopInstancesRequest request;
    request.AddInstanceIds(instanceId);
    request.SetDryRun(true);

    Aws::EC2::Model::StopInstancesOutcome dryRunOutcome = ec2Client.StopInstances(request);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to stop instance. A dry run should trigger an error."
                << std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType() !=
               Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to stop instance " << instanceId << ": "
                  << dryRunOutcome.GetError().GetMessage() << std::endl;
        return false;
    }

    request.SetDryRun(false);
    Aws::EC2::Model::StopInstancesOutcome outcome = ec2Client.StopInstances(request);
    if (!outcome.IsSuccess()) {
        std::cout << "Failed to stop instance " << instanceId << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully stopped instance " << instanceId <<
                  std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/start_stop_instance.cpp).

## Reinicializar uma instância
<a name="reboot-an-instance"></a>

Para reinicializar uma instância do Amazon EC2, chame EC2 a função `RebootInstances` do cliente, fornecendo a ela [RebootInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_reboot_instances_request.html)um contendo o ID da instância a ser reinicializada.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/RebootInstancesRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::RebootInstancesRequest request;
    request.AddInstanceIds(instanceId);
    request.SetDryRun(true);

    Aws::EC2::Model::RebootInstancesOutcome dry_run_outcome = ec2Client.RebootInstances(request);
    if (dry_run_outcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to reboot on instance. A dry run should trigger an error."
                <<
                std::endl;
        return false;
    } else if (dry_run_outcome.GetError().GetErrorType()
               != Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to reboot instance " << instanceId << ": "
                  << dry_run_outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    request.SetDryRun(false);
    Aws::EC2::Model::RebootInstancesOutcome outcome = ec2Client.RebootInstances(request);
    if (!outcome.IsSuccess()) {
        std::cout << "Failed to reboot instance " << instanceId << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully rebooted instance " << instanceId <<
                  std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/reboot_instance.cpp).

## Descrever instâncias
<a name="describe-instances"></a>

Para listar suas instâncias, crie uma [DescribeInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_instances_request.html)e chame a `DescribeInstances` função do EC2 cliente. Ele retornará um [DescribeInstancesResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_instances_response.html)objeto que você pode usar para listar as instâncias do Amazon EC2 para seu e. Conta da AWS Região da AWS

As instâncias são agrupadas por *reserva*. Cada reserva corresponde à chamada a `StartInstances` que iniciou a instância. Para listar as instâncias, você deve primeiro chamar a função `GetReservations` da classe `DescribeInstancesResponse` e chamar `getInstances` em cada objeto Reservation exibido.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeInstancesRequest.h>
#include <aws/ec2/model/DescribeInstancesResponse.h>
#include <iomanip>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeInstancesRequest request;
    bool header = false;
    bool done = false;
    while (!done) {
        Aws::EC2::Model::DescribeInstancesOutcome outcome = ec2Client.DescribeInstances(request);
        if (outcome.IsSuccess()) {
            if (!header) {
                std::cout << std::left <<
                          std::setw(48) << "Name" <<
                          std::setw(20) << "ID" <<
                          std::setw(25) << "Ami" <<
                          std::setw(15) << "Type" <<
                          std::setw(15) << "State" <<
                          std::setw(15) << "Monitoring" << std::endl;
                header = true;
            }

            const std::vector<Aws::EC2::Model::Reservation> &reservations =
                    outcome.GetResult().GetReservations();

            for (const auto &reservation: reservations) {
                const std::vector<Aws::EC2::Model::Instance> &instances =
                        reservation.GetInstances();
                for (const auto &instance: instances) {
                    Aws::String instanceStateString =
                            Aws::EC2::Model::InstanceStateNameMapper::GetNameForInstanceStateName(
                                    instance.GetState().GetName());

                    Aws::String typeString =
                            Aws::EC2::Model::InstanceTypeMapper::GetNameForInstanceType(
                                    instance.GetInstanceType());

                    Aws::String monitorString =
                            Aws::EC2::Model::MonitoringStateMapper::GetNameForMonitoringState(
                                    instance.GetMonitoring().GetState());
                    Aws::String name = "Unknown";

                    const std::vector<Aws::EC2::Model::Tag> &tags = instance.GetTags();
                    auto nameIter = std::find_if(tags.cbegin(), tags.cend(),
                                                 [](const Aws::EC2::Model::Tag &tag) {
                                                     return tag.GetKey() == "Name";
                                                 });
                    if (nameIter != tags.cend()) {
                        name = nameIter->GetValue();
                    }
                    std::cout <<
                              std::setw(48) << name <<
                              std::setw(20) << instance.GetInstanceId() <<
                              std::setw(25) << instance.GetImageId() <<
                              std::setw(15) << typeString <<
                              std::setw(15) << instanceStateString <<
                              std::setw(15) << monitorString << std::endl;
                }
            }

            if (!outcome.GetResult().GetNextToken().empty()) {
                request.SetNextToken(outcome.GetResult().GetNextToken());
            } else {
                done = true;
            }
        } else {
            std::cerr << "Failed to describe EC2 instances:" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }
    }
```

Os resultados são paginados. É possível acessar mais resultados passando o valor exibido pela função `GetNextToken` do objeto de resultados à função `SetNextToken` do objeto de solicitação original e usando o mesmo objeto de solicitação na próxima chamada para `DescribeInstances`.

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_instances.cpp).

## Habilitar monitoramento de instâncias
<a name="enable-instance-monitoring"></a>

Você pode monitorar diversos aspectos das instâncias do Amazon EC2, como utilização de CPU e rede, memória disponível e espaço em disco restante. Para saber mais sobre o monitoramento de instâncias, consulte [Monitorar o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) no Guia do usuário do Amazon EC2.

Para começar a monitorar uma instância, você deve criar uma [MonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_monitor_instances_request.html)com o ID da instância a ser monitorada e passá-la para a `MonitorInstances` função do EC2 cliente.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/MonitorInstancesRequest.h>
#include <aws/ec2/model/UnmonitorInstancesRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::MonitorInstancesRequest request;
    request.AddInstanceIds(instanceId);
    request.SetDryRun(true);

    Aws::EC2::Model::MonitorInstancesOutcome dryRunOutcome = ec2Client.MonitorInstances(request);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to enable monitoring on instance. A dry run should trigger an error."
                <<
                std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType()
               != Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cerr << "Failed dry run to enable monitoring on instance " <<
                  instanceId << ": " << dryRunOutcome.GetError().GetMessage() <<
                  std::endl;
        return false;
    }

    request.SetDryRun(false);
    Aws::EC2::Model::MonitorInstancesOutcome monitorInstancesOutcome = ec2Client.MonitorInstances(request);
    if (!monitorInstancesOutcome.IsSuccess()) {
        std::cerr << "Failed to enable monitoring on instance " <<
                  instanceId << ": " <<
                  monitorInstancesOutcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully enabled monitoring on instance " <<
                  instanceId << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/monitor_instance.cpp).

## Desabilitar monitoramento de instâncias
<a name="disable-instance-monitoring"></a>

Para parar de monitorar uma instância, crie um [UnmonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_unmonitor_instances_request.html)com o ID da instância para interromper o monitoramento e passe-o para a `UnmonitorInstances` função do EC2 cliente.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/MonitorInstancesRequest.h>
#include <aws/ec2/model/UnmonitorInstancesRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::UnmonitorInstancesRequest unrequest;
    unrequest.AddInstanceIds(instanceId);
    unrequest.SetDryRun(true);

    Aws::EC2::Model::UnmonitorInstancesOutcome dryRunOutcome = ec2Client.UnmonitorInstances(unrequest);
    if (dryRunOutcome.IsSuccess()) {
        std::cerr
                << "Failed dry run to disable monitoring on instance. A dry run should trigger an error."
                <<
                std::endl;
        return false;
    } else if (dryRunOutcome.GetError().GetErrorType() !=
               Aws::EC2::EC2Errors::DRY_RUN_OPERATION) {
        std::cout << "Failed dry run to disable monitoring on instance " <<
                  instanceId << ": " << dryRunOutcome.GetError().GetMessage() <<
                  std::endl;
        return false;
    }

    unrequest.SetDryRun(false);
    Aws::EC2::Model::UnmonitorInstancesOutcome unmonitorInstancesOutcome = ec2Client.UnmonitorInstances(unrequest);
    if (!unmonitorInstancesOutcome.IsSuccess()) {
        std::cout << "Failed to disable monitoring on instance " << instanceId
                  << ": " << unmonitorInstancesOutcome.GetError().GetMessage() <<
                  std::endl;
    } else {
        std::cout << "Successfully disable monitoring on instance " <<
                  instanceId << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/monitor_instance.cpp).

## Mais informações
<a name="more-information"></a>
+  [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)na referência de API do Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)na referência de API do Amazon EC2
+  [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)na referência de API do Amazon EC2
+  [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)na referência de API do Amazon EC2
+  [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html)na referência de API do Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)na referência de API do Amazon EC2
+  [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html)na referência de API do Amazon EC2
+  [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html)na referência de API do Amazon EC2

# Usar endereços IP elásticos no Amazon EC2
<a name="examples-ec2-elastic-ip"></a>

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

## Alocar um endereço IP elástico
<a name="allocate-an-elastic-ip-address"></a>

Para usar um endereço IP elástico, você primeiro aloca um para sua conta e o associa à instância ou a uma interface de rede.

Para alocar um endereço IP elástico, chame a `AllocateAddress` função do EC2 cliente com um [AllocateAddressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_allocate_address_request.html)objeto contendo o tipo de rede (EC2 ou VPC clássico). 

**Atenção**  
Estamos aposentando o EC2-Classic em 15 de agosto de 2022. É recomendável migrar do EC2-Classic para uma VPC. Para acessar mais informações, consulte **Migrar do EC2-Classic para uma VPC** no [Guia do usuário das instâncias do Linux do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html) ou no [Guia do usuário das instâncias do Windows do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/vpc-migrate.html). Consulte também a publicação do blog [EC2-Classic Networking is Retiring - Here's How to Prepare](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) (O EC2-Classic está sendo retirado: veja como se preparar).

A [AllocateAddressResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_allocate_address_response.html)classe no objeto de resposta contém uma ID de alocação que você pode usar para associar o endereço a uma instância, passando a ID de alocação e a ID da instância em [AssociateAddressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_associate_address_request.html)a para a função do EC2 `AssociateAddress` Cliente.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/AllocateAddressRequest.h>
#include <aws/ec2/model/AssociateAddressRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::AllocateAddressRequest request;
    request.SetDomain(Aws::EC2::Model::DomainType::vpc);

    const Aws::EC2::Model::AllocateAddressOutcome outcome =
            ec2Client.AllocateAddress(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to allocate Elastic IP address:" <<
                  outcome.GetError().GetMessage() << std::endl;
        return false;
    }
    const Aws::EC2::Model::AllocateAddressResponse &response = outcome.GetResult();
    allocationID = response.GetAllocationId();
    publicIPAddress = response.GetPublicIp();


    Aws::EC2::Model::AssociateAddressRequest associate_request;
    associate_request.SetInstanceId(instanceId);
    associate_request.SetAllocationId(allocationID);

    const Aws::EC2::Model::AssociateAddressOutcome associate_outcome =
            ec2Client.AssociateAddress(associate_request);
    if (!associate_outcome.IsSuccess()) {
        std::cerr << "Failed to associate Elastic IP address " << allocationID
                  << " with instance " << instanceId << ":" <<
                  associate_outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    std::cout << "Successfully associated Elastic IP address " << allocationID
              << " with instance " << instanceId << std::endl;
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/allocate_address.cpp).

## Descrever endereços IP elásticos
<a name="describe-elastic-ip-addresses"></a>

Para listar os endereços IP elásticos atribuídos à sua conta, chame a `DescribeAddresses` função do EC2 cliente. Ele retorna um objeto de resultado que contém um [DescribeAddressesResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_addresses_response.html)que você pode usar para obter uma lista de objetos de [endereço](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_address.html) que representam os endereços IP elásticos em sua conta.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeAddressesRequest.h>
#include <aws/ec2/model/DescribeAddressesResponse.h>
#include <iomanip>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeAddressesRequest request;
    Aws::EC2::Model::DescribeAddressesOutcome outcome = ec2Client.DescribeAddresses(request);
    if (outcome.IsSuccess()) {
        std::cout << std::left << std::setw(20) << "InstanceId" <<
                  std::setw(15) << "Public IP" << std::setw(10) << "Domain" <<
                  std::setw(30) << "Allocation ID" << std::setw(25) <<
                  "NIC ID" << std::endl;

        const Aws::Vector<Aws::EC2::Model::Address> &addresses = outcome.GetResult().GetAddresses();
        for (const auto &address: addresses) {
            Aws::String domainString =
                    Aws::EC2::Model::DomainTypeMapper::GetNameForDomainType(
                            address.GetDomain());

            std::cout << std::left << std::setw(20) <<
                      address.GetInstanceId() << std::setw(15) <<
                      address.GetPublicIp() << std::setw(10) << domainString <<
                      std::setw(30) << address.GetAllocationId() << std::setw(25)
                      << address.GetNetworkInterfaceId() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe Elastic IP addresses:" <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_addresses.cpp).

## Liberar um endereço IP elástico
<a name="release-an-elastic-ip-address"></a>

Para liberar um endereço IP elástico, chame a `ReleaseAddress` função do EC2 cliente, passando a ela um [ReleaseAddressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_release_address_request.html)contendo o ID de alocação do endereço IP elástico que você deseja liberar.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/ReleaseAddressRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2(clientConfiguration);

    Aws::EC2::Model::ReleaseAddressRequest request;
    request.SetAllocationId(allocationID);

    Aws::EC2::Model::ReleaseAddressOutcome outcome = ec2.ReleaseAddress(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to release Elastic IP address " <<
                  allocationID << ":" << outcome.GetError().GetMessage() <<
                  std::endl;
    } else {
        std::cout << "Successfully released Elastic IP address " <<
                  allocationID << std::endl;
    }
```

Depois de liberar um endereço IP elástico, ele é liberado para o pool de endereços AWS IP e pode ficar indisponível para você posteriormente. Não se esqueça de atualizar os registros DNS e todos os servidores ou dispositivos que se comunicam com o endereço. Se você tentar liberar um endereço IP elástico que você já liberou, receberá um *AuthFailure*erro se o endereço já estiver alocado para outra AWS conta.

Se você estiver usando a *VPC padrão*, liberar um endereço IP elástico o desassociará automaticamente de qualquer instância a qual esteja associado. Para desassociar um endereço IP elástico sem liberá-lo, use a função do EC2 `DisassociateAddress` cliente.

Se estiver usando uma VPC não padrão, você *deverá* usar `DisassociateAddress` para desassociar o endereço IP elástico antes de tentar liberá-lo. *Caso contrário, o Amazon EC2 retornará um erro (inválido). IPAddress InUse*).

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/release_address.cpp).

## Mais informações
<a name="more-information"></a>
+  [Endereços IP elásticos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) no Guia do usuário do Amazon EC2.
+  [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)na referência de API do Amazon EC2
+  [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)na referência de API do Amazon EC2
+  [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)na referência de API do Amazon EC2

# Uso de regiões e zonas de disponibilidade para o Amazon EC2
<a name="examples-ec2-regions-zones"></a>

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

## Descrever regiões
<a name="describe-regions"></a>

Para listar o que Regiões da AWS está disponível para você Conta da AWS, chame a `DescribeRegions` função do EC2 cliente com um [DescribeRegionsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_regions_request.html).

Você receberá um [DescribeRegionsResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_regions_response.html)no objeto de resultado. Chame sua função `GetRegions` para ver uma lista de objetos [Region](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_region.html) que representam cada região.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeRegionsRequest.h>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::DescribeRegionsRequest request;
    Aws::EC2::Model::DescribeRegionsOutcome outcome = ec2Client.DescribeRegions(request);
    if (outcome.IsSuccess()) {
        std::cout << std::left <<
                  std::setw(32) << "RegionName" <<
                  std::setw(64) << "Endpoint" << std::endl;

        const auto &regions = outcome.GetResult().GetRegions();
        for (const auto &region: regions) {
            std::cout << std::left <<
                      std::setw(32) << region.GetRegionName() <<
                      std::setw(64) << region.GetEndpoint() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe regions:" <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_regions_and_zones.cpp).

## Descrever as zonas de disponibilidade
<a name="describe-availability-zones"></a>

Para listar cada zona de disponibilidade disponível para sua conta, chame a `DescribeAvailabilityZones` função do EC2 Cliente com um [DescribeAvailabilityZonesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_availability_zones_request.html).

Você receberá um [DescribeAvailabilityZonesResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_availability_zones_response.html)no objeto de resultado. Chame sua `GetAvailabilityZones` função para obter uma lista de [AvailabilityZone](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_availability_zone.html)objetos que representam cada zona de disponibilidade.

 **Inclui** 

```
#include <aws/ec2/model/DescribeAvailabilityZonesRequest.h>
```

 **Código** 

```
    Aws::EC2::Model::DescribeAvailabilityZonesRequest request;
    Aws::EC2::Model::DescribeAvailabilityZonesOutcome outcome = ec2Client.DescribeAvailabilityZones(request);

    if (outcome.IsSuccess()) {
        std::cout << std::left <<
                  std::setw(32) << "ZoneName" <<
                  std::setw(20) << "State" <<
                  std::setw(32) << "Region" << std::endl;

        const auto &zones =
                outcome.GetResult().GetAvailabilityZones();

        for (const auto &zone: zones) {
            Aws::String stateString =
                    Aws::EC2::Model::AvailabilityZoneStateMapper::GetNameForAvailabilityZoneState(
                            zone.GetState());
            std::cout << std::left <<
                      std::setw(32) << zone.GetZoneName() <<
                      std::setw(20) << stateString <<
                      std::setw(32) << zone.GetRegionName() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe availability zones:" <<
                  outcome.GetError().GetMessage() << std::endl;

    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_regions_and_zones.cpp).

## Mais informações
<a name="more-information"></a>
+  [Regiões e zonas de disponibilidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) no Guia do usuário do Amazon EC2
+  [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)na referência de API do Amazon EC2
+  [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)na referência de API do Amazon EC2

# Trabalhar com pares de chaves do Amazon EC2
<a name="examples-ec2-key-pairs"></a>

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

## Criar um par de chaves
<a name="create-a-key-pair"></a>

Para criar um par de chaves, chame a `CreateKeyPair` função do EC2 cliente com um [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_create_key_pair_request.html)que contenha o nome da chave.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/CreateKeyPairRequest.h>
#include <iostream>
#include <fstream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::CreateKeyPairRequest request;
    request.SetKeyName(keyPairName);

    Aws::EC2::Model::CreateKeyPairOutcome outcome = ec2Client.CreateKeyPair(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to create key pair - "  << keyPairName << ". " <<
                  outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully created key pair named " <<
                  keyPairName << std::endl;
        if (!keyFilePath.empty()) {
            std::ofstream keyFile(keyFilePath.c_str());
            keyFile << outcome.GetResult().GetKeyMaterial();
            keyFile.close();
            std::cout << "Keys written to the file " <<
                      keyFilePath << std::endl;
        }

    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_key_pair.cpp).

## Descrever pares de chaves
<a name="describe-key-pairs"></a>

Para listar seus pares de chaves ou obter informações sobre eles, chame a `DescribeKeyPairs` função do EC2 Cliente com [DescribeKeyPairsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_key_pairs_request.html)a.

Você receberá uma [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_key_pairs_response.html)que pode ser usada para acessar a lista de pares de chaves chamando sua `GetKeyPairs` função, que retorna uma lista de [KeyPairInfo](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_key_pair_info.html)objetos.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeKeyPairsRequest.h>
#include <aws/ec2/model/DescribeKeyPairsResponse.h>
#include <iomanip>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeKeyPairsRequest request;

    Aws::EC2::Model::DescribeKeyPairsOutcome outcome = ec2Client.DescribeKeyPairs(request);
    if (outcome.IsSuccess()) {
        std::cout << std::left <<
                  std::setw(32) << "Name" <<
                  std::setw(64) << "Fingerprint" << std::endl;

        const std::vector<Aws::EC2::Model::KeyPairInfo> &key_pairs =
                outcome.GetResult().GetKeyPairs();
        for (const auto &key_pair: key_pairs) {
            std::cout << std::left <<
                      std::setw(32) << key_pair.GetKeyName() <<
                      std::setw(64) << key_pair.GetKeyFingerprint() << std::endl;
        }
    } else {
        std::cerr << "Failed to describe key pairs:" <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_key_pairs.cpp).

## Excluir um par de chaves
<a name="delete-a-key-pair"></a>

Para excluir um par de chaves, chame a `DeleteKeyPair` função do EC2 cliente, passando a ela um [DeleteKeyPairRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_delete_key_pair_request.html)que contenha o nome do par de chaves a ser excluído.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DeleteKeyPairRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DeleteKeyPairRequest request;

    request.SetKeyName(keyPairName);
    const Aws::EC2::Model::DeleteKeyPairOutcome outcome = ec2Client.DeleteKeyPair(
            request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to delete key pair " << keyPairName <<
                  ":" << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully deleted key pair named " << keyPairName <<
                  std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/delete_key_pair.cpp).

## Mais informações
<a name="more-information"></a>
+  [Pares de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) no Guia do usuário do Amazon EC2.
+  [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)na referência de API do Amazon EC2
+  [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)na referência de API do Amazon EC2
+  [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)na referência de API do Amazon EC2

# Trabalhar com grupos de segurança no Amazon EC2
<a name="examples-ec2-security-groups"></a>

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

## Criar um grupo de segurança
<a name="create-a-security-group"></a>

Para criar um grupo de segurança, chame a `CreateSecurityGroup` função do EC2 Cliente com uma [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_create_security_group_request.html)que contenha o nome da chave.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/CreateSecurityGroupRequest.h>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);

    Aws::EC2::Model::CreateSecurityGroupRequest request;

    request.SetGroupName(groupName);
    request.SetDescription(description);
    request.SetVpcId(vpcID);

    const Aws::EC2::Model::CreateSecurityGroupOutcome outcome =
            ec2Client.CreateSecurityGroup(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to create security group:" <<
                  outcome.GetError().GetMessage() << std::endl;
        return false;
    }

    std::cout << "Successfully created security group named " << groupName <<
              std::endl;
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_security_group.cpp).

## Configurar um grupo de segurança
<a name="configure-a-security-group"></a>

Um grupo de segurança pode controlar os tráfegos de entrada e saída para as instâncias do Amazon EC2.

Para adicionar regras de entrada ao seu grupo de segurança, use a `AuthorizeSecurityGroupIngress` função EC2 Client, fornecendo o nome do grupo de segurança e as regras de acesso ([IpPermission](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_ip_permission.html)) que você deseja atribuir a ele em um [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_authorize_security_group_ingress_request.html)objeto. O exemplo a seguir mostra como adicionar permissões de IP a um grupo de segurança.

 **Inclui** 

```
#include <aws/ec2/model/AuthorizeSecurityGroupIngressRequest.h>
```

 **Código** 

```
    Aws::EC2::Model::AuthorizeSecurityGroupIngressRequest authorizeSecurityGroupIngressRequest;
    authorizeSecurityGroupIngressRequest.SetGroupId(groupID);
```

```
    Aws::String ingressIPRange = "203.0.113.0/24";  // Configure this for your allowed IP range.
    Aws::EC2::Model::IpRange ip_range;
    ip_range.SetCidrIp(ingressIPRange);

    Aws::EC2::Model::IpPermission permission1;
    permission1.SetIpProtocol("tcp");
    permission1.SetToPort(80);
    permission1.SetFromPort(80);
    permission1.AddIpRanges(ip_range);

    authorize_request.AddIpPermissions(permission1);

    Aws::EC2::Model::IpPermission permission2;
    permission2.SetIpProtocol("tcp");
    permission2.SetToPort(22);
    permission2.SetFromPort(22);
    permission2.AddIpRanges(ip_range);

    authorize_request.AddIpPermissions(permission2);
```

```
    Aws::EC2::Model::AuthorizeSecurityGroupIngressOutcome authorizeSecurityGroupIngressOutcome =
            ec2Client.AuthorizeSecurityGroupIngress(authorizeSecurityGroupIngressRequest);

    if (authorizeSecurityGroupIngressOutcome.IsSuccess()) {
        std::cout << "Successfully authorized security group ingress." << std::endl;
    } else {
        std::cerr << "Error authorizing security group ingress: "
                  << authorizeSecurityGroupIngressOutcome.GetError().GetMessage() << std::endl;
    }
```

Para adicionar uma regra de saída ao grupo de segurança, forneça dados semelhantes na `AuthorizeSecurityGroupEgress` função do EC2 Cliente. [AuthorizeSecurityGroupEgressRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_authorize_security_group_egress_request.html)

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_security_group.cpp).

## Descrever security groups
<a name="describe-security-groups"></a>

Para descrever seus grupos de segurança ou obter informações sobre eles, chame a `DescribeSecurityGroups` função do EC2 Cliente com um [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_security_groups_request.html).

Você receberá um [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_describe_security_groups_response.html)no objeto de resultado que poderá ser usado para acessar a lista de grupos de segurança chamando sua `GetSecurityGroups` função, que retorna uma lista de [SecurityGroup](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_security_group.html)objetos.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DescribeSecurityGroupsRequest.h>
#include <aws/ec2/model/DescribeSecurityGroupsResponse.h>
#include <iomanip>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DescribeSecurityGroupsRequest request;

    if (!groupID.empty()) {
        request.AddGroupIds(groupID);
    }

    Aws::String nextToken;
    do {
        if (!nextToken.empty()) {
            request.SetNextToken(nextToken);
        }

        Aws::EC2::Model::DescribeSecurityGroupsOutcome outcome = ec2Client.DescribeSecurityGroups(request);
        if (outcome.IsSuccess()) {
            std::cout << std::left <<
                      std::setw(32) << "Name" <<
                      std::setw(30) << "GroupId" <<
                      std::setw(30) << "VpcId" <<
                      std::setw(64) << "Description" << std::endl;

            const std::vector<Aws::EC2::Model::SecurityGroup> &securityGroups =
                    outcome.GetResult().GetSecurityGroups();

            for (const auto &securityGroup: securityGroups) {
                std::cout << std::left <<
                          std::setw(32) << securityGroup.GetGroupName() <<
                          std::setw(30) << securityGroup.GetGroupId() <<
                          std::setw(30) << securityGroup.GetVpcId() <<
                          std::setw(64) << securityGroup.GetDescription() <<
                          std::endl;
            }
        } else {
            std::cerr << "Failed to describe security groups:" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }

        nextToken = outcome.GetResult().GetNextToken();
    } while (!nextToken.empty());
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_security_groups.cpp).

## Excluir um grupo de segurança
<a name="delete-a-security-group"></a>

Para excluir um grupo de segurança, chame a `DeleteSecurityGroup` função do EC2 cliente, passando a ela uma [DeleteSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-ec2/html/class_aws_1_1_e_c2_1_1_model_1_1_delete_security_group_request.html)que contenha o ID do grupo de segurança a ser excluído.

 **Inclui** 

```
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/DeleteSecurityGroupRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::EC2::EC2Client ec2Client(clientConfiguration);
    Aws::EC2::Model::DeleteSecurityGroupRequest request;

    request.SetGroupId(securityGroupID);
    Aws::EC2::Model::DeleteSecurityGroupOutcome outcome = ec2Client.DeleteSecurityGroup(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to delete security group " << securityGroupID <<
                  ":" << outcome.GetError().GetMessage() << std::endl;
    } else {
        std::cout << "Successfully deleted security group " << securityGroupID <<
                  std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/delete_security_group.cpp).

## Mais informações
<a name="more-information"></a>
+  [Grupos de segurança do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) no Guia do usuário do EC2.
+  [Autorizar o tráfego de entrada para suas instâncias do Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) no Guia do usuário do Amazon EC2.
+  [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)na referência de API do Amazon EC2
+  [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)na referência de API do Amazon EC2
+  [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)na referência de API do Amazon EC2
+  [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)na referência de API do Amazon EC2

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

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

O Amazon Simple Queue Service (Amazon SQS) é um serviço de filas de mensagens totalmente gerenciado que facilita a separação e escalabilidade de microsserviços, sistemas distribuídos e aplicativos sem servidor. É possível usar os exemplos a seguir para programar o [Amazon SQS](https://aws.amazon.com/sqs) usando o AWS SDK para C\$1\$1.

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

**Topics**
+ [Trabalhar com filas de mensagens do Amazon SQS](examples-sqs-message-queues.md)
+ [Enviar, receber e excluir mensagens do Amazon SQS](examples-sqs-messages.md)
+ [Habilitar a sondagem longa para filas de mensagens do Amazon SQS](examples-sqs-long-polling.md)
+ [Definir o tempo limite de visibilidade no SQS](examples-sqs-visibility-timeout.md)
+ [Usar dead letter queues no Amazon SQS](examples-sqs-dead-letter-queues.md)

# Trabalhar com filas de mensagens do Amazon SQS
<a name="examples-sqs-message-queues"></a>

*Fila de mensagens* é o contêiner lógico usado para enviar mensagens de maneira confiável no Amazon SQS. Existem dois tipos de filas: *padrão* e *First-In, First-Out* (FIFO – Primeiro a entrar, primeiro a sair). Para saber mais sobre as filas e as diferenças entre esses tipos, consulte o [Guia do desenvolvedor do Amazon Simple Queue Service](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).

Esses exemplos de C\$1\$1 mostram como usar o AWS SDK para C\$1\$1 para criar, listar, excluir e obter a URL de uma fila do Amazon SQS.

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

## Criar uma fila
<a name="sqs-create-queue"></a>

Use a função de `CreateQueue` membro da SQSClient classe e forneça a ela um [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_create_queue_request.html)objeto que descreva os parâmetros da fila.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/CreateQueueRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::CreateQueueRequest request;
    request.SetQueueName(queueName);

    const Aws::SQS::Model::CreateQueueOutcome outcome = sqsClient.CreateQueue(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully created queue " << queueName << " with a queue URL "
                  << outcome.GetResult().GetQueueUrl() << "." << std::endl;
    }
    else {
        std::cerr << "Error creating queue " << queueName << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/create_queue.cpp).

## Listar filas
<a name="sqs-list-queues"></a>

Para listar as filas do Amazon SQS para sua conta, chame a função de `ListQueues` membro da SQSClient classe e passe um objeto para ela. [ListQueuesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_list_queues_request.html)

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ListQueuesRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::ListQueuesRequest listQueuesRequest;

    Aws::String nextToken; // Used for pagination.
    Aws::Vector<Aws::String> allQueueUrls;

    do {
        if (!nextToken.empty()) {
            listQueuesRequest.SetNextToken(nextToken);
        }
        const Aws::SQS::Model::ListQueuesOutcome outcome = sqsClient.ListQueues(
                listQueuesRequest);
        if (outcome.IsSuccess()) {
            const Aws::Vector<Aws::String> &queueUrls = outcome.GetResult().GetQueueUrls();
            allQueueUrls.insert(allQueueUrls.end(),
                                queueUrls.begin(),
                                queueUrls.end());

            nextToken = outcome.GetResult().GetNextToken();
        }
        else {
            std::cerr << "Error listing queues: " <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }

    } while (!nextToken.empty());

    std::cout << allQueueUrls.size() << " Amazon SQS queue(s) found." << std::endl;
    for (const auto &iter: allQueueUrls) {
        std::cout << " " << iter << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/list_queues.cpp).

## Recuperar o URL da fila
<a name="sqs-get-queue-url"></a>

Para obter a URL de uma fila existente do Amazon SQS, chame a função de membro da SQSClient classe`GetQueueUrl`.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/GetQueueUrlRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::GetQueueUrlRequest request;
    request.SetQueueName(queueName);

    const Aws::SQS::Model::GetQueueUrlOutcome outcome = sqsClient.GetQueueUrl(request);
    if (outcome.IsSuccess()) {
        std::cout << "Queue " << queueName << " has url " <<
                  outcome.GetResult().GetQueueUrl() << std::endl;
    }
    else {
        std::cerr << "Error getting url for queue " << queueName << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/get_queue_url.cpp).

## Excluir uma fila
<a name="sqs-delete-queue"></a>

Forneça o [URL](#sqs-get-queue-url) para a função do `DeleteQueue` membro da SQSClient classe.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/core/client/DefaultRetryStrategy.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/DeleteQueueRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::Model::DeleteQueueRequest request;
    request.SetQueueUrl(queueURL);

    const Aws::SQS::Model::DeleteQueueOutcome outcome = sqsClient.DeleteQueue(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully deleted queue with url " << queueURL <<
                  std::endl;
    }
    else {
        std::cerr << "Error deleting queue " << queueURL << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/delete_queue.cpp).

## Mais informações
<a name="more-info"></a>
+  [How Amazon SQS Queues Work](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) no Guia do desenvolvedor do Amazon Simple Queue Service.
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)na referência de API do Amazon Simple Queue Service
+  [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)na referência de API do Amazon Simple Queue Service
+  [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)na referência de API do Amazon Simple Queue Service
+  [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)na referência de API do Amazon Simple Queue Service

# Enviar, receber e excluir mensagens do Amazon SQS
<a name="examples-sqs-messages"></a>

As mensagens são sempre entregues usando uma [fila do SQS](examples-sqs-message-queues.md). Esses exemplos de C\$1\$1 mostram como usar o AWS SDK para C\$1\$1 para enviar, receber e excluir mensagens do Amazon SQS das filas do SQS.

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

## Enviar uma mensagem
<a name="sqs-message-send"></a>

Você pode adicionar uma única mensagem a uma fila do Amazon SQS chamando a função de membro da SQSClient classe`SendMessage`. Você `SendMessage` fornece um [SendMessageRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_send_message_request.html)objeto contendo o [URL](examples-sqs-message-queues.md#sqs-get-queue-url) da fila, o corpo da mensagem e um valor de atraso opcional (em segundos).

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/SendMessageRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::SendMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetMessageBody(messageBody);

    const Aws::SQS::Model::SendMessageOutcome outcome = sqsClient.SendMessage(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully sent message to " << queueUrl <<
                  std::endl;
    }
    else {
        std::cerr << "Error sending message to " << queueUrl << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/send_message.cpp).

## Receber mensagens
<a name="sqs-messages-receive"></a>

Recupere todas as mensagens que estão atualmente na fila chamando a função do `ReceiveMessage` membro da SQSClient classe, passando a URL da fila. As mensagens são retornadas como uma lista de objetos [Message](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_message.html).

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ReceiveMessageRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::ReceiveMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetMaxNumberOfMessages(1);

    const Aws::SQS::Model::ReceiveMessageOutcome outcome = sqsClient.ReceiveMessage(
            request);
    if (outcome.IsSuccess()) {

        const Aws::Vector<Aws::SQS::Model::Message> &messages =
                outcome.GetResult().GetMessages();
        if (!messages.empty()) {
            const Aws::SQS::Model::Message &message = messages[0];
            std::cout << "Received message:" << std::endl;
            std::cout << "  MessageId: " << message.GetMessageId() << std::endl;
            std::cout << "  ReceiptHandle: " << message.GetReceiptHandle() << std::endl;
            std::cout << "  Body: " << message.GetBody() << std::endl << std::endl;
        }
        else {
            std::cout << "No messages received from queue " << queueUrl <<
                      std::endl;

        }
    }
    else {
        std::cerr << "Error receiving message from queue " << queueUrl << ": "
                  << outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

### Excluir mensagens depois do recebimento
<a name="sqs-messages-delete"></a>

Depois de receber uma mensagem e processar seu conteúdo, exclua a mensagem da fila enviando o identificador de recebimento da mensagem e o URL da fila para a função de `DeleteMessage` membro da SQSClient classe.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/DeleteMessageRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::Model::DeleteMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetReceiptHandle(messageReceiptHandle);

    const Aws::SQS::Model::DeleteMessageOutcome outcome = sqsClient.DeleteMessage(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully deleted message from queue " << queueUrl
                  << std::endl;
    }
    else {
        std::cerr << "Error deleting message from queue " << queueUrl << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

## Mais informações
<a name="more-info"></a>
+  [How Amazon SQS Queues Work](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) no Guia do desenvolvedor do Amazon Simple Queue Service.
+  [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)na referência de API do Amazon Simple Queue Service
+  [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)na referência de API do Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)na referência de API do Amazon Simple Queue Service
+  [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)na referência de API do Amazon Simple Queue Service

# Habilitar a sondagem longa para filas de mensagens do Amazon SQS
<a name="examples-sqs-long-polling"></a>

Por padrão, o Amazon SQS; usa *sondagem curta*, consultando somente um subconjunto dos servidores, com base em uma distribuição aleatória ponderada, para determinar se há alguma mensagem disponível para inclusão na resposta.

A sondagem longa ajuda a reduzir seu custo de uso do Amazon SQS, reduzindo o número de respostas vazias quando não há mensagens disponíveis para retornar em resposta a ReceiveMessage uma solicitação enviada para uma fila do Amazon SQS e eliminando respostas falsas vazias. Você pode definir uma frequência de sondagem longa de *1 a 20 segundos*.

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

## Habilitar a sondagem longa ao criar uma fila
<a name="sqs-long-polling-create-queue"></a>

Para permitir uma sondagem longa ao criar uma fila do Amazon SQS, defina `ReceiveMessageWaitTimeSeconds` o atributo no objeto antes de chamar [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_create_queue_request.html)a função de membro SQSClient da `CreateQueue` classe.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/CreateQueueRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::CreateQueueRequest request;
    request.SetQueueName(queueName);
    request.AddAttributes(
            Aws::SQS::Model::QueueAttributeName::ReceiveMessageWaitTimeSeconds,
            pollTimeSeconds);

    const Aws::SQS::Model::CreateQueueOutcome outcome = sqsClient.CreateQueue(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully created queue " << queueName <<
                  std::endl;
    }
    else {
        std::cout << "Error creating queue " << queueName << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_create_queue.cpp).

## Habilitar a sondagem longa em uma fila existente
<a name="sqs-long-polling-existing-queue"></a>

Além de ativar a sondagem longa ao criar uma fila, você também pode ativá-la em uma fila existente `ReceiveMessageWaitTimeSeconds` configurando a função de membro da SQSClient classe [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_set_queue_attributes_request.html)`SetQueueAttributes`antes de chamar.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/SetQueueAttributesRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(clientConfiguration);

    Aws::SQS::Model::SetQueueAttributesRequest request;
    request.SetQueueUrl(queueURL);
    request.AddAttributes(
            Aws::SQS::Model::QueueAttributeName::ReceiveMessageWaitTimeSeconds,
            pollTimeSeconds);

    const Aws::SQS::Model::SetQueueAttributesOutcome outcome = sqsClient.SetQueueAttributes(
            request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully updated long polling time for queue " <<
                  queueURL << " to " << pollTimeSeconds << std::endl;
    }
    else {
        std::cout << "Error updating long polling time for queue " <<
                  queueURL << ": " << outcome.GetError().GetMessage() <<
                  std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_existing_queue.cpp).

## Habilitar sondagem longa no recebimento da mensagem
<a name="sqs-long-polling-receive-message"></a>

Você pode ativar a sondagem longa ao receber uma mensagem definindo o tempo de espera em segundos no [ReceiveMessageRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_receive_message_request.html)que você fornece para a função de ReceiveMessage membro da SQSClient classe.

**nota**  
Você deve se certificar de que o tempo limite da solicitação do AWS cliente seja maior que o tempo máximo de pesquisa longa (20s) para que suas `ReceiveMessage` solicitações não se esgotem enquanto aguarda o próximo evento de enquete\$1

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ReceiveMessageRequest.h>
```

 **Código** 

```
    Aws::SQS::SQSClient sqsClient(customConfiguration);

    Aws::SQS::Model::ReceiveMessageRequest request;
    request.SetQueueUrl(queueUrl);
    request.SetMaxNumberOfMessages(1);
    request.SetWaitTimeSeconds(waitTimeSeconds);

    auto outcome = sqsClient.ReceiveMessage(request);
    if (outcome.IsSuccess()) {
        const auto &messages = outcome.GetResult().GetMessages();
        if (messages.empty()) {
            std::cout << "No messages received from queue " << queueUrl <<
                      std::endl;
        }
        else {
            const auto &message = messages[0];
            std::cout << "Received message:" << std::endl;
            std::cout << "  MessageId: " << message.GetMessageId() << std::endl;
            std::cout << "  ReceiptHandle: " << message.GetReceiptHandle() << std::endl;
            std::cout << "  Body: " << message.GetBody() << std::endl << std::endl;
        }
    }
    else {
        std::cout << "Error receiving message from queue " << queueUrl << ": "
                  << outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_message_receipt.cpp).

## Mais informações
<a name="more-info"></a>
+  [Amazon SQS Long Polling](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) no Guia do desenvolvedor do Amazon Simple Queue Service.
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)na referência de API do Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)na referência de API do Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)na referência de API do Amazon Simple Queue Service

# Definir o tempo limite de visibilidade no SQS
<a name="examples-sqs-visibility-timeout"></a>

Quando for recebida no Amazon SQS, uma mensagem permanecerá na fila até ser excluída para garantir o recebimento. Uma mensagem que foi recebida, mas não excluída, estará disponível em requisições subsequentes depois de um determinado *tempo limite de visibilidade* para ajudar a evitar que a mensagem seja recebida mais de uma vez antes de ser processada e excluída.

Ao usar [filas padrão](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), o tempo limite de visibilidade não é uma garantia em relação ao recebimento de uma mensagem duas vezes. Se você estiver usando uma fila padrão, verifique se o código pode processar o caso em que a mesma mensagem foi entregue mais de uma vez.

## 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 o tempo limite de visibilidade de mensagens no recebimento de mensagens
<a name="sqs-visibility-timeout-receipt"></a>

Depois de receber uma mensagem, você pode modificar seu tempo limite de visibilidade passando o identificador de recebimento em um [ChangeMessageVisibilityRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_change_message_visibility_request.html)que você passa para a função de `ChangeMessageVisibility` membro da SQSClient classe.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/ChangeMessageVisibilityRequest.h>
#include <aws/sqs/model/ReceiveMessageRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::Model::ChangeMessageVisibilityRequest request;
    request.SetQueueUrl(queue_url);
    request.SetReceiptHandle(messageReceiptHandle);
    request.SetVisibilityTimeout(visibilityTimeoutSeconds);

    auto outcome = sqsClient.ChangeMessageVisibility(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully changed visibility of message " <<
                  messageReceiptHandle << " from queue " << queue_url << std::endl;
    }
    else {
        std::cout << "Error changing visibility of message from queue "
                  << queue_url << ": " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/change_message_visibility.cpp).

## Mais informações
<a name="more-info"></a>
+  [Tempo limite de visibilidade](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) no Guia do desenvolvedor do Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)na referência de API do Amazon Simple Queue Service
+  [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)na referência de API do Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)na referência de API do Amazon Simple Queue Service
+  [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)na referência de API do Amazon Simple Queue Service
+  [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)na referência de API do Amazon Simple Queue Service

# Usar dead letter queues no Amazon SQS
<a name="examples-sqs-dead-letter-queues"></a>

O Amazon SQS comporta *filas de mensagens não entregues*. Fila de mensagens não entregues é uma fila para a qual outras filas podem enviar as mensagens que não são processadas com êxito. Você pode separar e isolar essas mensagens na dead letter queue para determinar por que o processamento não teve sucesso.

Para criar uma fila de mensagens não entregues, é necessário criar primeiro uma *política de redirecionamento* e definir a política nos atributos da fila.

**Importante**  
Uma fila de mensagens não entregues deve ter o mesmo tipo de fila (FIFO ou padrão) da fila de origem. Ela também deve ser criada usando a mesma fila Conta da AWS e Região da AWS como a de origem.

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

## Criar uma política de redirecionamento
<a name="sqs-dead-letter-queue-create-redrive-policy"></a>

Uma política de redirecionamento é especificada em JSON. Para criá-la, você pode usar a classe de utilitário JSON fornecida com o AWS SDK para C\$1\$1.

Veja um exemplo de função que cria uma política de redirecionamento fornecendo a ela o ARN da fila de mensagens não entregues, além do número máximo de vezes em que a mensagem pode ser recebida e não processada antes ser enviada à fila de mensagens não entregues.

 **Inclui** 

```
#include <aws/core/Aws.h>
#include <aws/core/utils/json/JsonSerializer.h>
```

 **Código** 

```
Aws::String MakeRedrivePolicy(const Aws::String &queueArn, int maxReceiveCount) {
    Aws::Utils::Json::JsonValue redrive_arn_entry;
    redrive_arn_entry.AsString(queueArn);

    Aws::Utils::Json::JsonValue max_msg_entry;
    max_msg_entry.AsInteger(maxReceiveCount);

    Aws::Utils::Json::JsonValue policy_map;
    policy_map.WithObject("deadLetterTargetArn", redrive_arn_entry);
    policy_map.WithObject("maxReceiveCount", max_msg_entry);

    return policy_map.View().WriteReadable();
}
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Definir a política de redirecionamento em sua fila de origem
<a name="sqs-dead-letter-queue-set-redrive-policy"></a>

Para concluir a configuração da fila de letras mortas, chame a função de `SetQueueAttributes` membro da SQSClient classe com um [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-sqs/html/class_aws_1_1_s_q_s_1_1_model_1_1_set_queue_attributes_request.html)objeto para o qual você definiu o `RedrivePolicy` atributo com sua política de redrive JSON.

 **Inclui** 

```
#include <aws/sqs/SQSClient.h>
#include <aws/sqs/model/SetQueueAttributesRequest.h>
#include <iostream>
```

 **Código** 

```
    Aws::SQS::Model::SetQueueAttributesRequest request;
    request.SetQueueUrl(srcQueueUrl);
    request.AddAttributes(
            Aws::SQS::Model::QueueAttributeName::RedrivePolicy,
            redrivePolicy);

    const Aws::SQS::Model::SetQueueAttributesOutcome outcome =
            sqsClient.SetQueueAttributes(request);
    if (outcome.IsSuccess()) {
        std::cout << "Successfully set dead letter queue for queue  " <<
                  srcQueueUrl << " to " << deadLetterQueueARN << std::endl;
    }
    else {
        std::cerr << "Error setting dead letter queue for queue " <<
                  srcQueueUrl << ": " << outcome.GetError().GetMessage() <<
                  std::endl;
    }
```

Consulte o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Mais informações
<a name="more-info"></a>
+  [Usar filas de mensagens não entregues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) no Guia do desenvolvedor do Amazon Simple Queue Service.
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)na referência de API do Amazon Simple Queue Service