Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejemplos guiados de llamadas Servicios de AWS mediante el AWS SDK para C\$1\$1
<a name="programming-services"></a>

Si es nuevo en los ejemplos de AWS código, le recomendamos que comience con[Introducción a los ejemplos de código](getting-started-code-examples.md). AWS 

El código fuente que muestra cómo trabajar con AWS los servicios mediante el AWS SDK para C\$1\$1 está disponible en el [Ejemplos de código](cpp_code_examples.md) capítulo de esta guía o directamente en el [repositorio de ejemplos de AWS código](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) en GitHub. 

Esta sección selecciona varios AWS servicios y le guía a través de los ejemplos en los que se utilizan. Los siguientes ejemplos guiados son un subconjunto de lo que está disponible en GitHub.


**Ejemplos de servicios con una explicación adicional (consulte el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code) para ver la lista completa)**  

| Servicio | Resumen de lo que el servicio proporciona al programa | 
| --- | --- | 
| [Amazon CloudWatch](examples-cloudwatch.md) | Recopila y monitorea las métricas de AWS los recursos que está utilizando | 
| [Amazon DynamoDB](examples-dynamodb.md) | Un servicio de base de datos NoSQL | 
| [Amazon Elastic Compute Cloud (Amazon EC2)](examples-ec2.md) | Capacidad de computación segura y de tamaño ajustable | 
| [Amazon Simple Storage Service (Amazon S3)](examples-s3.md) | Almacenamiento y recuperación de datos (objetos en buckets) | 
| [Amazon Simple Queue Service (Amazon SQS)](examples-sqs.md) | Servicio de cola de mensajes para enviar, almacenar y recibir mensajes entre componentes de software | 

También hay ejemplos que muestran cómo utilizar los [métodos asíncronos](async-methods.md).

Para proponer un nuevo ejemplo de código al equipo de AWS documentación, consulta [las pautas de contribución](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/CONTRIBUTING.md) sobre GitHub la creación de una nueva solicitud. El equipo prefiere crear ejemplos de código que muestren escenarios amplios en lugar de llamadas individuales a la API.

**Uso de los ejemplos de código en Windows**

Si está compilando los ejemplos en Windows con la versión 1.9 del SDK, consulte [Solución de problemas de compilación del AWS SDK para C\$1\$1](troubleshooting-cmake.md).

# CloudWatch Ejemplos de Amazon que utilizan el AWS SDK para C\$1\$1
<a name="examples-cloudwatch"></a>

Amazon CloudWatch (CloudWatch) es un servicio de supervisión de los recursos de la AWS nube y las aplicaciones en las que se ejecuta AWS. Puede utilizar los siguientes ejemplos para programar [CloudWatch](https://aws.amazon.com/cloudwatch)con AWS SDK para C\$1\$1.

Amazon CloudWatch monitorea tus AWS recursos y las aplicaciones en las que AWS ejecutas en tiempo real. Puede utilizarlas CloudWatch para recopilar y realizar un seguimiento de las métricas, que son variables que puede medir para sus recursos y aplicaciones. CloudWatchlas alarmas envían notificaciones o modifican automáticamente los recursos que está supervisando en función de las reglas que usted defina.

Para obtener más información al respecto CloudWatch, consulta la [Guía del CloudWatch usuario de Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/).

**nota**  
En esta guía solo se proporciona el código necesario para demostrar determinadas técnicas, pero el [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub Puede descargar un único archivo fuente o clonar el repositorio localmente para obtener, compilar y ejecutar todos los ejemplos.

**Topics**
+ [Obtención de métricas de CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Publicación de datos de métricas personalizadas](examples-cloudwatch-publish-custom-metrics.md)
+ [Trabajar con CloudWatch alarmas](examples-cloudwatch-create-alarms.md)
+ [Uso de acciones de alarma en CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Envío de eventos a CloudWatch](examples-cloudwatch-send-events.md)

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

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

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

Para enumerar CloudWatch las métricas, cree una [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)y llame a CloudWatchClient la `ListMetrics` función. Puede utilizar el objeto `ListMetricsRequest` para filtrar las métricas devueltas por espacio de nombres, nombre de métrica o dimensiones.

**nota**  
Puedes encontrar una lista de métricas y dimensiones publicadas por AWS servicios en la [referencia de CloudWatch métricas y dimensiones de Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CW_Support_For_AWS.html) en la Guía del CloudWatch usuario de Amazon.

 **Incluye** 

```
#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();
        }
```

Las métricas se devuelven en 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)mediante una llamada a su `GetMetrics` función. Los resultados puede que estén *paginados*. Para recuperar el siguiente lote de resultados, llame a `SetNextToken` en el objeto de la solicitud original con el valor devuelto de la función `GetNextToken` del objeto `ListMetricsResult` y transfiera el objeto de la solicitud modificado a otra llamada a `ListMetrics`.

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

## Más información
<a name="more-information"></a>
+  [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/ListMetrics.html)en la referencia de la CloudWatch API de Amazon.

# Publicación de datos de métricas personalizadas
<a name="examples-cloudwatch-publish-custom-metrics"></a>

Varios AWS servicios publican [sus propias métricas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) en espacios de nombres empezando por. También `AWS/` puedes publicar datos de métricas personalizados con tu propio espacio de nombres (siempre y cuando no empiece por). `AWS/`

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Publicación de datos de métricas personalizadas
<a name="publish-custom-metric-data"></a>

Para publicar sus propios datos métricos, llame a la `PutMetricData` función CloudWatchClient's con un [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). `PutMetricDataRequest`Debe incluir el espacio de nombres personalizado que se utilizará para los datos e información sobre el propio punto de datos de un [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**  
No puede especificar un espacio de nombres que comience por. `AWS/` Los espacios de nombres que empiezan por `AWS/` están reservados para su uso por los productos de Amazon Web Services.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/put_metric_data.cpp)

## Más información
<a name="more-information"></a>
+  [Uso de Amazon CloudWatch Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) en la Guía del CloudWatch usuario de Amazon.
+  [AWS Espacios de nombres](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) en la Guía del CloudWatch usuario de Amazon.
+  [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricData.html)en la referencia de la CloudWatch API de Amazon.

# Trabajar con CloudWatch alarmas
<a name="examples-cloudwatch-create-alarms"></a>

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Crear una alarma
<a name="create-an-alarm"></a>

Para crear una alarma basada en una CloudWatch métrica, llama a CloudWatchClient la `PutMetricAlarm` función s y [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)rellena con las condiciones de la alarma.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/put_metric_alarm.cpp)

## Mostrar alarmas
<a name="list-alarms"></a>

Para enumerar las CloudWatch alarmas que ha creado, llame a CloudWatchClient la `DescribeAlarms` función s con una [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 pueda usar para configurar las opciones del resultado.

 **Incluye** 

```
#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();
        }
```

La lista de alarmas se puede obtener llamando `getMetricAlarms` a la [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 devuelve`DescribeAlarms`.

Los resultados puede que estén *paginados*. Para recuperar el siguiente lote de resultados, llame a `SetNextToken` en el objeto de la solicitud original con el valor devuelto de la función `GetNextToken` del objeto `DescribeAlarmsResult` y transfiera el objeto de la solicitud modificado a otra llamada a `DescribeAlarms`.

**nota**  
También puede recuperar las alarmas de una métrica específica mediante CloudWatchClient la `DescribeAlarmsForMetric` función. Su uso es similar a `DescribeAlarms`.

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

## Eliminar alarmas
<a name="delete-alarms"></a>

Para eliminar CloudWatch las alarmas, llame a CloudWatchClient la `DeleteAlarms` función [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)que contenga uno o más nombres de las alarmas que desee eliminar.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/delete_alarm.cpp)

## Más información
<a name="more-information"></a>
+  [Creación de CloudWatch alarmas de Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) en la guía del CloudWatch usuario de Amazon
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)en la referencia de la CloudWatch API de Amazon
+  [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DescribeAlarms.html)en la referencia de la CloudWatch API de Amazon
+  [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DeleteAlarms.html)en la referencia de la CloudWatch API de Amazon

# Uso de acciones de alarma en CloudWatch
<a name="examples-cloudwatch-use-alarm-actions"></a>

Con las acciones de CloudWatch alarma, puede crear alarmas que realicen acciones como detener, finalizar, reiniciar o recuperar automáticamente las instancias de Amazon EC2.

[Las acciones de alarma se pueden añadir a una alarma mediante la `SetAlarmActions` función s al [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)crear una alarma.](examples-cloudwatch-create-alarms.md)

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Habilitar acciones de alarma
<a name="enable-alarm-actions"></a>

Para activar las acciones de CloudWatch alarma de una alarma, llame a las CloudWatchClient [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)que contengan uno o más nombres de las alarmas cuyas acciones desee activar. `EnableAlarmActions`

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/enable_alarm_actions.cpp)

## Deshabilitar acciones de alarma
<a name="disable-alarm-actions"></a>

Para desactivar las acciones de CloudWatch alarma de una alarma, llama a las CloudWatchClient [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)que contengan uno o más nombres de las alarmas cuyas acciones desees desactivar. `DisableAlarmActions`

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch/disable_alarm_actions.cpp)

## Más información
<a name="more-information"></a>
+  [Cree alarmas para detener, finalizar, reiniciar o recuperar una instancia](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) en la Guía del CloudWatch usuario de Amazon
+  [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/PutMetricAlarm.html)en la referencia de la CloudWatch API de Amazon
+  [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/EnableAlarmActions.html)en la referencia de la CloudWatch API de Amazon
+  [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/DisableAlarmActions.html)en la referencia de la CloudWatch API de Amazon

# Envío de eventos a CloudWatch
<a name="examples-cloudwatch-send-events"></a>

CloudWatch Events ofrece una transmisión casi en tiempo real de los eventos del sistema que describen los cambios en los AWS recursos en las instancias de Amazon EC2, las funciones de Lambda, las transmisiones de Kinesis, las tareas de Amazon ECS, las máquinas de estado de Step Functions, los temas de Amazon SNS, las colas de Amazon SQS o los objetivos integrados. Mediante reglas sencillas, puede asignar los eventos y dirigirlos a una o más secuencias o funciones de destino.

**nota**  
[Estos fragmentos de código suponen que usted entiende el material de la sección [Cómo empezar a utilizar el código AWS SDK para C\$1\$1 y que ha configurado las credenciales predeterminadas AWS con la](getting-started.md) información que aparece en Proporcionar credenciales. AWS](credentials.md)

## Añadir eventos
<a name="add-events"></a>

Para añadir CloudWatch eventos personalizados, llame a la `PutEvents` función CloudWatchEventsClient's con un [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 contenga uno o más [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 proporcionen detalles sobre cada evento. Puede especificar varios parámetros para la entrada como el origen y el tipo del evento, los recursos asociados con el evento, etc.

**nota**  
Puede especificar un máximo de 10 eventos para cada llamada a `putEvents`.

 **Incluye** 

```
#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;
        }
```

## Añadir reglas
<a name="add-rules"></a>

Para crear o actualizar una regla, llame a la CloudWatchEventsClient `PutRule` función con una [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)con el nombre de la regla y parámetros opcionales, como el [patrón de eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), la función de IAM que desee asociar a la regla y una [expresión de programación](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) que describa la frecuencia con la que se ejecuta la regla.

 **Incluye** 

```
#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;
        }
```

## Añadir destinos
<a name="add-targets"></a>

Los destinos son los recursos que se invocan cuando se activa una regla. Algunos ejemplos de destinos son las instancias de Amazon ECS, funciones de Lambda, flujos de Kinesis, tareas de Amazon EC2, máquinas de estado de Step Functions y destinos integrados.

Para añadir un destino a una regla, llama a la `PutTargets` función CloudWatchEventsClient's con una [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)que contenga la regla que deseas actualizar y una lista de objetivos que añadir a la regla.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/eventbridge/put_targets.cpp)

## Más información
<a name="more-information"></a>
+  [Añadir eventos PutEvents en la](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) Guía del usuario de Amazon CloudWatch Events
+  [Programe expresiones para reglas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) en la guía del usuario de Amazon CloudWatch Events
+  [Tipos de CloudWatch eventos para eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) en la Guía del usuario de Amazon CloudWatch Events
+  [Eventos y patrones de eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) en la guía del usuario de Amazon CloudWatch Events
+  [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutEvents.html)en la referencia de la API de Amazon CloudWatch Events
+  [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutTargets.html)en la referencia de la API de Amazon CloudWatch Events
+  [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/PutRule.html)en la referencia de la API de Amazon CloudWatch Events

# Ejemplos de Amazon DynamoDB que utilizan AWS SDK para C\$1\$1
<a name="examples-dynamodb"></a>

Amazon DynamoDB es un servicio de base de datos NoSQL totalmente administrado que ofrece un rendimiento rápido y predecible, así como una perfecta escalabilidad. En los ejemplos siguientes se muestra cómo puede programar [Amazon DynamoDB](https://aws.amazon.com/dynamodb) con el AWS SDK para C\$1\$1.

**nota**  
En esta guía solo se proporciona el código necesario para demostrar determinadas técnicas, pero el [código de ejemplo completo está disponible](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp) en. GitHub GitHub Puede descargar un único archivo fuente o clonar el repositorio localmente para obtener, compilar y ejecutar todos los ejemplos.

**Topics**
+ [Uso de tablas en DynamoDB](examples-dynamodb-tables.md)
+ [Uso de elementos en DynamoDB](examples-dynamodb-items.md)

# Uso de tablas en DynamoDB
<a name="examples-dynamodb-tables"></a>

Las tablas son los contenedores de todos los elementos de una base de datos de DynamoDB. Para poder añadir o eliminar datos de DynamoDB, debe crear una tabla.

Para cada tabla, debe definir:
+ Un *nombre* de tabla que sea exclusivo para su Cuenta de AWS y Región de AWS.
+ Una *clave principal* para la que cada valor debe ser único. No hay dos elementos de la tabla que puedan tener el mismo valor de clave principal.

  Una clave principal puede ser *simple*, formada por una sola clave de partición (HASH) o *compuesta*, formada por una clave de partición y una clave de ordenación (RANGE).

  Cada valor de clave tiene un *tipo de datos* asociado, enumerado por la clase [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). El valor de clave puede ser binario (B), numérico (N) o una cadena (S). Para obtener más información, consulte [Reglas de nomenclatura y tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) en la Guía para desarrolladores de Amazon DynamoDB.
+  Valores de *rendimiento aprovisionados* que definen el número de unidades de read/write capacidad reservadas para la tabla.
**nota**  
 [Los precios de Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) se basan en los valores de desempeño aprovisionado que puede definir en sus tablas para que solo se reserve la capacidad que piensa que va a necesitar para la tabla.  
El desempeño aprovisionado para una tabla se puede modificar en cualquier momento, por lo que puede ajustar la capacidad si cambian sus necesidades.

## Crear una tabla
<a name="dynamodb-create-table"></a>

Use el método `CreateTable` del [cliente de 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 crear una tabla de DynamoDB. Debe crear los atributos de la tabla y un esquema de tabla, que se pueden usar para identificar la clave principal de la tabla. También debe proporcionar los valores iniciales de rendimiento aprovisionados y un nombre de tabla. `CreateTable` es una operación asíncrona. `GetTableStatus` devolverá CREATING hasta que la tabla esté ACTIVE y lista para su uso.

### Creación de una tabla con una clave principal simple
<a name="dynamodb-create-table-simple"></a>

Este código crea una tabla con una clave principal simple ("Name").

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/create_table.cpp)

### Creación de una tabla con una clave primaria compuesta
<a name="dynamodb-create-table-composite"></a>

Agrega otra [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)mano [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)a [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).

 **Incluye** 

```
#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);
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/create_table_composite_key.cpp) en GitHub.

## Mostrar tablas
<a name="dynamodb-list-tables"></a>

Puede mostrar las tablas de una región determinada llamando al método `ListTables` del [cliente de 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).

 **Incluye** 

```
#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;
}
```

De forma predeterminada, se devuelven hasta 100 tablas por llamada. `GetExclusiveStartTableName`Utilícelo en el [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 devuelto para obtener la última tabla que se evaluó. Puede utilizar este valor para iniciar el listado después del último valor devuelto de la enumeración anterior.

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

## Recuperación de información sobre una tabla
<a name="dynamodb-describe-table"></a>

Puede obtener más información sobre una tabla llamando al método `DescribeTable` del [cliente de 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).

 **Incluye** 

```
#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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/describe_table.cpp) en GitHub.

## Modificación de una tabla
<a name="dynamodb-update-table"></a>

Puede modificar los valores de rendimiento aprovisionados de la tabla en cualquier momento llamando al método `UpdateTable` del [cliente de 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).

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/update_table.cpp)

## Eliminar una tabla
<a name="dynamodb-delete-table"></a>

Llame al método `DeleteTable` del [cliente de 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) y transfiérale el nombre de la tabla.

 **Incluye** 

```
#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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/delete_table.cpp) en GitHub.

## Más información
<a name="more-info"></a>
+  [Prácticas recomendadas para trabajar con tablas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) en la Guía para desarrolladores de Amazon DynamoDB
+  [Uso de tablas en DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) en la Guía para desarrolladores de Amazon DynamoDB

# Uso de elementos en DynamoDB
<a name="examples-dynamodb-items"></a>

En DynamoDB, un elemento es una colección de *atributos*, cada uno de los cuales tiene un *nombre* y un *valor*. Los valores de los atributos pueden ser escalares, conjuntos o tipos de documentos. Para obtener más información, consulte [Reglas de nomenclatura y tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) en la Guía para desarrolladores de Amazon DynamoDB.

## Recuperación de un elemento de una tabla
<a name="dynamodb-get-item"></a>

Llame al método `GetItem` del [cliente de 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). Pásele un [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 con el nombre de la tabla y el valor de la clave principal del elemento que desee. Devuelve un [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.

Puede utilizar el `GetItem()` método del `GetItemResult` objeto devuelto para recuperar uno `Aws::Map` de los [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 clave `Aws::String` y valor asociados al elemento.

 **Incluye** 

```
#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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/get_item.cpp) en GitHub.

## Adición de un nuevo elemento a una tabla
<a name="dynamodb-add-item"></a>

Cree [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 claves `Aws::String` y valores que representen cada elemento. Estos deben incluir valores para los campos de la clave principal de la tabla. Si el elemento identificado por la clave principal ya existe, la solicitud *actualiza* sus campos. Agréguelos al método [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)mediante el `AddItem` método.

 **Incluye** 

```
#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);
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/put_item.cpp) en GitHub.

## Actualizar un elemento existente en una tabla
<a name="dynamodb-update-item"></a>

Puede actualizar un atributo de un elemento que ya existe en una tabla mediante el `UpdateItem` método de Dynamo, que proporciona el nombre DBClient de la tabla, el valor de la clave principal y los campos que se van a actualizar y su valor correspondiente.

 **Importaciones** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb/update_item.cpp)

## Más información
<a name="more-info"></a>
+  [Prácticas recomendadas para el uso de elementos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) en la Guía para desarrolladores de Amazon DynamoDB
+  [Uso de elementos en DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) en la Guía para desarrolladores de Amazon DynamoDB

# Ejemplos de Amazon EC2 que utilizan AWS SDK para C\$1\$1
<a name="examples-ec2"></a>

Amazon Elastic Compute Cloud (Amazon EC2) es un servicio web que proporciona capacidad de computación de tamaño variable, literalmente, en servidores de los centros de datos de Amazon, que puede usar para compilar y alojar sus sistemas de software. Puede utilizar los siguientes ejemplos para programar [Amazon EC2](https://aws.amazon.com/ec2) con el AWS SDK para C\$1\$1.

**nota**  
En esta guía solo se proporciona el código necesario para demostrar determinadas técnicas, pero el [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub Puede descargar un único archivo fuente o clonar el repositorio localmente para obtener, compilar y ejecutar todos los ejemplos.

**Topics**
+ [Administración de instancias de Amazon EC2](examples-ec2-instances.md)
+ [Uso de direcciones IP elásticas en Amazon EC2](examples-ec2-elastic-ip.md)
+ [Uso de las regiones y las zonas de disponibilidad de Amazon EC2](examples-ec2-regions-zones.md)
+ [Uso de pares de claves de Amazon EC2](examples-ec2-key-pairs.md)
+ [Trabajar con grupos de seguridad en Amazon EC2](examples-ec2-security-groups.md)

# Administración de instancias de Amazon EC2
<a name="examples-ec2-instances"></a>

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Crear una instancia de
<a name="create-an-instance"></a>

Cree una nueva instancia de Amazon EC2 llamando a la `RunInstances` función del EC2 cliente y proporcionándole una [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)que contenga la [imagen de máquina de Amazon (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) que va a utilizar y un tipo de [instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/run_instances.cpp)

## Inicio de una instancia
<a name="start-an-instance"></a>

Para iniciar una instancia de Amazon EC2, llame a la `StartInstances` función del EC2 cliente y suministre una [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)que contenga el ID de la instancia que se va a iniciar.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/start_stop_instance.cpp)

## Detención de una instancia
<a name="stop-an-instance"></a>

Para detener una instancia de Amazon EC2, llame a la `StopInstances` función del EC2 cliente y suministre el ID de [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)la instancia que se va a detener.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/start_stop_instance.cpp)

## Reiniciar una instancia
<a name="reboot-an-instance"></a>

Para reiniciar una instancia de Amazon EC2, llame a la `RebootInstances` función del EC2 cliente y suministre el ID de [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)la instancia que se va a reiniciar.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/reboot_instance.cpp)

## Describir instancias
<a name="describe-instances"></a>

Para enumerar tus instancias, crea una `DescribeInstances` función del EC2 cliente [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)y llámala. Devolverá un [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 puede utilizar para enumerar las instancias de Amazon EC2 para su Cuenta de AWS y. Región de AWS

Las instancias se agrupan por *reserva*. Cada reserva se corresponde con la llamada a `StartInstances` que lanzó la instancia. Para mostrar sus instancias, primero debe llamar a la función `GetReservations` de la clase `DescribeInstancesResponse` y, a continuación, llamar a `getInstances` en cada objeto Reservation devuelto.

 **Incluye** 

```
#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;
        }
    }
```

Los resultados se paginan; puede obtener más resultados transfiriendo el valor devuelto de la función `GetNextToken` del objeto resultante a la función `SetNextToken` del objeto de la solicitud original, y después usando el mismo objeto de solicitud en la siguiente llamada a `DescribeInstances`.

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

## Habilitación de la monitorización de instancias
<a name="enable-instance-monitoring"></a>

Puede monitorizar distintos aspectos de las instancias de Amazon EC2, como el uso de la CPU y la red, la memoria disponible y el espacio en disco restante. Para obtener más información sobre la monitorización de instancias, consulte [Monitoreo de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) en la Guía del usuario de Amazon EC2.

Para empezar a monitorizar una instancia, debe crear una [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)con el ID de la instancia que se va a monitorizar y pasarla a la `MonitorInstances` función del EC2 cliente.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/monitor_instance.cpp)

## Deshabilitación de la monitorización de instancias
<a name="disable-instance-monitoring"></a>

Para dejar de monitorizar una instancia, crea una [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)con el ID de la instancia para detener la monitorización y pásala a la `UnmonitorInstances` función del EC2 cliente.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/monitor_instance.cpp)

## Más información
<a name="more-information"></a>
+  [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)en la referencia de la API de Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)en la referencia de la API de Amazon EC2
+  [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)en la referencia de la API de Amazon EC2
+  [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)en la referencia de la API de Amazon EC2
+  [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html)en la referencia de la API de Amazon EC2
+  [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)en la referencia de la API de Amazon EC2
+  [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html)en la referencia de la API de Amazon EC2
+  [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html)en la referencia de la API de Amazon EC2

# Uso de direcciones IP elásticas en Amazon EC2
<a name="examples-ec2-elastic-ip"></a>

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Asignación de una dirección IP elástica
<a name="allocate-an-elastic-ip-address"></a>

Para utilizar una dirección IP elástica, primero asigne una a su cuenta y, a continuación, asóciela a su instancia o a una interfaz de red.

Para asignar una dirección IP elástica, llame a la `AllocateAddress` función del EC2 cliente con un [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 que contenga el tipo de red (EC2 clásico o VPC). 

**aviso**  
Vamos a retirar EC2-Classic el 15 de agosto de 2022. Le recomendamos que migre de EC2-Classic a una VPC. Para obtener más información, consulte **Migración de EC2-Classic a una VPC** en la [Guía del usuario de Amazon EC2 para instancias de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html) o en la [Guía del usuario de Amazon EC2 para instancias de Windows](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/vpc-migrate.html). Consulte también la entrada de 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/) (Se va a retirar la red EC2-Classic: cómo prepararse).

La [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)clase del objeto de respuesta contiene un identificador de asignación que puede utilizar para asociar la dirección a una instancia, pasando el identificador de asignación y el identificador de instancia en [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 a la función del EC2 `AssociateAddress` cliente.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/allocate_address.cpp)

## Describir direcciones IP elásticas
<a name="describe-elastic-ip-addresses"></a>

Para ver las direcciones IP elásticas asignadas a su cuenta, llame a la `DescribeAddresses` función del EC2 Cliente. Devuelve un objeto de resultado que contiene un objeto [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 puede utilizar para obtener una lista de objetos de [dirección](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 representan las direcciones IP elásticas de su cuenta.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_addresses.cpp)

## Liberación de una dirección IP elástica
<a name="release-an-elastic-ip-address"></a>

Para liberar una dirección IP elástica, llame a la `ReleaseAddress` función del EC2 cliente y pásele una que [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)contenga el ID de asignación de la dirección IP elástica que desee liberar.

 **Incluye** 

```
#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;
    }
```

Después de publicar una dirección IP elástica, se transfiere al conjunto de direcciones AWS IP y es posible que no esté disponible para usted posteriormente. Asegúrese de actualizar sus registros DNS y los servidores o dispositivos que se comunican con la dirección. Si intenta liberar una dirección IP elástica que ya ha publicado, aparecerá un mensaje de *AuthFailure*error si la dirección ya está asignada a otra AWS cuenta.

Si utiliza una *VPC predeterminada*, al liberar una dirección IP elástica, esta se desvincula automáticamente de cualquier instancia a la que esté asociada. Para desasociar una dirección IP elástica sin liberarla, utilice la `DisassociateAddress` función del EC2 cliente.

Si utiliza una VPC distinta de la predeterminada, *debe* usar `DisassociateAddress` para desvincular la dirección IP elástica antes de intentar liberarla. *De lo contrario, Amazon EC2 devuelve un error (no válido). IPAddress InUse*).

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

## Más información
<a name="more-information"></a>
+  [Direcciones IP elásticas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) en la Guía del usuario de Amazon EC2
+  [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)en la referencia de la API de Amazon EC2
+  [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)en la referencia de la API de Amazon EC2
+  [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)en la referencia de la API de Amazon EC2

# Uso de las regiones y las zonas de disponibilidad de Amazon EC2
<a name="examples-ec2-regions-zones"></a>

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Descripción de regiones
<a name="describe-regions"></a>

Para ver las que tiene Regiones de AWS disponibles Cuenta de AWS, llame a la `DescribeRegions` función del EC2 cliente con un [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).

Recibirás un [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)en el objeto resultante. Llame a su función `GetRegions` para obtener una 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 representen a cada región.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_regions_and_zones.cpp)

## Descripción de zonas de disponibilidad
<a name="describe-availability-zones"></a>

Para enumerar cada zona de disponibilidad disponible en su cuenta, llame a la `DescribeAvailabilityZones` función del EC2 Cliente con un [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).

Recibirás un objeto [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)en el resultado. Llame a su `GetAvailabilityZones` función para obtener una 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 representan cada zona de disponibilidad.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_regions_and_zones.cpp)

## Más información
<a name="more-information"></a>
+  [Regiones y zonas de disponibilidad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) en la Guía del usuario de Amazon EC2
+  [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)en la referencia de la API de Amazon EC2
+  [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)en la referencia de la API de Amazon EC2

# Uso de pares de claves de Amazon EC2
<a name="examples-ec2-key-pairs"></a>

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Creación de un par de claves
<a name="create-a-key-pair"></a>

Para crear un par de claves, llame a la `CreateKeyPair` función del EC2 cliente con una [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 contenga el nombre de la clave.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_key_pair.cpp)

## Describir pares de claves
<a name="describe-key-pairs"></a>

Para enumerar sus pares de claves o para obtener información sobre ellos, llame a la `DescribeKeyPairs` función del EC2 Cliente con un [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).

Recibirás una [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 podrás utilizar para acceder a la lista de pares de claves llamando a su `GetKeyPairs` función, que devuelve una 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.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_key_pairs.cpp)

## Eliminar un par de claves
<a name="delete-a-key-pair"></a>

Para eliminar un par de claves, llame a la `DeleteKeyPair` función del EC2 cliente y pásele una [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 contenga el nombre del par de claves que se va a eliminar.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/delete_key_pair.cpp)

## Más información
<a name="more-information"></a>
+  [Pares de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) en la Guía del usuario de Amazon EC2
+  [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)en la referencia de la API de Amazon EC2
+  [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)en la referencia de la API de Amazon EC2
+  [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)en la referencia de la API de Amazon EC2

# Trabajar con grupos de seguridad en Amazon EC2
<a name="examples-ec2-security-groups"></a>

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Creación de un grupo de seguridad
<a name="create-a-security-group"></a>

Para crear un grupo de seguridad, llame a la `CreateSecurityGroup` función del EC2 cliente con un nombre [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 contenga el nombre de la clave.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/create_security_group.cpp)

## Configuración de un grupo de seguridad
<a name="configure-a-security-group"></a>

Un grupo de seguridad puede controlar el tráfico de entrada y salida a sus instancias de Amazon EC2.

Para añadir reglas de entrada a su grupo de seguridad, utilice la `AuthorizeSecurityGroupIngress` función del EC2 cliente, proporcionando el nombre del grupo de seguridad y las reglas de acceso ([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 desee asignarle dentro de un [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. El siguiente ejemplo muestra cómo añadir permisos de IP a un grupo de seguridad.

 **Incluye** 

```
#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 añadir una regla de salida al grupo de seguridad, proporcione datos similares en y [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)a la `AuthorizeSecurityGroupEgress` función del EC2 cliente.

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

## Describir grupos de seguridad
<a name="describe-security-groups"></a>

Para describir sus grupos de seguridad u obtener información sobre ellos, llame a la `DescribeSecurityGroups` función del EC2 cliente con un [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).

[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)En el resultado recibirá un objeto que podrá utilizar para acceder a la lista de grupos de seguridad llamando a su `GetSecurityGroups` función, que devuelve una 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.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/describe_security_groups.cpp)

## Eliminación de un grupo de seguridad
<a name="delete-a-security-group"></a>

Para eliminar un grupo de seguridad, llame a la `DeleteSecurityGroup` función del EC2 cliente y pásele una [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 contenga el ID del grupo de seguridad que desee eliminar.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ec2/delete_security_group.cpp)

## Más información
<a name="more-information"></a>
+  [Grupos de seguridad de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) en la Guía del usuario de Amazon EC2
+  [Autorización del tráfico de entrada para sus instancias de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) en la Guía del usuario de Amazon EC2
+  [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)en la referencia de la API de Amazon EC2
+  [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)en la referencia de la API de Amazon EC2
+  [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)en la referencia de la API de Amazon EC2
+  [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)en la referencia de la API de Amazon EC2

# Ejemplos de código de Amazon S3 que utilizan AWS SDK para C\$1\$1
<a name="examples-s3"></a>

[Amazon S3](https://aws.amazon.com/s3) es un servicio de almacenamiento de objetos creado para almacenar y recuperar cualquier volumen de datos desde cualquier ubicación. La interfaz AWS SDK para C\$1\$1 to proporciona varias clases con Amazon S3. 

**nota**  
En esta guía solo se proporciona el código necesario para demostrar determinadas técnicas, pero el [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub Puede descargar un único archivo fuente o clonar el repositorio localmente para obtener, compilar y ejecutar todos los ejemplos.
+ Clase [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) 

  La biblioteca `S3Client` es una interfaz de Amazon S3 con todas las características.

  El `list_buckets_disabling_dns_cache.cpp` ejemplo de este conjunto está diseñado específicamente para funcionar con CURL Linux/Mac (aunque se puede modificar para que funcione en Windows). Si está en Windows, elimine el archivo `list_buckets_disabling_dns_cache.cpp` antes de compilar el proyecto, ya que se basa en el curl HttpClient de Linux.

  El código de ejemplo que utiliza `S3Client` está en la [carpeta `s3`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3) de GitHub. Consulte el archivo [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/README.md) en GitHub para ver una lista completa de las funciones que se muestran en este ejemplo.

  Algunas partes de los ejemplos de `s3` se tratan con más detalle en esta guía:
  + [Creación, listado y eliminación de buckets](examples-s3-buckets.md)
  + [Operaciones en objetos](examples-s3-objects.md): carga y descarga de objetos de datos
  + [Administración de permisos de acceso de Amazon S3](examples-s3-access-permissions.md)
  + [Administración del acceso a los buckets de Amazon S3 mediante políticas de buckets](examples-s3-bucket-policies.md)
  + [Configuración de un bucket de Amazon S3 como un sitio web](examples-s3-website-configuration.md)
+ Clase [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) 

  `S3CrtClient` se ha agregado en la versión 1.9 del SDK. `S3CrtClient` proporciona un rendimiento alto para las operaciones GET (descarga) y PUT (carga) de Amazon S3. `S3CrtClient`Se implementa en la parte superior de las bibliotecas de AWS Common Runtime (CRT). 

  El código de ejemplo que utiliza `S3CrtClient` está en la [carpeta `s3-crt`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt) de GitHub. Consulte el archivo [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/README.md) en GitHub para ver una lista completa de las funciones que se muestran en este ejemplo.
  + [Uso de `S3CrtClient` para operaciones de Amazon S3](examples-s3-crt.md)
+ Clase [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) 

  `TransferManager` es un servicio totalmente administrado que permite transferir archivos a través del Protocolo de File Transfer (FTP), el Protocolo de File Transfer a través de SSL (FTPS) o el Protocolo de File Transfer (SFTP) de Secure Shell (SSH) directamente hacia o desde Amazon S3.

  El código de ejemplo que utiliza `TransferManager` está en la [carpeta `transfer-manager`](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager) de GitHub. Consulte el archivo [Readme](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/README.md) en GitHub para ver una lista completa de las funciones que se muestran en este ejemplo.
  + [Uso TransferManager para operaciones de Amazon S3](examples-s3-transfermanager.md)

# Creación, listado y eliminación de buckets
<a name="examples-s3-buckets"></a>

Todos los *objetos* o archivos de Amazon Simple Storage Service (Amazon S3) están contenidos en un *bucket*, que representa una carpeta de objetos. Cada bucket tiene un nombre único a nivel mundial dentro de AWS. Para obtener más información, consulte [Uso de buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) en la Guía del usuario de Amazon Simple Storage Service.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que su código utilice para realizar las solicitudes debe tener los permisos adecuados en AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar credenciales de AWS](credentials.md).

## Obtener una lista de buckets
<a name="list-buckets"></a>

Para ejecutar el ejemplo `list_buckets`, en el símbolo del sistema, vaya hasta la carpeta en la que el sistema de compilación crea los ejecutables de compilación. Ejecute el ejecutable con un nombre similar a `run_list_buckets` (el nombre completo del archivo ejecutable variará en función de su sistema operativo). El resultado muestra una lista de los buckets de su cuenta, si tiene alguno, o una lista vacía si no tienes ningún bucket.

En `list_buckets.cpp`, hay dos métodos:
+ `main()` llama a `ListBuckets()`. 
+ `ListBuckets()` usa el SDK para consultar sus depósitos.

El objeto `S3Client` llama al método `ListBuckets()` del SDK. Si se ejecuta correctamente, el método devuelve un objeto `ListBucketOutcome`, que contiene un objeto `ListBucketResult`. El objeto `ListBucketResult` llama al método `GetBuckets()` para obtener una lista de objetos `Bucket` que contienen información sobre cada bucket de Amazon S3 de su cuenta.

 **Código de** 

```
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;
}
```

Consulte el [ejemplo de list\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_buckets.cpp) completo en Github.

## Crear un bucket
<a name="create-bucket"></a>



Para ejecutar el ejemplo `create_bucket`, en el símbolo del sistema, vaya hasta la carpeta en la que el sistema de compilación crea los ejecutables de compilación. Ejecute el ejecutable con un nombre similar a `run_create_bucket` (el nombre completo del archivo ejecutable variará en función de su sistema operativo). El código crea un depósito vacío en su cuenta y, a continuación, muestra si la solicitud se ha realizado correctamente o no.

En `create_bucket.cpp`, hay dos métodos: 
+ `main()` llama a `CreateBucket()`. En `main()`, tiene que cambiar Región de AWS por la región de su cuenta con `enum`. Para ver la región de su cuenta, inicie sesión en la [Consola de administración de AWS](https://console.aws.amazon.com/) y localice la región en la esquina superior derecha. 
+ `CreateBucket()` utiliza el SDK para crear un bucket. 



El objeto `S3Client` llama al método `CreateBucket()` del SDK, transfiriéndole un objeto `CreateBucketRequest` con el nombre del bucket. De forma predeterminada, los buckets se crean en la región *us-east-1* (Norte de Virginia). Si su región no es *us-east-1*, el código establece una restricción de bucket para garantizar que el bucket se cree en su región.

 **Código de** 

```
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();
}
```

Consulte el [ejemplo de create\$1buckets](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/create_bucket.cpp) completo en Github.

## Eliminar un bucket
<a name="delete-bucket"></a>



Para ejecutar el ejemplo `delete_bucket`, en el símbolo del sistema, vaya hasta la carpeta en la que el sistema de compilación crea los ejecutables de compilación. Ejecute el ejecutable con un nombre similar a `run_delete_bucket` (el nombre completo del archivo ejecutable variará en función de su sistema operativo). El código elimina el bucket especificado de su cuenta y, a continuación, muestra si la solicitud se ha realizado correctamente o no.

En `delete_bucket.cpp`, hay dos métodos. 
+ `main()` llama a `DeleteBucket()`. En `main()`, tiene que cambiar Región de AWS por la región de su cuenta con `enum`. También debe cambiar `bucket_name` por el nombre del bucket que desea eliminar. 
+ `DeleteBucket()` usa el SDK para eliminar el bucket. 



El objeto `S3Client` usa el método `DeleteBucket()` del SDK, transfiriéndole un objeto `DeleteBucketRequest` con el nombre del bucket que se va a eliminar. El bucket debe estar vacío para que funcione correctamente.

 **Código**

```
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();
}
```

Consulte el [ejemplo de delete\$1bucket](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket.cpp) completo en Github.

# Operaciones en objetos
<a name="examples-s3-objects"></a>

Un objeto de Amazon S3 representa un *archivo* o un conjunto de datos. Cada objeto debe residir en un [bucket](examples-s3-buckets.md).

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Para cargar un archivo en un bucket
<a name="upload-object"></a>

Utilice la función `PutObject` del objeto `S3Client` y proporcione un nombre de bucket, un nombre de clave y el archivo que se va a cargar. `Aws::FStream` se utiliza para cargar el contenido del archivo local en el bucket. El bucket debe existir o se producirá un error.

Para ver un ejemplo sobre cómo cargar objetos de forma asíncrona, consulte [Programación asíncrona mediante 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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object.cpp) en GitHub.

## Carga de una cadena en un bucket
<a name="upload-object-string"></a>

Utilice la función `PutObject` del objeto `S3Client` y proporcione un nombre de bucket, un nombre de clave y el archivo que se va a cargar. El bucket debe existir o se producirá un error. Este ejemplo se diferencia del anterior porque se utiliza `Aws::StringStream` para cargar un objeto de datos de cadena en memoria directamente en un bucket.

Para ver un ejemplo sobre cómo cargar objetos de forma asíncrona, consulte [Programación asíncrona mediante 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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_buffer.cpp) en GitHub.

## List objects
<a name="list-objects"></a>

Para obtener una lista de objetos dentro de un bucket, utilice la función `ListObjects` del objeto `S3Client`. Proporcione una solicitud `ListObjectsRequest` configurada con el nombre de un bucket para enumerar su contenido.

La función `ListObjects` devuelve un objeto `ListObjectsOutcome` que puede utilizar para obtener una lista de objetos en forma de instancias de `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;
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/list_objects.cpp) en GitHub.

## Descargar un objeto
<a name="download-object"></a>

Utilice la función `GetObject` del objeto `S3Client`, transfiriéndole una solicitud `GetObjectRequest` que debe configurar con el nombre de un bucket y la clave del objeto para descargar. `GetObject` devuelve un 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 consta de un objeto [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) y un [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` se puede usar para acceder a los datos del objeto S3.

En el siguiente ejemplo se descarga un objeto de Amazon S3. El contenido del objeto se almacena en una variable local y la primera línea del contenido se envía a la consola.

 **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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_object.cpp) en GitHub.

## Elimine un objeto
<a name="delete-object"></a>

Utilice la función `DeleteObject` del objeto `S3Client`, transfiriéndole una solicitud `DeleteObjectRequest` que debe configurar con el nombre de un bucket y el objeto para descargar. *El bucket y la clave de objeto especificados deben existir o se producirá un error*.

 **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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_object.cpp) en GitHub.

# Administración de permisos de acceso de Amazon S3
<a name="examples-s3-access-permissions"></a>

Los permisos de acceso para un bucket o un objeto de Amazon S3 se definen en una lista de control de acceso (ACL). La ACL especifica el propietario de las concesiones bucket/object y una lista de las mismas. Cada concesión especifica un usuario (o beneficiario) y los permisos del usuario para acceder al bucket o al objeto; por ejemplo, acceso de lectura (READ) o escritura (WRITE).

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Administración de la lista de control de acceso de un objeto
<a name="manage-an-object-s-access-control-list"></a>

La lista de control de acceso de un objeto se puede recuperar llamando al método`GetObjectAcl` de `S3Client`. El método acepta los nombres del objeto y su bucket. El valor devuelto incluye el `Owner` de las ACL y una 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";
    }
}
```

La ACL se puede modificar creando una nueva o cambiando las concesiones especificadas en la actual. La ACL actualizada se convierte en la nueva ACL actual al transferirla al método `PutObjectAcl`.

El siguiente código usa la ACL recuperada por `GetObjectAcl` y le agrega una nueva concesión. El usuario o beneficiario recibe el permiso READ para el objeto. La ACL modificada se pasa a `PutObjectAcl` y, de este modo, se convierte en la nueva ACL actual. 

```
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;
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_object_acl.cpp) en GitHub.

## Administración de la lista de control de acceso de un bucket
<a name="manage-a-bucket-s-access-control-list"></a>

En la mayoría de los casos, el método preferido para configurar los permisos de acceso de un bucket es definir una política de bucket. Sin embargo, los buckets también admiten listas de control de acceso para los usuarios que deseen utilizarlas.

La administración de una lista de control de acceso para un bucket es idéntica a la que se usa para un objeto. El método `GetBucketAcl` recupera la ACL actual de un bucket y `PutBucketAcl` aplica una nueva ACL al bucket.

El siguiente código muestra cómo obtener y configurar la ACL de un 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;
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_put_bucket_acl.cpp) en GitHub.

# Administración del acceso a los buckets de Amazon S3 mediante políticas de buckets
<a name="examples-s3-bucket-policies"></a>

Puede definir, obtener o eliminar una *política de bucket* para administrar el acceso a sus buckets de Amazon S3.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

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

Puede establecer la política de bucket para un bucket de S3 concreto llamando a la `PutBucketPolicy` función `S3Client`'s y proporcionándole el nombre del bucket y la representación en JSON de la política en un [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**  
La clase de [utilidad 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) puede usarse para ayudarle a construir objetos JSON válidos a los que pasar. `PutBucketPolicy`

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_bucket_policy.cpp) en GitHub.

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

Para recuperar la política de un bucket de Amazon S3, llama a la `GetBucketPolicy` función `S3Client`'s y pásale el nombre del bucket en un [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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_bucket_policy.cpp) en GitHub.

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

Para eliminar una política de bucket, llama a la `DeleteBucketPolicy` función `S3Client`'s y proporciona el nombre del bucket en un [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).

 **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();
}
```

Este función se ejecuta correctamente aunque el bucket no tenga una política todavía. Si especifica el nombre de un bucket que no existe o si no tiene acceso al bucket, se produce la excepción `AmazonServiceException`.

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_bucket_policy.cpp) en GitHub.

## Más información
<a name="more-info"></a>
+  [PutBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/PutBucketPolicy.html)en la referencia de la API de Amazon Simple Storage Service
+  [GetBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/GetBucketPolicy.html)en la referencia de la API de Amazon Simple Storage Service
+  [DeleteBucketPolicy](https://docs.aws.amazon.com/AmazonS3/latest/API/DeleteBucketPolicy.html)en la referencia de la API de Amazon Simple Storage Service
+  [Información general del lenguaje de la política de acceso](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) en la Guía del usuario de Amazon Simple Storage Service
+  [Ejemplos de política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) en la Guía del usuario de Amazon Simple Storage Service

# Configuración de un bucket de Amazon S3 como un sitio web
<a name="examples-s3-website-configuration"></a>

Puede configurar un bucket de Amazon S3 para que se comporte como un sitio web. Para ello, debe establecer la configuración de su sitio web.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utiliza tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Establecimiento de la configuración de sitio web de un bucket
<a name="set-a-bucket-s-website-configuration"></a>

Para establecer la configuración del sitio web de un bucket de Amazon S3, llame a la `PutBucketWebsite` función `S3Client`'s con un [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 que contenga el nombre del bucket y la configuración de su sitio web, proporcionados en un [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.

Es *obligatorio* establecer un documento de índice; todos los demás parámetros son opcionales.

 **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**  
El establecimiento de la configuración de sitio web no modifica los permisos de acceso del bucket. Para que los archivos estén visibles en la web, también deberá definir una *política de bucket* que permita el acceso de lectura pública a los archivos del bucket. Para obtener más información, consulte [Administración del acceso a buckets de Amazon S3 mediante políticas de buckets](examples-s3-bucket-policies.md).

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_website_config.cpp) en GitHub.

## Obtener la configuración de sitio web de un bucket
<a name="get-a-bucket-s-website-configuration"></a>

Para obtener la configuración del sitio web de un bucket de Amazon S3, llama a la `GetBucketWebsite` función `S3Client`'s y [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)contiene el nombre del bucket para recuperar la configuración.

La configuración se devolverá como un [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 del objeto de resultado. Si no hay ninguna configuración de sitio web para el bucket, se devolverá `null`.

 **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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/get_website_config.cpp) en GitHub.

## Eliminar la configuración de sitio web de un bucket
<a name="delete-a-bucket-s-website-configuration"></a>

Para eliminar la configuración del sitio web de un bucket de Amazon S3, llama a la `DeleteBucketWebsite` función `S3Client`'s con un [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): que contenga el nombre del bucket del que se va a eliminar la configuración.

 **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();
}
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/delete_website_config.cpp) en GitHub.

## Más información
<a name="more-information"></a>
+  [PUT Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) en la Referencia de la API de Amazon Simple Storage Service
+  [GET Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) en la Referencia de la API de Amazon Simple Storage Service
+  [DELETE Bucket website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) en la Referencia de la API de Amazon Simple Storage Service

# Uso TransferManager para operaciones de Amazon S3
<a name="examples-s3-transfermanager"></a>

Puede utilizar la AWS SDK para C\$1\$1 `TransferManager` clase para transferir archivos de forma fiable desde el entorno local a Amazon S3 y para copiar objetos de una ubicación de Amazon S3 a otra. `TransferManager`puede ver el progreso de una transferencia y pausar o reanudar las cargas y descargas.

**nota**  
Para evitar que te cobren por cargas incompletas o parciales, te recomendamos que habilites la regla de [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo de vida en tus buckets de Amazon S3.  
Esta regla le indica a Amazon S3 que anule las cargas multiparte que no se completen en un número especificado de días después de iniciarse. Cuando se supera el plazo establecido, Amazon S3 anula la carga y, a continuación, elimina los datos de la carga incompleta.   
Para obtener más información, consulte [Configuración del ciclo de vida de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) en la Guía del usuario de Amazon S3.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Carga y descarga de un objeto mediante `TransferManager`
<a name="stream"></a>

En este ejemplo, se muestra cómo [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) transfiere un objeto grande en la memoria. Se llama a los métodos `UploadFile` y `DownloadFile` de forma asíncrona que devuelven un `TransferHandle` para gestionar el estado de la solicitud. Si el objeto cargado es superior al `bufferSize`, se realiza una carga multiparte. El valor predeterminado del `bufferSize` es de 5 MB, pero se puede configurar mediante [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;
```

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/transfer-manager/transferOnStream.cpp) en GitHub.

# Uso de `S3CrtClient` para operaciones de Amazon S3
<a name="examples-s3-crt"></a>

La `S3CrtClient` clase está disponible en la versión 1.9 de AWS SDK para C\$1\$1 y mejora el rendimiento de la carga y descarga de archivos de datos de gran tamaño desde y hacia Amazon S3. Para obtener más información sobre las mejoras de esta versión, consulte [Mejorar el rendimiento de Amazon S3 con AWS SDK para C\$1\$1](https://github.com/aws/aws-sdk-cpp/wiki/Improving-S3-Throughput-with-AWS-SDK-for-CPP-v1.9) la versión 1.9

El `S3CrtClient` se implementa sobre las [bibliotecas Common Runtime (CRT) de AWS](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html).

**nota**  
Para evitar que te cobren por cargas incompletas o parciales, te recomendamos que habilites la regla de [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)ciclo de vida en tus buckets de Amazon S3.  
Esta regla le indica a Amazon S3 que anule las cargas multiparte que no se completen en un número especificado de días después de iniciarse. Cuando se supera el plazo establecido, Amazon S3 anula la carga y, a continuación, elimina los datos de la carga incompleta.   
Para obtener más información, consulte [Configuración del ciclo de vida de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) en la Guía del usuario de Amazon S3.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice tu código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Carga y descarga de un objeto mediante `S3CrtClient`
<a name="stream"></a>

En este ejemplo se muestra cómo usar [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). En el ejemplo se crea un bucket, se carga un objeto, se descarga el objeto y, a continuación, se eliminan el archivo y el bucket. Una operación PUT se convierte en una carga multiparte. Una operación GET se convierte en varias solicitudes GET "ordenadas". Para obtener más información sobre cargas multiparte, consulte [Carga y copia de objetos con carga multiparte](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) en la Guía del usuario de Amazon S3. 

En este ejemplo, el archivo de datos proporcionado, `ny.json`, se carga como una carga multiparte. Puede confirmarlo consultando los registros de depuración después de ejecutar correctamente el programa.

Si se produce un error en la carga, `AbortMultipartUpload` se emite en una en la biblioteca CRT subyacente para limpiar las partes ya cargadas. Sin embargo, no todos los fallos se pueden solucionar internamente (por ejemplo, si se desconecta un cable de red). Le recomendamos crear una regla de ciclo de vida en su bucket de Amazon S3 para garantizar que los datos cargados parcialmente no permanezcan en su cuenta (los datos cargados parcialmente siguen siendo facturables). Para obtener información sobre cómo configurar una regla de ciclo de vida, consulte [Descubrimiento y eliminación de cargas multiparte incompletas para reducir los costos de Amazon S3](https://aws.amazon.com/blogs/aws-cost-management/discovering-and-deleting-incomplete-multipart-uploads-to-lower-amazon-s3-costs/ ) 

**Uso del registro de depuración para explorar los detalles de las cargas multiparte**

1. En `main()`, tenga en cuenta que hay comentarios "TODO" con instrucciones para actualizar el código.

   1. Para `file_name`: desde el enlace proporcionado en el comentario del código, descargue un archivo de datos de muestra `ny.json` o utilice un archivo de datos de gran tamaño que sea suyo.

   1. Para`region`: Actualice la `region` variable, mediante la enumeración, a la Región de AWS de su cuenta. Para encontrar la región de su cuenta, inicie sesión en la Consola de administración de AWS y localice la región en la esquina superior derecha.

1. Compile el ejemplo.

1. Copie el archivo especificado en la variable `file_name` en su carpeta de ejecutables y ejecute el archivo ejecutable `s3-crt-demo`.

1. En la carpeta de ejecutables, busque el archivo `.log` más reciente.

1. Abra el archivo de registro, seleccione **buscar** y escriba **partNumber**.

1. El registro contiene entradas similares a las siguientes, donde se especifican `uploadId` y `partNumber` para cada parte del archivo cargado:

    `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 `

Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3-crt/s3-crt-demo.cpp) en GitHub.

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

Amazon Simple Queue Service (Amazon SQS) es un servicio de colas de mensajes completamente administrado que facilita el desacople y el escalado de microservicios, sistemas distribuidos y aplicaciones sin servidor. Puede utilizar los siguientes ejemplos para programar [Amazon SQS](https://aws.amazon.com/sqs) con el AWS SDK para C\$1\$1.

**nota**  
En esta guía solo se proporciona el código necesario para demostrar determinadas técnicas, pero el [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub Puede descargar un único archivo fuente o clonar el repositorio localmente para obtener, compilar y ejecutar todos los ejemplos.

**Topics**
+ [Trabajo con colas de mensajes de Amazon SQS](examples-sqs-message-queues.md)
+ [Envío, recepción y eliminación de mensajes de Amazon SQS](examples-sqs-messages.md)
+ [Habilitar sondeos largos para las colas de mensajes de Amazon SQS](examples-sqs-long-polling.md)
+ [Configuración del tiempo de espera de visibilidad en Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Uso de colas de mensajes fallidos en Amazon SQS](examples-sqs-dead-letter-queues.md)

# Trabajo con colas de mensajes de Amazon SQS
<a name="examples-sqs-message-queues"></a>

Una *cola de mensajes* es el contenedor lógico utilizado para enviar mensajes de forma fiable en Amazon SQS. Existen dos tipos de colas: *estándar* y *primero en entrar, primero en salir* (FIFO). Para obtener más información sobre las colas y las diferencias entre estos tipos, consulte la [Guía para desarrolladores de Amazon Simple Queue Service](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).

Estos ejemplos de C\$1\$1 muestran cómo utilizar la AWS SDK para C\$1\$1 para crear, enumerar, eliminar y obtener la URL de una cola de Amazon SQS.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Creación de una cola
<a name="sqs-create-queue"></a>

Utilice la función de `CreateQueue` miembro de la SQSClient clase y proporcione un [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 describa los parámetros de la cola.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/create_queue.cpp)

## Mostrar colas
<a name="sqs-list-queues"></a>

Para enumerar las colas de Amazon SQS de su cuenta, llame a la función `ListQueues` miembro de la SQSClient clase y pásele un objeto. [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)

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/list_queues.cpp)

## Cómo obtener la URL de la cola
<a name="sqs-get-queue-url"></a>

Para obtener la URL de una cola de Amazon SQS existente, llame a la función miembro de la SQSClient clase`GetQueueUrl`.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/get_queue_url.cpp)

## Eliminar una cola
<a name="sqs-delete-queue"></a>

Proporcione la [URL](#sqs-get-queue-url) de la función `DeleteQueue` miembro SQSClient de la clase.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/delete_queue.cpp)

## Más información
<a name="more-info"></a>
+  [Cómo funcionan las colas de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) en la Guía para desarrolladores de Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)en la referencia de la API de Amazon Simple Queue Service
+  [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)en la referencia de la API de Amazon Simple Queue Service
+  [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)en la referencia de la API de Amazon Simple Queue Service
+  [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)en la referencia de la API de Amazon Simple Queue Service

# Envío, recepción y eliminación de mensajes de Amazon SQS
<a name="examples-sqs-messages"></a>

Los mensajes se envían siempre a través de una [cola de SQS](examples-sqs-message-queues.md). Estos ejemplos de C\$1\$1 muestran cómo utilizar el AWS SDK para C\$1\$1 para enviar, recibir y eliminar mensajes de Amazon SQS de las colas de SQS.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Enviar un mensaje
<a name="sqs-message-send"></a>

Puede añadir un solo mensaje a una cola de Amazon SQS llamando a la función de miembro de la SQSClient clase`SendMessage`. Proporciona `SendMessage` un [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 que contiene la [URL](examples-sqs-message-queues.md#sqs-get-queue-url) de la cola, el cuerpo del mensaje y un valor de retraso opcional (en segundos).

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/send_message.cpp)

## Recibir mensajes
<a name="sqs-messages-receive"></a>

Recupera cualquier mensaje que esté actualmente en la cola llamando a la función `ReceiveMessage` miembro de la SQSClient clase y pasándole la URL de la cola. Los mensajes se devuelven como una 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).

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp)

### Eliminar mensajes después de su recepción
<a name="sqs-messages-delete"></a>

Tras recibir un mensaje y procesar su contenido, elimínelo de la cola enviando el identificador de recepción del mensaje y la URL de la cola a la función `DeleteMessage` miembro de la SQSClient clase.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp)

## Más información
<a name="more-info"></a>
+  [Cómo funcionan las colas de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) en la Guía para desarrolladores de Amazon Simple Queue Service
+  [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)en la referencia de la API de Amazon Simple Queue Service
+  [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)en la referencia de la API de Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)en la referencia de la API de Amazon Simple Queue Service
+  [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)en la referencia de la API de Amazon Simple Queue Service

# Habilitar sondeos largos para las colas de mensajes de Amazon SQS
<a name="examples-sqs-long-polling"></a>

Amazon SQS utiliza el *sondeo corto* de forma predeterminada: consulta únicamente un subconjunto de los servidores (en función de una distribución aleatoria ponderada) para determinar si hay algún mensaje disponible para su inclusión en la respuesta.

Las votaciones prolongadas ayudan a reducir el costo de usar Amazon SQS al reducir el número de respuestas vacías cuando no hay mensajes disponibles para devolver en respuesta a una ReceiveMessage solicitud enviada a una cola de Amazon SQS y eliminando las respuestas falsas vacías. Puede definir una frecuencia de sondeo largo de *1-20 segundos*.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (tanto para el servicio como para la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Cómo habilitar el sondeo largo al crear una cola
<a name="sqs-long-polling-create-queue"></a>

Para habilitar un sondeo prolongado al crear una cola de Amazon SQS, defina el `ReceiveMessageWaitTimeSeconds` atributo en el [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 antes de llamar a la función miembro de la SQSClient clase`CreateQueue`.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_create_queue.cpp)

## Habilitar el sondeo largo en una cola existente
<a name="sqs-long-polling-existing-queue"></a>

Además de habilitar un sondeo prolongado al crear una cola, también puede habilitarlo en una cola existente activando la `ReceiveMessageWaitTimeSeconds` función [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)antes de llamar al miembro de la SQSClient clase. `SetQueueAttributes`

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_existing_queue.cpp)

## Habilitar el sondeo largo al recibir un mensaje
<a name="sqs-long-polling-receive-message"></a>

Puede habilitar un sondeo prolongado al recibir un mensaje configurando el tiempo de espera en segundos del [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 proporcione a la función ReceiveMessage miembro de SQSClient la clase.

**nota**  
¡Asegúrese de que el tiempo de espera de la solicitud del AWS cliente sea superior al tiempo máximo de sondeo (20 segundos) para que sus `ReceiveMessage` solicitudes no se agoten mientras esperan al próximo evento de votación\$1

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_message_receipt.cpp)

## Más información
<a name="more-info"></a>
+  [Sondeo largo de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) en la Guía para desarrolladores de Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)en la referencia de la API de Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)en la referencia de la API de Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)en la referencia de la API de Amazon Simple Queue Service

# Configuración del tiempo de espera de visibilidad en Amazon SQS
<a name="examples-sqs-visibility-timeout"></a>

Cuando se recibe un mensaje en Amazon SQS, este permanece en la cola hasta que se elimina a fin de garantizar su recepción. Un mensaje que se ha recibido, pero no se ha eliminado, estará disponible en las solicitudes posteriores después de un determinado *tiempo de espera de visibilidad* para ayudar a evitar que el mensaje se reciba más de una vez antes de que pueda procesarse y eliminarse.

Cuando se utilizan [colas estándar](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), el tiempo de espera de visibilidad no es una garantía de que un mensaje no se reciba dos veces. Si utiliza una cola estándar, asegúrese de que el código pueda tratar aquellas situaciones en las que el mismo mensaje se entrega más de una vez.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice su código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Establecimiento del tiempo de espera de visibilidad del mensaje al recibirlo
<a name="sqs-visibility-timeout-receipt"></a>

Cuando reciba un mensaje, puede modificar su tiempo de espera de visibilidad pasando su identificador de recepción a la función `ChangeMessageVisibility` miembro de la SQSClient clase. [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)

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/change_message_visibility.cpp)

## Más información
<a name="more-info"></a>
+  [Tiempo de espera de visibilidad](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) en la Guía para desarrolladores de Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)en la referencia de la API de Amazon Simple Queue Service
+  [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)en la referencia de la API de Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)en la referencia de la API de Amazon Simple Queue Service
+  [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)en la referencia de la API de Amazon Simple Queue Service
+  [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)en la referencia de la API de Amazon Simple Queue Service

# Uso de colas de mensajes fallidos en Amazon SQS
<a name="examples-sqs-dead-letter-queues"></a>

Amazon SQS añade compatibilidad con las *colas de mensajes fallidos*. Una cola de mensajes fallidos es una cola a la que otras pueden enviar mensajes que no se pueden procesar correctamente. Puede apartar y aislar estos mensajes en la cola de mensajes fallidos para determinar por qué no se procesaron correctamente.

Para crear una cola de mensajes fallidos, primero debe crear una *política de redireccionamiento* y, a continuación, configurar la política en los atributos de la cola.

**importante**  
Una cola de mensajes fallidos debe ser el mismo tipo de cola (FIFO o estándar) que la cola de origen. También debe crearse utilizando la misma cola de origen Cuenta de AWS y Región de AWS como la cola de origen.

## Requisitos previos
<a name="codeExamplePrereq"></a>

Antes de comenzar, le recomendamos que lea [Primeros pasos con el AWS SDK para C\$1\$1](getting-started.md). 

Descargue el código de ejemplo y compile la solución tal y como se describe en [Introducción a los ejemplos de código](getting-started-code-examples.md). 

Para ejecutar los ejemplos, el perfil de usuario que utilice el código para realizar las solicitudes debe tener los permisos adecuados AWS (para el servicio y la acción). Para obtener más información, consulte [Proporcionar AWS credenciales](credentials.md).

## Creación de una política de redireccionamiento
<a name="sqs-dead-letter-queue-create-redrive-policy"></a>

La política de redireccionamiento se especifica en JSON. Para crearla, puede usar la clase de utilidad JSON que se proporciona con el AWS SDK para C\$1\$1.

Este es un ejemplo de función que crea una política de redireccionamiento proporcionándole el ARN de la cola de mensajes fallidos y el número máximo de veces que se puede recibir y no procesar el mensaje antes de que se envíe a la cola de mensajes fallidos.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp)

## Definición de la política de redireccionamiento en la cola de origen
<a name="sqs-dead-letter-queue-set-redrive-policy"></a>

Para terminar de configurar tu cola de cartas muertas, llama a la función `SetQueueAttributes` miembro de la SQSClient clase con un [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 el que hayas establecido el `RedrivePolicy` atributo con tu política de redrive de JSON.

 **Incluye** 

```
#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 el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp)

## Más información
<a name="more-info"></a>
+  [Uso de las colas de mensajes fallidos de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) en la Guía para desarrolladores de Amazon Simple Queue Service.
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)en la referencia de la API de Amazon Simple Queue Service