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