Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esempi di codice Amazon SQS che utilizzano AWS SDK per C\$1\$1
<a name="examples-sqs"></a>

Amazon Simple Queue Service (Amazon SQS) è un servizio di accodamento dei messaggi completamente gestito che semplifica il disaccoppiamento e la scalabilità di microservizi, sistemi distribuiti e applicazioni serverless. Puoi utilizzare i seguenti esempi per programmare [Amazon SQS utilizzando.](https://aws.amazon.com/sqs) AWS SDK per C\$1\$1

**Nota**  
In questa Guida viene fornito solo il codice necessario per dimostrare determinate tecniche, ma il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). GitHub È possibile scaricare un singolo file sorgente oppure clonare il repository localmente per ottenere, compilare ed eseguire tutti gli esempi.

**Topics**
+ [Utilizzo di Amazon SQS Message Queues](examples-sqs-message-queues.md)
+ [Invio, ricezione ed eliminazione di messaggi Amazon SQS](examples-sqs-messages.md)
+ [Abilitazione del polling lungo per le code di messaggi di Amazon SQS](examples-sqs-long-polling.md)
+ [Impostazione del timeout di visibilità in Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Utilizzo delle code DLQ in Amazon SQS](examples-sqs-dead-letter-queues.md)

# Utilizzo di Amazon SQS Message Queues
<a name="examples-sqs-message-queues"></a>

Una *coda di messaggi* è il contenitore logico che usi per inviare messaggi in modo affidabile in Amazon SQS. Sono disponibili due tipi di code: *standard* e *first-in, first-out* (FIFO). Per ulteriori informazioni sulle code e sulle differenze tra questi tipi, consulta la [Amazon Simple Queue Service Developer Guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).

Questi esempi in C\$1\$1 mostrano come utilizzare per creare, AWS SDK per C\$1\$1 elencare, eliminare e ottenere l'URL di una coda Amazon SQS.

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva](getting-started.md) all'uso di. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Creare una coda
<a name="sqs-create-queue"></a>

Utilizzate la funzione `CreateQueue` membro della SQSClient classe e fornitele 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)oggetto che descriva i parametri della coda.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/create_queue.cpp).

## Elencare code
<a name="sqs-list-queues"></a>

Per elencare le code Amazon SQS per il tuo account, chiama la funzione `ListQueues` membro della SQSClient classe e passale un oggetto. [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)

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/list_queues.cpp).

## Ottieni l'URL della coda
<a name="sqs-get-queue-url"></a>

Per ottenere l'URL di una coda Amazon SQS esistente, chiama la funzione member della SQSClient classe`GetQueueUrl`.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/get_queue_url.cpp).

## Eliminare una coda
<a name="sqs-delete-queue"></a>

Fornisci l'[URL](#sqs-get-queue-url) della funzione `DeleteQueue` membro SQSClient della classe.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/delete_queue.cpp).

## Ulteriori informazioni
<a name="more-info"></a>
+  [Come funzionano le code Amazon SQS nella Guida per gli sviluppatori](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) di Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Invio, ricezione ed eliminazione di messaggi Amazon SQS
<a name="examples-sqs-messages"></a>

I messaggi vengono sempre recapitati utilizzando una coda [SQS.](examples-sqs-message-queues.md) Questi esempi in C\$1\$1 mostrano come utilizzare per inviare, ricevere ed eliminare messaggi Amazon SQS dalle code SQS. AWS SDK per C\$1\$1 

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva](getting-started.md) all'uso di. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Inviare un messaggio
<a name="sqs-message-send"></a>

Puoi aggiungere un singolo messaggio a una coda Amazon SQS chiamando la funzione membro della SQSClient classe`SendMessage`. `SendMessage`Fornisci 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)oggetto contenente l'[URL](examples-sqs-message-queues.md#sqs-get-queue-url) della coda, il corpo del messaggio e un valore di ritardo opzionale (in secondi).

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/send_message.cpp).

## Ricevi messaggi
<a name="sqs-messages-receive"></a>

Recupera tutti i messaggi attualmente in coda chiamando la funzione `ReceiveMessage` membro della SQSClient classe, passandole l'URL della coda. I messaggi vengono restituiti come un elenco di oggetti [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).

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

### Eliminare i messaggi dopo la ricezione
<a name="sqs-messages-delete"></a>

Dopo aver ricevuto un messaggio e averne elaborato il contenuto, eliminatelo dalla coda inviando l'handle di ricezione del messaggio e l'URL della coda alla funzione `DeleteMessage` membro della SQSClient classe.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

## Ulteriori informazioni
<a name="more-info"></a>
+  [Come funzionano le code Amazon SQS nella Guida per gli sviluppatori](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) di Amazon Simple Queue Service
+  [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Abilitazione del polling lungo per le code di messaggi di Amazon SQS
<a name="examples-sqs-long-polling"></a>

Amazon SQS utilizza il *polling breve* per impostazione predefinita, interrogando solo un sottoinsieme di server, in base a una distribuzione casuale ponderata, per determinare se sono disponibili messaggi da includere nella risposta.

Il polling prolungato aiuta a ridurre i costi di utilizzo di Amazon SQS riducendo il numero di risposte vuote quando non ci sono messaggi disponibili da restituire in risposta a ReceiveMessage una richiesta inviata a una coda di Amazon SQS ed eliminando le false risposte vuote. *Puoi impostare una frequenza di polling lunga da 1 a 20 secondi.*

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva a utilizzare](getting-started.md) il. AWS SDK per C\$1\$1

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Abilita il polling lungo durante la creazione di una coda
<a name="sqs-long-polling-create-queue"></a>

Per abilitare il polling lungo durante la creazione di una coda Amazon SQS, imposta `ReceiveMessageWaitTimeSeconds` l'attributo sull'oggetto prima di chiamare [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)la funzione membro SQSClient della `CreateQueue` classe.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_create_queue.cpp).

## Abilitazione del long polling su una coda esistente
<a name="sqs-long-polling-existing-queue"></a>

Oltre ad abilitare il polling lungo durante la creazione di una coda, puoi anche abilitarlo su una coda esistente impostando la [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)funzione «`ReceiveMessageWaitTimeSeconds`before call member» della SQSClient classe`SetQueueAttributes`.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_existing_queue.cpp).

## Abilitazione del long polling sulla ricezione del messaggio
<a name="sqs-long-polling-receive-message"></a>

Puoi abilitare il polling prolungato quando ricevi un messaggio impostando il tempo di attesa in secondi sulla funzione ReceiveMessage membro della SQSClient classe. [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)

**Nota**  
Dovresti assicurarti che il timeout della richiesta del AWS cliente sia superiore al tempo massimo di sondaggio lungo (20 secondi) in modo che `ReceiveMessage` le tue richieste non scadano in attesa del prossimo evento di sondaggio\$1

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_message_receipt.cpp).

## Ulteriori informazioni
<a name="more-info"></a>
+  [Amazon SQS Long Polling nella Guida per gli sviluppatori di](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) Amazon Simple Queue Service
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Impostazione del timeout di visibilità in Amazon SQS
<a name="examples-sqs-visibility-timeout"></a>

Quando un messaggio viene ricevuto in Amazon SQS, rimane in coda fino a quando non viene eliminato per garantire la ricezione. Un messaggio ricevuto, ma non eliminato, sarà disponibile nelle richieste successive dopo un determinato *timeout di visibilità* per evitare che il messaggio venga ricevuto più di una volta prima di poter essere elaborato ed eliminato.

Quando si utilizzano [code standard](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), il timeout di visibilità non è una garanzia contro la ricezione di un messaggio due volte. Se utilizzi una coda standard, assicurati che il codice sia in grado di gestire il caso in cui lo stesso messaggio sia stato recapitato più di una volta.

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva a utilizzare il AWS SDK per C\$1\$1](getting-started.md). 

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Imposta il timeout di visibilità dei messaggi al momento della ricezione del messaggio
<a name="sqs-visibility-timeout-receipt"></a>

Quando hai ricevuto un messaggio, puoi modificarne il timeout di visibilità inserendo un codice di ricezione [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)che passi alla funzione membro della SQSClient classe. `ChangeMessageVisibility`

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/change_message_visibility.cpp).

## Ulteriori informazioni
<a name="more-info"></a>
+  [Visibility Timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) nella Guida per gli sviluppatori di Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service
+  [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service

# Utilizzo delle code DLQ in Amazon SQS
<a name="examples-sqs-dead-letter-queues"></a>

Amazon SQS fornisce supporto per le code di *lettere morte*. Una coda di lettere morte è una coda a cui altre code possono indirizzare i messaggi che non possono essere elaborati correttamente. Puoi riservare e isolare questi messaggi nella coda DLQ per determinare perché l'elaborazione non è riuscita.

Per creare una coda di lettere morte, è necessario innanzitutto creare una politica di *redrive e quindi impostare la politica* negli attributi della coda.

**Importante**  
Una coda di lettere morte deve essere dello stesso tipo di coda (FIFO o standard) della coda di origine. Inoltre, deve essere creata utilizzando la stessa coda di Account AWS origine Regione AWS .

## Prerequisiti
<a name="codeExamplePrereq"></a>

Prima di iniziare, ti consigliamo di leggere [Guida introduttiva all' AWS SDK per C\$1\$1 utilizzo](getting-started.md) di. 

Scarica il codice di esempio e crea la soluzione come descritto in[Guida introduttiva agli esempi di codice](getting-started-code-examples.md). 

Per eseguire gli esempi, il profilo utente utilizzato dal codice per effettuare le richieste deve disporre delle autorizzazioni appropriate AWS (per il servizio e l'azione). Per ulteriori informazioni, vedere [Fornitura di AWS credenziali](credentials.md).

## Crea una politica di Redrive
<a name="sqs-dead-letter-queue-create-redrive-policy"></a>

Una politica di redrive è specificata in JSON. Per crearla, è possibile utilizzare la classe di utilità JSON fornita con. AWS SDK per C\$1\$1

Ecco una funzione di esempio che crea una politica di redrive fornendole l'ARN della coda delle lettere morte e il numero massimo di volte in cui il messaggio può essere ricevuto e non elaborato prima di essere inviato alla coda di lettere morte.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Imposta la Redrive Policy nella tua coda di origine
<a name="sqs-dead-letter-queue-set-redrive-policy"></a>

Per completare la configurazione della coda delle lettere morte, chiama la funzione `SetQueueAttributes` member della SQSClient classe 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)oggetto per il quale hai impostato l'`RedrivePolicy`attributo con la tua politica di redrive JSON.

 **Include** 

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

 **Codice** 

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

Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Ulteriori informazioni
<a name="more-info"></a>
+  [Utilizzo di Amazon SQS Dead Letter Queues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) nella Guida per gli sviluppatori di Amazon Simple Queue Service
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nel riferimento all'API di riferimento di Amazon Simple Queue Service