Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Amazon SQS SQS-Codebeispiele mit dem AWS SDK für C\$1\$1
<a name="examples-sqs"></a>

Amazon Simple Queue Service (Amazon SQS) ist ein vollständig verwalteter Message Queuing-Service, der es einfach macht, Microservices, verteilte Systeme und serverlose Anwendungen zu entkoppeln und zu skalieren. Sie können die folgenden Beispiele verwenden, um [Amazon SQS](https://aws.amazon.com/sqs) mit dem AWS SDK für C\$1\$1 zu programmieren.

**Anmerkung**  
In diesem Handbuch ist nur der Code enthalten, der zur Veranschaulichung bestimmter Techniken erforderlich ist. Der [vollständige Beispielcode ist jedoch unter GitHub verfügbar](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp). Auf können GitHub Sie eine einzelne Quelldatei herunterladen oder das Repository lokal klonen, um alle Beispiele abzurufen, zu erstellen und auszuführen.

**Topics**
+ [Mit Amazon SQS Message Queues arbeiten](examples-sqs-message-queues.md)
+ [Senden, Empfangen und Löschen von Amazon SQS SQS-Nachrichten](examples-sqs-messages.md)
+ [Long Polling für Amazon SQS SQS-Nachrichtenwarteschlangen aktivieren](examples-sqs-long-polling.md)
+ [Einstellen des Sichtbarkeits-Timeouts in Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Verwenden von Warteschlangen für unzustellbare Nachrichten in Amazon SQS](examples-sqs-dead-letter-queues.md)

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

Eine *Nachrichtenwarteschlange* ist der logische Container, den Sie verwenden, um Nachrichten zuverlässig in Amazon SQS zu versenden. Es gibt zwei Arten von Warteschlangen: *Standard* und *First-in-First-out-Verfahren* (FIFO). Weitere Informationen zu Warteschlangen und den Unterschieden zwischen diesen Typen finden Sie im [Amazon Simple Queue Service Developer Guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).

Diese C\$1\$1-Beispiele zeigen Ihnen, wie Sie die verwenden, AWS SDK für C\$1\$1 um eine Amazon SQS SQS-Warteschlange zu erstellen, aufzulisten, zu löschen und deren URL abzurufen.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Erstellen einer Warteschlange
<a name="sqs-create-queue"></a>

Verwenden Sie die SQSClient `CreateQueue` Klassenmitgliedsfunktion und stellen Sie ihr ein [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)Objekt zur Verfügung, das die Warteschlangenparameter beschreibt.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/create_queue.cpp).

## Auflisten von Warteschlangen
<a name="sqs-list-queues"></a>

Um Amazon SQS SQS-Warteschlangen für Ihr Konto aufzulisten, rufen Sie die SQSClient `ListQueues` Klassenmitgliedsfunktion auf und übergeben Sie ihr ein [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)Objekt.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/list_queues.cpp).

## Ruft die URL der Warteschlange ab
<a name="sqs-get-queue-url"></a>

Rufen Sie die SQSClient `GetQueueUrl` Klassenmitgliedsfunktion auf, um die URL für eine bestehende Amazon SQS SQS-Warteschlange abzurufen.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/get_queue_url.cpp).

## Löschen einer Warteschlange
<a name="sqs-delete-queue"></a>

Geben Sie die [URL](#sqs-get-queue-url) zur SQSClient `DeleteQueue` Klassenmitgliedsfunktion an.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/delete_queue.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [So funktionieren Amazon SQS SQS-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) im Amazon Simple Queue Service Developer Guide
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)in der Amazon Simple Queue Service API-Referenz
+  [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)in der Amazon Simple Queue Service API-Referenz
+  [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)in der Amazon Simple Queue Service API-Referenz
+  [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)in der Amazon Simple Queue Service API-Referenz

# Senden, Empfangen und Löschen von Amazon SQS SQS-Nachrichten
<a name="examples-sqs-messages"></a>

Nachrichten werden immer über eine [SQS-Warteschlange](examples-sqs-message-queues.md) zugestellt. Diese C\$1\$1-Beispiele zeigen Ihnen, wie Sie Amazon SQS-Nachrichten aus SQS-Warteschlangen senden, empfangen und löschen können. AWS SDK für C\$1\$1 

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen. AWS SDK für C\$1\$1

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Senden einer Nachricht
<a name="sqs-message-send"></a>

Sie können einer Amazon SQS SQS-Warteschlange eine einzelne Nachricht hinzufügen, indem Sie die SQSClient `SendMessage` Klassenmitgliedsfunktion aufrufen. Sie stellen `SendMessage` ein [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)Objekt bereit, das die [URL](examples-sqs-message-queues.md#sqs-get-queue-url) der Warteschlange, den Nachrichtentext und einen optionalen Verzögerungswert (in Sekunden) enthält.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/send_message.cpp).

## Empfangen von Nachrichten
<a name="sqs-messages-receive"></a>

Ruft alle Nachrichten ab, die sich derzeit in der Warteschlange befinden, indem Sie die SQSClient `ReceiveMessage` Klassenmitgliedsfunktion aufrufen und ihr die URL der Warteschlange übergeben. Nachrichten werden als Liste von [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)-Objekten zurückgegeben.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

### Löschen von Nachrichten nach dem Empfangen
<a name="sqs-messages-delete"></a>

Nachdem Sie eine Nachricht empfangen und ihren Inhalt verarbeitet haben, löschen Sie die Nachricht aus der Warteschlange, indem Sie das Empfangs-Handle der Nachricht und die Warteschlangen-URL an die SQSClient `DeleteMessage` Klassenmitgliedsfunktion senden.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/receive_message.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [So funktionieren Amazon SQS SQS-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) im Amazon Simple Queue Service Developer Guide
+  [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)in der Amazon Simple Queue Service API-Referenz
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)in der Amazon Simple Queue Service API-Referenz

# Long Polling für Amazon SQS SQS-Nachrichtenwarteschlangen aktivieren
<a name="examples-sqs-long-polling"></a>

Amazon SQS verwendet standardmäßig *kurze Abfragen*, bei denen nur eine Teilmenge der Server abgefragt wird — basierend auf einer gewichteten Zufallsverteilung —, um festzustellen, ob Nachrichten für die Antwort verfügbar sind.

Lange Abfragen tragen dazu bei, Ihre Kosten für die Nutzung von Amazon SQS zu senken, indem die Anzahl der leeren Antworten reduziert wird, wenn keine Nachrichten als Antwort auf eine an eine Amazon SQS SQS-Warteschlange gesendete ReceiveMessage Anfrage zurückgesendet werden können, und falsche leere Antworten vermieden werden. Sie können eine Langabfragen-Häufigkeit von *1–20 Sekunden* festlegen.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen. AWS SDK für C\$1\$1

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Aktivieren Sie Long Polling beim Erstellen einer Warteschlange
<a name="sqs-long-polling-create-queue"></a>

Um lange Abfragen beim Erstellen einer Amazon SQS SQS-Warteschlange zu aktivieren, legen Sie das `ReceiveMessageWaitTimeSeconds` Attribut für das [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)Objekt fest, bevor Sie die Mitgliedsfunktion der SQSClient Klasse aufrufen. `CreateQueue`

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_create_queue.cpp).

## Aktivieren der Langabfrage für eine vorhandene Warteschlange
<a name="sqs-long-polling-existing-queue"></a>

Zusätzlich zur Aktivierung der langen Abfrage beim Erstellen einer Warteschlange können Sie diese Funktion auch in einer vorhandenen Warteschlange aktivieren, indem `ReceiveMessageWaitTimeSeconds` Sie die Funktion [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)vor dem Aufrufen der Member-Funktion der SQSClient Klasse aktivieren`SetQueueAttributes`.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_existing_queue.cpp).

## Aktivieren von Langabfragen beim Nachrichteneingang
<a name="sqs-long-polling-receive-message"></a>

Sie können lange Abfragen beim Empfang einer Nachricht aktivieren, indem Sie die Wartezeit in Sekunden für den Wert festlegen [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), den Sie an die ReceiveMessage Mitgliedsfunktion der SQSClient Klasse übergeben.

**Anmerkung**  
Sie sollten sicherstellen, dass das Anfrage-Timeout des AWS Clients größer ist als die maximale lange Abfragezeit (20 s), damit Ihre `ReceiveMessage` Anfragen beim Warten auf das nächste Umfrageereignis nicht zu einem Timeout kommen\$1

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/long_polling_on_message_receipt.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [Amazon SQS Long Polling](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) im Amazon Simple Queue Service Developer Guide
+  [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)in der Amazon Simple Queue Service API-Referenz
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz

# Einstellen des Sichtbarkeits-Timeouts in Amazon SQS
<a name="examples-sqs-visibility-timeout"></a>

Wenn eine Nachricht in Amazon SQS empfangen wird, bleibt sie in der Warteschlange, bis sie gelöscht wird, um den Empfang sicherzustellen. Eine empfangene, aber nicht gelöschte Nachricht erscheint erst nach Ablauf einer bestimmten *Zeitbeschränkung für die Sichtbarkeit* in nachfolgenden Anforderungen. Dadurch wird gewährleistet, dass die Nachricht nicht mehrmals empfangen wird, bevor sie verarbeitet und gelöscht werden kann.

Bei Nutzung von [Standard-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html) kann durch die Zeitbeschränkung für die Sichtbarkeit nicht garantiert werden, dass eine Nachricht mehrmals empfangen wird. Wenn Sie eine Standard-Warteschlange verwenden, achten Sie darauf, dass Ihr Code mit dem Fall umgehen kann, dass dieselbe Nachricht mehrmals eingeht.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem AWS SDK für C\$1\$1 zu](getting-started.md) lesen. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Legen Sie das Timeout für die Nachrichtensichtbarkeit beim Empfang der Nachricht fest
<a name="sqs-visibility-timeout-receipt"></a>

Wenn Sie eine Nachricht erhalten haben, können Sie das Zeitlimit für die Sichtbarkeit ändern, indem Sie die Empfangsnummer in einer Nachricht übergeben [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), die Sie an die Mitgliederfunktion der SQSClient Klasse übergeben. `ChangeMessageVisibility`

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/change_message_visibility.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [Visibility Timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) im Amazon Simple Queue Service Developer Guide
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz
+  [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz
+  [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon Simple Queue Service API-Referenz
+  [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)in der Amazon Simple Queue Service API-Referenz
+  [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)in der Amazon Simple Queue Service API-Referenz

# Verwenden von Warteschlangen für unzustellbare Nachrichten in Amazon SQS
<a name="examples-sqs-dead-letter-queues"></a>

Amazon SQS bietet Unterstützung für *Warteschlangen mit unbestätigten Briefen*. Eine Warteschlange für unzustellbare Nachrichten ist eine Warteschlange, die von anderen Warteschlangen für Nachrichten ausgewählt werden kann, die nicht erfolgreich verarbeitet werden können. Sie können diese Nachrichten in der Warteschlange für unzustellbare Nachrichten sammeln und isolieren, um zu bestimmen, warum die Verarbeitung fehlgeschlagen ist.

Um eine Warteschlange für unzustellbare Nachrichten zu erstellen, müssen Sie zuerst eine *Redrive-Richtlinie* erstellen und diese dann in den Attributen der Warteschlange festlegen.

**Wichtig**  
Bei einer Warteschlange für unzustellbare Nachrichten muss es sich um dieselbe Art von Warteschlange (FIFO oder Standard) handeln wie bei der Quellwarteschlange. Sie muss außerdem mit demselben AWS-Konto und AWS-Region wie die Quellwarteschlange erstellt werden.

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

Bevor Sie beginnen, empfehlen wir Ihnen, [Erste Schritte mit dem zu](getting-started.md) lesen AWS SDK für C\$1\$1. 

Laden Sie den Beispielcode herunter und erstellen Sie die Lösung wie unter beschrieben[Erste Schritte mit Codebeispielen](getting-started-code-examples.md). 

Um die Beispiele ausführen zu können, muss das Benutzerprofil, das Ihr Code für die Anfragen verwendet, über die entsprechenden Berechtigungen verfügen AWS (für den Dienst und die Aktion). Weitere Informationen finden Sie unter [Bereitstellen von AWS Anmeldeinformationen](credentials.md).

## Erstellen Sie eine Redrive-Richtlinie
<a name="sqs-dead-letter-queue-create-redrive-policy"></a>

Eine Redrive-Richtlinie ist in JSON angegeben. Um sie zu erstellen, können Sie die JSON-Utility-Klasse verwenden, die im AWS SDK für C\$1\$1 Lieferumfang von enthalten ist.

Hier ist eine Beispielfunktion, die eine Redrive-Richtlinie erstellt, indem sie ihr den ARN Ihrer Warteschlange für unzustellbare Briefe und die maximale Häufigkeit, mit der die Nachricht empfangen und nicht verarbeitet werden kann, zur Verfügung stellt, bevor sie an die Warteschlange für unzustellbare Briefe gesendet wird.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Legen Sie die Redrive-Richtlinie für Ihre Quellwarteschlange fest
<a name="sqs-dead-letter-queue-set-redrive-policy"></a>

Um die Einrichtung Ihrer Warteschlange für unzustellbare Briefe abzuschließen, rufen Sie die SQSClient `SetQueueAttributes` Mitgliederfunktion der Klasse mit einem [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)Objekt auf, für das Sie das `RedrivePolicy` Attribut mit Ihrer JSON-Redrive-Richtlinie festgelegt haben.

 **Beinhaltet** 

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

 **Code** 

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

Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs/dead_letter_queue.cpp).

## Weitere Infos
<a name="more-info"></a>
+  [Verwenden von Amazon SQS Dead Letter Queues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) im Amazon Simple Queue Service Developer Guide
+  [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon Simple Queue Service API-Referenz