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

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

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

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

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

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

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

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

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

    } while (!nextToken.empty());

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

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

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

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

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

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

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

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

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

## Definir o tempo limite de visibilidade de mensagens no recebimento de mensagens
<a name="sqs-visibility-timeout-receipt"></a>

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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

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

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

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

 **Inclui** 

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

 **Código** 

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

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

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

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