amazon simple queue service - entwicklerhandbuch · amazon mq ist ein verwalteter message...

Amazon Simple Queue ServiceEntwicklerhandbuch

Amazon Simple Queue Service Entwicklerhandbuch

Amazon Simple Queue Service: EntwicklerhandbuchCopyright © 2019 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.


Table of ContentsWas ist Amazon SQS? ........................................................................................................................ 1

Was sind die größten Vorteile von Amazon SQS? ........................................................................... 1Wie unterscheidet sich Amazon SQS von Amazon MQ oder Amazon SNS? ......................................... 2Welchen Warteschlangentyp benötige ich? ..................................................................................... 2Wie sehen meine ersten Schritte mit Amazon SQS aus? .................................................................. 3Bitte geben Sie uns Feedback ...................................................................................................... 3

Einrichten .......................................................................................................................................... 4Schritt 1: Erstellen eines AWS-Kontos ........................................................................................... 4Schritt 2: Erstellen eines IAM-Benutzers ......................................................................................... 4Schritt 3: Abrufen Ihrer Zugriffsschlüssel-ID und Ihres geheimen Zugriffsschlüssels ............................... 5Schritt 4: Vorbereiten der Verwendung des Beispiel-Codes ............................................................... 6Nächste Schritte ......................................................................................................................... 7

Erste Schritte ..................................................................................................................................... 8Voraussetzungen ........................................................................................................................ 8Schritt 1: Erstellen einer Warteschlange ......................................................................................... 8Schritt 2: Senden einer Nachricht .................................................................................................. 9Schritt 3: Empfangen und Löschen Ihrer Nachricht ......................................................................... 11Schritt 4: Löschen Ihrer Warteschlange ........................................................................................ 14Nächste Schritte ....................................................................................................................... 15

Tutorials .......................................................................................................................................... 16Erstellen von Warteschlangen ..................................................................................................... 16

Erstellen einer Warteschlange ............................................................................................. 16Erstellen einer Warteschlange mit SSE ................................................................................ 20

Auflisten aller Warteschlangen .................................................................................................... 24AWS Management Console ................................................................................................ 24AWS SDK for Java ........................................................................................................... 25

Hinzufügen von Berechtigungen zu einer Warteschlange ................................................................ 25AWS Management Console ................................................................................................ 25

Hinzufügen, Aktualisieren und Entfernen von Tags für eine Warteschlange ........................................ 28AWS Management Console ................................................................................................ 28AWS SDK for Java ........................................................................................................... 29

Senden von Nachrichten ............................................................................................................ 30Senden einer Nachricht ..................................................................................................... 30Senden einer Nachricht mit Attributen .................................................................................. 34Senden einer Nachricht mit einem Timer .............................................................................. 40Senden einer Nachricht von einer VPC ................................................................................ 43

Empfangen und Löschen einer Nachricht ..................................................................................... 47AWS Management Console ................................................................................................ 48AWS SDK for Java ........................................................................................................... 51

Abonnieren einer Warteschlange für ein Thema ............................................................................. 53AWS Management Console ................................................................................................ 54

Konfigurieren eines Lambda-Auslösers ......................................................................................... 56Voraussetzungen .............................................................................................................. 56AWS Management Console ................................................................................................ 57

Bereinigen einer Warteschlange .................................................................................................. 58AWS Management Console ................................................................................................ 59

Löschen einer Warteschlange ..................................................................................................... 60AWS Management Console ................................................................................................ 60AWS SDK for Java ........................................................................................................... 61

Konfigurieren von Warteschlangen .............................................................................................. 62Konfigurieren von SSE für eine Warteschlange ...................................................................... 62Konfigurieren einer Langabfrage für eine Warteschlange ......................................................... 66Konfigurieren einer Warteschlange für unzustellbare Nachrichten ............................................. 69Konfigurieren der Zeitbeschränkung für die Sichtbarkeit für eine Warteschlange .......................... 73

iii


Konfigurieren einer Amazon SQS-Verzögerungswarteschlange ................................................ 77Funktionsweise von Amazon SQS ....................................................................................................... 80

Grundlegende Architektur ........................................................................................................... 80Verteilte Warteschlangen .................................................................................................... 80Lebenszyklus einer Nachricht ............................................................................................. 81

Standard-Warteschlangen .......................................................................................................... 83Nachrichtenreihenfolge ....................................................................................................... 83Mindestens einmalige Lieferung .......................................................................................... 83Funktionierendes Java-Beispiel für Standard-Warteschlangen .................................................. 84

FIFO-Warteschlangen ................................................................................................................ 86Nachrichtenreihenfolge ....................................................................................................... 87Wichtige Begriffe ............................................................................................................... 87FIFO-Bereitstellungslogik .................................................................................................... 88Garantiert einmalige Verarbeitung ........................................................................................ 89Von einer Standard-Warteschlange in eine FIFO-Warteschlange wechseln ................................. 89Kompatibilität .................................................................................................................... 90Funktionierendes Java-Beispiel für FIFO-Warteschlangen ........................................................ 91

Warteschlangen- und Nachrichten-IDs .......................................................................................... 93IDs für Standard- und FIFO-Warteschlangen ......................................................................... 94Zusätzliche Kennungen für FIFO-Warteschlangen .................................................................. 95

Nachrichtenmetadaten ............................................................................................................... 95Nachrichtenattribute ........................................................................................................... 95Nachrichtensystemattribute ................................................................................................. 98

Für die Nachrichtenverarbeitung erforderliche Ressourcen .............................................................. 98Kostenzuordnungs-Tags ............................................................................................................. 99Kurz- und Langabfragen ........................................................................................................... 100

Abrufen von Nachrichten durch Kurzabfragen ...................................................................... 100Verarbeiten von Nachrichten mithilfe von Langabfragen ......................................................... 101Unterschiede zwischen Lang- und Kurzabfragen .................................................................. 101

Warteschlange für unzustellbare Nachrichten ............................................................................... 102Funktionsweise von Warteschlangen für unzustellbare Nachrichten ......................................... 102Welche Vorteile bieten Warteschlangen für unzustellbare Nachrichten? .................................... 103Wie lassen sich die Fehlerarten beim Verarbeiten von Nachrichten unterscheiden? .................... 104Wann sollte ich eine Warteschlange für unzustellbare Nachrichten verwenden? ......................... 104Fehlerbehebung für Warteschlangen für unzustellbare Nachrichten ......................................... 105

Zeitbeschränkung für die Sichtbarkeit ......................................................................................... 106In Übertragung befindliche Nachrichten .............................................................................. 107Einrichten der Zeitbeschränkung für die Sichtbarkeit ............................................................. 107Ändern der Zeitbeschränkung für die Sichtbarkeit für eine Nachricht ........................................ 108Beenden der Zeitbeschränkung für die Sichtbarkeit für eine Nachricht ...................................... 108

Verzögerungswarteschlangen .................................................................................................... 108Temporäre Warteschlangen ...................................................................................................... 109

Virtuelle Warteschlangen .................................................................................................. 110Request-Response-Messaging-Muster (virtuelle Warteschlangen) ........................................... 111Beispielszenario: Verarbeiten einer Anmeldeanforderung ....................................................... 111Bereinigen von Warteschlangen ........................................................................................ 113

Nachrichten-Timer ................................................................................................................... 113Verwalten großer Nachrichten ................................................................................................... 114

Funktionierendes Java-Beispiel für die Verwendung von Amazon S3 ....................................... 114Arbeiten mit JMS .................................................................................................................... 117

-Anforderungen ............................................................................................................... 118Erste Schritte mit Java Messaging-Bibliothek ....................................................................... 118Verwenden von JMS-Client mit anderen Amazon SQS-Clients ................................................ 124Funktionierendes Java-Beispiel für die Verwendung von JMS mit Amazon SQS Standard-Warteschlangen .............................................................................................................. 125Unterstützte JMS 1.1-Implementierungen ............................................................................ 139

Bewährte Methoden ......................................................................................................................... 141

iv


Empfehlungen für Standard- und FIFO-Warteschlangen ................................................................ 141Arbeiten mit Nachrichten .................................................................................................. 141Reduzieren von Kosten .................................................................................................... 144Von einer Standard-Warteschlange in eine FIFO-Warteschlange wechseln ............................... 144

Zusätzliche Empfehlungen für FIFO-Warteschlangen .................................................................... 145Verwenden der Nachrichtendeduplizierungs-ID .................................................................... 145Verwenden der Nachrichtengruppen-ID ............................................................................... 146Verwenden der Empfangsanforderungsversuch-ID ................................................................ 147

Kontingente .................................................................................................................................... 148Kontingente im Zusammenhang mit Warteschlangen .................................................................... 148Kontingente im Zusammenhang mit Nachrichten .......................................................................... 149Kontingente im Zusammenhang mit Richtlinien ............................................................................ 151

Automatisierung und Fehlerbehebung ................................................................................................. 152Automatisieren von Benachrichtigungen mit CloudWatch-Ereignisse ................................................ 152Fehlerbehebung von Warteschlangen mit X-Ray .......................................................................... 152

Sicherheit ....................................................................................................................................... 154Datenschutz ........................................................................................................................... 154

Datenverschlüsselung ...................................................................................................... 154Richtlinie für den Datenverkehr zwischen Netzwerken ........................................................... 162

Identitäts- und Zugriffsverwaltung ............................................................................................... 163Authentifizierung .............................................................................................................. 163Zugriffskontrolle ............................................................................................................... 165Übersicht ....................................................................................................................... 165Verwenden identitätsbasierter Richtlinien ............................................................................ 171Verwenden benutzerdefinierter Richtlinien mit der Access Policy Language .............................. 180Using Temporary Security Credentials ................................................................................ 190Referenztabelle für API-Berechtigungen .............................................................................. 191

Protokollieren und überwachen .................................................................................................. 194Protokollieren von API-Aufrufen mithilfe von CloudTrail ......................................................... 194Überwachen von Warteschlangen mit CloudWatch ............................................................... 198

Compliance-Validierung ............................................................................................................ 207Ausfallsicherheit ...................................................................................................................... 207

Verteilte Warteschlangen .................................................................................................. 207Sicherheit der Infrastruktur ........................................................................................................ 208Bewährte Methoden ................................................................................................................. 208

Vorbeugende bewährte Methoden ..................................................................................... 209Arbeiten mit APIs ............................................................................................................................ 212

Erstellen von Query API-Anforderungen ...................................................................................... 212Einen Endpunkt erstellen .................................................................................................. 212Eine GET-Anforderung durchführen ................................................................................... 213Eine POST-Anforderung durchführen ................................................................................. 213Authentifizieren von Anforderungen .................................................................................... 214Antworten interpretieren ................................................................................................... 217

Stapelaktionen ........................................................................................................................ 218Aktivieren clientseitiger Pufferung und Stapelverarbeitung von Anforderungen ........................... 219Erhöhen des Durchsatzes mit horizontaler Skalierung und Aktionsstapelverarbeitung .................. 223

Verwandte Ressourcen .................................................................................................................... 233Versionshinweise ............................................................................................................................. 234

Dokumentverlauf ..................................................................................................................... 241AWS-Glossar .................................................................................................................................. 261

v

Amazon Simple Queue Service EntwicklerhandbuchWas sind die größten Vorteile von Amazon SQS?

Was ist Amazon Simple QueueService?

Amazon Simple Queue Service (Amazon SQS) bietet eine sichere, belastbare und verfügbar gehosteteWarteschlange, die Ihnen gestattet, verteilte Software-Systeme und -Komponenten zu integrieren undzu entkoppeln. Amazon SQS bietet allgemeine Konstrukte, wie beispielsweise Warteschlangen fürunzustellbare Nachrichten (p. 102) sowie Tags für die Kostenzuordnung (p. 99). Es bietet einegenerische Web-Services-API und ist über alle Programmiersprachen zugänglich, die von der AWS-SDKunterstützt werden.

Amazon SQS unterstützt sowohl Standard- (p. 83) als auch FIFO-Warteschlangen (p. 86). WeitereInformationen finden Sie unter Welchen Warteschlangentyp benötige ich? (p. 2)

Themen• Was sind die größten Vorteile von Amazon SQS? (p. 1)• Wie unterscheidet sich Amazon SQS von Amazon MQ oder Amazon SNS? (p. 2)• Welchen Warteschlangentyp benötige ich? (p. 2)• Wie sehen meine ersten Schritte mit Amazon SQS aus? (p. 3)• Bitte geben Sie uns Feedback (p. 3)

Was sind die größten Vorteile von Amazon SQS?• Sicherheit – Sie kontrollieren, (p. 163) wer Nachrichten an eine Amazon SQS-Warteschlange senden

und von dieser empfangen kann.

Server-side encryption (SSE) (p. 154) ermöglicht Ihnen die Übertragung vertraulicher Daten durchSchützen der Inhalte von Nachrichten in Warteschlangen mithilfe in AWS Key Management Service(AWS KMS) verwalteter Schlüssel.

• Haltbarkeit – Um die Sicherheit Ihrer Nachrichten zu gewährleisten, speichert Amazon SQSsie auf mehreren Servern. Standard-Warteschlangen unterstützen die mindestens einmaligeNachrichtenbereitstellung (p. 83), und FIFO-Warteschlangen unterstützen die genau einmaligeNachrichtenverarbeitung (p. 89).

• Verfügbarkeit – Amazon SQS verwendet eine redundante Infrastruktur (p. 80) für den simultanenZugriff auf Nachrichten und hohe Verfügbarkeit zum Erstellen und Verwenden von Nachrichten.

• Skalierbarkeit – Amazon SQS kann jede gepufferte Anfrage (p. 219) unabhängigverarbeiten und transparent skalieren, um sämtliche zunehmenden Lasten oder Spitzen ohneBereitstellungsanweisungen zu verarbeiten.

• Zuverlässigkeit – Amazon SQS sperrt Ihre Nachrichten während der Verarbeitung, damit mehrereProduzenten und mehrere Konsumenten Nachrichten gleichzeitig senden und empfangen können.

• Anpassung – Ihre Warteschlangen müssen nicht genau übereinstimmen—, Sie können z. B.Standardverzögerung für eine Warteschlange festlegen (p. 108). Sie können den Inhalt der Nachrichtenmit mehr als 256 KB mithilfe von Amazon Simple Storage Service (Amazon S3) (p. 114) oder AmazonDynamoDB speichern, wenn Amazon SQS einen Verweis auf das Amazon S3-Objekt enthält. Sie könnengroße Nachrichten auch in kleinere Nachrichten aufteilen.

1

Amazon Simple Queue Service EntwicklerhandbuchWie unterscheidet sich Amazon SQSvon Amazon MQ oder Amazon SNS?

Wie unterscheidet sich Amazon SQS von AmazonMQ oder Amazon SNS?

Amazon SQS und Amazon SNS sind Warteschlangen- und Themen-Services, die hochgradig skalierbarund benutzerfreundlich sind und keine Einrichtung von Message Brokern erfordern. Wir empfehlen dieseServices für neue Anwendungen, die von praktisch unbegrenzter Skalierbarkeit und einfacher APIsprofitieren können.

Amazon MQ ist ein verwalteter Message Broker-Service, der Kompatibilität mit vielen beliebten MessageBrokern bietet. Wir empfehlen Amazon MQ zur Migration von Anwendungen von vorhandenen MessageBrokern, die auf Kompatibilität mit APIs, wie JMS, oder Protokolle, wie AMQP, MQTT, OpenWire undSTOMP, beruhen.

Welchen Warteschlangentyp benötige ich?Standard-Warteschlange FIFO-Warteschlange

Unbegrenzter Durchsatz – Standard-Warteschlangen unterstützen eine fastunbegrenzte Anzahl an Transaktionen proSekunde (TPS) pro API-Aktion (SendMessage,ReceiveMessage oder DeleteMessage).

Mindestens einmalige Lieferung: – Eine Nachrichtwird mindestens einmal übermittelt; gelegentlichwird eine Nachricht mehr als einmal gesendet.

Bestmögliche Einhaltung von Reihenfolgen: –Mitunter werden Nachrichten in der falschenReihenfolge zugestellt.

Hoher Durchsatz – MitStapelverarbeitung (p. 218) unterstützenFIFO-Warteschlangen standardmäßig bis zu3.000 Nachrichten pro Sekunde (TPS) pro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage). Um eine Kontingenterhöhunganzufordern, übermitteln Sie eine Support-Anforderung. Ohne Stapelverarbeitungunterstützen FIFO-Warteschlangen bis zu300 Nachrichten pro Sekunde und pro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage).

Genau einmalige Verarbeitung: – Eine Nachrichtwird einmal gesendet und bleibt solange verfügbar,bis der Kunde sie gelesen und gelöscht hat.Duplikate werden nicht in die Warteschlangeaufgenommen.

First-in-First-out-Übermittlung: – Die Reihenfolge, inder Nachrichten gesendet und empfangen werden,wird strikt beibehalten.

Übertragen Sie Daten zwischen Anwendungen,wenn der Durchsatz wichtig ist, beispielsweise:

• Entkoppeln Sie Anfragen von Live-Benutzern vonintensiver Hintergrundarbeit: Benutzer könnenMedien hochladen, während Sie die Größe derMedien anpassen oder sie kodieren.

Übertragen Sie Daten zwischen Anwendungen,wenn die Reihenfolge der Ereignisse wichtig ist,zum Beispiel:

• Sicherstellen, dass vom Benutzer eingegebeneBefehle in der richtigen Reihenfolge ausgeführtwerden

2

https://aws.amazon.com/sns/

https://aws.amazon.com/amazon-mq/

https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase&limitType=service-code-sqs


Amazon Simple Queue Service EntwicklerhandbuchWie sehen meine ersten Schritte mit Amazon SQS aus?

Standard-Warteschlange FIFO-Warteschlange• Weisen Sie Aufgaben mehreren Worker-

Knoten zu: Bearbeiten Sie eine große Menge anKreditkarten-Validierungsanfragen.

• Bündeln Sie Nachrichten für künftigeVerarbeitung: Setzen Sie Zeitpunkte fest, zudenen Einträge in Datenbanken hinzugefügtwerden.

• Anzeigen des richtigen Produktpreises, indemPreisänderungen in der richtigen Reihenfolgegesendet werden

• Verhindern, dass sich ein Student vor demErstellen eines Benutzerkontos in einen Kurseinschreibt

Wie sehen meine ersten Schritte mit Amazon SQSaus?

• Informationen zum Erstellen Ihrer ersten Warteschlange mit Amazon SQS und Senden, Empfangen undLöschen einer Nachricht finden Sie unter Erste Schritte mit Amazon SQS (p. 8).

• Weitere Informationen über Funktionalität und Architektur von Amazon SQS finden Sie unterFunktionsweise von Amazon SQS (p. 80).

• Weitere Informationen über Richtlinien und Einschränkungen, die Ihnen dabei helfen, den größtenNutzen aus Amazon SQS zu ziehen, finden Sie unter Bewährte Methoden für Amazon SQS (p. 141).

• Informationen zu Amazon SQS-Aktionen finden Sie unter Amazon Simple Queue Service API Reference.• Informationen zu Amazon SQS AWS CLI-Befehlen finden Sie unter Amazon SQS im AWS CLI

Command Reference.

Bitte geben Sie uns FeedbackWir freuen uns über Ihr Feedback. Um Kontakt mit uns aufzunehmen, besuchen Sie das Amazon SQS-Diskussionsforum.

3

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/

https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html


https://forums.aws.amazon.com/forum.jspa?forumID=12


Amazon Simple Queue Service EntwicklerhandbuchSchritt 1: Erstellen eines AWS-Kontos

Amazon SQS einrichtenBevor Sie Amazon SQS zum ersten Mal verwenden können, müssen Sie die folgenden Schritte ausführen.

Schritt 1: Erstellen eines AWS-KontosFür den Zugriff auf einen AWS-Service müssen Sie zunächst ein AWS-Konto erstellen, d. h. ein Amazon-Konto, das die AWS-Produkte nutzen kann. Sie können Ihr AWS-Konto dazu verwenden, Ihre Aktivitätenund Nutzungsberichte anzuzeigen und die Authentifizierung und den Zugriff zu verwalten.

Damit Sie den Root-Benutzer für Ihr AWS-Konto nicht für Amazon SQS-Aktionen verwenden müssen, hates sich als Methode bewährt, einen IAM-Benutzer für jede Person zu erstellen, die Verwaltungszugriff aufAmazon SQS benötigt.

So richten Sie ein neues Konto ein

1. Öffnen Sie https://portal.aws.amazon.com/billing/signup.2. Folgen Sie den Onlineanweisungen.

Der Anmeldeprozess beinhaltet auch einen Telefonanruf und die Eingabe eines Verifizierungscodesüber die Telefontastatur.

Schritt 2: Erstellen eines IAM-BenutzersSo erstellen Sie einen Administratorbenutzer für sich selbst und fügen ihn einerAdministratorengruppe hinzu (Konsole)

1. Verwenden Sie die E-Mail-Adresse und das Passwort Ihres AWS-Kontos für die Anmeldung alsStammbenutzer des AWS-Kontos bei der IAM-Konsole unter https://console.aws.amazon.com/iam/.

Note

Wir empfehlen ausdrücklich, die bewährten Verfahren mithilfe des AdministratorIAM-Benutzers unten zu verwenden und die Anmeldeinformationen des Stammbenutzers aneinem sicheren Ort abzulegen. Melden Sie sich als Stammbenutzer an, um einige Konto- undService-Verwaltungsaufgaben durchzuführen.

2. Wählen Sie im Navigationsbereich Users und dann Add User aus.3. Geben Sie unter Benutzername Administrator als Benutzernamen ein.4. Aktivieren Sie das Kontrollkästchen neben AWS Management Console access (Konsolenzugriff).

Wählen Sie dann Custom password (Benutzerdefiniertes Passwort) aus und geben Sie danach Ihrneues Passwort in das Textfeld ein.

5. (Optional) Standardmäßig erfordert AWS, dass der neue Benutzer bei der ersten Anmeldung ein neuesPasswort erstellt. Sie können das Kontrollkästchen neben User must create a new password at nextsign-in (Benutzer muss bei der nächsten Anmeldung ein neues Passwort erstellen) deaktivieren, umdem neuen Benutzer zu ermöglichen, sein Kennwort nach der Anmeldung zurückzusetzen.

6. Wählen Sie Next: Permissions aus.

4

https://aws.amazon.com/

https://portal.aws.amazon.com/billing/signup

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html

https://console.aws.amazon.com/iam/

https://docs.aws.amazon.com/general/latest/gr/aws_tasks-that-require-root.html

https://docs.aws.amazon.com/general/latest/gr/aws_tasks-that-require-root.html

Amazon Simple Queue Service EntwicklerhandbuchSchritt 3: Abrufen Ihrer Zugriffsschlüssel-ID und Ihres geheimen Zugriffsschlüssels

7. Wählen Sie unter Set permissions (Berechtigungen festlegen) die Option Add user to group (Benutzerder Gruppe hinzufügen) aus.

8. Wählen Sie Create group (Gruppe erstellen) aus.9. Geben Sie im Dialogfeld Create group (Gruppe erstellen) unter Group name (Gruppenname)

Administrators ein.10. Wählen Sie Filter policies (Richtlinien filtern) und anschließend AWS-managed job function (AWS-

verwaltete Auftragsfunktion) aus, um den Tabelleninhalt zu filtern.11. Aktivieren Sie in der Richtlinienliste das Kontrollkästchen AdministratorAccess. Wählen Sie dann

Create group aus.

Note

Sie müssen den Zugriff der IAM-Benutzer und -Rollen auf die Fakturierung aktivieren, bevorSie die AdministratorAccess-Berechtigungen verwenden können, um auf die AWS Billingand Cost Management-Konsole zuzugreifen. Befolgen Sie hierzu die Anweisungen in Schritt 1des Tutorials zum Delegieren des Zugriffs auf die Abrechnungskonsole.

12. Kehren Sie zur Gruppenliste zurück und aktivieren Sie das Kontrollkästchen der neuen Gruppe.Möglicherweise müssen Sie Refresh auswählen, damit die Gruppe in der Liste angezeigt wird.

13. Wählen Sie Weiter: Tags aus.14. (Optional) Fügen Sie dem Benutzer Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare

anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter Tagging von IAM-Entitäten im IAM-Benutzerhandbuch.

15. Wählen Sie Next: Review aus, damit die Liste der Gruppenmitgliedschaften angezeigt wird, die demneuen Benutzer hinzugefügt werden soll. Wenn Sie bereit sind, fortzufahren, wählen Sie Create user(Benutzer erstellen) aus.

Mit diesen Schritten können Sie weitere Gruppen und Benutzer erstellen und Ihren Benutzern Zugriffauf Ihre AWS-Kontoressourcen gewähren. Weitere Informationen dazu, wie Sie die Berechtigungeneines Benutzers auf bestimmte AWS-Ressourcen mithilfe von Richtlinien beschränken, finden Sie unterZugriffsverwaltung und Beispielrichtlinien.

Schritt 3: Abrufen Ihrer Zugriffsschlüssel-ID undIhres geheimen Zugriffsschlüssels

Für Amazon SQS-Aktionen (z. B. mit Java oder über die AWS Command Line Interface) benötigen Sie eineZugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel.

Note

Die Zugriffsschlüssel-ID und der geheimen Zugriffsschlüssel sind für AWS Identity and AccessManagement spezifisch. Verwechseln Sie diese nicht mit Anmeldeinformationen für andere AWS-Services, wie z. B. Amazon EC2-Schlüsselpaare.

Zugriffsschlüssel bestehen aus einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel. Diesewerden zum Signieren der von Ihnen ausgeführten programmgesteuerten Anforderungen an AWSverwendet. Wenn Sie noch keine Zugriffsschlüssel besitzen, können Sie diese über die AWS ManagementConsole erstellen. Verwenden Sie als bewährte Methode nicht die Stammbenutzer des AWS-Kontos-Zugriffsschlüssel für Aufgaben, für die dies nicht erforderlich ist. Erstellen Sie stattdessen einen neuen IAM-Benutzer mit Administratorrechten und mit Zugriffschlüsseln für Sie selbst.

Beim Erstellen der geheimen Zugriffschlüssel besteht die einzige Möglichkeit, diese anzuzeigen oderherunterzuladen. Später lassen sie sich nicht wieder wiederherstellen. Sie können jedoch jederzeit neueZugriffsschlüssel erstellen. Sie müssen auch über Berechtigungen verfügen, um die benötigten IAM-

5

https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_billing.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_billing.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_examples.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html

Amazon Simple Queue Service EntwicklerhandbuchSchritt 4: Vorbereiten der Verwendung des Beispiel-Codes

Aktionen durchzuführen. Weitere Informationen finden Sie unter Erforderliche Berechtigungen für denZugriff auf IAM-Ressourcen im IAM-Benutzerhandbuch.

So erstellen Sie Zugriffsschlüssel für einen IAM-Benutzer

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Klicken Sie im Navigationsbereich auf Users.3. Wählen Sie erst den Namen des Benutzers, dessen Zugriffsschlüssel Sie erstellen möchten, und dann

die Registerkarte Security credentials (Sicherheitsanmeldeinformationen) aus.4. Wählen Sie im Bereich Access keys (Zugriffsschlüssel) die Option Create access key

(Zugriffsschlüssel erstellen).5. Um das neue Zugriffsschlüsselpaar anzuzeigen, wählen Sie Show (Anzeigen). Sie haben keinen

Zugriff auf den geheimen Zugriffsschlüssel mehr, nachdem das Dialogfeld geschlossen wird. IhreAnmeldeinformationen sehen etwa folgendermaßen aus:

• Zugriffsschlüssel-ID: AKIAIOSFODNN7EXAMPLE• Geheimer Zugriffsschlüssel: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

6. Wählen Sie zum Herunterladen des Schlüsselpaares Download .csv file aus. Speichern Sie dieSchlüssel an einem sicheren Ort. Sie haben keinen Zugriff auf den geheimen Zugriffsschlüssel mehr,nachdem das Dialogfeld geschlossen wird.

Behandeln Sie die Schlüssel vertraulich, um Ihr AWS-Konto zu schützen, und senden Sie dieSchlüssel niemals per E-Mail. Geben Sie die Schlüssel nicht außerhalb Ihrer Organisation weiter, auchnicht im Falle von Anfragen, die von AWS oder Amazon.com zu kommen scheinen. Niemand, derAmazon legitim vertritt, wird Sie nach dem geheimen Schlüssel fragen.

7. Nachdem Sie die .csv-Datei heruntergeladen haben, klicken Sie auf Close (Schließen). Wenn Sieeinen Zugriffsschlüssel erstellen, ist das Schlüsselpaar standardmäßig aktiv, und Sie können es sofortverwenden.

Verwandte Themen

• Was ist IAM? im IAM-Benutzerhandbuch• AWS-Sicherheitsanmeldeinformationen in der AWS General Reference

Schritt 4: Vorbereiten der Verwendung des Beispiel-Codes

In diesem Abschnitt wird dargestellt, wie Sie mit Amazon SQS arbeiten, wenn Sie die AWS ManagementConsole oder Java verwenden. Wenn Sie den Beispielcode verwenden möchten, müssen Sie das JavaStandard Edition Development Kit installieren und einige Konfigurationsänderungen am Beispielcodevornehmen.

Sie können Code in anderen Programmiersprachen schreiben. Weitere Informationen finden Sie in derDokumentation der AWS-SDKs.

Note

Sie können Amazon SQS erkunden, ohne Code zu schreiben. Verwenden Sie dazu Toolswie AWS Command Line Interface (AWS CLI) oder Windows PowerShell. Im Amazon SQS-Abschnitt im AWS CLI Command Reference finden Sie AWS CLI-Beispiele. Im Amazon SimpleQueue Service-Abschnitt im AWS-Tools für PowerShell Cmdlet Reference finden Sie WindowsPowerShell-Beispiele.

6

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html



https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html

https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html

http://www.oracle.com/technetwork/java/javase/downloads/


https://aws.amazon.com//tools/#sdk



https://docs.aws.amazon.com/powershell/latest/reference/

Amazon Simple Queue Service EntwicklerhandbuchNächste Schritte

Nächste SchritteSie sind nun bereit für die Arbeit mit Amazon SQS und können die ersten Schritte (p. 8) zur Verwaltungvon Amazon SQS-Warteschlangen und -Nachrichten mithilfe der AWS Management Console ausführen.Sie können auch die fortgeschrittenen Amazon SQSTutorials (p. 16) durcharbeiten.

7

Amazon Simple Queue Service EntwicklerhandbuchVoraussetzungen

Erste Schritte mit Amazon SQSDieser Abschnitt trägt dazu bei, dass Sie mit Amazon SQS noch vertrauter werden, indem gezeigt wird, wieSie mithilfe der AWS Management Console Warteschlangen und Nachrichten verwalten.

VoraussetzungenBevor Sie beginnen, führen Sie die Schritte in Amazon SQS einrichten (p. 4) aus.

Schritt 1: Erstellen einer WarteschlangeDie erste und häufigste Amazon SQS-Aufgabe ist das Erstellen von Warteschlangen. In diesem Tutorialerfahren Sie, wie Sie eine Warteschlange erstellen und konfigurieren.

1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Wählen Sie Create New Queue (Neue Warteschlange erstellen).3. Vergewissern Sie sich auf der Seite Create New Queue (Neue Warteschlange erstellen), dass Sie sich

in der korrekten Region befinden, und geben Sie dann den Queue Name (Namen der Warteschlange)ein.

Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.4. Standard ist standardmäßig ausgewählt. Wählen Sie FIFO.5. Wählen Sie Quick-Create Queue (Warteschlange schnell erstellen), um eine Warteschlange mit den

Standardparametern zu erstellen.

Die neue Warteschlange wurde erstellt und in der Warteschlangenliste ausgewählt.Note

Wenn Sie eine Warteschlange erstellen, kann es kurze Zeit dauern, bis diese über AmazonSQS verteilt wird.

Die Spalte Queue Type (Warteschlangentyp) hilft dabei, Standard-Warteschlangen auf einenBlick von FIFO-Warteschlangen zu unterscheiden. Bei einer FIFO-Warteschlange zeigt die SpalteContent-Based Deduplication (Inhaltsbasierte Deduplizierung) an, ob Sie die garantierte einmaligeVerarbeitung (p. 89) aktiviert haben.

Name, URL und ARN der Warteschlange werden auf der Registerkarte Details angezeigt.

8

https://console.aws.amazon.com/sqs/

Amazon Simple Queue Service EntwicklerhandbuchSchritt 2: Senden einer Nachricht

Schritt 2: Senden einer NachrichtNachdem Sie Ihre Warteschlange erstellt haben, können Sie eine Nachricht an die Warteschlange senden.Das folgende Beispiel zeigt, wie eine Nachricht an eine vorhandene Warteschlange gesendet wird.

1. Wählen Sie die Warteschlange, die Sie erstellt haben, aus der Warteschlangenliste aus.

2. Wählen Sie unter Queue Actions (Warteschlangenaktionen) die Option Send a Message (Nachrichtsenden) aus.

Das Dialogfeld Send a Message to QueueName (Nachricht an QueueName senden) wird angezeigt.

Im folgenden Beispiel werden die Parameter Message Group ID (Nachrichtengruppen-ID) undMessage Deduplication ID (Nachrichtendeduplizierungs-ID) gezeigt, die für FIFO-Warteschlangengelten (inhaltsbasierte Deduplizierung (p. 89) ist deaktiviert).

9

Amazon Simple Queue Service EntwicklerhandbuchSchritt 2: Senden einer Nachricht

3. Um eine Nachricht an eine FIFO-Warteschlange zu senden, geben SieMessage Body (Nachrichtentext), Message Group ID (Nachrichtengruppen-ID)MyMessageGroupId1234567890 und Message Deduplication ID (Nachrichtendeduplizierungs-ID) MyMessageDeduplicationId1234567890 ein. Wählen Sie dann Send Message (Nachrichtsenden) aus. Weitere Informationen finden Sie unter FIFO-Bereitstellungslogik (p. 88).

Note

Die Nachrichtengruppen-ID ist immer erforderlich. Bei aktivierter Content-basierterDeduplizierung ist die Nachrichtendeduplizierungs-ID jedoch optional.

Die Nachricht wird gesendet und das Dialogfeld Send a Message to QueueName (Nachricht anQueueName senden) wird mit den Attributen der gesendeten Nachricht angezeigt.

10

Amazon Simple Queue Service EntwicklerhandbuchSchritt 3: Empfangen und Löschen Ihrer Nachricht

Im folgenden Beispiel wird das Attribut Sequence Number (Sequenznummer) gezeigt, das für FIFO-Warteschlange gilt.

4. Klicken Sie auf Close.

Schritt 3: Empfangen und Löschen Ihrer NachrichtNachdem Sie eine Nachricht an eine Warteschlange gesendet haben, kann sie aus der Warteschlangeabgerufen werden. Wenn Sie eine Nachricht aus einer Warteschlange anfordern, können Sie nichtfestlegen, welche Nachricht abgerufen werden soll. Stattdessen können Sie die maximale Anzahl vonNachrichten angeben (bis zu 10), die Sie erhalten möchten.

In diesem Tutorial erfahren Sie, wie Sie eine Nachricht empfangen und löschen.

1. Wählen Sie die Warteschlange, die Sie erstellt haben, aus der Warteschlangenliste aus.2. Wählen Sie im Menü Queue Actions (Warteschlangenaktionen) die Option View/Delete Messages

(Nachrichten anzeigen oder löschen) aus.

11


Das Dialogfeld View/Delete Messages in QueueName (Nachrichten in QueueName anzeigen oderlöschen) wird angezeigt.

Note

Wenn Sie diese Aktion zum ersten Mal ausführen, wird ein Informationsbildschirm angezeigt.Um den Bildschirm auszublenden, wählen Sie Don't show this again (Nicht wieder anzeigen)aus.

3. Klicken Sie auf Start Polling for Messages (Nachrichtenabruf starten).

Amazon SQS beginnt damit, die Nachrichten in der Warteschlange abzurufen. Im Dialogfeld wirdeine Nachricht aus der Warteschlange angezeigt. Ein Fortschrittsbalken unten im Dialogfeld zeigt denStatus der Zeitbeschränkung für die Sichtbarkeit der Nachricht an.

Im folgenden Beispiel werden die Spalten Message Group ID (Nachrichtengruppen-ID), MessageDeduplication ID (Nachrichtendeduplizierungs-ID) und Sequence Number (Sequenznummer) gezeigt,die den FIFO-Warteschlangen zugeordnet sind.

Note

Wenn der Fortschrittsbalken ausgefüllt ist, läuft die Zeitbeschränkung für dieSichtbarkeit (p. 106) ab und die Nachricht wird für Konsumenten sichtbar.

12


4. Bevor die Zeitbeschränkung für die Sichtbarkeit abläuft, wählen Sie die Nachricht aus, die Sie löschenmöchten, und klicken Sie dann auf Delete 1 Message (1 Nachricht löschen).

5. Überprüfen Sie, ob die Nachricht, die Sie löschen möchten, im Dialogfeld Delete Messages(Nachrichten löschen) ausgewählt ist, und klicken Sie auf Yes, Delete Checked Messages (Ja,ausgewählte Nachrichten löschen).

Die gewählte Nachricht wird gelöscht.6. Klicken Sie auf Close (Schließen).

13

Amazon Simple Queue Service EntwicklerhandbuchSchritt 4: Löschen Ihrer Warteschlange

Schritt 4: Löschen Ihrer WarteschlangeWenn Sie keine Amazon SQS-Warteschlange verwenden (und dies auch nicht in naher Zukunft planen),ist es eine bewährte Vorgehensweise, diese aus Amazon SQS zu löschen. In diesem Tutorial erfahren Sie,wie Sie eine Warteschlange löschen.

1. Wählen Sie die Warteschlange, die Sie erstellt haben, aus der Warteschlangenliste aus.

2. Wählen Sie im Menü Queue Actions (Warteschlangenaktionen) die Option Delete Queue(Warteschlange löschen) aus.

Das Dialogfeld Delete Queues (Warteschlangen löschen) wird angezeigt.

3. Wählen Sie Yes, Delete Queue (Ja, Warteschlange löschen) aus.

Die Warteschlange wird gelöscht.

14

Amazon Simple Queue Service EntwicklerhandbuchNächste Schritte

Nächste SchritteNachdem Sie eine Warteschlange erstellt und erfahren haben, wie Sie Nachrichten senden, empfangenund löschen, führen Sie z. B. die folgenden Schritte aus:

• Aktivieren Sie server-side encryption (SSE) für eine neue Warteschlange (p. 20) oder konfigurierenSie SSE für eine vorhandene Warteschlange. (p. 62)

• Fügen Sie einer Warteschlange Berechtigungen hinzu. (p. 25)• Tags für eine Warteschlange hinzufügen, aktualisieren oder entfernen. (p. 28)• Konfigurieren Sie eine Langabfrage für eine Warteschlange. (p. 66)• Senden Sie eine Nachricht mit Attributen. (p. 34)• Senden einer Nachricht mit einem Timer. (p. 40)• Senden Sie eine Nachricht von einer VPC. (p. 43)• Konfigurieren Sie eine Warteschlange für unzustellbare Nachrichten. (p. 69)• Konfigurieren Sie eine Zeitbeschränkung für die Sichtbarkeit für eine Warteschlange. (p. 73)• Konfigurieren einer Verzögerungswarteschlange. (p. 77)• Abonnieren Sie eine Warteschlange für ein Amazon SNS-Thema. (p. 53)• Konfigurieren Sie eingehende Nachrichten in einer Warteschlange so, dass sie eine Lambda-Funktion

auslösen. (p. 56)• Bereinigen Sie eine Warteschlange. (p. 58)• Weitere Informationen zu Amazon SQS-Workflows und Prozessen: Lesen Sie die Abschnitte

Funktionsweise von Warteschlangen (p. 80), Bewährte Methoden (p. 141) undKontingente (p. 148). Sie können sich auch die Amazon SQS-Artikel und Tutorials ansehen. WennSie Fragen haben, durchsuchen Sie die Amazon SQS-FAQs oder nehmen Sie an den Amazon SQS-Entwicklerforen teil.

• Erfahren Sie, wie Sie mit Amazon SQS programmgesteuert interagieren: Lesen Sie den AbschnittArbeiten mit APIs (p. 212) und sehen Sie sich den Abschnitt Beispiel-Code und Bibliotheken sowie dieEntwicklerzentren an:• Java• JavaScript• PHP• Python• Ruby• Windows und .NET

• Erfahren Sie mehr über Kosten- und Ressourcenkontrolle im Abschnitt Amazon SQS-Automatisierungund -Fehlerbehebung (p. 152).

• Erfahren Sie mehr über den Schutz Ihrer Daten und Zugriffsberechtigungen im AbschnittSicherheit (p. 154).

15

https://aws.amazon.com/articles/Amazon-SQS?browse=1

https://aws.amazon.com/sqs/faqs/



https://aws.amazon.com/code/Amazon-SQS?browse=1

https://aws.amazon.com/java/

https://aws.amazon.com/javascript/

https://aws.amazon.com/php/

https://aws.amazon.com/python/

https://aws.amazon.com/ruby/

https://aws.amazon.com/net/

Amazon Simple Queue Service EntwicklerhandbuchErstellen von Warteschlangen

Amazon SQS-TutorialsIn diesem Abschnitt wird dargestellt, wie Sie mit Amazon SQS arbeiten, wenn Sie die AWS ManagementConsole oder Java verwenden. Wenn Sie den Beispielcode verwenden möchten, müssen Sie das JavaStandard Edition Development Kit installieren und einige Konfigurationsänderungen am Beispielcodevornehmen.

Sie können Code in anderen Programmiersprachen schreiben. Weitere Informationen finden Sie in derDokumentation der AWS-SDKs.

Note

Sie können Amazon SQS erkunden, ohne Code zu schreiben. Verwenden Sie dazu Toolswie AWS Command Line Interface (AWS CLI) oder Windows PowerShell. Im Amazon SQS-Abschnitt im AWS CLI Command Reference finden Sie AWS CLI-Beispiele. Im Amazon SimpleQueue Service-Abschnitt im AWS-Tools für PowerShell Cmdlet Reference finden Sie WindowsPowerShell-Beispiele.

Themen• Tutorial: Erstellen von Amazon SQS-Warteschlangen (p. 16)• Tutorial: Auflisten aller Amazon SQS-Warteschlangen in einer Region (p. 24)• Tutorial: Hinzufügen von Berechtigungen zu einer Amazon SQS-Warteschlange (p. 25)• Tutorial: Hinzufügen, Aktualisieren und Entfernen von Kostenzuordnungs-Tags für eine Amazon SQS-

Warteschlange (p. 28)• Tutorials: Senden von Nachrichten an Amazon SQS-Warteschlangen (p. 30)• Tutorial: Empfangen und Löschen einer Nachricht in einer Amazon SQS-Warteschlange (p. 47)• Tutorial: Abonnieren einer Amazon SQS-Warteschlange für ein Amazon SNS-Thema (p. 53)• Tutorial: Konfigurieren von eingehenden Nachrichten in einer Amazon SQS-Warteschlange zum

Auslösen einer AWS Lambda-Funktion (p. 56)• Tutorial: Löschen von Nachrichten und Bereinigen einer Amazon SQS-Warteschlange (p. 58)• Tutorial: Löschen einer Amazon SQS-Warteschlange (p. 60)• Tutorials: Konfigurieren von Amazon SQS-Warteschlangen (p. 62)

Tutorial: Erstellen von Amazon SQS-Warteschlangen

Die folgenden Tutorials zeigen, wie Sie Amazon SQS-Warteschlangen auf verschiedene Weisen erstellen.

Themen• Tutorial: Erstellen einer Amazon SQS-Warteschlange (p. 16)• Tutorial: Erstellen einer Amazon SQS-Warteschlange mit Serverseitige Verschlüsselung

(SSE) (p. 20)

Tutorial: Erstellen einer Amazon SQS-WarteschlangeDie erste und häufigste Amazon SQS-Aufgabe ist das Erstellen von Warteschlangen. In diesem Tutorialerfahren Sie, wie Sie eine Warteschlange erstellen und konfigurieren.

Themen

16



https://aws.amazon.com//tools/#sdk




Amazon Simple Queue Service EntwicklerhandbuchErstellen einer Warteschlange

• AWS Management Console (p. 17)• AWS SDK for Java (p. 18)• AWS CloudFormation (p. 19)

AWS Management Console1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Wählen Sie Create New Queue (Neue Warteschlange erstellen).3. Vergewissern Sie sich auf der Seite Create New Queue (Neue Warteschlange erstellen), dass Sie sich


Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.4. Standard ist standardmäßig ausgewählt. Wählen Sie FIFO.5. Erstellen Sie Ihre Warteschlange.

• Wählen Sie Quick-Create Queue (Warteschlange schnell erstellen), um eine Warteschlange mit denStandardparametern zu erstellen.

• Wählen Sie zum Konfigurieren der Warteschlangenparameter Configure Queue (Warteschlangekonfigurieren) aus. Wählen Sie Create Queue (Warteschlange erstellen) aus, nachdem Sie dieParameter konfiguriert haben. Weitere Informationen zum Erstellen einer Warteschlange mit SSEfinden Sie unter Erstellen einer Amazon SQS-Warteschlange mit SSE (p. 20).

Im folgenden Beispiel wird der Parameter Content-Based Deduplication (InhaltsbasierteDeduplizierung) angezeigt, der nur für FIFO-Warteschlangen gilt.

Die neue Warteschlange wurde erstellt und in der Warteschlangenliste ausgewählt.

Note


17





AWS SDK for JavaBevor Sie mit dem Beispielcode zu arbeiten beginnen, geben Sie Ihre AWS-Anmeldeinformationen an.Weitere Informationen finden Sie unter Einrichten der AWS-Anmeldeinformationen und -Region für dieEntwicklung im AWS SDK for Java Developer Guide.

Erstellen Sie einer Standard-Warteschlange

1. Kopieren Sie das Beispielprogramm (p. 84).

Der folgende Codeabschnitt erstellt die MyQueue-Warteschlange:

// Create a queueSystem.out.println("Creating a new SQS queue called MyQueue.\n");final CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyQueue");final String myQueueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();

2. Kompilieren und führen Sie das Beispiel aus.

Die -Warteschlange wurde erstellt.

Erstellen Sie einer FIFO-Warteschlange


Der folgende Codeabschnitt erstellt die MyFifoQueue.fifo-Warteschlange:

// Create a FIFO queueSystem.out.println("Creating a new Amazon SQS FIFO queue called " + "MyFifoQueue.fifo.\n");final Map<String, String> attributes = new HashMap<String, String>();

// A FIFO queue must have the FifoQueue attribute set to Trueattributes.put("FifoQueue", "true");

// If the user doesn't provide a MessageDeduplicationId, generate a MessageDeduplicationId based on the content.attributes.put("ContentBasedDeduplication", "true");

18

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html



// The FIFO queue name must end with the .fifo suffixfinal CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyFifoQueue.fifo") .withAttributes(attributes);final String myQueueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();


Die -Warteschlange wurde erstellt.

AWS CloudFormationSie können die AWS CloudFormation-Konsole und eine JSON- oder YAML-Vorlage verwenden, umeine Amazon SQS-Warteschlange zu erstellen. Weitere Informationen finden Sie unter Arbeiten mitAWS CloudFormation-Vorlagen und unter AWS::SQS::Queue-Ressource im AWS CloudFormation-Benutzerhandbuch.

1. Kopieren Sie den JSON-Code in eine Datei mit dem Namen MyQueue.json. ZumErstellen einer Standard-Warteschlange lassen Sie die Eigenschaften FifoQueue undContentBasedDeduplication weg. Weitere Informationen zur inhaltsbasierten Deduplizierungfinden Sie unter Garantiert einmalige Verarbeitung (p. 89).

Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.

{ "AWSTemplateFormatVersion": "2010-09-09", "Resources": { "MyQueue": { "Properties": { "QueueName": "MyQueue.fifo", "FifoQueue": true, "ContentBasedDeduplication": true }, "Type": "AWS::SQS::Queue" } }, "Outputs": { "QueueName": { "Description": "The name of the queue", "Value": { "Fn::GetAtt": [ "MyQueue", "QueueName" ] } }, "QueueURL": { "Description": "The URL of the queue", "Value": { "Ref": "MyQueue" } }, "QueueARN": { "Description": "The ARN of the queue", "Value": { "Fn::GetAtt": [ "MyQueue", "Arn" ] }

19

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sqs-queues.html

Amazon Simple Queue Service EntwicklerhandbuchErstellen einer Warteschlange mit SSE

} }}

2. Melden Sie sich bei der AWS CloudFormation-Konsole an und wählen Sie dann Create Stack (Stackerstellen) aus.

3. Klicken Sie auf der Seite Select Template (Vorlage auswählen) auf die Option Upload a templateto Amazon S3 (Vorlage in &S3; hochladen). Wählen Sie dann Ihre MyQueue.json-Datei und Next(Weiter) aus.

4. Geben Sie auf der Seite Specify Details MyQueue unter Stack Name ein und wählen Sie Next aus.5. Wählen Sie auf der Seite Options Weiter.6. Klicken Sie auf der Seite Review auf Create.

AWS CloudFormation beginnt mit der Erstellung des MyQueue-Stacks und zeigt den StatusCREATE_IN_PROGRESS an. Wenn der Prozess abgeschlossen ist, zeigt AWS CloudFormation denStatus CREATE_COMPLETE an.

7. (Optional) Um den Namen, die URL und den ARN der Warteschlange anzuzeigen, wählen Sie denNamen des Stacks aus und erweitern Sie auf der nächsten Seite den Abschnitt Outputs.

Tutorial: Erstellen einer Amazon SQS-Warteschlangemit Serverseitige Verschlüsselung (SSE)Sie können SSE für eine Warteschlange aktivieren, um ihre Daten zu schützen. Weitere Informationen zurVerwendung von SSE finden Sie unter Verschlüsselung im Ruhezustand (p. 154).

20

https://console.aws.amazon.com/cloudformation


Important

Alle Anforderungen an Warteschlangen mit aktivierter SSE müssen HTTPS und Signature Version4 verwenden.

In diesem Tutorial erfahren Sie, wie Sie eine Amazon SQS-Warteschlange bei aktivierter SSE erstellen.Das Beispiel verwendet zwar eine FIFO-Warteschlange, arbeitet SSE sowohl mit Standard-, als auch mitFIFO-Warteschlangen.

Themen• AWS Management Console (p. 21)• AWS SDK for Java (p. 22)



Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.4. Standard ist standardmäßig ausgewählt. Wählen Sie FIFO.5. Klicken Sie auf Configure Queue und wählen Sie dann Use SSE aus.6. Geben Sie die ID des Customer Master Key (CMK, Kundenhauptschlüssel). Weitere Informationen

finden Sie unter Wichtige Begriffe (p. 156). an

Für jeden CMK-Typ werden Description, Account und Key ARN des CMK angezeigt.

Important

Wenn Sie nicht der Besitzer des CMK sind oder wenn Sie sich mit einem Konto anmelden,das über keine kms:ListAliases- und kms:DescribeKey-Berechtigungen verfügt,können Sie auf der Amazon SQS-Konsole keine Informationen über den CMK aufrufen.Bitten Sie den Inhaber des CMK, Ihnen diese Berechtigungen zu erteilen. WeitereInformationen finden Sie unter der AWS KMS-API-Berechtigungen: Referenztabelle fürAktionen und Ressourcen im AWS Key Management Service Developer Guide.

• Der von AWS verwaltete CMK für Amazon SQS wird standardmäßig ausgewählt.

Note

Beachten Sie Folgendes:• Wenn Sie keinen benutzerdefinierten CMK festlegen, verwendet Amazon SQS den mit

AWS verwalteten CMK für Amazon SQS. Informationen zum Erstellen benutzerdefinierterCMKs finden Sie unter Erstellen von Schlüsseln im AWS Key Management ServiceDeveloper Guide.

21

https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html



https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html


https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html


• Wenn Sie die AWS Management Console zum ersten Mal verwenden, um den AWSverwalteten CMK für Amazon SQS für eine Warteschlange festzulegen, erstellt AWSKMS den AWS-verwalteten CMK für Amazon SQS.

• Alternativ erstellt AWS KMS, wenn Sie zum ersten Mal die SendMessage- oderSendMessageBatch-Aktion für eine Warteschlange mit aktiviertem SSE verwenden, dasvon AWS verwaltete CMK für Amazon SQS.

• Um einen benutzerdefinierten CMK aus Ihrem AWS-Konto zu verwenden, wählen Sie diesen aus derListe aus.

Note

Informationen zum Erstellen benutzerdefinierter CMKs finden Sie unter Erstellen vonSchlüsseln im AWS Key Management Service Developer Guide.

• Um einen benutzerdefinierten CMK-ARN in Ihrem AWS-Konto oder in einem anderen AWS-Konto zuverwenden, wählen Sie Enter an existing CMK ARN (Existierenden CMK-ARN eingeben) in der Listeaus und geben Sie den CMK ein bzw. kopieren Sie ihn.

7. (Optional) Geben Sie für Data key reuse period (Wiederverwendungszeitraum des Datenschlüssels)einen Wert zwischen 1 Minute und 24 Stunden an. Der Standardwert ist 5 Minuten. WeitereInformationen finden Sie unter Grundlegendes zum Wiederverwendungszeitraum für denDatenschlüssel (p. 157).

8. Wählen Sie Create Queue aus.

Ihre neue Warteschlange wird mit SSE erstellt. Der Verschlüsselungsstatus, der Alias des CMK,Description, Account, Key ARN und Data Key Reuse Period werden auf der Registerkarte Encryptionangezeigt.


Bevor Sie SSE verwenden können, müssen Sie AWS KMS-Schlüsselrichtlinien konfigurieren, umeine Verschlüsselung von Warteschlangen und eine Verschlüsselung sowie Entschlüsselung von

22






Nachrichten zu ermöglichen. Weitere Informationen finden Sie unter Konfigurieren von AWS KMS-Berechtigungen (p. 159)

1. die ID des Customer Master Key (CMK, Kundenhauptschlüssel). Weitere Informationen finden Sieunter Wichtige Begriffe (p. 156). ermitteln

Note

Beachten Sie Folgendes:

• Wenn Sie keinen benutzerdefinierten CMK festlegen, verwendet Amazon SQS den mitAWS verwalteten CMK für Amazon SQS. Informationen zum Erstellen benutzerdefinierterCMKs finden Sie unter Erstellen von Schlüsseln im AWS Key Management ServiceDeveloper Guide.

• Wenn Sie die AWS Management Console zum ersten Mal verwenden, um den AWSverwalteten CMK für Amazon SQS für eine Warteschlange festzulegen, erstellt AWS KMSden AWS-verwalteten CMK für Amazon SQS.


2. Geben Sie zum Aktivieren von server-side encryption die CMK-ID ein, indem Sie dasKmsMasterKeyId-Attribut der Aktion CreateQueue oder SetQueueAttributes festlegen.

Das folgende Codebeispiel erstellt eine neue Warteschlange mit SSE mithilfe des von AWSverwalteten CMK für Amazon SQS:

final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();final Map<String, String> attributes = new HashMap<String, String>();final CreateQueueRequest createRequest = new CreateQueueRequest("MyQueue").withAttributes(attributes); // Enable server-side encryption by specifying the alias ARN of the// AWS managed CMK for Amazon SQS.final String kmsMasterKeyAlias = "arn:aws:kms:us-east-2:123456789012:alias/aws/sqs";attributes.put("KmsMasterKeyId", kmsMasterKeyAlias); // (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse attributes.put("KmsDataKeyReusePeriodSeconds", "60");

final CreateQueueResult createResult = client.createQueue(createRequest);

Das folgende Codebeispiel erstellt eine neue Warteschlange mit SSE mithilfe eines benutzerdefiniertenCMK:

final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();final Map<String, String> attributes = new HashMap<String, String>();final CreateQueueRequest createRequest = new CreateQueueRequest("MyQueue").withAttributes(attributes); // Enable server-side encryption by specifying the alias ARN of the custom CMK.final String kmsMasterKeyAlias = "arn:aws:kms:us-east-2:123456789012:alias/MyAlias";attributes.put("KmsMasterKeyId", kmsMasterKeyAlias); // (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse // a data key to encrypt or decrypt messages before calling AWS KMS again.attributes.put("KmsDataKeyReusePeriodSeconds", "864000"); final CreateQueueResult createResult = client.createQueue(createRequest);

23


https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html

Amazon Simple Queue Service EntwicklerhandbuchAuflisten aller Warteschlangen

3. (Optional) Geben Sie die Zeit in Sekunden an, wie lange Amazon SQS einen Datenschlüsselwiederverwenden kann (p. 156), um Nachrichten vor dem erneuten Aufrufen von AWS KMS zuver- oder entschlüsseln. Legen Sie das KmsDataKeyReusePeriodSeconds-Attribut der AktionCreateQueue oder SetQueueAttributes fest. Die Werte können zwischen 60 Sekunden(1 Minute) und 86 400 Sekunden (24 Stunden) liegen. Wenn Sie keinen Wert angeben, wird derStandardwert von 300 Sekunden (5 Minuten) verwendet.

Im ersten Codebeispiel wird der Wiederverwendungszeitraum für den Datenschlüssel auf 60 Sekunden(1 Minute) festgelegt. Im zweiten Codebeispiel beträgt der Zeitraum 86 400 Sekunden (24 Stunden).Im folgenden Codebeispiel wird der Wiederverwendungszeitraum für den Datenschlüssel auf60 Sekunden (1 Minute) festgelegt:

// (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse // a data key to encrypt or decrypt messages before calling AWS KMS again.attributes.put("KmsDataKeyReusePeriodSeconds", "60");

Informationen darüber, wie Sie Attribute einer Warteschlange abrufen, finden Sie in den Beispielen imAmazon Simple Queue Service API Reference.

Um die CMK-ID oder den Weiterverwendungszeitraum des Datenschlüssels für einebestimmte Warteschlange abzurufen, verwenden Sie die Attribute KmsMasterKeyId undKmsDataKeyReusePeriodSeconds der Aktion GetQueueAttributes.

Informationen darüber, wie Sie eine Warteschlange zu einem anderen CMK mit demselben Aliasverschieben, finden Sie unter Aktualisieren eines Alias im AWS Key Management Service DeveloperGuide.

Tutorial: Auflisten aller Amazon SQS-Warteschlangen in einer Region

Wenn Sie eine Warteschlange erstellen, kann es kurze Zeit dauern, bis diese über Amazon SQS verteiltwird. In diesem Tutorial lernen Sie, wie Sie das Vorhandensein Ihrer Warteschlange bestätigen, indem Siealle Warteschlangen in der aktuellen Region auflisten.


AWS Management Console1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Die Warteschlangen in der aktuellen Region werden aufgelistet.


24



https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html#API_GetQueueAttributes_Examples

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html

https://docs.aws.amazon.com/kms/latest/developerguide/programming-aliases.html#update-alias


Amazon Simple Queue Service EntwicklerhandbuchAWS SDK for Java



Note

Diese Aktion ist für Standard- und FIFO-Warteschlangen identisch.

1. Kopieren Sie das Beispielprogramm für die Standard-Warteschlange (p. 84) oder dasBeispielprogramm für die FIFO-Warteschlange (p. 91).

Der folgende Codeabschnitt listet alle Warteschlangen in der aktuellen Region auf:

// List queuesSystem.out.println("Listing all queues in your account.\n");for (final String queueUrl : sqs.listQueues().getQueueUrls()) { System.out.println(" QueueUrl: " + queueUrl);}System.out.println();


Alle Warteschlangen in der aktuell erstellten Region, die die API-Version 2012-11-05 verwenden, sindaufgelistet. Die Antwort enthält die folgenden Elemente:

• Eindeutige Warteschlangen-URL• Anforderungs-ID, die Amazon SQS Ihrer Anforderung zugewiesen hat

Tutorial: Hinzufügen von Berechtigungen zu einerAmazon SQS-Warteschlange

Sie können festlegen, welchen Benutzern Sie bestimmte Interaktionen mit Ihrer Warteschlange erlauben(oder explizit verweigern), indem Sie einer Warteschlange Berechtigungen hinzufügen. Das folgendeBeispiel veranschaulicht, wie die Berechtigung für alle Benutzer zum Abrufen der URL einer Warteschlangehinzugefügt wird.

Note

Ein Amazon SQS-Richtlinie kann maximal 7 Aktionen aufweisen.

AWS Management Console1. Melden Sie sich bei der Amazon SQS-Konsole an.

25




Amazon Simple Queue Service EntwicklerhandbuchAWS Management Console

2. Wählen Sie eine Warteschlange aus der Warteschlangenliste aus.

3. Wählen Sie im Menü Queue Actions die Option Add a Permission aus.

Das Dialogfeld Add a Permission wird angezeigt.4. In diesem Beispiel erlauben Sie allen Benutzern, die URL der Warteschlange abzurufen:

26


Stellen Sie sicher, dass neben Effect die Option Allow ausgewählt ist.

Aktivieren Sie neben Principal das Kontrollkästchen Everybody.

Wählen Sie in der Dropdown-Liste Actions die Option GetQueueUrl aus.

Wählen Sie Add Permissions aus.

Die Berechtigung wird der Warteschlange hinzugefügt.

Ihre Warteschlangenrichtlinien Effect (Effekt), Principals (Prinzipale), Actions (Aktionen) und Conditions(Bedingungen) werden auf der Registerkarte Permissions (Berechtigungen) Ihrer Warteschlangeangezeigt.

27

Amazon Simple Queue Service EntwicklerhandbuchHinzufügen, Aktualisieren und Entfernen

von Tags für eine Warteschlange

Tutorial: Hinzufügen, Aktualisieren und Entfernenvon Kostenzuordnungs-Tags für eine Amazon SQS-Warteschlange

Sie können Ihren Amazon SQS-Warteschlangen Kostenzuordnungs-Tags hinzufügen, um sie zuorganisieren und zu identifizieren. Das folgende Beispiel zeigt das Hinzufügen, Aktualisieren und Entfernenvon Tags für eine Warteschlange. Weitere Informationen finden Sie unter Amazon SQS Kostenzuordnungs-Tags (p. 99).


AWS Management ConsoleIn den folgenden Schritte wird angenommen, dass Sie bereits eine Amazon SQS-Warteschlangeerstellt (p. 16) haben.

1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Wählen Sie eine Warteschlange aus der Warteschlangenliste aus.

3. Wählen Sie die Registerkarte Tags aus.

Die dieser Warteschlange hinzugefügten Tags werden aufgelistet.

4. Wählen Sie Add/Edit Tags aus.5. Ändern von Warteschlangen-Tags:

• Um ein Tag hinzuzufügen, wählen Sie Add New Tag, geben einen Key und einen Value ein, undwählen dann Apply Changes.

• Um ein Tag zu aktualisieren, ändern Sie seinen Key und seinen Value und wählen dann ApplyChanges.

• Zum Entfernen eines Tags wählen Sie neben einem Schlüssel-Wert-Paar und klicken dann aufApply Changes (Änderungen anwenden).

28



Ihre Änderungen der Warteschlangen-Tags werden angewendet.


Hinzufügen, Aktualisieren und Entfernen von Tags zu bzw. voneiner Warteschlange1. Kopieren Sie das Beispielprogramm für eine Standard-Warteschlange (p. 84) oder eine FIFO-

Warteschlange (p. 91).2. Zum Auflisten der Tags, die einer Warteschlange hinzugefügt wurden, fügen Sie den folgenden Code

hinzu, der die ListQueueTags-Aktion verwendet:

final ListQueueTagsRequest listQueueTagsRequest = new ListQueueTagsRequest(queueUrl);final ListQueueTagsResult listQueueTagsResult = SQSClientFactory.newSQSClient() .listQueueTags(listQueueTagsRequest);System.out.println(String.format("ListQueueTags: \tTags for queue %s are %s.\n", QUEUE_NAME, listQueueTagsResult.getTags()));

3. Um die Werte der Tags einer Warteschlange unter Verwendung des Tag-Schlüssels hinzuzufügenoder zu aktualisieren, fügen Sie den folgenden Code hinzu, der die TagQueue-Aktion verwendet:

final Map<String, String> addedTags = new HashMap<>();addedTags.put("Team", "Development");addedTags.put("Priority", "Beta");addedTags.put("Accounting ID", "456def");final TagQueueRequest tagQueueRequest = new TagQueueRequest(queueUrl, addedTags);

System.out.println(String.format("TagQueue: \t\tAdd tags %s to queue %s.\n", addedTags, QUEUE_NAME));SQSClientFactory.newSQSClient().tagQueue(tagQueueRequest);

4. Um ein Tag mit dem Tag-Schlüssel aus der Warteschlange zu entfernen, fügen Sie den folgendenCode hinzu, der die UntagQueue-Aktion verwendet:

final List<String> tagKeys = Arrays.asList("Accounting ID");final UntagQueueRequest untagQueueRequest = new UntagQueueRequest(queueUrl, tagKeys);System.out.println(String.format("UntagQueue: \tRemove tags %s from queue %s.\n", tagKeys, QUEUE_NAME));SQSClientFactory.newSQSClient().untagQueue(untagQueueRequest);

5. Kompilieren und Ausführen Ihres Programms.

Die vorhandenen Tags werden aufgelistet; drei wurden aktualisiert, ein Tag wurde von derWarteschlange entfernt.

29



Amazon Simple Queue Service EntwicklerhandbuchSenden von Nachrichten

Tutorials: Senden von Nachrichten an AmazonSQS-Warteschlangen

Die folgenden Tutorials zeigen, wie Sie auf verschiedene Weisen Nachrichten an Amazon SQS-Warteschlangen senden.

Themen• Tutorial: Senden einer Nachricht an eine Amazon SQS-Warteschlange (p. 30)• Tutorial: Senden einer Nachricht mit Attributen an eine Amazon SQS-Warteschlange (p. 34)• Tutorial: Senden einer Nachricht mit Timer an eine Amazon SQS-Warteschlange (p. 40)• Tutorial: Senden einer Nachricht an eine Amazon SQS-Warteschlange von Amazon Virtual Private

Cloud (p. 43)

Tutorial: Senden einer Nachricht an eine AmazonSQS-WarteschlangeNachdem Sie Ihre Warteschlange erstellt haben, können Sie eine Nachricht an die Warteschlange senden.Das folgende Beispiel zeigt, wie eine Nachricht an eine vorhandene Warteschlange gesendet wird.


AWS Management Console1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Wählen Sie eine Warteschlange aus der Warteschlangenliste aus.


30


Amazon Simple Queue Service EntwicklerhandbuchSenden einer Nachricht



31


4. Um eine Nachricht an eine FIFO-Warteschlange zu senden, geben SieMessage Body (Nachrichtentext), Message Group ID (Nachrichtengruppen-ID)MyMessageGroupId1234567890 und Message Deduplication ID (Nachrichtendeduplizierungs-ID) MyMessageDeduplicationId1234567890 ein. Wählen Sie dann Send Message (Nachrichtsenden) aus. Weitere Informationen finden Sie unter FIFO-Bereitstellungslogik (p. 88).

Note

Die Nachrichtengruppen-ID ist immer erforderlich. Bei aktivierter Content-basierterDeduplizierung ist die Nachrichtendeduplizierungs-ID jedoch optional.

Die Nachricht wird gesendet und das Dialogfeld Send a Message to QueueName (Nachricht anQueueName senden) wird mit den Attributen der gesendeten Nachricht angezeigt.

32


Im folgenden Beispiel wird das Attribut Sequence Number (Sequenznummer) gezeigt, das für FIFO-Warteschlange gilt.



So senden Sie eine Nachricht an eine Standard-Warteschlange


Mit dem folgenden Codeabschnitt wird die Nachricht This is my message text. an IhreWarteschlange gesendet:

// Send a messageSystem.out.println("Sending a message to MyQueue.\n");sqs.sendMessage(new SendMessageRequest(myQueueUrl, "This is my message text."));


Die Nachricht wird an die Warteschlange gesendet. Die Antwort enthält die folgenden Elemente:

• Nachrichten-ID (p. 94), die Amazon SQS der Nachricht zuweist• Ein MD5 Digest des Nachrichtentexts, in dem bestätigt wird, dass Amazon SQS die Nachricht

korrekt erhalten hat (weitere Informationen finden Sie unter RFC1321).• Anforderungs-ID, die Amazon SQS Ihrer Anforderung zugewiesen hat

So senden Sie eine Nachricht an eine FIFO-Warteschlange


Mit dem folgenden Codeabschnitt wird die Nachricht This is my message text. an IhreWarteschlange gesendet:

// Send a messageSystem.out.println("Sending a message to MyFifoQueue.fifo.\n");

33



http://faqs.org/rfcs/rfc1321.html

Amazon Simple Queue Service EntwicklerhandbuchSenden einer Nachricht mit Attributen

final SendMessageRequest sendMessageRequest = new SendMessageRequest(myQueueUrl, "This is my message text.");

// When you send messages to a FIFO queue, you must provide a non-empty MessageGroupId.sendMessageRequest.setMessageGroupId("messageGroup1");

// Uncomment the following to provide the MessageDeduplicationId//sendMessageRequest.setMessageDeduplicationId("1");final SendMessageResult sendMessageResult = sqs.sendMessage(sendMessageRequest);final String sequenceNumber = sendMessageResult.getSequenceNumber();final String messageId = sendMessageResult.getMessageId();System.out.println("SendMessage succeed with messageId " + messageId + ", sequence number " + sequenceNumber + "\n");


Die Nachricht wird an Ihre Warteschlange gesendet.

Tutorial: Senden einer Nachricht mit Attributen an eineAmazon SQS-WarteschlangeSie können Berücksichtigen Sie strukturierte Metadaten (z. B. Zeitstempel, Geodaten, Signaturen oderIDs) bei Nachrichten mit Nachrichtenattributen.. In diesem Tutorial erfahren Sie, wie Sie eine Nachricht mitAttributen an eine vorhandene Warteschlange senden. Weitere Informationen finden Sie unter AmazonSQS-Nachrichtenattribute (p. 95).

Eine detailliertere Erläuterung des Sendens von Nachrichten an Standard- und FIFO-Warteschlangenfinden Sie unter Senden einer Nachricht an eine Amazon SQS-Warteschlange (p. 30).




34





35


4. Um eine Nachricht an eine FIFO-Warteschlange zu senden, geben Sie denMessage Body (Nachrichtentext), die Message Group ID (Nachrichtengruppen-ID)MyMessageGroupId1234567890 und die Message Deduplication ID (Nachrichtendeduplizierungs-ID) MyMessageDeduplicationId1234567890 ein und wählen Sie dann Message Attributes(Nachrichtenattribute) aus.

36


5. Definieren Sie die Nachrichtenattributparameter. Weitere Informationen finden Sie unterNachrichtenattributkomponenten (p. 96) und Datentypen für das Nachrichtenattribut (p. 96).

a. Geben Sie für das Nachrichtenattribut Name MyMessageAttribute ein.b. Wählen Sie für den Nachrichtenattributdaten-Typ eine Anzahl aus und geben Sie byte für den

optionalen benutzerdefinierten Typ ein.c. Geben Sie für das Nachrichtenattribut Wert 24 ein.

Wählen Sie Add Attribute.

Das Attribut wird der Nachricht als Number.byte hinzugefügt.

37


Sie können den Wert ändern, bevor die Nachricht gesendet wird. Um das Attribut zu löschen, wählenSie .

6. Wenn Sie mit dem Hinzufügen von Attributen zur Nachricht fertig sind, wählen Sie Send Message.

Ihre Nachricht wird gesendet und das Dialogfeld Send a Message to QueueName wird mit denAttributen der gesendeten Nachricht angezeigt.

Das folgende Beispiel zeigt die MD5 der Nachrichtenattribute, die für Ihr benutzerdefiniertesNachrichtenattribut spezifisch ist, und das für FIFO-Warteschlangen spezifische Sequenznummern-Attribut.



So senden Sie eine Nachricht mit Attributen an eine Warteschlange


2. Zum Definieren eines Attributs für eine Nachricht fügen Sie den folgenden Code hinzu, derden MessageAttributeValue-Datentyp verwendet. Weitere Informationen finden Sie unterNachrichtenattributkomponenten (p. 96) und Datentypen für das Nachrichtenattribut (p. 96).

Note

AWS SDK for Java berechnet automatisch die Prüfsummen für den Nachrichtentext unddas Nachrichtenattribut vergleicht sie mit den Daten, die Amazon SQS zurückgibt. WeitereInformationen finden Sie im AWS SDK for Java Developer Guide und Berechnung des MD5-Nachrichtendigests für Nachrichtenattribute (p. 97) für andere Programmiersprachen.

String

Dieses Beispiel definiert ein String-Attribut mit der Bezeichnung Name und dem Wert Jane.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("Name", new MessageAttributeValue()

38



https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_MessageAttributeValue.html

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/


.withDataType("String") .withStringValue("Jane"));

Number

Dieses Beispiel definiert ein Number-Attribut mit der Bezeichnung AccurateWeight und demWert 230.000000000000000001.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("AccurateWeight", new MessageAttributeValue() .withDataType("Number") .withStringValue("230.000000000000000001"));

Binary

Dieses Beispiel definiert ein Binary-Attribut mit dem Namen ByteArray und dem Wert einesnicht initialisierten 10-Byte-Arrays.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("ByteArray", new MessageAttributeValue() .withDataType("Binary") .withBinaryValue(ByteBuffer.wrap(new byte[10])));

String (Custom)

Dieses Beispiel definiert das benutzerdefinierte Attribut String.EmployeeId mit derBezeichnung EmployeeId und dem Wert ABC123456.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("EmployeeId", new MessageAttributeValue() .withDataType("String.EmployeeId") .withStringValue("ABC123456"));

Number (Custom)

Dieses Beispiel definiert das benutzerdefinierte Attribut Number.AccountId mit der BezeichnungAccountId und dem Wert 0023456.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("AccountId", new MessageAttributeValue() .withDataType("Number.AccountId") .withStringValue("000123456"));

Note

Da der Basisdatentyp Number lautet, gibt die ReceiveMessage-Aktion 123456 zurück.Binary (Custom)

Dieses Beispiel definiert das benutzerdefinierte Attribut Binary.JPEG mit dem NamenApplicationIcon und dem Wert eines nicht initialisierten 10-Byte-Arrays.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("ApplicationIcon", new MessageAttributeValue() .withDataType("Binary.JPEG") .withBinaryValue(ByteBuffer.wrap(new byte[10])));

3. Tauschen Sie den Codeabschnitt aus, der die Nachricht sendet:39

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html

Amazon Simple Queue Service EntwicklerhandbuchSenden einer Nachricht mit einem Timer

// Send a message with an attributefinal SendMessageRequest sendMessageRequest = new SendMessageRequest();sendMessageRequest.withMessageBody("This is my message text.");sendMessageRequest.withQueueUrl(myQueueUrl);sendMessageRequest.withMessageAttributes(messageAttributes);sqs.sendMessage(sendMessageRequest);

Important

Wenn Sie eine Nachricht an eine FIFO-Warteschlange senden, stellen Sie sicher, dass diesendMessage-Methode ausgeführt wird, nachdem Sie die Nachrichtengruppen-ID angeben.Wenn Sie die SendMessageBatch-Aktion anstelle von SendMessage verwenden, müssenSie Nachrichtenattribute für jede einzelne Nachricht im Stapel angeben.




korrekt erhalten hat (weitere Informationen finden Sie unter RFC1321).• Ein MD5-Digest der Nachrichtenattribute wird verwendet, um zu bestätigen, dass Amazon SQS die

Nachrichtenattribute ordnungsgemäß erhalten hat.• Anforderungs-ID, die Amazon SQS Ihrer Anforderung zugewiesen hat

Tutorial: Senden einer Nachricht mit Timer an eineAmazon SQS-WarteschlangeMit Nachrichten-Timern können Sie einen Zeitraum festlegen, innerhalb dessen eine der Warteschlangehinzugefügte Nachricht unsichtbar ist. Wenn Sie beispielsweise eine Nachricht mit einem 45-Sekunden-Timer senden, wird die Nachricht die ersten 45 Sekunden in der Warteschlange nicht für Konsumentenangezeigt. Die standardmäßige (minimale) Verzögerung für eine Nachricht beträgt 0 Sekunden. Diemaximale Größe ist 15 Minuten.In diesem Tutorial erfahren Sie, wie Sie eine Nachricht mit einem Timeran eine vorhandene Warteschlange senden. Weitere Informationen finden Sie unter Amazon SQS-Nachrichten-Timer (p. 113).

Note

FIFO-Warteschlangen unterstützen keine Timer für einzelne Nachrichten.

Eine detailliertere Erläuterung des Sendens von Nachrichten an Standard- und FIFO-Warteschlangenfinden Sie unter Senden einer Nachricht an eine Amazon SQS-Warteschlange (p. 30).



40

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html




3. Wählen Sie im Menü Queue Actions die Option Send a Message aus.

Das Dialogfeld Send a Message to QueueName wird angezeigt.

41


4. Um eine Nachricht an eine Standard-Warteschlange zu senden, geben Sie den Nachrichtentext ein,wählen Delay delivery of this message by (Verzögerung der Nachrichtenauslieferung) und geben einenWert ein, z. B. 60 Sekunden.

5. Klicken Sie auf Send Message.

Ihre Nachricht wird gesendet und das Dialogfeld Send a Message to QueueName wird mit denAttributen der gesendeten Nachricht angezeigt.

42

Amazon Simple Queue Service EntwicklerhandbuchSenden einer Nachricht von einer VPC



So senden Sie eine Nachricht mit einem Timer an eine Warteschlange

1. Kopieren Sie das Beispielprogramm für Standard-Warteschlangen (p. 84).2. Ändern Sie die main-Methodensignatur wie folgt:

public static void main(String[] args) throws InterruptedException

3. Tauschen Sie den Codeabschnitt aus, der die Nachricht sendet:

// Send a message with a 5-second timer.System.out.println("Sending a message with a 5-second timer to MyQueue.\n");SendMessageRequest request = new SendMessageRequest(myQueueUrl, "This is my message text.");request.setDelaySeconds(5);sqs.sendMessage(request);

// Wait for 10 seconds.System.out.println("Waiting for 10 seconds.");Thread.sleep(10000L);




korrekt erhalten hat (weitere Informationen finden Sie unter RFC1321).• Anforderungs-ID, die Amazon SQS Ihrer Anforderung zugewiesen hat

Tutorial: Senden einer Nachricht an eine AmazonSQS-Warteschlange von Amazon Virtual Private CloudIn diesem Tutorial erfahren Sie, wie Sie Nachrichten über ein sicheres, privates Netzwerk zu einer AmazonSQS-Warteschlange senden. Dieses Netzwerk besteht aus einer VPC, die eine Amazon EC2-Instanceenthält. Die Instance stellt über einen Schnittstellen-VPC-Endpunkt eine Verbindung zu Amazon SQS her,sodass Sie sich sogar dann mit der Amazon EC2-Instance verbinden und Nachrichten an die AmazonSQS-Warteschlange senden können, wenn das Netzwerk vom öffentlichen Internet getrennt ist. WeitereInformationen finden Sie unter Amazon Virtual Private Cloud-Endpunkte für Amazon SQS (p. 162).

Important

• Sie können Amazon Virtual Private Cloud nur mit HTTPS-Amazon SQS-Endpunktenverwenden.

• Wenn Sie Amazon SQS zum Senden von Nachrichten aus Amazon VPC konfigurieren, müssenSie privates DNS aktivieren und Endpunkte im Format sqs.us-east-2.amazonaws.comangeben.

43





• Ein privates DNS unterstützt keine Legacy-Endpunkte wie queue.amazonaws.com oder us-east-2.queue.amazonaws.com.

Themen• Schritt 1: Erstellen eines Amazon EC2-Schlüsselpaares (p. 44)• Schritt 2: Erstellen von AWS-Ressourcen (p. 44)• Schritt 3: Bestätigen Sie, dass Ihre EC2-Instance nicht öffentlich zugänglich ist (p. 45)• Schritt 4: Erstellen eines Amazon VPC-Endpunkts für Amazon SQS (p. 46)• Schritt 5: Senden einer Nachricht an Ihre Amazon SQS-Warteschlange (p. 47)

Schritt 1: Erstellen eines Amazon EC2-SchlüsselpaaresEin Schlüsselpaar ermöglicht Ihnen die Verbindung mit einer Amazon EC2-Instance. Es besteht aus einemöffentlichen Schlüssel, mit dem Ihre Anmeldeinformationen verschlüsselt werden, und einem privatenSchlüssel, mit dem sie entschlüsselt werden.

1. Melden Sie sich bei der Amazon EC2-Konsole an.2. Klicken Sie im Navigationsmenü unter Network & Security (Netzwerk und Sicherheit) auf Key Pairs

(Schlüsselpaare).3. Wählen Sie Create Key Pair aus.4. Geben Sie im Dialogfeld Create Key Pair (Schlüsselpaar erstellen) im Feld Key pair name

(Schlüsselpaarname) als Namen SQS-VPCE-Tutorial-Key-Pair ein und klicken Sie auf Create(Erstellen).

5. Ihr Browser lädt die private Schlüsseldatei SQS-VPCE-Tutorial-Key-Pair.pem automatischherunter.

Important

Speichern Sie diese Datei an einem sicheren Ort. EC2 generiert eine .pem-Datei für dasselbeSchlüsselpaar kein zweites Mal.

6. Um einem SSH-Client das Herstellen einer Verbindung mit Ihrer EC2-Instance zu ermöglichen,legen Sie die Berechtigungen für Ihre private Schlüsseldatei so fest, dass nur Ihrem BenutzerLeseberechtigungen für sie gewährt werden, zum Beispiel:

chmod 400 SQS-VPCE-Tutorial-KeyPair.pem

Schritt 2: Erstellen von AWS-RessourcenUm die erforderliche Infrastruktur einzurichten, müssen Sie eine AWS CloudFormation-Vorlage verwenden.Dabei handelt es sich um eine Vorlage zum Erstellen eines Stacks aus AWS-Ressourcen, wie z. B.Amazon EC2-Instances und Amazon SQS-Warteschlangen.

Der Stack für dieses Tutorial enthält die folgenden Ressourcen:

• Eine VPC und die zugehörigen Netzwerkressourcen, einschließlich eines Subnetzes, einerSicherheitsgruppe, eines Internet-Gateways und einer Routing-Tabelle.

• Eine im VPC-Subnetz gestartete Amazon EC2-Instance• Eine Amazon SQS-Warteschlange

1. Laden Sie die AWS CloudFormation-Vorlage mit dem Namen SQS-VPCE-Tutorial-CloudFormation.yaml vom GitHub herunter.

44

https://console.aws.amazon.com/ec2/

https://github.com/aws-samples/amazon-sqs-samples/blob/master/templates/SQS-VPCE-Tutorial-CloudFormation.yaml

https://github.com/aws-samples/amazon-sqs-samples/blob/master/templates/SQS-VPCE-Tutorial-CloudFormation.yaml


2. Melden Sie sich bei der AWS CloudFormation-Konsole an.3. Wählen Sie Create Stack aus.4. Wählen Sie auf der Seite Select Template (Vorlage auswählen) die Option Upload a template to

Amazon S3 (Eine Vorlage zu Amazon S3 hochladen). Wählen Sie dann die Datei SQS-VPCE-SQS-Tutorial-CloudFormation.yaml aus und klicken Sie auf Next (Weiter).

5. Führen Sie auf der Seite Specify DB Details (Festlegen von DB-Detail) die folgenden Schritte aus:

a. Geben Sie unter Stack name (Stack-Name) SQS-VPCE-Tutorial-Stack ein.b. Wählen Sie für KeyName die Option SQS-VPCE-Tutorial-KeyPair aus.c. Wählen Sie Next.

6. Wählen Sie auf der Seite Options Weiter.7. Wählen Sie auf der Seite Review (Prüfen) im Bereich Capabilities (Funktionen) die Option I

acknowledge that AWS CloudFormation might create IAM resources with custom names (Ich bestätige,dass AWS CloudFormation möglicherweise IAM-Ressourcen mit benutzerdefinierten Namen erstellt)und danach Create (Erstellen) aus.

AWS CloudFormation beginnt mit der Erstellung des Stacks und zeigt als Status CREATE_IN_PROGRESSan. Wenn der Prozess abgeschlossen ist, zeigt AWS CloudFormation den Status CREATE_COMPLETEan.

Schritt 3: Bestätigen Sie, dass Ihre EC2-Instance nicht öffentlichzugänglich istIhre AWS CloudFormation-Vorlage startet eine EC2-Instance mit dem Namen SQS-VPCE-Tutorial-EC2-Instance in Ihrer VPC. Diese EC2-Instance lässt keinen ausgehenden Datenverkehr zu und kannkeine Nachrichten an Amazon SQS senden. Um dies zu überprüfen, müssen Sie eine Verbindung mit derInstance herstellen. Versuchen Sie dann, eine Verbindung mit einem öffentlichen Endpunkt herzustellenund eine Nachricht an Amazon SQS zu senden.

1. Melden Sie sich bei der Amazon EC2-Konsole an.2. Wählen Sie im Navigationsmenü unter Instances die Option Instances.3. Wählen Sie SQS-VPCE-Tutorial-EC2Instance.4. Kopieren Sie den Hostnamen unter Public DNS (IPv4) (Öffentliches DNS (IPv4)), z. B.

ec2-203-0-113-0.us-west-2.compute.amazonaws.com.5. Stellen Sie über das Verzeichnis, in dem sich das Schlüsselpaar befindet, das Sie zuvor erstellt

haben (p. 44), mit dem folgenden Befehl eine Verbindung mit der Instance her, zum Beispiel:

ssh -i SQS-VPCE-Tutorial-KeyPair.pem [email protected]

6. Versuchen Sie, eine Verbindung mit einem öffentlichen Endpunkt herzustellen, zum Beispiel:

ping amazon.com

Der Verbindungsversuch schlägt erwartungsgemäß fehl.7. Melden Sie sich bei der Amazon SQS-Konsole an.8. Wählen Sie aus der Liste der Warteschlangen die Warteschlange aus, die von Ihrer AWS

CloudFormation-Vorlage erstellt wurde, z. B. VPCE-SQS-Tutorial-Stack-CFQueue-1ABCDEFGH2IJK.9. Kopieren Sie die URL in der Tabelle Details, zum Beispiel: https://sqs.us-

east-2.amazonaws.com/123456789012/.

45

https://console.aws.amazon.com/cloudformation/

https://console.aws.amazon.com/ec2/



10. Versuchen Sie, über Ihre EC2-Instance mit dem folgenden Befehl eine Nachricht an die Warteschlangezu veröffentlichen, zum Beispiel:

aws sqs send-message --region us-east-2 --endpoint-url https://sqs.us-east-2.amazonaws.com/ --queue-url https://sqs.us-east-2.amazonaws.com/123456789012/ --message-body "Hello from Amazon SQS."

Der Sendeversuch schlägt erwartungsgemäß fehl.

Important

Später, wenn Sie einen VPC-Endpunkt für Amazon SQS erstellen, ist Ihr Sendeversucherfolgreich.

Schritt 4: Erstellen eines Amazon VPC-Endpunkts für AmazonSQSZum Herstellen einer Verbindung der VPC mit Amazon SQS müssen Sie einen Schnittstellen-VPC-Endpunkt definieren. Nachdem Sie den Endpunkt hinzugefügt haben, können Sie die Amazon SQS-APIvon der EC2-Instance in Ihrer VPC verwenden. Dies ermöglicht Ihnen, ganz ohne das öffentliche InternetNachrichten an eine Warteschlange innerhalb des AWS-Netzwerks zu senden.

Note

Die EC2-Instance hat weiterhin keinen Zugriff auf andere AWS-Services und -Endpunkte imInternet.

1. Melden Sie sich bei der Amazon VPC-Konsole an.2. Wählen Sie im Navigationsmenü Endpoints (Endpunkte).3. Klicken Sie auf Create Endpoint.4. Wählen Sie auf der Seite Create Endpoint (Endpunkt erstellen) für Service Name (Servicename) den

Servicenamen für Amazon SQS aus.

Note

Die Servicenamen variieren abhängig von der derzeit ausgewählten AWS-Region. Beispiel: InUSA Ost (Ohio) lautet der Servicename com.amazonaws.us-east-2.sqs.

5. Wählen Sie für VPC die Option SQS-VPCE-Tutorial-VPC.6. Wählen Sie für Subnets (Subnetze) das Subnetz aus, dessen Subnet ID (Subnetz-ID) den Wert SQS-

VPCE-Tutorial-Subnet enthält.7. Wählen Sie für Security group (Sicherheitsgruppe) die Option Select security groups

(Sicherheitsgruppen auswählen). Wählen Sie dann die Sicherheitsgruppe aus, deren Group Name(Gruppenname) den Wert SQS VPCE Tutorial Security Group enthält.

8. Wählen Sie Create endpoint.

Der Schnittstellen-VPC-Endpunkt wird erstellt und seine ID wird angezeigt, z. B.vpce-0ab1cdef2ghi3j456k.


Die Amazon VPC-Konsole öffnet die Seite Endpoints (Endpunkte).

Amazon VPC beginnt mit der Erstellung des Endpunkts und zeigt als Status pending (Ausstehend) an.Wenn der Prozess abgeschlossen ist, zeigt Amazon VPC als Status available (Verfügbar) an.

46

https://console.aws.amazon.com/vpc/

Amazon Simple Queue Service EntwicklerhandbuchEmpfangen und Löschen einer Nachricht

Schritt 5: Senden einer Nachricht an Ihre Amazon SQS-WarteschlangeDa Ihre VPC nun einen Endpunkt für Amazon SQS erhält, können Sie sich mit Ihrer EC2-Instanceverbinden und Nachrichten zu Ihrer Warteschlange senden.

1. Verbinden Sie sich erneut mit Ihrer EC2-Instance, z. B.:

ssh -i SQS-VPCE-Tutorial-KeyPair.pem [email protected]

2. Versuchen Sie erneut, mit dem folgenden Befehl eine Nachricht in der Warteschlange zuveröffentlichen, zum Beispiel:

aws sqs send-message --region us-east-2 --endpoint-url https://sqs.us-east-2.amazonaws.com/ --queue-url https://sqs.us-east-2.amazonaws.com/123456789012/ --message-body "Hello from Amazon SQS."

Der Sendeversuch ist erfolgreich und der MD5 Digest des Nachrichtentexts und die Nachrichten-IDwerden angezeigt, zum Beispiel:

{ "MD5OfMessageBody": "a1bcd2ef3g45hi678j90klmn12p34qr5", "MessageId": "12345a67-8901-2345-bc67-d890123e45fg"}

Weitere Informationen zum Empfangen und Löschen der Nachricht aus der durch IhreAWS CloudFormation-Vorlage erstellten Warteschlange (z. B. VPCE-SQS-Tutorial-Stack-CFQueue-1ABCDEFGH2IJK) finden Sie unter Empfangen und Löschen einer Nachricht aus einer AmazonSQS-Warteschlange (p. 47).

Weitere Informationen zum Löschen Ihrer Ressourcen finden Sie unter:

• Löschen eines VPC-Endpunkts im Amazon VPC Benutzerhandbuch• Löschen einer Amazon SQS-Warteschlange (p. 60)• Beenden Ihrer Instance im Amazon EC2-Benutzerhandbuch für Linux-Instances• Löschen Ihrer VPC im Amazon VPC Benutzerhandbuch• Löschen eines Stacks auf der AWS CloudFormation-Konsole im AWS CloudFormation

Benutzerhandbuch• Löschen des Schlüsselpaars im Amazon EC2-Benutzerhandbuch für Linux-Instances

Tutorial: Empfangen und Löschen einer Nachricht ineiner Amazon SQS-Warteschlange

Nachdem Sie eine Nachricht an eine Warteschlange gesendet haben, kann sie aus der Warteschlangeabgerufen werden. Wenn Sie eine Nachricht aus einer Warteschlange anfordern, können Sie nichtfestlegen, welche Nachricht abgerufen werden soll. Stattdessen können Sie die maximale Anzahl vonNachrichten angeben (bis zu 10), die Sie erhalten möchten.

47

https://docs.aws.amazon.com/vpc/latest/userguide/delete-vpc-endpoint.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html

https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#VPC_Deleting

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-delete-stack.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#delete-key-pair


Note

Da Amazon SQS ein verteiltes System ist, kann eine Warteschlange mit sehr wenigen Nachrichteneine leere Antwort auf eine Empfangsanforderung anzeigen. In diesem Fall können Sie dieAnforderung erneut ausführen, um Ihre Nachricht zu erhalten. Je nach den Anforderungen IhrerAnwendung müssen Sie zum Erhalt von Nachrichten entweder Kurz- oder Langabfragen (p. 100)verwenden.

Amazon SQS löscht eine Nachricht nicht automatisch, nachdem diese empfangen wurde, für den Fall,dass die Nachricht nicht erfolgreich zugestellt wird (es kann z. B. ein Fehler beim Konsumenten auftretenoder die Verbindung abbrechen). Um eine Nachricht zu löschen, müssen Sie eine separate Anforderungsenden, die bestätigt, dass Sie die Nachricht nicht mehr benötigen, da Sie sie erfolgreich empfangen undverarbeitet haben.

In diesem Tutorial erfahren Sie, wie Sie eine Nachricht empfangen und löschen.



3. Wählen Sie im Menü Queue Actions (Warteschlangenaktionen) die Option View/Delete Messages(Nachrichten anzeigen oder löschen) aus.

48



Das Dialogfeld View/Delete Messages in QueueName (Nachrichten in QueueName anzeigen oderlöschen) wird angezeigt.

Note

Wenn Sie diese Aktion zum ersten Mal ausführen, wird ein Informationsbildschirm angezeigt.Um den Bildschirm auszublenden, wählen Sie Don't show this again (Nicht wieder anzeigen)aus.

4. Klicken Sie auf Start Polling for Messages (Nachrichtenabruf starten).

Amazon SQS beginnt damit, die Nachrichten in der Warteschlange abzurufen. Im Dialogfeld wirdeine Nachricht aus der Warteschlange angezeigt. Ein Fortschrittsbalken unten im Dialogfeld zeigt denStatus der Zeitbeschränkung für die Sichtbarkeit der Nachricht an.

Im folgenden Beispiel werden die Spalten Message Group ID (Nachrichtengruppen-ID), MessageDeduplication ID (Nachrichtendeduplizierungs-ID) und Sequence Number (Sequenznummer) gezeigt,die den FIFO-Warteschlangen zugeordnet sind.

49


Note

Wenn der Fortschrittsbalken ausgefüllt ist, läuft die Zeitbeschränkung für dieSichtbarkeit (p. 106) ab und die Nachricht wird für Konsumenten sichtbar.

5. Bevor die Zeitbeschränkung für die Sichtbarkeit abläuft, wählen Sie die Nachricht aus, die Sie löschenmöchten, und klicken Sie dann auf Delete 1 Message (1 Nachricht löschen).

50


6. Überprüfen Sie, ob die Nachricht, die Sie löschen möchten, im Dialogfeld Delete Messages(Nachrichten löschen) ausgewählt ist, und klicken Sie auf Yes, Delete Checked Messages (Ja,ausgewählte Nachrichten löschen).

Die gewählte Nachricht wird gelöscht.7. Klicken Sie auf Close (Schließen).

AWS SDK for JavaUm festzulegen, welche Nachricht gelöscht werden soll, stellen Sie die Empfangs-Mitteilung (p. 94)bereit, die Amazon SQS bei Erhalt der Nachricht zurückgegeben hat. Sie können nur eine Nachricht

51


pro Aktion löschen. Zum Löschen einer ganzen Warteschlange müssen Sie die DeleteQueue-Aktionverwenden. (Sie können eine ganze Warteschlange löschen, auch wenn sich darin Nachrichten befinden.)

Note

Wenn Sie die Empfangs-Mitteilung der Nachricht nicht haben, können Sie die ReceiveMessage-Aktion aufrufen, um die Nachricht noch einmal zu erhalten. Jedes Mal, wenn Sie die Nachrichterhalten, wird Ihnen eine andere Empfangs-Mitteilung geschickt. Verwenden Sie die neuesteEmpfangs-Mitteilung für die DeleteMessage-Aktion. Andernfalls wird Ihre Nachrichtmöglicherweise nicht aus der Warteschlange gelöscht.

Bevor Sie mit dem Beispielcode zu arbeiten beginnen, geben Sie Ihre AWS-Anmeldeinformationen an.Weitere Informationen finden Sie unter Einrichten der AWS-Anmeldeinformationen und -Region für dieEntwicklung im AWS SDK for Java Developer Guide.

So empfangen und löschen Sie eine Nachricht in einer Standard-Warteschlange1. Kopieren Sie das Beispielprogramm (p. 84).

Mit dem folgenden Codeabschnitt wird eine Nachricht von Ihrer Warteschlange empfangen:

// Receive messagesSystem.out.println("Receiving messages from MyQueue.\n");final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl);final List<Message> messages = sqs.receiveMessage(receiveMessageRequest).getMessages();for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle()); System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes().entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry.getKey()); System.out.println(" Value: " + entry.getValue()); }}System.out.println();

Der folgende Codeabschnitt löscht die Nachricht:

// Delete the messageSystem.out.println("Deleting a message.\n");final String messageReceiptHandle = messages.get(0).getReceiptHandle();sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle));


Die Warteschlange wurde abgefragt und gibt 0 oder mehr Nachrichten zurück. Im Beispiel werden diefolgenden Elemente gedruckt:

• Nachrichten-ID (p. 94), die Sie erhalten haben, als Sie die Nachricht an die Warteschlangegesendet haben

• Empfangs-Mitteilung (p. 94), die Sie später zum Löschen der Nachricht verwenden• MD5 Digest des Nachrichtentexts (weitere Informationen finden Sie unter RFC1321)• Nachrichtentext

52




Amazon Simple Queue Service EntwicklerhandbuchAbonnieren einer Warteschlange für ein Thema

• Anforderungs-ID, die Amazon SQS Ihrer Anforderung zugewiesen hat

Wenn in diesem speziellen Aufruf keine Nachrichten empfangen wurden, enthält die Antwort nur dieAnforderungs-ID.

Die Nachricht wird gelöscht. Die Antwort enthält die Anforderungs-ID, die Amazon SQS IhrerAnforderung zugewiesen hat.

So empfangen und löschen Sie eine Nachricht in einer FIFO-Warteschlange1. Kopieren Sie das Beispielprogramm (p. 91).

Mit dem folgenden Codeabschnitt wird eine Nachricht von Ihrer Warteschlange empfangen:

// Receive messagesSystem.out.println("Receiving messages from MyFifoQueue.fifo.\n");final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl);

// Uncomment the following to provide the ReceiveRequestDeduplicationId//receiveMessageRequest.setReceiveRequestAttemptId("1");final List<Message> messages = sqs.receiveMessage(receiveMessageRequest).getMessages();for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle()); System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes().entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry.getKey()); System.out.println(" Value: " + entry.getValue()); }}System.out.println();

Der folgende Codeabschnitt löscht die Nachricht:

// Delete the messageSystem.out.println("Deleting the message.\n");final String messageReceiptHandle = messages.get(0).getReceiptHandle();sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle));


Die Nachricht wird empfangen und gelöscht.

Tutorial: Abonnieren einer Amazon SQS-Warteschlange für ein Amazon SNS-Thema

Sie können eine oder mehrere Amazon SQS-Warteschlangen für ein Amazon SNS-Thema aus einer Listeder Themen für die ausgewählte Warteschlange abonnieren. Amazon SQS verwaltet das Abonnementund alle erforderlichen Berechtigungen. Wenn Sie eine Nachricht in einem Thema veröffentlichen, sendet

53


Amazon SNS die Nachricht an alle abonnierten Warteschlangen. Weitere Informationen über Amazon SNSfinden Sie unter Was ist Amazon Simple Notification Service? im Entwicklerhandbuch für Amazon SimpleNotification Service.

Important

• Amazon SNS ist zurzeit nicht mit FIFO-Warteschlangen kompatibel.• Weitere Informationen zur Verwendung von Amazon SNS mit verschlüsselten Amazon SQS-

Warteschlangen finden Sie unter Aktivieren der Kompatibilität zwischen AWS-Services undverschlüsselten Warteschlangen (p. 160).

• Wenn Sie eine Amazon SQS-Warteschlange für ein Amazon SNS-Thema abonnieren,verwendet Amazon SNS HTTPS, um Nachrichten an Amazon SQS weiterzuleiten.

In diesem Tutorial erfahren Sie, wie Sie für eine bestehende Amazon SQS-Warteschlange ein bestehendesAmazon SNS-Thema abonnieren.

AWS Management Console1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Wählen Sie in der Liste der Warteschlangen die Warteschlange(n) aus, die Sie für ein Amazon SNS-

Thema abonnieren möchten.

3. Wählen Sie unter Queue Actions die Option Subscribe Queue to SNS Topic (oder Subscribe Queuesto SNS Topic) aus.

54

https://docs.aws.amazon.com/sns/latest/dg/welcome.html



Das Dialogfeld Subscribe to a Topic wird angezeigt.4. Wählen Sie in der Dropdown-Liste Choose a Topic (Ein Thema auswählen) ein Amazon SNS-

Thema aus, für das Sie Ihre Warteschlange(n) abonnieren möchten. Wählen Sie die Topic Region(Themenregion) (optional) aus und klicken Sie dann auf Subscribe (Abonnieren).

Note

Geben Sie am besten einen anderen Topic ARN (Themen-ARN) an, wenn Sie eineWarteschlange für ein Amazon SNS-Thema nicht mit dem AWS-Konto abonnieren möchten,mit dem Sie Ihre Amazon SQS-Warteschlange erstellt haben.Dies ist auch nützlich, wenn das Amazon SNS-Thema nicht in der Dropdown-Liste Choose aTopic (Ein Thema auswählen) aufgeführt wird.

Das Dialogfeld Topic Subscription Result wird angezeigt.5. Überprüfen Sie die Liste der Amazon SQS-Warteschlangen, die Sie für das Amazon SNS-Thema

abonniert haben, und wählen Sie OK aus.

Die Warteschlange wird für das Thema abonniert.

Note

Wenn sich Ihre Amazon SQS-Warteschlange und das Amazon SNS-Thema in verschiedenenAWS-Konten befinden, muss der Besitzer des Themas das Abonnement zuerst bestätigen.Weitere Informationen erhalten Sie unter Confirm the Subscription (Bestätigen desAbonnements) im Entwicklerhandbuch für Amazon Simple Notification Service.

55

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToHttp.html#SendMessageToHttp.confirm

Amazon Simple Queue Service EntwicklerhandbuchKonfigurieren eines Lambda-Auslösers

Verwenden Sie die Amazon SNS-Konsole, wenn Sie Ihre Abonnements auflisten, sich vonThemen abmelden und Themen löschen möchten. Weitere Informationen finden Sie unterBereinigen.

Überprüfen Sie das Ergebnis des Abonnements, indem Sie eine Nachricht im Thema veröffentlichenund dann die Nachricht überprüfen, die das Thema an die Warteschlange sendet. WeitereInformationen finden Sie unter Senden von Amazon SNS-Nachrichten an Amazon SQS-Warteschlangen im Entwicklerhandbuch für Amazon Simple Notification Service.

Tutorial: Konfigurieren von eingehendenNachrichten in einer Amazon SQS-Warteschlangezum Auslösen einer AWS Lambda-Funktion

In diesem Tutorial erfahren Sie, wie Sie eine vorhandene Amazon SQS-Warteschlange so konfigurieren,dass eine AWS Lambda-Funktion ausgelöst wird, wenn neue Nachrichten in einer Warteschlangeeintreffen.

Mit Lambda-Funktionen können Sie Code ausführen, ohne einen Server bereitstellen oder verwaltenzu müssen. Beispiel: Sie können eine Lambda-Funktion konfigurieren, damit sie Nachrichten aus einerWarteschlange verarbeitet, während eine andere Warteschlange als Warteschlange für unzustellbareNachrichten für Nachrichten fungiert, die Ihre Lambda-Funktion nicht erfolgreich verarbeiten kann.Wenn Sie das Problem beheben, können Sie die Nachrichten aus der Warteschlange für unzustellbareNachrichten erneut durch die Lambda-Funktion leiten. Weitere Informationen finden Sie unter AmazonSQSWarteschlange für unzustellbare Nachrichten (p. 102) sowie unter Was ist AWS Lambda? undVerwenden von AWS Lambda mit Amazon SQS im AWS Lambda Developer Guide.

Note

• Ihre Warteschlange und die Lambda-Funktion müssen sich in derselben AWS-Region befinden.• Sie können jeweils nur eine Warteschlange mit einer oder mehreren Lambda-Funktionen

verknüpfen.

• Es ist nicht möglich, eine verschlüsselte Warteschlange (p. 154), die einen von AWSverwalteten Kunden-Masterschlüssel für Amazon SQS verwendet, mit einer Lambda-Funktion ineinem anderen AWS-Konto zu verknüpfen.

• Wenn Sie eine verschlüsselte Warteschlange mit einer Lambda-Funktion verknüpfen,Lambda jedoch keine Nachrichten abfragt, fügen Sie Ihrer Lambda-Rolle die Berechtigungkms:Decrypt hinzu.

VoraussetzungenZum Konfigurieren der Lambda-Funktionsauslöser mithilfe der Konsole müssen Sie Folgendessicherstellen:

• Wenn Sie einen IAM-Benutzer verwenden, muss Ihre Amazon SQS-Rolle die folgenden Berechtigungeneinschließen:• lambda:CreateEventSourceMapping

• lambda:ListEventSourceMappings

• lambda:ListFunctions

56

https://docs.aws.amazon.com/sns/latest/dg/CleanUp.html

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToSQS.html

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToSQS.html

https://docs.aws.amazon.com/lambda/latest/dg/welcome.html

https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html


• Ihre Lambda-Rolle muss die folgenden Berechtigungen enthalten:• sqs:DeleteMessage

• sqs:GetQueueAttributes

• sqs:ReceiveMessage

Weitere Informationen finden Sie unter Übersicht über die Verwaltung vonZugriffsberechtigungen (p. 165).

AWS Management Console1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Wählen Sie in der Liste der Warteschlangen die Warteschlange, die eine Lambda-Funktion auslösen

soll.

3. Wählen Sie im Menü Queue Actions (Warteschlangenaktionen) die Option Configure Trigger forLambda Function (Auslöser für &LAM;-Funktion konfigurieren).

4. Führen Sie eine der folgenden Aktionen im Dialogfeld Configure Incoming Messages to Trigger aLambda Function (Eingehende Nachrichten zum Auslösen einer &LAM;-Funktion konfigurieren) durch:

• Um eine vorhandene Lambda-Funktion zu verwenden, wählen Sie Select a LambdaFunction (EineFunktion auswählen) aus.

57


Amazon Simple Queue Service EntwicklerhandbuchBereinigen einer Warteschlange

• Zum Erstellen einer neuen Lambda-Funktion in der AWS Lambda-Konsole wählen Sie Create New(Neu erstellen) aus. Weitere Informationen finden Sie unter Eine einfache Lambda-Funktion erstellenim AWS Lambda Developer Guide.

5. Wählen Sie Save aus.6. Prüfen Sie im Dialogfeld Lambda Function Trigger Configuration Result (Konfigurationsergebnis des

Auslösers der Lambda-Funktion) die Lambda-Funktion, die von Ihrer Amazon SQS-Warteschlangeausgelöst wird, und wählen Sie OK.

Note

Es dauert etwa 1 Minute, bis die Lambda-Funktion Ihrer Warteschlange zugeordnet wird.

Die Lambda-Funktion und ihr Status werden auf der Registerkarte Lambda Triggers (Lambda-Auslöser) angezeigt.

• Zum Überprüfen der Ergebnisse der Konfiguration können Sie eine Nachricht an Ihre Warteschlangesenden (p. 30) und dann die ausgelöste Lambda-Funktion in der Lambda-Konsole anzeigen.

• Zum Löschen der Zuordnung zwischen einer Lambda-Funktion und Ihrer Warteschlange wählen Sie neben einem ARN einer Lambda-Funktion.

Tutorial: Löschen von Nachrichten und Bereinigeneiner Amazon SQS-Warteschlange

Wenn Sie eine Amazon SQS-Warteschlange nicht löschen möchten, aber alle darin enthaltenenNachrichten löschen müssen, können Sie die Warteschlange bereinigen. In diesem Tutorial erfahren Sie,wie Sie eine Warteschlange löschen.

58

https://docs.aws.amazon.com/lambda/latest/dg/get-started-create-function.html


Important

Wenn Sie eine Warteschlange leeren, können die daraus gelöschten Nachrichten nicht mehrabgerufen werden.Das Löschen von Nachrichten dauert bis zu 60 Sekunden. Wir empfehlen, unabhängig von derWarteschlangengröße 60 Sekunden zu warten.


3. Wählen Sie im Menü Queue Actions die Option Purge Queue aus.

Das Dialogfeld Purge Queues wird angezeigt.

59


Amazon Simple Queue Service EntwicklerhandbuchLöschen einer Warteschlange

4. Wählen Sie Yes, Purge Queue aus.

Alle Nachrichten werden aus der Warteschlange entfernt.

Das Bestätigungsdialogfeld Purge Queues wird angezeigt.

5. Klicken Sie auf OK.

Tutorial: Löschen einer Amazon SQS-Warteschlange

Wenn Sie keine Amazon SQS-Warteschlange verwenden (und dies auch nicht in naher Zukunft planen),ist es eine bewährte Vorgehensweise, diese aus Amazon SQS zu löschen. In diesem Tutorial erfahren Sie,wie Sie eine Warteschlange löschen.

Note

Sie können eine Warteschlange auch dann löschen, wenn sie nicht leer ist. Wenn Sie Nachrichtenin einer Warteschlange löschen möchten, aber nicht die Warteschlange selbst, können Sie dieWarteschlange leeren (p. 58).Standardmäßig wird eine Nachricht in einer Warteschlange nach dem Senden vier Tage langaufbewahrt. Sie können eine Warteschlange so konfigurieren, dass sie Nachrichten bis zu 14 Tageaufbewahrt.



60



3. Wählen Sie im Menü Queue Actions (Warteschlangenaktionen) die Option Delete Queue(Warteschlange löschen) aus.

Das Dialogfeld Delete Queues (Warteschlangen löschen) wird angezeigt.

4. Wählen Sie Yes, Delete Queue (Ja, Warteschlange löschen) aus.



61



Amazon Simple Queue Service EntwicklerhandbuchKonfigurieren von Warteschlangen

Note

Diese Aktion ist für Standard- und FIFO-Warteschlangen identisch.


Der folgende Codeabschnitt löscht die Warteschlange:

// Delete the queueSystem.out.println("Deleting the test queue.\n");sqs.deleteQueue(new DeleteQueueRequest(myQueueUrl));



Tutorials: Konfigurieren von Amazon SQS-Warteschlangen

Die folgenden Tutorials zeigen, wie Sie Amazon SQS-Warteschlangen auf verschiedene Weisenkonfigurieren.

Themen• Tutorial: Konfigurieren von Serverseitige Verschlüsselung (SSE) für eine vorhandene Amazon SQS-

Warteschlange (p. 62)• Tutorial: Konfigurieren einer Langabfrage für eine Amazon SQS-Warteschlange (p. 66)• Tutorial: Konfigurieren einer Amazon SQS-Warteschlange für unzustellbare Nachrichten (p. 69)• Tutorial: Konfigurieren der Zeitbeschränkung für die Sichtbarkeit für eine Amazon SQS-

Warteschlange (p. 73)• Tutorial: Konfigurieren einer Amazon SQS-Verzögerungswarteschlange (p. 77)

Tutorial: Konfigurieren von ServerseitigeVerschlüsselung (SSE) für eine vorhandene AmazonSQS-WarteschlangeSie können SSE für eine Warteschlange aktivieren, um ihre Daten zu schützen. Weitere Informationen zurVerwendung von SSE finden Sie unter Verschlüsselung im Ruhezustand (p. 154).

Important

Alle Anforderungen an Warteschlangen mit aktivierter SSE müssen HTTPS und Signature Version4 verwenden.Wenn Sie SSE deaktivieren, bleiben Nachrichten verschlüsselt, die in der Warteschlange bereitsvorhanden sind. Diese Nachrichten sind für Konsumenten weiterhin verfügbar, solange der KMS-Schlüssel aktiviert und zugänglich bleibt.

In diesem Tutorial erfahren Sie, wie Sie SSE für eine bestehende Amazon SQS-Warteschlange aktivieren,deaktivieren und konfigurieren.

Themen• AWS Management Console (p. 63)

62



Amazon Simple Queue Service EntwicklerhandbuchKonfigurieren von SSE für eine Warteschlange

• AWS SDK for Java (p. 64)


3. Wählen Sie unter Queue Actions (Warteschlangenaktionen) die Option Configure Queue(Warteschlange konfigurieren) aus.

Das Dialogfeld Configure QueueName (Warteschlangennamen konfigurieren) wird angezeigt.4. Zum Aktivieren oder Deaktivieren von SSE verwenden Sie das Kontrollkästchen Use SSE (SSE

verwenden).5. Angeben der die ID des Customer Master Key (CMK, Kundenhauptschlüssel). Weitere Informationen

finden Sie unter Wichtige Begriffe (p. 156).

Für jeden CMK-Typ werden Description, Account und Key ARN des CMK angezeigt.

Important

Wenn Sie nicht der Besitzer des CMK sind oder wenn Sie sich mit einem Konto anmelden,das über keine kms:ListAliases- und kms:DescribeKey-Berechtigungen verfügt,können Sie auf der Amazon SQS-Konsole keine Informationen über den CMK aufrufen.Bitten Sie den Inhaber des CMK, Ihnen diese Berechtigungen zu erteilen. WeitereInformationen finden Sie unter der AWS KMS-API-Berechtigungen: Referenztabelle fürAktionen und Ressourcen im AWS Key Management Service Developer Guide.

• Um den AWS-verwalteten CMK für Amazon SQS zu verwenden, wählen Sie ihn in der Liste aus.

63





Note


AWS verwalteten CMK für Amazon SQS. Informationen zum Erstellen benutzerdefinierterCMKs finden Sie unter Erstellen von Schlüsseln im AWS Key Management ServiceDeveloper Guide.

• Wenn Sie die AWS Management Console zum ersten Mal verwenden, um den AWSverwalteten CMK für Amazon SQS für eine Warteschlange festzulegen, erstellt AWSKMS den AWS-verwalteten CMK für Amazon SQS.


• Um einen benutzerdefinierten CMK aus Ihrem AWS-Konto zu verwenden, wählen Sie diesen aus derListe aus.

Note

Informationen zum Erstellen benutzerdefinierter CMKs finden Sie unter Erstellen vonSchlüsseln im AWS Key Management Service Developer Guide.

• Um einen benutzerdefinierten CMK-ARN in Ihrem AWS-Konto oder in einem anderen AWS-Konto zuverwenden, wählen Sie Enter an existing CMK ARN (Existierenden CMK-ARN eingeben) in der Listeaus und geben Sie den CMK ein bzw. kopieren Sie ihn.

6. (Optional) Geben Sie für Data key reuse period (Wiederverwendungszeitraum des Datenschlüssels)einen Wert zwischen 1 Minute und 24 Stunden an. Der Standardwert ist 5 Minuten. WeitereInformationen finden Sie unter Grundlegendes zum Wiederverwendungszeitraum für denDatenschlüssel (p. 157).

7. Wählen Sie Save Changes.

Ihre Änderungen werden auf die Warteschlange angewendet.


64







Bevor Sie SSE verwenden können, müssen Sie AWS KMS-Schlüsselrichtlinien konfigurieren, umeine Verschlüsselung von Warteschlangen und eine Verschlüsselung sowie Entschlüsselung vonNachrichten zu ermöglichen. Weitere Informationen finden Sie unter Konfigurieren von AWS KMS-Berechtigungen (p. 159)

1. die ID des Customer Master Key (CMK, Kundenhauptschlüssel). Weitere Informationen finden Sieunter Wichtige Begriffe (p. 156). ermitteln

Note

Beachten Sie Folgendes:

• Wenn Sie keinen benutzerdefinierten CMK festlegen, verwendet Amazon SQS den mitAWS verwalteten CMK für Amazon SQS. Informationen zum Erstellen benutzerdefinierterCMKs finden Sie unter Erstellen von Schlüsseln im AWS Key Management ServiceDeveloper Guide.



2. Geben Sie zum Aktivieren von server-side encryption die CMK-ID ein, indem Sie dasKmsMasterKeyId-Attribut der Aktion CreateQueue oder SetQueueAttributes festlegen.

Das folgende Codebeispiel aktiviert SSE für eine vorhandene Warteschlange mithilfe des AWS-verwalteten CMK für Amazon SQS:

final SetQueueAttributesRequest setAttributesRequest = new SetQueueAttributesRequest();setAttributesRequest.setQueueUrl(queueUrl); // Enable server-side encryption by specifying the alias ARN of the// AWS managed CMK for Amazon SQS.final String kmsMasterKeyAlias = "arn:aws:kms:us-east-2:123456789012:alias/aws/sqs";attributes.put("KmsMasterKeyId", kmsMasterKeyAlias); final SetQueueAttributesResult setAttributesResult = client.setQueueAttributes(setAttributesRequest);

Zum Deaktivieren von server-side encryption für eine vorhandene Warteschlange legen Sie dasKmsMasterKeyId-Attribut mithilfe der Aktion SetQueueAttributes auf eine leere Zeichenfolgefest.

Important

null ist kein gültiger Wert für KmsMasterKeyId.3. (Optional) Geben Sie die Zeit in Sekunden an, wie lange Amazon SQS einen Datenschlüssel

wiederverwenden kann (p. 156), um Nachrichten vor dem Aufrufen von AWS KMS zu ver- oderentschlüsseln. Legen Sie das KmsDataKeyReusePeriodSeconds-Attribut der Aktion CreateQueueoder SetQueueAttributes fest. Die Werte können zwischen 60 Sekunden (1 Minute) und86 400 Sekunden (24 Stunden) liegen. Wenn Sie keinen Wert angeben, wird der Standardwert von300 Sekunden (5 Minuten) verwendet.

Im folgenden Codebeispiel wird der Wiederverwendungszeitraum für den Datenschlüssel auf60 Sekunden (1 Minute) festgelegt:

// (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse // a data key to encrypt or decrypt messages before calling AWS KMS again.

65






Amazon Simple Queue Service EntwicklerhandbuchKonfigurieren einer Langabfrage für eine Warteschlange

attributes.put("KmsDataKeyReusePeriodSeconds", "60");

Informationen darüber, wie Sie Attribute einer Warteschlange abrufen, finden Sie in den Beispielen imAmazon Simple Queue Service API Reference.

Um die CMK-ID oder den Weiterverwendungszeitraum des Datenschlüssels für einebestimmte Warteschlange abzurufen, verwenden Sie die Attribute KmsMasterKeyId undKmsDataKeyReusePeriodSeconds der Aktion GetQueueAttributes.

Informationen darüber, wie Sie eine Warteschlange zu einem anderen CMK mit demselben Aliasverschieben, finden Sie unter Aktualisieren eines Alias im AWS Key Management Service DeveloperGuide.

Tutorial: Konfigurieren einer Langabfrage für eineAmazon SQS-WarteschlangeWenn die Wartezeit für die API-Aktion ReceiveMessage größer als 0 ist, ist die Langabfrage aktiviert.Mithilfe von Langabfragen können Sie die Kosten für die Verwendung von Amazon SQS reduzieren,indem Sie die Anzahl der leeren Antworten (wenn bei einer ReceiveMessage-Anfrage keine Nachrichtenvorhanden sind) und fälschlicherweise leeren Antworten (wenn Nachrichten vorhanden sind, diese abernicht in einer Antwort enthalten sind) eliminieren. In diesem Tutorial erfahren Sie, wie Sie Langabfragenfür eine Amazon SQS-Warteschlange konfigurieren. Weitere Informationen finden Sie unter Amazon SQS-Kurz- und -Langabfragen (p. 100).




Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.4. Standard ist standardmäßig ausgewählt. Wählen Sie FIFO.5. Wählen Sie Configure Queue aus.6. Geben Sie für Receive Message Wait Time (Wartezeit für den Empfang von Nachrichten) eine Zahl

zwischen 1 und 20 ein.

Note

Wenn Sie den Wert auf 0 setzen, wird eine Kurzabfrage konfiguriert. Weitere Informationenfinden Sie unter Unterschiede zwischen Lang- und Kurzabfragen (p. 101).


66

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html#API_GetQueueAttributes_Examples


https://docs.aws.amazon.com/kms/latest/developerguide/programming-aliases.html#update-alias




Ihre neue Warteschlange wird für die Verwendung von Langanfragen konfiguriert, erstellt und in derWarteschlangenliste ausgewählt.

Note



Konfigurieren einer Langabfrage für eine Warteschlange

Voraussetzungen

Fügen Sie dem Pfad für Ihre Java-Klasse das aws-java-sdk-sqs.jar-Pakete hinzu. Das folgendeBeispiel zeigt diese Abhängigkeit in der pom.xml-Datei eines Maven-Projekts.

<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-sqs</artifactId> <version><replaceable>LATEST</replaceable></version> </dependency></dependencies>

SQSLongPollingExample.java

Der folgende Java-Beispielcode erstellt eine Standard-Warteschlange und konfiguriert Langabfragen dafür.

/* * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */ import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.CreateQueueRequest;import com.amazonaws.services.sqs.model.QueueAttributeName;

import java.util.Scanner;

public class SQSLongPollingExample {

67




public static void main(String[] args) {

final Scanner input = new Scanner(System.in);

System.out.print("Enter the queue name: "); final String queueName = input.nextLine();

System.out.print("Enter the ReceiveMessage wait time (1-20 seconds): "); final String receiveMessageWaitTime = input.nextLine();

/* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

try { // Create a queue with long polling. final CreateQueueRequest createQueueRequest = new CreateQueueRequest() .withQueueName(queueName) .addAttributesEntry(QueueAttributeName.ReceiveMessageWaitTimeSeconds .toString(), receiveMessageWaitTime); sqs.createQueue(createQueueRequest);

System.out.println("Created queue " + queueName + " with " + "ReceiveMessage wait time set to " + receiveMessageWaitTime + " seconds.");

} catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

So konfigurieren Sie eine Langabfrage für eine Warteschlange und senden,empfangen und löschen eine Nachricht

1. Kopieren Sie das Beispielprogramm für eine Standard-Warteschlange (p. 84) oder eine FIFO-Warteschlange (p. 91).

2. Die URL der Warteschlange abrufen:

final String queueUrl = sqs.getQueueUrl(queueName).getQueueUrl();

3. Verwenden Sie die SetQueueAttributesRequest-Aktion, um eine Langabfrage für einevorhandene Warteschlange zu konfigurieren:

final SetQueueAttributesRequest setQueueAttributesRequest = new SetQueueAttributesRequest()

68

Amazon Simple Queue Service EntwicklerhandbuchKonfigurieren einer Warteschlange

für unzustellbare Nachrichten

.withQueueUrl(queueUrl) .addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");sqs.setQueueAttributes(setQueueAttributesRequest);

4. Verwenden Sie die ReceiveMessageRequest-Aktion, um die Langabfrage für einenNachrichtenempfang zu konfigurieren:

final ReceiveMessageRequest receive_request = new ReceiveMessageRequest() .withQueueUrl(queueUrl) .withWaitTimeSeconds(20);sqs.receiveMessage(receive_request);


Die Langabfrage für Ihre Warteschlange ist konfiguriert und die Nachricht wird gesendet, empfangenund gelöscht.

Tutorial: Konfigurieren einer Amazon SQS-Warteschlange für unzustellbare NachrichtenAndere (Quell-)Warteschlangen können Nachrichten, die nicht erfolgreich verarbeitet werden konnten,an die Warteschlange für unzustellbare Nachrichten senden. In diesem Tutorial erfahren Sie, wie Sieeine Amazon SQS-Quellwarteschlange erstellen und dafür eine zweite Warteschlange für unzustellbareNachrichten konfigurieren. Weitere Informationen finden Sie unter Amazon SQSWarteschlange fürunzustellbare Nachrichten (p. 102).

Important

Wenn Sie eine Warteschlange als Quellwarteschlange bestimmen, wird nicht automatischeine Warteschlange für unzustellbare Nachrichten erstellt. Sie müssen zuerst eine normaleStandard- oder FIFO-Warteschlange erstellen, bevor Sie sie als Warteschlange für unzustellbareNachrichten bestimmen. In diesem Tutorial wird davon ausgegangen, dass Sie bereits über einenormale FIFO-Warteschlange mit dem Namen MyDeadLetterQueue.fifo verfügen.Die Warteschlange für unzustellbare Nachrichten einer FIFO-Warteschlange muss auch eineFIFO-Warteschlange sein. Ebenso muss die Warteschlange für unzustellbare Nachrichten einerStandard-Warteschlange auch eine Standard-Warteschlange sein.




Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.4. Standard ist standardmäßig ausgewählt. Wählen Sie FIFO.5. Wählen Sie Configure Queue aus.

69




6. In diesem Beispiel aktivieren Sie die Redrive-Richtlinie für Ihre neue Warteschlange, legen dieMyDeadLetterQueue.fifo-Warteschlange als Warteschlange für unzustellbare Nachrichten festund stellen die Anzahl der maximal zu empfangenden Nachrichten auf 50 ein.

Zum Konfigurieren der Warteschlange für unzustellbare Nachrichten wählen Sie Use Redrive Policyaus.

Geben Sie den Namen der vorhandenen Dead Letter Queue (Warteschlange für unzustellbareNachrichten) ein, an die Quellwarteschlangen Nachrichten senden sollen.

Zum Konfigurieren, wie oft eine Nachricht empfangen werden kann, bevor sie an eineWarteschlange für unzustellbare Nachrichten gesendet wird, legen Sie Maximum Receives auf einenWert zwischen 1 und 1 000 fest.

Note

Die Einstellung Maximum Receives gilt nur für einzelne Nachrichten.

Wählen Sie Create Queue aus.

Die neue Warteschlange für unzustellbare Nachrichten wird erstellt und in der Warteschlangenlisteausgewählt.

Note


Die Einstellungen Maximum Receives und der Dead Letter Queue-ARN für Ihre Warteschlange werdenauf der Registerkarte Redrive Policy angezeigt.


70





So konfigurieren Sie eine Warteschlange für unzustellbare Nachrichten

Voraussetzungen



SQSDeadLetterQueueExample.java

Der folgende Java-Beispielcode erstellt zwei Standard-Warteschlangen und konfiguriert eineWarteschlange als Quellwarteschlange für die andere — eine Warteschlange für unzustellbareNachrichten.

/* * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */

import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;import com.amazonaws.services.sqs.model.GetQueueAttributesResult;import com.amazonaws.services.sqs.model.QueueAttributeName;import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;


public class SQSDeadLetterQueueExample { public static void main(String[] args) {


System.out.print("Enter the source queue name: "); final String sourceQueueName = input.nextLine();

System.out.print("Enter the dead-letter queue name: "); final String deadLetterQueueName = input.nextLine();

/* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see

71



* Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

try { // Create a source queue. sqs.createQueue(sourceQueueName);

// Create a dead-letter queue. sqs.createQueue(deadLetterQueueName);

// Get the dead-letter queue ARN. final String deadLetterQueueUrl = sqs.getQueueUrl(deadLetterQueueName) .getQueueUrl(); final GetQueueAttributesResult deadLetterQueueAttributes = sqs.getQueueAttributes( new GetQueueAttributesRequest(deadLetterQueueUrl) .withAttributeNames("QueueArn")); final String deadLetterQueueArn = deadLetterQueueAttributes.getAttributes().get("QueueArn");

// Set the dead-letter queue for the source queue using the redrive policy. final String sourceQueueUrl = sqs.getQueueUrl(sourceQueueName) .getQueueUrl(); final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(sourceQueueUrl) .addAttributesEntry(QueueAttributeName.RedrivePolicy.toString(), "{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\"" + deadLetterQueueArn + "\"}"); sqs.setQueueAttributes(request);

System.out.println("Set queue " + sourceQueueName + " as source queue " + "for dead-letter queue " + deadLetterQueueName + ".");


So konfigurieren Sie eine Warteschlange für unzustellbare Nachrichten undsenden, empfangen und löschen eine Nachricht


2. Legen Sie eine Zeichenfolge mit JSON-formatierten Parametern und Werten für das RedrivePolicy-Warteschlangenattribut fest:

final String redrivePolicy =

72

Amazon Simple Queue Service EntwicklerhandbuchKonfigurieren der Zeitbeschränkung fürdie Sichtbarkeit für eine Warteschlange

"{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\"arn:aws:sqs:us-east-2:123456789012:MyDeadLetterQueue\"}";

3. Verwenden Sie die API-Aktion CreateQueue oder SetQueueAttributesRequest, um dasRedrivePolicy-Warteschlangenattribut zu konfigurieren:

final SetQueueAttributesRequest queueAttributes = new SetQueueAttributesRequest();final Map<String,String> attributes = new HashMap<String,String>(); attributes.put("RedrivePolicy", redrivePolicy); queueAttributes.setAttributes(attributes);queueAttributes.setQueueUrl(myQueueUrl);sqs.setQueueAttributes(queueAttributes);


Die Warteschlange für unzustellbare Nachrichten ist konfiguriert und die Nachricht wird gesendet,empfangen und gelöscht.

Tutorial: Konfigurieren der Zeitbeschränkung für dieSichtbarkeit für eine Amazon SQS-WarteschlangeDie Nachricht verbleibt direkt nach dem Empfang in der Warteschlange. Um zu verhindern, dassandere Konsumenten die Nachricht erneut verarbeiten, legt Amazon SQS eine Zeitbeschränkung fürdie Sichtbarkeit fest, also einen Zeitraum, in dem Amazon SQS verhindert, dass andere Consumer dieNachricht empfangen und verarbeiten können. Die Standardzeitbeschränkung für die Sichtbarkeit einerNachricht beträgt 30 Sekunden. Das Minimum beträgt 0 Sekunden. Der Höchstwert beträgt 12 Stunden.In diesem Tutorial erfahren Sie, wie Sie eine Zeitbeschränkung für die Sichtbarkeit für eine Warteschlangeüber die AWS Management Console oder für eine oder mehrere Nachrichten unter Verwendung der AWSSDK for Java konfigurieren. Weitere Informationen finden Sie unter Amazon SQS Zeitbeschränkung für dieSichtbarkeit (p. 106).

Note

Sie können die AWS Management Console nur für die Konfiguration der Zeitbeschränkung fürdie Sichtbarkeit für Warteschlangen nutzen, nicht für einzelne oder mehrere Nachrichten. Dazumüssen Sie eines der AWS SDKs verwenden. Weitere Informationen finden Sie nachfolgend imzweiten Java-Beispielcode.




Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.4. Standard ist standardmäßig ausgewählt. Wählen Sie FIFO.

73



5. Wählen Sie Configure Queue aus.6. In diesem Beispiel setzen Sie die standardmäßige Zeitbeschränkung für die Sichtbarkeit auf 1 Minute.


Die neue Warteschlange wird für eine Zeitbeschränkung für die Sichtbarkeit von 1 Minute konfiguriert,erstellt und in der Warteschlangenliste ausgewählt.

Note


Das Default Visibility Timeout (Standard-Zeitbeschränkung für die Sichtbarkeit) für Ihre Warteschlangewird auf der Registerkarte Details angezeigt.


Konfigurieren einer Zeitbeschränkung für eine Warteschlange

Voraussetzungen



SQSVisibilityTimeoutExample.java

Der folgende Java-Beispielcode erstellt eine Standard-Warteschlange und setzt die Zeitbeschränkung fürdie Sichtbarkeit dafür auf 1 Minute.

/* * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either

74




* express or implied. See the License for the specific language governing * permissions and limitations under the License. * */ import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.CreateQueueRequest;import com.amazonaws.services.sqs.model.QueueAttributeName;import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;


public class SQSVisibilityTimeoutExample { public static void main(String[] args) {



System.out.print("Enter the visibility timeout in seconds " + "(0 seconds to 12 hours): "); final String visibilityTimeout = input.nextLine();


try { // Create a queue. final CreateQueueRequest createQueueRequest = new CreateQueueRequest() .withQueueName(queueName); sqs.createQueue(createQueueRequest);

// Set the visibility timeout for the queue. final String queueUrl = sqs.getQueueUrl(queueName) .getQueueUrl(); final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .addAttributesEntry(QueueAttributeName.VisibilityTimeout .toString(), visibilityTimeout); sqs.setQueueAttributes(request);

System.out.println("Created queue " + queueName + " with " + "visibility timeout set to " + visibilityTimeout + " seconds.");

} catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " +

75


"being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

Konfigurieren der Zeitbeschränkung für die Sichtbarkeit für eine einzelneNachricht oder mehrere Nachrichten und Nachrichten senden, empfangen undlöschen


2. Konfigurieren der Zeitbeschränkung für die Sichtbarkeit für eine einzelne Nachricht, Übergabeder Warteschlangen-URL, der Empfangs-Mitteilung für die Nachricht und des Werts für dieZeitbeschränkung für die Sichtbarkeit in Sekunden.

// Get the message receipt handle.String receiptHandle = sqs.receiveMessage(myQueueUrl) .getMessages() .get(0) .getReceiptHandle();

// Pass the queue URL, the message receipt handle, and the visibility timeout value.sqs.changeMessageVisibility(myQueueUrl, receiptHandle, timeoutValue);

3. Um die Zeitbeschränkung für die Sichtbarkeit für mehrere Nachrichten zu konfigurieren (z. B. wenn Sieunterschiedliche Zeitbeschränkungswerte für verschiedene Nachrichten realisieren wollen), erstellenSie eine ArrayList, fügen ihr die Nachrichten mit der Zeitbeschränkung für die Sichtbarkeit inSekunden hinzu und übergeben dann die Warteschlangen-URL und die ArrayList mit Nachrichten.

// Create an ArrayList for batched messages.List<ChangeMessageVisibilityBatchRequestEntry> entries = new ArrayList<ChangeMessageVisibilityBatchRequestEntry>();

// Add the first message to the ArrayList with a visibility timeout value.entries.add(new ChangeMessageVisibilityBatchRequestEntry( "uniqueMessageId123", sqs.receiveMessage(myQueueUrl) .getMessages() .get(0) .getReceiptHandle()) .withVisibilityTimeout(timeoutValue));

// Add the second message to the ArrayList with a different timeout value. entries.add(new ChangeMessageVisibilityBatchRequestEntry( "uniqueMessageId456", sqs.receiveMessage(myQueueUrl) .getMessages() .get(0) .getReceiptHandle()) .withVisibilityTimeout(timeoutValue + 60));

sqs.changeMessageVisibilityBatch(myQueueUrl, entries);


Die Zeitbeschränkung für die Sichtbarkeit für eine einzelne oder mehrere Nachrichten wird konfiguriertund die Nachricht wird gesendet, empfangen und gelöscht.

76

Amazon Simple Queue Service EntwicklerhandbuchKonfigurieren einer Amazon SQS-

Verzögerungswarteschlange

Tutorial: Konfigurieren einer Amazon SQS-VerzögerungswarteschlangeMithilfe von Verzögerungswarteschlangen können Sie die Bereitstellung von neuen Nachrichtenfür eine Warteschlange um eine bestimmte Anzahl an Sekunden verzögern. Wenn Sie eineVerzögerungswarteschlange erstellen, bleiben alle an diese Warteschlange gesendeten Nachrichtenfür die Dauer des Verzögerungszeitraums für Konsumenten unsichtbar. Die standardmäßige (minimale)Verzögerung für eine Warteschlange beträgt 0 Sekunden. Die maximale Größe ist 15 Minuten. In diesemTutorial erfahren Sie, wie Sie eine Verzögerungswarteschlange unter Verwendung der AWS ManagementConsole oder der AWS SDK for Java konfigurieren. Weitere Informationen finden Sie unter Amazon SQS-Verzögerungswarteschlangen (p. 108).




Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.4. Standard ist standardmäßig ausgewählt. Wählen Sie FIFO.5. Wählen Sie Configure Queue aus.6. In diesem Beispiel setzen Sie die Verzögerung für die Zustellung auf 1 Minute.


Die neue Warteschlange wird für eine Verzögerung von 1 Minute konfiguriert, erstellt und in derWarteschlangenliste ausgewählt.

Note


Das Delivery Delay (Zustellungsverzögerung) für Ihre Warteschlange wird auf der Registerkarte Detailsangezeigt.


77






So konfigurieren Sie eine Verzögerungswarteschlange

Voraussetzungen



SQSDelayQueueExample.java

Der folgende Java-Beispielcode erstellt eine Standard-Warteschlange und setzt die Verzögerung dafür auf1 Minute.

/* * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */ import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.CreateQueueRequest;import com.amazonaws.services.sqs.model.QueueAttributeName;import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;


public class SQSDelayQueueExample { public static void main(String[] args) {



System.out.print("Enter the delay in seconds (0 seconds to 15 minutes): "); final String queueDelay = input.nextLine();


78



try { // Create a queue. final CreateQueueRequest createQueueRequest = new CreateQueueRequest() .withQueueName(queueName); sqs.createQueue(createQueueRequest);

// Set the delay for the queue. final String queueUrl = sqs.getQueueUrl(queueName) .getQueueUrl(); final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .addAttributesEntry(QueueAttributeName.DelaySeconds .toString(), queueDelay); sqs.setQueueAttributes(request);

System.out.println("Created queue " + queueName + " with " + "delay set to " + queueDelay + " seconds.");


So konfigurieren Sie eine Verzögerungswarteschlange und senden, empfangenund löschen Nachrichten


2. Um eine Verzögerungswarteschlange zu konfigurieren, übergeben Sie den Verzögerungswert inSekunden.

// Set the delay for the queue.final String queueUrl = sqs.getQueueUrl(queueName).getQueueUrl();final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .addAttributesEntry(QueueAttributeName.DelaySeconds.toString(), queueDelay);sqs.setQueueAttributes(request);


Die Verzögerungswarteschlange ist konfiguriert und die Nachricht wird gesendet, empfangen undgelöscht.

79

Amazon Simple Queue Service EntwicklerhandbuchGrundlegende Architektur

Funktionsweise von Amazon SQSIn diesem Abschnitt werden die Arten von Amazon SQS-Warteschlangen und deren grundlegendeEigenschaften beschrieben. Außerdem werden die IDs sowie die verschiedenen Verwaltungs-Workflowsvon Warteschlangen und Nachrichten vorgestellt.

Themen• Grundlegende Amazon SQS-Architektur (p. 80)• Amazon SQS Standard-Warteschlangen (p. 83)• Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86)• Amazon SQS-Warteschlangen- und -Nachrichten-IDs (p. 93)• Nachrichtenmetadaten (p. 95)• Für die Verarbeitung von Amazon SQS-Nachrichten erforderliche Ressourcen (p. 98)• Amazon SQS Kostenzuordnungs-Tags (p. 99)• Amazon SQS-Kurz- und -Langabfragen (p. 100)• Amazon SQSWarteschlange für unzustellbare Nachrichten (p. 102)• Amazon SQS Zeitbeschränkung für die Sichtbarkeit (p. 106)• Amazon SQS-Verzögerungswarteschlangen (p. 108)• Temporäre Warteschlangen in Amazon SQS (p. 109)• Amazon SQS-Nachrichten-Timer (p. 113)• Verwalten von großen Amazon SQS-Nachrichten mit Amazon S3 (p. 114)• Arbeiten mit JMS und Amazon SQS (p. 117)

Grundlegende Amazon SQS-Architektur

In diesem Abschnitt sind die Teile eines verteilten Messaging-Systems aufgeführt. Zudem wird derLebenszyklus einer Amazon SQS-Nachricht erläutert.

Verteilte WarteschlangenEs gibt drei Hauptkomponenten in einem verteilten Messaging-System: die Komponenten des verteiltenSystems, die Warteschlange (auf Amazon SQS-Server verteilt) und die Nachrichten in der Warteschlange.

Im folgenden Szenario ist Ihr System mit mehreren Komponenten dargestellt, die Nachrichten an dieWarteschlange senden und aus der Warteschlange empfangen. Die Warteschlange (die die Nachrichten Abis E enthält) speichert die Nachrichten redundant auf mehreren Amazon SQS-Servern.

80

Amazon Simple Queue Service EntwicklerhandbuchLebenszyklus einer Nachricht

Lebenszyklus einer NachrichtDas folgende Szenario stellt den Lebenszyklus einer Amazon SQS-Nachricht in einer Warteschlange vonder Erstellung zur Löschung dar.

81

Amazon Simple Queue Service EntwicklerhandbuchLebenszyklus einer Nachricht

Ein Produzent (Komponente 1) sendet Nachricht A an eine Warteschlange und die Nachricht wirdredundant über die Amazon SQS-Server verteilt.

Wenn ein Konsument (Komponente 2) bereit ist, Nachrichten zu verarbeiten, werden Nachrichten ausder Warteschlange konsumiert und Nachricht A wird zurückgegeben. Während Nachricht A verarbeitet wird,verbleibt sie in der Warteschlange und wird während der Zeitbeschränkung für die Sichtbarkeit (p. 106)nicht an nachfolgende Empfangsanforderungen zurückgegeben.

Der Konsument (Komponente 2) löscht Nachricht A aus der Warteschlange, um zu verhindern, dass dieNachricht nach Ablauf der Zeitbeschränkung für die Sichtbarkeit erneut empfangen und verarbeitet wird.

Note

Amazon SQS löscht Nachrichten automatisch, die sich länger als den maximalenAufbewahrungszeitraum für Nachrichten in einer Warteschlange befunden haben. DerStandardaufbewahrungszeitraum für Nachrichten beträgt 4 Tage. Sie können jedoch denAufbewahrungszeitraum für Nachrichten mit der Aktion SetQueueAttributes von 60 Sekundenauf 1.209.600 Sekunden (14 Tage) festlegen.

82


Amazon Simple Queue Service EntwicklerhandbuchStandard-Warteschlangen

Amazon SQS Standard-WarteschlangenAmazon SQS bietet Standard als Standardwarteschlangentyp. Standard-Warteschlangen unterstützeneine fast unbegrenzte Anzahl an Transaktionen pro Sekunde (TPS) pro API-Aktion (SendMessage,ReceiveMessage oder DeleteMessage). Standard-Warteschlangen unterstützen die mindestenseinmalige Nachrichtenübermittlung. Gelegentlich wird jedoch (aufgrund der hochgradig verteiltenArchitektur, die den nahezu unbegrenzten Durchsatz ermöglicht) mehr als eine Kopie einer Nachricht nichtin der richtigen Reihenfolge zugestellt. Standard-Warteschlangen bieten eine bestmögliche Sortierung,womit sichergestellt wird, dass Nachrichten in der Regel in der gleichen Reihenfolge zugestellt werden, wiesie gesendet werden.

Weitere Informationen zum Erstellen von Standard-Warteschlangen mit oder ohne server-side encryptionunter Verwendung der AWS Management Console, der AWS SDK for Java (und der CreateQueue-Aktion) oder AWS CloudFormation finden Sie unter Erstellen einer Amazon SQS-Warteschlange (p. 16)und Erstellen einer Amazon SQS-Warteschlange mit SSE (p. 20).

Sie können Standard-Warteschlangen für Nachrichten in vielen Bereichen einsetzen, sofern IhreAnwendung Nachrichten verarbeiten kann, die mehr als einmal und nicht der Reihenfolge nach eingehen,z. B.:

• Echtzeit-Benutzeranfragen von intensiven Hintergrundaufgaben entkoppeln – Benutzer können Medienhochladen, während diese skaliert und verschlüsselt werden.

• Aufgaben mehreren Worker-Knoten zuweisen – Eine hohe Anzahl von Kreditkarten-Validierungsanfragenkönnen verarbeitet werden.

• Stapelnachrichten für zukünftige Verarbeitung – Mehrere Einträge können für das Hinzufügen zu einerDatenbank geplant werden.

Kontingente für Standard-Warteschlangen finden Sie unter Kontingente im Zusammenhang mitWarteschlangen (p. 148).

Informationen zu bewährten Methoden für die Arbeit mit Standard-Warteschlangen finden Sie unterEmpfehlungen für Amazon SQS Standard- und FIFO (First-In-First-Out)-Warteschlangen (p. 141).

Themen• Nachrichtenreihenfolge (p. 83)• Mindestens einmalige Lieferung (p. 83)• Funktionierendes Java-Beispiel für Standard-Warteschlangen (p. 84)

NachrichtenreihenfolgeIn einer Standard-Warteschlange wird bestmöglich versucht, die Reihenfolge von Nachrichten zubewahren. Wenn jedoch mehrere Kopien einer Nachricht gesendet werden, kann die Reihenfolge nichtgarantiert werden. Wenn Ihr System eine Beibehaltung der Reihenfolge erfordert, wird empfohlen, eineFIFO (First-In-First-Out)-Warteschlange (p. 86) zu verwenden oder in jede Nachricht Informationen fürdie Reihenfolge einzufügen, sodass Sie die Nachrichten nach dem Empfang neu anordnen können.

Mindestens einmalige LieferungAmazon SQS speichert aus Gründen der Redundanz und Hochverfügbarkeit Kopien der Nachrichtenauf mehreren Servern. In seltenen Fällen kann es vorkommen, dass einer der Server, auf dem eineNachrichtenkopie gespeichert ist, nicht verfügbar ist, wenn Sie eine Nachricht erhalten oder löschen.

In diesem Fall wird die Kopie der Nachricht auf dem nicht verfügbaren Server nicht gelöscht und Sieerhalten diese Nachrichtenkopie erneut, wenn Sie Nachrichten empfangen. Konzipieren Sie Ihre

83


Amazon Simple Queue Service EntwicklerhandbuchFunktionierendes Java-Beispielfür Standard-Warteschlangen

Anwendungen idempotent (d. h., die mehrmalige Verarbeitung derselben Nachricht darf die Anwendungnicht nachteilig beeinflussen).

Funktionierendes Java-Beispiel für Standard-WarteschlangenErfahren Sie mehr Amazon SQS Standard-Warteschlangenfunktionen mit den angegebenen Maven-Voraussetzungen und Java-Beispielcode.

VoraussetzungenFügen Sie dem Pfad für Ihre Java-Klasse das aws-java-sdk-sqs.jar-Pakete hinzu. Das folgendeBeispiel zeigt diese Abhängigkeit in der pom.xml-Datei eines Maven-Projekts.


SQSSimpleJavaClientExample.javaMit dem folgenden Java-Beispiel-Code wird eine Warteschlange erstellt und eine Nachricht gesendet,empfangen und gelöscht.


import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;

import java.util.List;import java.util.Map.Entry;

/** * This sample demonstrates how to make basic requests to Amazon SQS using the * AWS SDK for Java. * <p> * Prerequisites: You must have a valid Amazon Web Services developer account, * and be signed up to use Amazon SQS. For more information about Amazon SQS, * see https://aws.amazon.com/sqs * <p>

84

Amazon Simple Queue Service EntwicklerhandbuchFunktionierendes Java-Beispielfür Standard-Warteschlangen

* Make sure that your credentials are located in ~/.aws/credentials */public class SQSSimpleJavaClientExample { public static void main(String[] args) { /* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

System.out.println("==============================================="); System.out.println("Getting Started with Amazon SQS Standard Queues"); System.out.println("===============================================\n");

try { // Create a queue. System.out.println("Creating a new SQS queue called MyQueue.\n"); final CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyQueue"); final String myQueueUrl = sqs.createQueue(createQueueRequest) .getQueueUrl();

// List all queues. System.out.println("Listing all queues in your account.\n"); for (final String queueUrl : sqs.listQueues().getQueueUrls()) { System.out.println(" QueueUrl: " + queueUrl); } System.out.println();

// Send a message. System.out.println("Sending a message to MyQueue.\n"); sqs.sendMessage(new SendMessageRequest(myQueueUrl, "This is my message text."));

// Receive messages. System.out.println("Receiving messages from MyQueue.\n"); final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl); final List<Message> messages = sqs.receiveMessage(receiveMessageRequest) .getMessages(); for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle()); System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes() .entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry .getKey()); System.out.println(" Value: " + entry .getValue()); } } System.out.println();

// Delete the message. System.out.println("Deleting a message.\n"); final String messageReceiptHandle = messages.get(0).getReceiptHandle(); sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl,

85

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/creating-clients.html

Amazon Simple Queue Service EntwicklerhandbuchFIFO-Warteschlangen

messageReceiptHandle));

// Delete the queue. System.out.println("Deleting the test queue.\n"); sqs.deleteQueue(new DeleteQueueRequest(myQueueUrl)); } catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

Amazon SQS FIFO (First-In-First-Out)-Warteschlangen

FIFO-Warteschlangen haben den Funktionsumfang der Standard-Warteschlange (p. 83).

Weitere Informationen zum Erstellen von FIFO-Warteschlangen mit oder ohne server-side encryption unterVerwendung der AWS Management Console, der AWS SDK for Java (und der CreateQueue-Aktion)oder von AWS CloudFormation finden Sie unter Erstellen einer Amazon SQS-Warteschlange (p. 16) undErstellen einer Amazon SQS-Warteschlange mit SSE (p. 20).

FIFO (First-In-First-Out)-Warteschlangen sollen die Nachrichtenübermittlung zwischen Anwendungenverbessern, wenn die Reihenfolge von Vorgängen und Ereignissen entscheidend ist, oder wenn keineDuplikate zulässig sind, z. B.:

• Sicherstellen, dass vom Benutzer eingegebene Befehle in der richtigen Reihenfolge ausgeführt werden• Anzeigen des richtigen Produktpreises, indem Preisänderungen in der richtigen Reihenfolge gesendet

werden• Verhindern, dass sich ein Student vor dem Erstellen eines Benutzerkontos in einen Kurs einschreibt

Darüber hinaus stellen FIFO-Warteschlangen auch eine garantierte einmalige Verarbeitung bereit, sindjedoch auf eine begrenzte Anzahl an Transaktionen pro Sekunde (TPS) beschränkt.

• Mit Stapelverarbeitung (p. 218) unterstützen FIFO-Warteschlangen standardmäßig bis zu3.000 Nachrichten pro Sekunde (TPS) pro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage). Um eine Kontingenterhöhung anzufordern, übermitteln Sie eine Support-Anforderung.

• Ohne Stapelverarbeitung unterstützen FIFO-Warteschlangen bis zu 300 Nachrichten pro Sekunde undpro API-Aktion (SendMessage, ReceiveMessage oder DeleteMessage).

Note

• Amazon SNS ist zurzeit nicht mit FIFO-Warteschlangen kompatibel.

86



Amazon Simple Queue Service EntwicklerhandbuchNachrichtenreihenfolge

• Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden. Das Suffix wird fürdas 80-Zeichen-Kontingent für den Warteschlangennamen berücksichtigt. Um festzustellen,ob eine Warteschlange eine FIFO (p. 86)-Warteschlange ist, können Sie prüfen, ob derWarteschlangenname mit dem Suffix endet.

Kontingente für FIFO-Warteschlangen finden Sie unter Kontingente im Zusammenhang mitWarteschlangen (p. 148).

Informationen zu bewährten Methoden für die Arbeit mit FIFO-Warteschlangen finden Sie unter ZusätzlicheEmpfehlungen für Amazon SQS FIFO-Warteschlangen (p. 145) und Empfehlungen für Amazon SQSStandard- und FIFO (First-In-First-Out)-Warteschlangen (p. 141).

Weitere Informationen zur Kompatibilität von Clients und Services mit FIFO-Warteschlangen finden Sieunter Kompatibilität (p. 90).

Themen• Nachrichtenreihenfolge (p. 87)• Wichtige Begriffe (p. 87)• FIFO-Bereitstellungslogik (p. 88)• Garantiert einmalige Verarbeitung (p. 89)• Von einer Standard-Warteschlange in eine FIFO-Warteschlange wechseln (p. 89)• Kompatibilität (p. 90)• Funktionierendes Java-Beispiel für FIFO-Warteschlangen (p. 91)

NachrichtenreihenfolgeDie FIFO-Warteschlange ist eine Verbesserung und Ergänzung der Standard-Warteschlange (p. 83).Die wichtigsten Funktionen dieses Warteschlangentyps sind FIFO (First-In-First-Out)Bereitstellung (p. 88) und genau einmalige Verarbeitung (p. 89):

• Die Reihenfolge, in der Nachrichten gesendet und empfangen werden, wird streng beibehalten, und einegesendete Nachricht bleibt verfügbar, bis ein Verbraucher sie verarbeitet und löscht.

• Duplikate werden nicht in die Warteschlange aufgenommen.

Außerdem unterstützen FIFO-Warteschlangen Nachrichtengruppen, die mehrere geordneteNachrichtengruppen innerhalb einer einzigen Warteschlange ermöglichen. Die Zahl derNachrichtengruppen in einer FIFO-Warteschlange ist nicht kontingentiert.

Wichtige BegriffeDie folgenden wichtigen Begriffe vermitteln Ihnen ein besseres Verständnis für die Funktionalität vonFIFO-Warteschlangen. Weitere Informationen hierzu finden Sie unter Amazon Simple Queue Service APIReference.

Nachrichtendeduplizierungs-ID

The Token, das für die Deduplizierung von gesendeten Nachrichten verwendet wird Wenn eineNachricht mit einer bestimmten Nachrichtendeduplizierungs-ID erfolgreich gesendet wurde, werdenalle Nachrichten mit derselben Nachrichtendeduplizierungs-ID erfolgreich akzeptiert, aber nichtwährend des fünfminütigen Deduplizierungsintervalls übermittelt.

87



Amazon Simple Queue Service EntwicklerhandbuchFIFO-Bereitstellungslogik

Note

Die Deduplizierung von Nachrichten wird auf die gesamte Warteschlange angewendet undnicht auf einzelne Nachrichtengruppen.Amazon SQS setzt die Nachverfolgung der Nachrichtendeduplizierungs-ID auch dann fort,nachdem die Nachricht empfangen und gelöscht wurde.

Nachrichtengruppen-ID

Tag, das festlegt, dass eine Nachricht zu einer bestimmten Nachrichtengruppe gehört. Nachrichten,die zur selben Nachrichtengruppe gehören, werden immer einzeln verarbeitet. In Bezug auf dieNachrichtengruppe wird eine strenge Reihenfolge eingehalten (Nachrichten, die zu verschiedenenNachrichtengruppen gehören, können jedoch in anderer Reihenfolge verarbeitet werden).

Empfangsanforderungsversuch-ID

Token, das für die Deduplizierung von ReceiveMessage-Aufrufen verwendet wirdSequenznummer

hohe, nicht aufeinanderfolgende Nummern, die Amazon SQS den einzelnen Nachrichten zuweist

FIFO-BereitstellungslogikDie folgenden Konzepte können Ihnen dabei helfen, das Senden von Nachrichten an und das Empfangenvon Nachrichten von FIFO besser zu verstehen.

Senden von Nachrichten

Wenn nacheinander mehrere Nachrichten mit je einer eindeutigen Nachrichtendeduplizierungs-ID aneine FIFO-Warteschlange gesendet werden, speichert Amazon SQS die Nachrichten und bestätigt dieÜbertragung. Jede Nachricht kann dann in genau der Reihenfolge empfangen und verarbeitet werden,in der sie übertragen wurde.

Nachrichten werden in FIFO-Warteschlangen basierend auf einer Nachrichtengruppen-ID sortiert.Wenn mehrere Hosts (oder verschiedene Threads auf dem gleichen Host) Nachrichten mit derselbenNachrichtengruppen-ID an eine FIFO-Warteschlange senden, speichert Amazon SQS die Nachrichtenin der Reihenfolge, in der sie für die Verarbeitung eingehen. Um sicherzustellen, dass Amazon SQSdie Reihenfolge beim Senden und Empfangen von Nachrichten bewahrt, müssen Sie sicherstellen,dass alle Nachrichten mit einer eindeutigen Nachrichtengruppen-ID gesendet werden.

Die FIFO-Warteschlangenlogik gilt nur pro Nachrichtengruppen-ID. Jede Nachrichtengruppen-IDstellt eine eindeutig geordnete Nachrichtengruppe innerhalb einer Amazon SQS-Warteschlangedar. Für jede Nachrichtengruppen-ID werden alle Nachrichten in einer strikten Reihenfolgegesendet und empfangen. Nachrichten mit anderen Werten der Nachrichtengruppen-ID werdenjedoch möglicherweise nicht der Reihenfolge nach gesendet und empfangen. Sie müssen dieNachrichtengruppen-ID einer Nachricht zuordnen. Wenn Sie keine Nachrichtengruppen-ID angeben,schlägt die Aktion fehl. Wenn Sie eine einzelne Gruppe von sortierten Nachrichten benötigen, stellenSie dieselbe Nachrichtengruppen-ID für Nachrichten bereit, die an die FIFO-Warteschlange gesendetwerden.

Empfangen von Nachrichten

Sie können keine Anforderung für den Empfang von Nachrichten mit einer bestimmtenNachrichtengruppen-ID senden.

Beim Empfangen von Nachrichten aus einer FIFO-Warteschlange mit mehreren Nachrichtengruppen-IDs versucht Amazon SQS zunächst, so viele Nachrichten mit derselben Nachrichtengruppen-ID wie möglich zurückzugeben. So können andere Konsumenten Nachrichten mit einer anderenNachrichtengruppen-ID verarbeiten.

88

Amazon Simple Queue Service EntwicklerhandbuchGarantiert einmalige Verarbeitung

Note

Mit dem Anforderungsparameter MaxNumberOfMessages der API-Aktion ReceiveMessageist es möglich, bis zu 10 Nachrichten in einem einzelnen Aufruf zu empfangen. DieseNachrichten behalten ihre FIFO-Reihenfolge bei und können dieselbe Nachrichtengruppen-IDbesitzen. Wenn weniger als 10 Nachrichten mit derselben Nachrichtengruppen-ID verfügbarsind, erhalten Sie daher möglicherweise Nachrichten von einer anderen Nachrichtengruppen-ID im gleichen Stapel wie die 10 Nachrichten, aber nach wie vor in FIFO-Reihenfolge.

Mehrere Versuche

FIFO-Warteschlangen ermöglichen dem Produzenten oder Konsumenten mehrereWiederholungsversuche:• Wenn der Produzent eine fehlgeschlagene SendMessage-Aktion erkennt, kann er so oft wie nötig

versuchen, die Nachricht erneut zu senden. Dabei kann er dieselbe Nachrichtendeduplizierungs-ID verwenden. Wenn der Produzent mindestens eine Bestätigung erhält, bevor dasDeduplizierungsintervall abläuft, haben mehrere Wiederholungsversuche keine Auswirkung auf dieReihenfolge der Nachrichten und es werden auch keine Duplikate erzeugt.

• Wenn der Konsument eine fehlgeschlagene ReceiveMessage-Aktion erkennt, kanner so oft wie nötig versuchen, die Nachricht erneut zu senden. Dabei kann er dieselbeEmpfangsanforderungsversuch-ID verwenden. Wenn der Konsument mindestens eineBestätigung erhält, bevor die Zeitbeschränkung für die Sichtbarkeit abläuft, haben mehrereWiederholungsversuche keine Auswirkung auf die Reihenfolge der Nachrichten.

• Wenn Sie eine Nachricht mit einer Nachrichtengruppen-ID erhalten, werde keine weiterenNachrichten derselben Nachrichtengruppen-ID zurückgegeben, außer Sie löschen die Nachrichtoder sie wird sichtbar.

Garantiert einmalige VerarbeitungIm Gegensatz zu Standard-Warteschlangen führen FIFO-Warteschlangen keine Duplikate ein. FIFO-Warteschlangen helfen Ihnen, zu vermeiden, Duplikate an eine Warteschlange zu senden. Wenn Sie dieAktion SendMessage innerhalb des 5-minütigen Deduplizierungsintervalls erneut ausführen, stellt AmazonSQS keine Duplikate in die Warteschlange.

Um die Deduplizierung zu konfigurieren, müssen Sie eine der folgenden Aktionen ausführen:

• Aktivieren Sie inhaltsbasierte Deduplizierung. So wird Amazon SQS angewiesen, einen SHA-256-Hash zum Generieren der Nachrichtendeduplizierungs-ID zu verwenden. Dabei wird der Inhalt derNachricht—, nicht jedoch die Attribute der Nachricht verwendet. Weitere Informationen finden Sie in derDokumentation zu den Aktionen CreateQueue, GetQueueAttributes und SetQueueAttributesim Amazon Simple Queue Service API Reference.

• Stellen Sie die Nachrichtendeduplizierungs-ID für die Nachricht explizit bereit (oder rufen Sie dieSequenznummer ab). Weitere Informationen finden Sie in der Dokumentation zu den AktionenSendMessage, SendMessageBatch und ReceiveMessage im Amazon Simple Queue Service APIReference.

Von einer Standard-Warteschlange in eine FIFO-Warteschlange wechselnWenn Sie in einer vorhandenen Anwendung bereits Standard-Warteschlangen verwenden und von denSortierfunktionen oder der garantierten einmaligen Verarbeitung von FIFO-Warteschlangen profitierenmöchten, müssen Sie die Warteschlange und Ihre Anwendung korrekt konfigurieren.

89








Amazon Simple Queue Service EntwicklerhandbuchKompatibilität

Note

Sie können eine bestehende Standard-Warteschlange nicht in eine FIFO-Warteschlangeumwandeln. Um Ihre Warteschlange zu verschieben, müssen Sie entweder eine neue FIFO-Warteschlange für Ihre Anwendung erstellen oder Ihre bestehende Standard-Warteschlangelöschen und diese als FIFO-Warteschlange neu erstellen.

Verwenden Sie die folgende Checkliste, um sicherzustellen, dass Ihre Anwendung mit einer FIFO-Warteschlange korrekt funktioniert.

• Mit Stapelverarbeitung (p. 218) unterstützen FIFO-Warteschlangen standardmäßig bis zu3.000 Nachrichten pro Sekunde (TPS) pro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage). Um eine Kontingenterhöhung anzufordern, übermitteln Sie eine Support-Anforderung.Ohne Stapelverarbeitung unterstützen FIFO-Warteschlangen bis zu 300 Nachrichten pro Sekunde undpro API-Aktion (SendMessage, ReceiveMessage oder DeleteMessage).

• FIFO-Warteschlangen unterstützen keine Verzögerung pro Nachricht, sondern nur Verzögerungenpro Warteschlange. Wenn Ihre Anwendung für jede Nachricht denselben Wert für den ParameterDelaySeconds festlegt, müssen Sie die Anwendung anpassen und die Verzögerung pro Nachrichtentfernen und den Parameter DelaySeconds stattdessen für die gesamte Warteschlange konfigurieren.

• Jede an eine FIFO-Warteschlange gesendete Nachricht benötigt eine Nachrichtengruppen-ID. WennSie nur eine sortierte Nachrichtengruppe benötigen, legen Sie dieselbe Nachrichtengruppen-ID für alleNachrichten fest.

• Überprüfen Sie vor dem Senden von Nachrichten an eine FIFO-Warteschlange Folgendes:• Wenn Ihre Anwendung Nachrichten mit identischem Nachrichtentext senden kann, können

Sie die Anwendung dahingehend modifizieren, dass jede gesendete Nachricht eine eindeutigeNachrichtendeduplizierungs-ID erhält.

• Wenn Ihre Anwendung Nachrichten mit eindeutigem Nachrichtentext sendet, können Sie eineinhaltsbasierte Deduplizierung einrichten.

• Sie müssen keine Codeänderungen am Konsumenten vornehmen. Wenn die Verarbeitung vonNachrichten jedoch viel Zeit in Anspruch nimmt und Sie einen hohen Wert für die Zeitbeschränkungfür die Sichtbarkeit konfiguriert haben, sollten Sie zu jeder ReceiveMessage-Aktion eineEmpfangsanforderungsversuch-ID hinzufügen. So können Sie im Fall von Netzwerkausfällen erneut eineEmpfangsanforderung senden und verhindern, dass Warteschlangen aufgrund von fehlgeschlagenenEmpfangsversuchen pausiert werden.

Weitere Informationen hierzu finden Sie im Amazon Simple Queue Service API Reference.

KompatibilitätClients

Der Gepufferter asynchroner Client von Amazon SQS unterstützt derzeit keine FIFO-Warteschlangen.Services

Wenn Ihre Anwendung mehrere AWS-Services oder eine Mischung aus externen und AWS-Servicesverwendet, müssen Sie verstehen, welche Servicefunktionen FIFO-Warteschlangen nicht unterstützen.

Einige AWS oder externe Services, die Benachrichtigungen an Amazon SQS senden, sind eventuellnicht mit FIFO-Warteschlangen kompatibel, obwohl Sie eine FIFO-Warteschlange als Ziel festlegenkönnen.

Die folgenden Funktionen von AWS-Services sind derzeit nicht mit FIFO-Warteschlangen kompatibel:• Amazon S3-Ereignisbenachrichtigungen• Auto Scaling-Lebenszyklus-Hooks• AWS IoT-Regelaktionen

90



https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html

https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html

https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html

Amazon Simple Queue Service EntwicklerhandbuchFunktionierendes Java-Beispiel für FIFO-Warteschlangen

• AWS Lambda-Warteschlangen für unzustellbare Nachrichten

Weitere Informationen zur Kompatibilität anderer Services mit FIFO-Warteschlangen finden Sie in derServicedokumentation.

Funktionierendes Java-Beispiel für FIFO-WarteschlangenErfahren Sie mehr Amazon SQS FIFO-Warteschlangenfunktionen mit den angegebenen Maven-Voraussetzungen und Java-Beispielcode.

VoraussetzungenFügen Sie dem Pfad für Ihre Java-Klasse das aws-java-sdk-sqs.jar-Pakete hinzu. Das folgendeBeispiel zeigt diese Abhängigkeit in der pom.xml-Datei eines Maven-Projekts.


SQSFIFOJavaClientExample.javaMit dem folgenden Java-Beispiel-Code wird eine Warteschlange erstellt und eine Nachricht gesendet,empfangen und gelöscht.


import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;

import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Map.Entry;

public class SQSFIFOJavaClientExample { public static void main(String[] args) {

91

https://docs.aws.amazon.com/lambda/latest/dg/dlq.html

Amazon Simple Queue Service EntwicklerhandbuchFunktionierendes Java-Beispiel für FIFO-Warteschlangen


System.out.println("==========================================="); System.out.println("Getting Started with Amazon SQS FIFO Queues"); System.out.println("===========================================\n");

try {

// Create a FIFO queue. System.out.println("Creating a new Amazon SQS FIFO queue called " + "MyFifoQueue.fifo.\n"); final Map<String, String> attributes = new HashMap<>();

// A FIFO queue must have the FifoQueue attribute set to true. attributes.put("FifoQueue", "true");

/* * If the user doesn't provide a MessageDeduplicationId, generate a * MessageDeduplicationId based on the content. */ attributes.put("ContentBasedDeduplication", "true");

// The FIFO queue name must end with the .fifo suffix. final CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyFifoQueue.fifo") .withAttributes(attributes); final String myQueueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();

// List all queues. System.out.println("Listing all queues in your account.\n"); for (final String queueUrl : sqs.listQueues().getQueueUrls()) { System.out.println(" QueueUrl: " + queueUrl); } System.out.println();

// Send a message. System.out.println("Sending a message to MyFifoQueue.fifo.\n"); final SendMessageRequest sendMessageRequest = new SendMessageRequest(myQueueUrl, "This is my message text.");

/* * When you send messages to a FIFO queue, you must provide a * non-empty MessageGroupId. */ sendMessageRequest.setMessageGroupId("messageGroup1");

// Uncomment the following to provide the MessageDeduplicationId //sendMessageRequest.setMessageDeduplicationId("1"); final SendMessageResult sendMessageResult = sqs .sendMessage(sendMessageRequest); final String sequenceNumber = sendMessageResult.getSequenceNumber(); final String messageId = sendMessageResult.getMessageId(); System.out.println("SendMessage succeed with messageId " + messageId + ", sequence number " + sequenceNumber + "\n");

// Receive messages. System.out.println("Receiving messages from MyFifoQueue.fifo.\n"); final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl);

92

Amazon Simple Queue Service EntwicklerhandbuchWarteschlangen- und Nachrichten-IDs

// Uncomment the following to provide the ReceiveRequestDeduplicationId //receiveMessageRequest.setReceiveRequestAttemptId("1"); final List<Message> messages = sqs.receiveMessage(receiveMessageRequest) .getMessages(); for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle()); System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes() .entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry.getKey()); System.out.println(" Value: " + entry.getValue()); } } System.out.println();

// Delete the message. System.out.println("Deleting the message.\n"); final String messageReceiptHandle = messages.get(0).getReceiptHandle(); sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle));

// Delete the queue. System.out.println("Deleting the queue.\n"); sqs.deleteQueue(new DeleteQueueRequest(myQueueUrl)); } catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

Amazon SQS-Warteschlangen- und -Nachrichten-IDs

In diesem Abschnitt werden die IDs von Standard- und FIFO-Warteschlangen beschrieben. Diese IDshelfen Ihnen beim Suchen und Bearbeiten spezifischer Warteschlangen und Nachrichten.

Themen• IDs für Amazon SQS Standard- und FIFO-Warteschlangen (p. 94)• Zusätzliche Kennungen für Amazon SQS FIFO-Warteschlangen (p. 95)

93

Amazon Simple Queue Service EntwicklerhandbuchIDs für Standard- und FIFO-Warteschlangen

IDs für Amazon SQS Standard- und FIFO-WarteschlangenWeitere Informationen über die folgenden IDs finden Sie im Amazon Simple Queue Service API Reference.

Warteschlangenname und URLWenn Sie eine neue Warteschlange erstellen, müssen Sie einen eindeutigen Warteschlangennamen für IhrAWS-Konto und Ihre Region eingeben. Amazon SQS weist jeder von Ihnen erstellten Warteschlange eineKennung, eine sogenannte Warteschlangen-URL zu, die den Warteschlangennamen und andere AmazonSQS-Komponenten enthält. Wenn Sie eine Aktion für die Warteschlange ausführen möchten, müssen Siederen Warteschlangen-URL angeben.

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden. Das Suffix wird für das80-Zeichen-Kontingent für den Warteschlangennamen berücksichtigt. Um festzustellen, ob eineWarteschlange eine FIFO (p. 86)-Warteschlange ist, können Sie prüfen, ob der Warteschlangennamemit dem Suffix endet.

Nachfolgend finden Sie die Warteschlangen-URL für eine Warteschlange namens MyQueue, die einemBenutzer mit der AWS-Kontonummer 123456789012 gehört:

https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue

Sie können die URL einer Warteschlange programmgesteuert abrufen, indem Sie Ihre Warteschlangenauflisten und die Zeichenfolge analysieren, die der Kontonummer folgt. Weitere Informationen finden Sieunter ListQueues.

Nachrichten-IDJeder Nachricht wird vom System eine Nachrichten-ID zugewiesen, die Amazon SQS in derSendMessage-Antwort zurückgibt. Diese ID dient der Identifizierung von Nachrichten. (Für das Löscheneiner Nachricht benötigen Sie jedoch deren Empfangs-Mitteilung.) Die maximale Länge einer Nachrichten-ID beträgt 100 Zeichen.

Empfangs-MitteilungBeim Empfang einer Nachricht aus einer Warteschlange erhalten Sie jedes Mal eine Empfangs-Mitteilungfür diese Nachricht. Diese Mitteilung ist der Aktion des Nachrichtenempfangs zugeordnet und nichtder Nachricht selbst. Um eine Nachricht zu löschen oder ihre Sichtbarkeit zu ändern, müssen Siedie Empfangs-Mitteilung (und nicht die Nachrichten-ID) angeben. Daher müssen Sie eine Nachrichtimmer zunächst empfangen, bevor Sie sie löschen können. Es ist nicht möglich, eine Nachricht in dieWarteschlange zu setzen und dann zurückzurufen. Die maximale Länge einer Empfangs-Mitteilung beträgt1.024 Zeichen.

Important

Wenn Sie eine Nachricht mehrmals empfangen, erhalten Sie jedes Mal eine unterschiedlicheEmpfangs-Mitteilung. Wenn Sie die Nachricht löschen möchten, müssen Sie die zuletztempfangene Empfangs-Mitteilung angeben, da die Nachricht sonst möglicherweise nicht gelöschtwird.

Es folgt ein Beispiel für eine Empfangs-Mitteilung (unterteilt in drei Zeilen).

MbZj6wDWli+JvwwJaBV+3dcjk2YW2vA3+STFFljTM8tJJg6HRG6PYSasuWXPJB+CwLj1FjgXUv1uSj1gUPAWV66FU/WeR4mq2OKpEGYWbnLmpRCJVAyeMjeU5ZBdtcQ+QEauMZc8ZRv37sIW2iJKq3M9MFx1YvV11A2x/KSbkJ0=

94


https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html


Amazon Simple Queue Service EntwicklerhandbuchZusätzliche Kennungen für FIFO-Warteschlangen

Zusätzliche Kennungen für Amazon SQS FIFO-WarteschlangenWeitere Informationen über die folgenden IDs finden Sie unter Garantiert einmalige Verarbeitung (p. 89)und im Amazon Simple Queue Service API Reference.

Nachrichtendeduplizierungs-IDThe Token, das für die Deduplizierung von gesendeten Nachrichten verwendet wird Wenn eine Nachrichtmit einer bestimmten Nachrichtendeduplizierungs-ID erfolgreich gesendet wurde, werden alle Nachrichtenmit derselben Nachrichtendeduplizierungs-ID erfolgreich akzeptiert, aber nicht während des fünfminütigenDeduplizierungsintervalls übermittelt.

Nachrichtengruppen-IDTag, das festlegt, dass eine Nachricht zu einer bestimmten Nachrichtengruppe gehört. Nachrichten, die zurselben Nachrichtengruppe gehören, werden immer einzeln verarbeitet. In Bezug auf die Nachrichtengruppewird eine strenge Reihenfolge eingehalten (Nachrichten, die zu verschiedenen Nachrichtengruppengehören, können jedoch in anderer Reihenfolge verarbeitet werden).

Sequenznummerhohe, nicht aufeinanderfolgende Nummern, die Amazon SQS den einzelnen Nachrichten zuweist

NachrichtenmetadatenSie können Nachrichtenattribute verwenden, um benutzerdefinierte Metadaten an Amazon SQS-Nachrichten für Ihre Anwendungen anzufügen. Sie können Nachrichtensystemattribute verwenden, umMetadaten für andere AWS-Services wie AWS X-Ray zu speichern.

Themen• Amazon SQS-Nachrichtenattribute (p. 95)• Amazon SQS-Nachrichtensystemattribute (p. 98)

Amazon SQS-NachrichtenattributeAmazon SQS ermöglicht Ihnen Berücksichtigen Sie strukturierte Metadaten (z. B. Zeitstempel, Geodaten,Signaturen oder IDs) bei Nachrichten mit Nachrichtenattributen.. Jede Nachricht kann bis zu 10 Attributeaufweisen. Nachrichtenattribute sind optional und separat vom Nachrichtentext (werden aber mitdiesem versendet). Ihr Konsument kann Nachrichtenattribute für die Verarbeitung einer Nachricht aufeine bestimmte Weise verwenden, ohne erst den Nachrichtentext verarbeiten zu müssen. WeitereInformationen über das Senden von Nachrichten mit Attributen mithilfe der AWS Management Consoleoder AWS SDK for Java finden Sie unter Senden einer Nachricht mit Attributen an eine Amazon SQS-Warteschlange (p. 34).

Note

Verwechseln Sie Nachrichtenattribute nicht mit Nachrichtensystemattributen: Während SieNachrichtenattribute verwenden können, um Amazon SQS-Nachrichten benutzerdefinierteMetadaten für Ihre Anwendungen anzufügen, können Sie Nachrichtensystemattribute (p. 98)verwenden, um Metadaten für andere AWS-Services wie AWS X-Ray zu speichern.

95


Amazon Simple Queue Service EntwicklerhandbuchNachrichtenattribute

Themen• Nachrichtenattributkomponenten (p. 96)• Datentypen für das Nachrichtenattribut (p. 96)• Berechnung des MD5-Nachrichtendigests für Nachrichtenattribute (p. 97)

NachrichtenattributkomponentenImportant

Alle Komponenten eines Nachrichtenattributs sind in der Größenbeschränkung der Nachricht von256 KB enthalten.Name, Type, Value und der Nachrichtentext dürfen nicht leer oder null sein.

Jedes Nachrichtenattribut besteht aus den folgenden Komponenten:

• Name –– Der Name des Nachrichtenattributs kann folgende Zeichen enthalten: A–Z, a–z, 0–9,Unterstrich (_), Bindestrich (-) und Punkt (.). Beachten Sie die folgenden Einschränkungen:• Kann bis zu 256 Zeichen lang sein.• Darf nicht mit AWS. oder Amazon. (oder beliebige Varianten in Groß-/Kleinschreibung) beginnen• Berücksichtigt Groß- und Kleinschreibung• Muss unter allen Attributnamen für die Nachricht eindeutig sein• Darf nicht mit einem Punkt beginnen oder enden• Darf keine Punkte in einer Sequenz enthalten

• Typ – der Datentyp des Nachrichtenattributs. Unterstützte Typen sind u. a.: String, Number undBinary. Sie können auch benutzerdefinierte Informationen für alle Datentypen hinzufügen. Der Datentypweist dieselben Einschränkungen wie der Nachrichtentext auf (weitere Informationen finden Sie unterSendMessage im Amazon Simple Queue Service API Reference). Darüber hinaus gelten die folgendenEinschränkungen:• Kann bis zu 256 Zeichen lang sein.• Berücksichtigt Groß- und Kleinschreibung

• Wert – der Wert des Nachrichtenattributs. Für den Datentyp String unterliegen die Attributwertedenselben Beschränkungen wie der Nachrichtentext.

Datentypen für das NachrichtenattributÜber den Datentyp des Nachrichtenattributs wird Amazon SQS angewiesen, wie die entsprechendenNachrichtenattributwerte verarbeitet werden. Beispiel: Wenn der Typ Number ist, überprüft Amazon SQSnumerische Werte.

Amazon SQS unterstützt die logischen Datentypen String, Number und Binary, mit optionalenbenutzerdefinierten Datentypenbezeichnungen im Format .custom-data-type.

• Zeichenfolge – String Attribute können Unicode-Text unter Verwendung beliebiger gültiger XML-Zeichen speichern.

• Number– Number-Attribute können positive oder negative numerische Werte speichern. Zahlen könnenbis zu 38 Ziffern und Werte von 10^-128 bis 10^+126 umfassen.

Note

Amazon SQS entfernt voranstehende und nachgestellte Nullen.• Binary – Mit den Binary-Attributen können Sie alle binären Daten speichern, wie etwa komprimierte oder

verschlüsselte Daten und Bilder.

96


Amazon Simple Queue Service EntwicklerhandbuchNachrichtenattribute

• Custom – Hängen Sie eine benutzerdefinierte Typenbezeichnung an jeden unterstützten Datentyp an,um einen benutzerdefinierten Datentyp zu erstellen. Beispiel:• Number.byte, Number.short, Number.int und Number.float können beim Unterscheiden

zwischen den Zahlentypen helfen.• Binary.gif und Binary.png können beim Unterscheiden zwischen den Dateitypen helfen.

Note

Amazon SQS interpretiert, validiert und verwendet die angefügten Daten nicht.Die benutzerdefinierte Typenbezeichnung unterliegt denselben Beschränkungen wie derNachrichtentext.

Berechnung des MD5-Nachrichtendigests für NachrichtenattributeWenn Sie AWS SDK for Java verwenden, können Sie diesen Abschnitt überspringen. DieMessageMD5ChecksumHandler-Klasse von SDK für Java unterstützt MD5-Nachrichtendigest für AmazonSQS-Nachrichtenattribute.

Wenn Sie die Abfrage-API oder eines der AWS-SDKs verwenden, die keine MD5-Nachrichtendigests fürAmazon SQS-Nachrichtenattribute verwenden, müssen Sie die folgenden Richtlinien verwenden, um dieMD5-Nachrichtendigest-Berechnung durchzuführen.

Note

Berücksichtigen Sie bei der Berechnung des MD5 Fügen Sie immer benutzerdefinierteDatentypsuffixe in die MD5-Nachrichtendigest immer die Suffixe der benutzerdefiniertenDatentypen.

ÜbersichtIm Folgenden finden Sie eine Übersicht über den MD5-Nachrichtendigest-Berechnungsalgorithmus:

1. Er sortiert alle Nachrichtenattribute in aufsteigender Reihenfolge nach ihrem Namen.2. Er verschlüsselt die einzelnen Teile der Attribute (Name, Type und Value) im Puffer.3. Er berechnet den Nachrichtendigest des gesamten Puffers.

In der folgenden Abbildung ist die Verschlüsselung des MD5-Nachrichtendigests für ein einzelnesNachrichtenattribut dargestellt:

97

Amazon Simple Queue Service EntwicklerhandbuchNachrichtensystemattribute

So wird ein einzelnes Amazon SQS-Nachrichtenattribut verschlüsselt

1. Verschlüsselung des Namens: Länge (4 Bytes) und UTF-8-Bytes des Namens.2. Verschlüsselung des Datentyps: Länge (4 Bytes) und UTF-8-Bytes des Datentyps.3. Verschlüsselung des Übertragungstyps (String oder Binary) des Werts (1 Byte).

Note

Für die logischen Datentypen String und Number wird der Übertragungstyp Stringverwendet.Für den logischen Datentyp Binary wird der Übertragungstyp Binary verwendet.

a. Verwenden Sie für den Transporttyp String die Verschlüsselung 1.b. Verwenden Sie für den Transporttyp Binary die Verschlüsselung 2.

4. Verschlüsselung des Attributwerts

a. Verschlüsselung des Attributwerts für den Übertragungstyp String: Länge(4 Bytes) und UTF-8 Bytes des Werts.

b. Verschlüsselung des Attributwerts für den Übertragungstyp Binary: Länge (4 Bytes) undRohbytes des Werts.

Amazon SQS-NachrichtensystemattributeWährend Sie Nachrichtenattribute (p. 95) verwenden können, um Amazon SQS-Nachrichtenbenutzerdefinierte Metadaten für Ihre Anwendungen anzufügen, können Sie Nachrichtensystemattributeverwenden, um Metadaten für andere AWS-Services wie AWS X-Ray zu speichern. Weitere Informationenfinden Sie beim MessageSystemAttribute-Anforderungsparameter der API-Aktionen SendMessageund SendMessageBatch, beim AWSTraceHeader-Attribut der ReceiveMessage-API-Aktion und beimMessageSystemAttributeValue-Datentyp imAmazon Simple Queue Service API Reference.

Nachrichtensystemattribute sind genau wie Nachrichtenattribute strukturiert, mit folgenden Ausnahmen:

• Derzeit wird AWSTraceHeader als einziges Nachrichtensystemattribut unterstützt. Es muss vom TypString sein und der Wert muss eine korrekt formatierte AWS X-Ray-Ablaufverfolgungs-Header-Zeichenfolge sein.

• Die Größe eines Nachrichtensystemattributs zählt nicht zur Gesamtgröße einer Nachricht.

Für die Verarbeitung von Amazon SQS-Nachrichtenerforderliche Ressourcen

Zur Einschätzung der für die Verarbeitung der Nachrichten in der Warteschlange benötigten Ressourcenkann Amazon SQS die ungefähre Anzahl an verzögerten, sichtbaren und nicht sichtbaren Nachrichten ineiner Warteschlange bestimmen. Weitere Informationen zur Sichtbarkeit finden Sie unter Amazon SQSZeitbeschränkung für die Sichtbarkeit (p. 106).

Note

Bei Standard-Warteschlangen ist das Ergebnis aufgrund der verteilten Architektur von AmazonSQS ein ungefährer Wert. In den meisten Fällen sollte der Wert etwa der tatsächlichen Anzahl derNachrichten in der Warteschlange entsprechen.Bei FIFO-Warteschlangen ist das Ergebnis ein exakter Wert.

Die folgende Tabelle enthält die Attributnamen, die mit der GetQueueAttributes-Aktion verwendetwerden.

98




https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_MessageSystemAttributeValue.html


Amazon Simple Queue Service EntwicklerhandbuchKostenzuordnungs-Tags

Aufgabe Attributname

Abrufen der ungefähren Anzahl der Nachrichten,die von der Warteschlange abgerufen werdenkönnen.

ApproximateNumberOfMessages

Abrufen der ungefähren Anzahl der Nachrichtenin der Warteschlange, die verzögert und zumLesen nicht sofort verfügbar sind. Dies kannvorkommen, wenn die Warteschlange alsVerzögerungswarteschlange konfiguriert ist odereine Mitteilung mit einem Verzögerungsparametergesendet worden ist.

ApproximateNumberOfMessagesDelayed

Abrufen der ungefähren Anzahl der in Übertragungbefindlichen Mitteilungen. Die Mitteilungenbefinden sich in Übertragung, wenn sie aneinen Client gesendet, aber noch nicht gelöschtworden sind oder noch nicht das Ende ihresSichtbarkeitsfensters erreicht haben.

ApproximateNumberOfMessagesNotVisible

Amazon SQS Kostenzuordnungs-TagsZum Strukturieren und Identifizieren Ihrer Amazon SQS-Warteschlangen für die Kostenzuordnungkönnen Sie Metadaten-Tags hinzufügen, die den Zweck, den Eigentümer oder die Umgebung einerWarteschlange identifizieren. —Dies ist vor allem nützlich, wenn Sie sehr viele Warteschlangen haben.Weitere Informationen zum Verwalten von Amazon SQS-Warteschlangen-Tags unter Verwendung derAWS Management Console oder dem AWS SDK for Java (und der Aktionen TagQueue, UntagQueue undListQueueTags) finden Sie im Hinzufügen, Aktualisieren und Entfernen von Tags für eine Amazon SQS-Warteschlange (p. 28)-Tutorial.

Sie können Kostenzuordnungs-Tags zum Organisieren Ihrer AWS-Kontorechnung verwenden, um Ihreeigene Kostenstruktur darzustellen. Dazu müssen Sie sich registrieren, um Ihre AWS-Kontorechnung mitTag-Schlüsselwerten zu erhalten. Weitere Informationen finden Sie unter Einrichten Ihres monatlichenKostenzuordnungsberichts im Benutzerhandbuch für AWS Billing and Cost Management.

Jedes Tag besteht aus einem Schlüssel-Wert-Paar, das Sie definieren. Beispielsweise können Sie aufeinfache Weise Ihre Produktions- und Test- Warteschlangen identifizieren, wenn Sie Ihre Warteschlangenwie folgt kennzeichnen:

Warteschlange Schlüssel Wert

MyQueueA QueueType Production

MyQueueB QueueType Testing

Note

Beachten Sie bei der Verwendung von Warteschlangen-Tags die folgenden Richtlinien:

• Wir raten davon ab, einer Warteschlange mehr als 50 Tags hinzuzufügen.• Tags haben keine semantische Bedeutung. Amazon SQS interpretiert Tags als Zeichenfolgen.• Tags unterscheiden zwischen Groß- und Kleinschreibung.

99

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_TagQueue.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_UntagQueue.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueueTags.html

https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/configurecostallocreport.html#allocation-report

https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/configurecostallocreport.html#allocation-report

Amazon Simple Queue Service EntwicklerhandbuchKurz- und Langabfragen

• Ein neues Tag, dessen Schlüssel mit dem Schlüssel eines vorhandenen Tags identisch ist,überschreibt das vorhandene Tag.

• Tagging-Aktionen sind auf 5 TPS pro AWS-Konto begrenzt. Wenn die Anwendung einenhöheren Durchsatz benötigt, übermitteln Sie eine Anforderung.

Eine vollständige Liste der Tag-Einschränkungen finden Sie unter Kontingente im Zusammenhangmit Warteschlangen (p. 148).

Sie können keine Tags zu einer neuen Warteschlange hinzufügen, wenn Sie diese mit der AWSManagement Console erstellen (Sie können Tags hinzufügen, nachdem die Warteschlange erstelltwurde). Sie können jedoch jederzeit mithilfe der Amazon SQS-Aktionen Warteschlangen-Tags hinzufügen,aktualisieren oder entfernen.

Amazon SQS-Kurz- und -LangabfragenDas Verfahren zum Verarbeiten von Nachrichten aus einer Warteschlange hängt davon ab, ob Sie Kurz-oder Langabfragen verwenden. Standardmäßig verwendet Amazon SQS Kurzabfragen und sendet(anhand einer gewichteten zufälligen Verteilung) Abfragen an einen Teil seiner Server, um zu bestimmen,ob neue Nachrichten für eine Antwort verfügbar sind.

Themen• Abrufen von Nachrichten durch Kurzabfragen (p. 100)• Verarbeiten von Nachrichten mithilfe von Langabfragen (p. 101)• Unterschiede zwischen Lang- und Kurzabfragen (p. 101)

Abrufen von Nachrichten durch KurzabfragenWenn Sie mithilfe von kurzem Abrufen Nachrichten aus einer Warteschlange abrufen, nimmt AmazonSQS (anhand einer gewichteten zufälligen Verteilung) eine Stichprobe von mehreren Servernund gibt Nachrichten ausschließlich von diesen Servern zurück. Daher werden für eine bestimmteReceiveMessage-Anforderung möglicherweise nicht alle Nachrichten zurückgegeben. Wenn Sie jedochweniger als 1000 Nachrichten in Ihrer Warteschlange haben, gibt die nächste Anfrage Ihre Nachrichtenzurück. Wenn Sie das Abrufen aus Ihren Warteschlangen fortsetzen, nimmt Amazon SQS Stichproben allerseiner Server und Sie erhalten alle Ihre Nachrichten.

Die folgende Abbildung zeigt das kurze Abrufverhalten von Nachrichten, die von einer Standard-Warteschlange zurückgegeben werden, nachdem eine Ihrer Systemkomponenten eineEmpfangsanforderung stellt. Amazon SQS nimmt Stichproben von mehreren seiner Server (graudargestellt) und gibt die Nachrichten A, C, D und B von diesen Servern zurück. Nachricht E wird nicht fürdiese Anforderung zurückgegeben, sondern für eine nachfolgende Anforderung.

100



Amazon Simple Queue Service EntwicklerhandbuchVerarbeiten von Nachrichten mithilfe von Langabfragen

Verarbeiten von Nachrichten mithilfe vonLangabfragenWenn die Wartezeit für die API-Aktion ReceiveMessage größer als 0 ist, ist die Langabfrage aktiviert.Mithilfe von Langabfragen können Sie die Kosten für die Verwendung von Amazon SQS reduzieren,indem Sie die Anzahl der leeren Antworten (wenn bei einer ReceiveMessage-Anfrage keine Nachrichtenvorhanden sind) und fälschlicherweise leeren Antworten (wenn Nachrichten vorhanden sind, diese abernicht in einer Antwort enthalten sind) eliminieren.Weitere Informationen zur Aktivierung von Langabfragenfür eine neue oder vorhandene Warteschlange mit der AWS Management Console oder dem AWS SDKfor Java (und den Aktionen CreateQueue, SetQueueAttributes und ReceiveMessage) finden Sie imKonfigurieren einer Langabfrage für eine Amazon SQS-Warteschlange (p. 66)-Tutorial. Bewährte Methodenfinden Sie unter Langabfragen einrichten (p. 142).

Die Langabfrage bietet die folgenden Vorteile:

• Eliminieren leerer Antworten, da Amazon SQS wartet, bis eine Nachricht in der Warteschlangevorhanden ist, bevor eine Antwort gesendet wird. Sofern die Verbindung nicht abläuft, enthält die Antwortauf die ReceiveMessage-Anfrage mindestens eine der verfügbaren Nachrichten bis zur in der AktionReceiveMessage definierten maximalen Anzahl an Nachrichten.

• Eliminieren falscher leerer Antworten durch Abfragen aller —-Server (statt nur eines Teils der —AmazonSQS-Server).

Note

Sie können überprüfen, dass eine Warteschlange leer ist, wenn Sie eine langeAbfrage ausführen und die Metriken ApproximateNumberOfMessagesDelayed,ApproximateNumberOfMessagesNotVisible undApproximateNumberOfMessagesVisible mindestens 1 Minute, nachdem die Produzentenaufhören, Nachrichten zu senden, gleich 0 sind (wenn die Metadaten der Warteschlangeschließlich konsistent werden). Weitere Informationen finden Sie unter Verfügbare CloudWatch-Metriken für Amazon SQS (p. 201).

• Zurückgeben von Nachrichten, sobald sie verfügbar werden.

Unterschiede zwischen Lang- und KurzabfragenKurzabfragen werden ausgeführt, wenn der Parameter WaitTimeSeconds einer ReceiveMessage-Anfrage mit einer der beiden folgenden Methoden auf den Wert 0 festgelegt wurde:

101






Amazon Simple Queue Service EntwicklerhandbuchWarteschlange für unzustellbare Nachrichten

• Der ReceiveMessage-Aufruf legt WaitTimeSeconds auf 0 fest.• Der ReceiveMessage-Aufruf legt WaitTimeSeconds nicht fest, aber das WarteschlangenattributReceiveMessageWaitTimeSeconds ist auf 0 festgelegt.

Amazon SQSWarteschlange für unzustellbareNachrichten

Amazon SQS unterstützt Warteschlangen für unzustellbare Nachrichten, die andere Warteschlangen(Quellwarteschlangen) für Nachrichten verwenden können, die nicht erfolgreich verarbeitet (verbraucht)werden können. Warteschlangen für unzustellbare Nachrichten sind praktisch für das Debugging IhrerAnwendung oder Ihres Messaging-Systems, weil sie Ihnen ermöglichen, problematische Nachrichtenzu isolieren, um festzustellen, warum die Verarbeitung nicht abgeschlossen werden kann. WeitereInformationen zum Erstellen einer Warteschlange und Konfigurieren einer Warteschlange für unzustellbareNachrichten über die AWS Management Console oder das AWS SDK for Java (und die AktionenCreateQueue, SetQueueAttributes und GetQueueAttributes) finden Sie unter Konfigurieren einerAmazon SQS-Warteschlange für unzustellbare Nachrichten (p. 69).

Important

Wenn Sie eine Warteschlange als Quellwarteschlange bestimmen, wird nicht automatischeine Warteschlange für unzustellbare Nachrichten erstellt. Sie müssen zuerst eine normaleStandard- oder FIFO-Warteschlange erstellen, bevor Sie sie als Warteschlange für unzustellbareNachrichten bestimmen.

Themen• Funktionsweise von Warteschlangen für unzustellbare Nachrichten (p. 102)• Welche Vorteile bieten Warteschlangen für unzustellbare Nachrichten? (p. 103)• Wie lassen sich die Fehlerarten beim Verarbeiten von Nachrichten unterscheiden? (p. 104)• Wann sollte ich eine Warteschlange für unzustellbare Nachrichten verwenden? (p. 104)• Fehlerbehebung für Warteschlangen für unzustellbare Nachrichten (p. 105)

Funktionsweise von Warteschlangen für unzustellbareNachrichtenEs kann vorkommen, dass Nachrichten aus den unterschiedlichsten Gründen, wie z. B. fehlerhafteBedingungen bei der Produzenten- oder Konsumentenanwendung oder eine unerwarteteZustandsänderung, die zu einem Problem mit Ihrem Anwendungscode führt, nicht verarbeitet werdenkönnen. Beispiel: Wenn ein Benutzer eine Webbestellung mit einer bestimmten Produkt-ID aufgibt, dieProdukt-ID aber gelöscht wurde, schlägt der Code des Web-Store fehl und zeigt eine Fehlermeldungan. Die Nachricht mit der Bestellanforderung wird an eine Warteschlange für unzustellbare Nachrichtengesendet.

Es kann vorkommen, dass Produzenten und Konsumenten Aspekte des zur Kommunikation verwendetenProtokolls nicht interpretieren können, wodurch die Nachricht beschädigt werden oder verloren gehen kann.Auch Hardwarefehler beim Konsumenten können zur Beschädigung einer Nachrichtennutzlast führen.

In der Redrive-Richtlinie werden die Quell-Warteschlange, die Warteschlange für unzustellbare Nachrichtensowie die Bedingungen festgelegt, unter denen Amazon SQS Nachrichten von der ersteren in die letztereWarteschlange verschiebt, wenn der Konsument der Quell-Warteschlange eine Nachricht während

102





Amazon Simple Queue Service EntwicklerhandbuchWelche Vorteile bieten Warteschlangen

für unzustellbare Nachrichten?

einer festen Anzahl an Versuchen nicht verarbeiten kann. Wenn ReceiveCount für eine NachrichtmaxReceiveCount für eine Warteschlange überschreitet, verschiebt Amazon SQS die Nachricht (mitder ursprünglichen Mitteilungs-ID) in eine Warteschlange für unzustellbaren Nachrichten. Wenn in derRedrive-Richtlinie der Quell-Warteschlange beispielsweise für maxReceiveCount 5 festgelegt ist und derKonsument der Quell-Warteschlange eine Nachricht sechsmal empfängt, ohne sie zu verarbeiten und zulöschen, verschiebt Amazon SQS die Nachricht in die Warteschlange für unzustellbare Nachrichten.

Um eine Warteschlange für unzustellbare Nachrichten festzulegen, können Sie die AWS ManagementConsole oder die AWS SDK for Java (p. 69) verwenden. Dies ist für jede Warteschlange erforderlich,die Nachrichten an eine Warteschlange für unzustellbare Nachrichten sendet. Eine Warteschlange fürunzustellbare Nachrichten kann von mehreren Warteschlangen verwendet werden. Weitere Informationenfinden Sie unter Konfigurieren einer Amazon SQS-Warteschlange für unzustellbare Nachrichten (p. 69) unddem RedrivePolicy-Attribut der Aktion CreateQueue oder SetQueueAttributes.

Important

Die Warteschlange für unzustellbare Nachrichten einer FIFO-Warteschlange muss auch eineFIFO-Warteschlange sein. Ebenso muss die Warteschlange für unzustellbare Nachrichten einerStandard-Warteschlange auch eine Standard-Warteschlange sein.Für das Erstellen der Warteschlange für unzustellbare Nachrichten und die anderenWarteschlangen, die Nachrichten an diese Warteschlange senden, muss dasselbe AWS-Kontoverwendet werden. Warteschlangen für unzustellbare Nachrichten müssen sich außerdem inderselben Region befinden wie andere Warteschlangen, die die Warteschlange für unzustellbareNachrichten verwenden. Wenn Sie z. B. eine Warteschlange in der Region USA Ost (Ohio)erstellen und mit dieser Warteschlange eine Warteschlange für unzustellbare Nachrichtenverwenden möchten, muss sich auch die zweite Warteschlange in der Region USA Ost (Ohio)befinden.Nachrichten laufen immer abhängig vom ursprünglichen Warteschlangenzeitstempel ab. Wenneine Nachricht in eine Warteschlange für unzustellbare Nachrichten (p. 102) verschoben wird,bleibt der Warteschlangenzeitstempel unverändert. Beispiel: Wenn eine Nachricht einen Tag langin der ursprünglichen Warteschlange verbleibt, dann in eine Warteschlange für unzustellbareNachrichten verschoben wird und der Aufbewahrungszeitraum für diese Warteschlange vier Tagebeträgt, wird die Nachricht nach drei Tagen aus der Warteschlange für unzustellbare Nachrichtengelöscht. Daher sollte der Aufbewahrungszeitraum einer Warteschlange für unzustellbareNachrichten immer länger sein als der Aufbewahrungszeitraum der ursprünglichen Warteschlange.

Welche Vorteile bieten Warteschlangen fürunzustellbare Nachrichten?Die Hauptaufgabe einer Warteschlange für unzustellbare Nachrichten besteht im Verarbeiten vonNachrichtenfehlern. Mithilfe einer Warteschlange für unzustellbare Nachrichten können Sie Nachrichten,die nicht korrekt verarbeitet wurden, sammeln und isolieren, um zu bestimmen, warum die Verarbeitungfehlgeschlagen ist. Durch das Einrichten einer Warteschlange für unzustellbare Nachrichten haben Siezudem folgende Möglichkeiten:

• Konfigurieren eines Alarms für Nachrichten, die an die Warteschlange für unzustellbare Nachrichtengesendet werden

• Prüfung der Protokolle auf Ausnahmen, die dazu geführt haben, dass Nachrichten an eineWarteschlange für unzustellbare Nachrichten gesendet wurden

• Analysieren des Inhalts der an die Warteschlange für unzustellbare Nachrichten gesendetenNachrichten, um Probleme mit der Software oder mit der Hardware des Produzenten oder desKonsumenten zu diagnostizieren

• Bestimmen, ob der Konsument ausreichend Zeit zum Verarbeiten der Nachrichten hatte

103

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html#API_CreateQueue_RequestParameters

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html#API_SetQueueAttributes_RequestParameters

Amazon Simple Queue Service EntwicklerhandbuchWie lassen sich die Fehlerarten beim

Verarbeiten von Nachrichten unterscheiden?

Wie lassen sich die Fehlerarten beim Verarbeiten vonNachrichten unterscheiden?Standard-WarteschlangenStandard-Warteschlangen (p. 83) verarbeiten Nachrichten so lange, bis der Aufbewahrungszeitraumabgelaufen ist. So wird sichergestellt, dass Nachrichten immer weiter verarbeitet werden und dieWarteschlange nicht durch Nachrichten blockiert wird, die nicht verarbeitet werden können. Außerdem wirdsichergestellt, dass die Warteschlange schnell wiederhergestellt wird.

In einem System, in dem tausende Nachrichten verarbeitet werden, kann eine hohe Anzahl an Nachrichten,die vom Konsumenten wiederholt nicht bestätigt und gelöscht werden, zu höheren Kosten und einerhöheren Auslastung der Hardware führen. Statt bis zum Ablaufen einer Nachricht zu versuchen,diese zu verarbeiten, ist es sinnvoller, sie nach einer bestimmten Anzahl von fehlgeschlagenenVerarbeitungsversuchen in eine Warteschlange für unzustellbare Nachrichten zu verschieben.

Note

In Standard-Warteschlangen kann sich eine große Anzahl von Nachrichten in der Übertragungbefinden. Wenn ein Großteil dieser Nachrichten nicht verarbeitet werden kann und nicht an eineWarteschlange für unzustellbare Nachrichten gesendet wird, kann die Verarbeitungsrate fürgültige Nachrichten sinken. Um die Effizienz der Warteschlange zu erhalten, müssen Sie dahersicherstellen, dass Ihre Anwendung die Nachrichtenverarbeitung korrekt durchführt.

FIFO-WarteschlangenFIFO-Warteschlangen (p. 86) stellen sicher, dass Nachrichten genau einmal verarbeitet werden,indem diese nacheinander einer Nachrichtengruppe entnommen werden. Obwohl der Konsument alsoweiterhin Nachrichten aus einer anderen Nachrichtengruppe der Reihe nach abrufen kann, ist die ersteNachrichtengruppe solange nicht verfügbar, bis die Nachricht, die die Warteschlange blockiert, erfolgreichverarbeitet wurde.

Note

In FIFO-Warteschlangen kann sich nur eine geringere Anzahl von Nachrichten in der Übertragungbefinden. Um daher sicherzustellen, dass Ihre FIFO-Warteschlange nicht von einer Nachrichtblockiert wird, müssen Sie sicherstellen, dass Ihre Anwendung Nachrichten korrekt verarbeitet.

Wann sollte ich eine Warteschlange für unzustellbareNachrichten verwenden?

Verwenden Sie Warteschlangen für unzustellbare Nachrichten in Verbindung mit Standard-Warteschlangen. Sie sollten Warteschlangen für unzustellbare Nachrichten immer dann einsetzen, wennfür Ihre Anwendungen die Reihenfolge der Nachrichtenverarbeitung keine Rolle spielt. Verwenden SieWarteschlangen für unzustellbare Nachrichten, um Fehler bei der inkorrekten Übertragung von Nachrichtenzu beheben.

Note

Auch bei der Verwendung von Warteschlangen für unzustellbare Nachrichten sollten Sie IhreWarteschlangen überwachen und Nachrichten erneut senden, deren Übertragung aufgrund vonvorübergehenden Ursachen fehlgeschlagen ist.

104

Amazon Simple Queue Service EntwicklerhandbuchFehlerbehebung für Warteschlangen


Verwenden Sie Warteschlangen für unzustellbare Nachrichten, um die Anzahl der Nachrichten zureduzieren und das Risiko von Poison-Pill-Nachrichten zu senken, also Nachrichten, die Empfangen, abernicht verarbeitet werden können.

Verwenden Sie Warteschlangen für unzustellbare Nachrichten nicht in Verbindung mit Standard-Warteschlangen, wenn Sie fehlgeschlagene Nachrichten unbegrenzt oft erneut senden möchten.Verwenden Sie beispielsweise keine Warteschlange für unzustellbare Nachrichten, wenn Ihre Anwendungauf einen abhängigen Prozess warten muss, um aktiv bzw. verfügbar zu werden.

Verwenden Sie keine Warteschlangen für unzustellbare Nachrichten in Verbindung mit FIFO-Warteschlangen, wenn Sie die Reihenfolge von Nachrichten oder Vorgängen nicht unterbrechen möchten.Verwenden Sie eine Warteschlange für unzustellbare Nachrichten beispielsweise nicht zusammen mitAnweisungen in einer Bearbeitungsentscheidungsliste (Edit Decision List, EDL) für eine Videobearbeitungs-Suite, wo sich Änderungen an der Reihenfolge von vorgenommenen Änderungen auf den Inhalt vonFolgeänderungen auswirken können.

Fehlerbehebung für Warteschlangen für unzustellbareNachrichtenEs kann vorkommen, dass sich Amazon SQS-Warteschlangen für unzustellbare Nachrichtenunvorhergesehen verhalten. In diesem Abschnitt erhalten Sie einen Überblick über häufige Probleme undderen Lösungen.

Durch das Anzeigen von Nachrichten mithilfe der AWSManagement Console können Nachrichten in eine Warteschlangefür unzustellbare Nachrichten verschoben werdenAmazon SQS zählt das Anzeigen einer Nachricht in der AWS Management Console im Rahmen derzugehörigen Redrive-Richtlinie der Warteschlange. Wenn Sie eine Nachricht daher entsprechend oft der inder Redrive-Richtlinie der Warteschlange definierten Anzahl in der AWS Management Console anzeigen,wird die Nachricht in die entsprechende Warteschlange für unzustellbare Nachrichten der Warteschlangeverschoben.

Führen Sie einen der folgenden Schritte aus, um dieses Verhalten anzupassen:

• Erhöhen Sie die Einstellung Maximum Receives für die Redrive-Richtlinie der entsprechendenWarteschlange.

• Rufen Sie Nachrichten der betroffenen Warteschlange nicht in der AWS Management Console auf.

Die Werte für NumberOfMessagesSent undNumberOfMessagesReceived für eine Warteschlange fürunzustellbare Nachrichten stimmen nicht übereinWenn Sie eine Nachricht manuell an eine Warteschlange für unzustellbare Nachrichten senden, wirdsie in der Metrik NumberOfMessagesSent erfasst. Wenn eine Nachricht jedoch aufgrund einesfehlgeschlagenen Verarbeitungsversuchs an eine Warteschlange für unzustellbare Nachrichten gesendet

105

Amazon Simple Queue Service EntwicklerhandbuchZeitbeschränkung für die Sichtbarkeit

wird, wird sie von dieser Metrik nicht erfasst. Daher können die Werte von NumberOfMessagesSent undNumberOfMessagesReceived voneinander abweichen.

Amazon SQS Zeitbeschränkung für die SichtbarkeitWenn ein Konsument eine Nachricht aus einer Warteschlange empfängt und verarbeitet, verbleibt dieseNachricht in der Warteschlange. Amazon SQS löscht die Nachricht nicht automatisch. Da es sich beiAmazon SQS um ein verteiltes System handelt, gibt es keine Garantie dafür, dass der Konsument dieNachricht tatsächlich erhält (z. B. aufgrund eines Konnektivitätsproblems oder aufgrund eines Problemsin der Konsumentenanwendung). Daher muss der Konsument die Nachricht nach dem Empfang und derVerarbeitung aus der Warteschlange löschen.

Die Nachricht verbleibt direkt nach dem Empfang in der Warteschlange. Um zu verhindern, dassandere Konsumenten die Nachricht erneut verarbeiten, legt Amazon SQS eine Zeitbeschränkung fürdie Sichtbarkeit fest, also einen Zeitraum, in dem Amazon SQS verhindert, dass andere Consumerdie Nachricht empfangen und verarbeiten können. Die Standardzeitbeschränkung für die Sichtbarkeiteiner Nachricht beträgt 30 Sekunden. Das Minimum beträgt 0 Sekunden. Der Höchstwert beträgt 12Stunden. Weitere Informationen über die Konfiguration der Zeitbeschränkung für die Sichtbarkeit füreine Warteschlange mit der AWS Management Console und für eine oder mehrere Nachrichten unterVerwendung des AWS SDK for Java (und der Aktionen SetQueueAttributes, GetQueueAttributes,ReceiveMessage, ChangeMessageVisibility und ChangeMessageVisibilityBatch) finden Sieunter Konfigurieren der Zeitbeschränkung für die Sichtbarkeit für eine Amazon SQS-Warteschlange (p. 73).

Note

Für StandardStandard-Warteschlangen kann auch durch die Zeitbeschränkung für die Sichtbarkeitnicht garantiert werden, dass eine Nachricht mehrmals empfangen wird. Weitere Informationenfinden Sie unter Mindestens einmalige Lieferung (p. 83).FIFO-Warteschlangen ermöglichen dem Produzenten oder Konsumenten mehrereWiederholungsversuche:

• Wenn der Produzent eine fehlgeschlagene SendMessage-Aktion erkennt, kann erso oft wie nötig versuchen, die Nachricht erneut zu senden. Dabei kann er dieselbeNachrichtendeduplizierungs-ID verwenden. Wenn der Produzent mindestens eine Bestätigungerhält, bevor das Deduplizierungsintervall abläuft, haben mehrere Wiederholungsversuche keineAuswirkung auf die Reihenfolge der Nachrichten und es werden auch keine Duplikate erzeugt.

• Wenn der Konsument eine fehlgeschlagene ReceiveMessage-Aktion erkennt, kanner so oft wie nötig versuchen, die Nachricht erneut zu senden. Dabei kann er dieselbeEmpfangsanforderungsversuch-ID verwenden. Wenn der Konsument mindestens eineBestätigung erhält, bevor die Zeitbeschränkung für die Sichtbarkeit abläuft, haben mehrereWiederholungsversuche keine Auswirkung auf die Reihenfolge der Nachrichten.

106




https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html

Amazon Simple Queue Service EntwicklerhandbuchIn Übertragung befindliche Nachrichten

• Wenn Sie eine Nachricht mit einer Nachrichtengruppen-ID erhalten, werde keine weiterenNachrichten derselben Nachrichtengruppen-ID zurückgegeben, außer Sie löschen die Nachrichtoder sie wird sichtbar.

Themen• In Übertragung befindliche Nachrichten (p. 107)• Einrichten der Zeitbeschränkung für die Sichtbarkeit (p. 107)• Ändern der Zeitbeschränkung für die Sichtbarkeit für eine Nachricht (p. 108)• Beenden der Zeitbeschränkung für die Sichtbarkeit für eine Nachricht (p. 108)

In Übertragung befindliche NachrichtenEine Amazon SQS-Nachricht hat drei grundlegende Status:

1. Von einem Produzenten an eine Warteschlange gesendet.2. Aus der Warteschlange von einem Konsumenten entgegengenommen.3. Aus der Warteschlange gelöscht.

Eine Nachricht wird als gespeichert betrachtet, wenn sie von einem Produzenten an eine Warteschlangegesendet, aber noch nicht von einem Konsumenten aus der Warteschlange empfangen. ist (d. h. zwischenden Status 1 und 2). Die Anzahl der gespeicherten Nachrichten ist nicht kontingentiert. Eine Nachrichtbefindet sich in Übertragung, wenn sie von einem Konsumenten aus einer Warteschlange empfangen, abernoch nicht aus der Warteschlange gelöscht. ist (d. h. sie befindet sich zwischen den Status 2 und 3). DieAnzahl der Nachrichten in Übertragung ist kontingentiert.

Important

Quotas that apply to inflight messages are unrelated to the unlimited number of stored messages.

Für die meisten Standard-Warteschlangen (je nach Warteschlangendatenverkehr undNachrichtenrückstand) können höchstens etwa 120.000 Inflight-Nachrichten (von einem Konsumentenaus einer Warteschlange empfangen, aber noch nicht aus der Warteschlange gelöscht.) enthalten sein.Wenn Sie dieses Kontingent erreichen, gibt Amazon SQS die Fehlermeldung OverLimit zurück. Um zuvermeiden, dass dieses Kontingent erreicht wird, sollten Sie Nachrichten aus der Warteschlange löschen,nachdem sie verarbeitet wurden. Sie können auch die Anzahl der Warteschlangen erhöhen, die Sie zurVerarbeitung Ihrer Nachrichten verwenden. Um eine Kontingenterhöhung anzufordern, übermitteln Sie eineSupport-Anforderung.

Für FIFO-Warteschlangen sind maximal 20 000 in Übertragung befindliche Nachrichten zulässig (voneinem Konsumenten aus einer Warteschlange empfangen, aber noch nicht aus der Warteschlangegelöscht.). Wenn Sie dieses Kontingent erreichen, gibt Amazon SQS keine Fehlermeldungen zurück.

Einrichten der Zeitbeschränkung für die SichtbarkeitDie Zeitbeschränkung für die Sichtbarkeit beginnt, sobald Amazon SQS eine Nachricht zurückgibt.Innerhalb dieser Zeit verarbeitet und löscht der Konsument die Nachricht. Wenn jedoch der Konsumentausfällt, bevor er die Nachricht löscht, und Ihr System nicht vor Ablauf der Zeitbeschränkung für dieSichtbarkeit die Aktion DeleteMessage für diese Nachricht aufruft, wird die Nachricht für andereKonsumenten wieder sichtbar und die Nachricht wird erneut empfangen. Wenn eine Nachricht nur einmalempfangen werden darf, muss Ihr Konsument sie innerhalb der Zeitbeschränkung für die Sichtbarkeitlöschen.

Für jede Amazon SQS-Warteschlange sind 30 Sekunden als Standardwert für die Zeitbeschränkung fürdie Sichtbarkeit vorgegeben. Sie können diese Einstellung für die gesamte Warteschlange ändern. In

107



https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html

Amazon Simple Queue Service EntwicklerhandbuchÄndern der Zeitbeschränkung fürdie Sichtbarkeit für eine Nachricht

der Regel sollten Sie für die Zeitbeschränkung für die Sichtbarkeit die maximale Zeitdauer festlegen, wielange Ihre Anwendung benötigt, eine Nachricht aus der Warteschlange zu verarbeiten und zu löschen. Siekönnen beim Empfangen von Nachrichten auch eine spezifische Zeitbeschränkung für die Sichtbarkeit fürdie zurückgegebenen Nachrichten festlegen, ohne die Zeitbeschränkungen der Warteschlange zu ändern.Weitere Informationen finden Sie unter den bewährten Methoden im Abschnitt Zeitnahe Verarbeitung vonNachrichten (p. 141).

Wenn Sie nicht wissen, wie lange es dauert, eine Nachricht zu verarbeiten, erstellen Sie einen heartbeatfür Ihren Verbraucherprozess: Geben Sie die anfängliche Zeitbeschränkung für die Sichtbarkeit an (z.B. 2 Minuten) und dann — solange Ihr Verbraucher noch an der Nachricht arbeitet — verlängern Sie dieZeitbeschränkung für die Sichtbarkeit jede Minute um 2 Minuten.

Ändern der Zeitbeschränkung für die Sichtbarkeit füreine NachrichtWenn Sie eine Nachricht aus einer Warteschlange empfangen und mit der Verarbeitung beginnen, kannes vorkommen, dass die Zeitbeschränkung für die Sichtbarkeit für die Warteschlange nicht ausreicht (z. B.für das Verarbeiten und Löschen einer Nachricht). Sie können die Sichtbarkeit einer Nachricht verkürzenoder verlängern. Geben Sie dazu mit der Aktion ChangeMessageVisibility einen neuen Wert für dieZeitbeschränkung ein.

Beispiel: Die Standardzeitbeschränkung für eine Warteschleife beträgt 60 Sekunden. Seit dem Empfangder Nachricht sind bereits 15 Sekunden vergangen und Sie senden einen ChangeMessageVisibility-Aufruf mit dem Attribut VisibilityTimeout auf 10 Sekunden. Diese 10 Sekunden werden ab demZeitpunkt des ChangeMessageVisibility-Aufrufs heruntergezählt. Daher führt jeder Versuch, innerhalbvon 10 Sekunden nach der Änderung der Zeitbeschränkung für die Sichtbarkeit (insgesamt 25 Sekunden)die Nachricht zu löschen, zu einem Fehler.

Note

Der neue Zeitbeschränkungszeitraum beginnt ab dem Aufruf der AktionChangeMessageVisibility. Darüber hinaus wird der neue Zeitbeschränkungszeitraum nur aufdiesen Empfang der Nachricht angewendet. ChangeMessageVisibility wirkt sich nicht auf dieZeitbeschränkung für einen späteren Empfang der Nachricht oder spätere Warteschlangen aus.

Beenden der Zeitbeschränkung für die Sichtbarkeit füreine NachrichtWenn Sie eine Nachricht aus einer Warteschlange empfangen, stellen Sie möglicherweise fest, dassSie diese Nachricht nicht verarbeiten und löschen möchten. Amazon SQS ermöglicht das Beenden derZeitbeschränkung für die Sichtbarkeit für eine bestimmte Nachricht. Dadurch wird die Nachricht sofortwieder für andere Komponenten im System sichtbar und kann verarbeitet werden.

Um die Zeitbeschränkung für die Sichtbarkeit einer Nachricht nach dem Aufrufen von ReceiveMessagezu beenden, rufen Sie ChangeMessageVisibility mit dem Attribut VisibilityTimeout auf, das auf0 Sekunden festgelegt ist.

Amazon SQS-VerzögerungswarteschlangenMithilfe von Verzögerungswarteschlangen können Sie die Bereitstellung von neuen Nachrichtenfür eine Warteschlange um eine bestimmte Anzahl an Sekunden verzögern. Wenn Sie eineVerzögerungswarteschlange erstellen, bleiben alle an diese Warteschlange gesendeten Nachrichtenfür die Dauer des Verzögerungszeitraums für Konsumenten unsichtbar. Die standardmäßige (minimale)Verzögerung für eine Warteschlange beträgt 0 Sekunden. Die maximale Größe ist 15 Minuten. Weitere

108



Amazon Simple Queue Service EntwicklerhandbuchTemporäre Warteschlangen

Informationen zum Konfigurieren von Verzögerungswarteschlangen mithilfe der AWS ManagementConsole oder des AWS SDK for Java (und der Aktion SetQueueAttributes) finden Sie unterKonfigurieren einer Amazon SQS-Verzögerungswarteschlange (p. 77).

Note

Für Standard-Warteschlangen ist die Einstellung für die Verzögerung pro Warteschlange nichtretroaktiv — wenn Sie die Einstellung ändern, wirkt sich das nicht auf die Verzögerung vonNachrichten aus, die sich bereits in der Warteschlange befinden.Für FIFO-Warteschlangen ist die Einstellung für die Verzögerung pro Warteschlange retroaktiv —wenn Sie die Einstellung ändern, wirkt sich das auf die Verzögerung von Nachrichten aus, die sichbereits in der Warteschlange befinden.

Verzögerungswarteschlangen funktionieren vergleichbar mit Zeitbeschränkungen für dieSichtbarkeit (p. 106), da durch beide Funktionen Nachrichten eine bestimmte Zeit lang fürKonsumenten nicht verfügbar gemacht werden. Der Unterschied zwischen beidem besteht darin,dass in Verzögerungswarteschlangen die Nachricht direkt nach dem Hinzufügen zur Warteschlangeverborgen wird, bei Zeitbeschränkungen für die Sichtbarkeit hingegen erst, nachdem die Nachricht ausder Warteschlange abgerufen wurde. Das folgende Diagramm verdeutlicht die Beziehung zwischenVerzögerungswarteschlangen und Zeitbeschränkungen für die Sichtbarkeit.

Um Verzögerungssekunden für einzelne Nachrichten (p. 113) statt für eine ganze Warteschlangefestzulegen, verwenden Sie Amazon SQSNachrichten-TimerDelaySeconds, sodass DelaySeconds den-Wert des Nachrichten-Timers statt des -Werts der Verzögerungswarteschlange verwenden kann.

Temporäre Warteschlangen in Amazon SQSTemporäre Warteschlangen helfen Ihnen, Entwicklungszeit und Entwicklungskosten einzusparen, wennSie gängige Nachrichtenmuster, wie z. B. request-response, verwenden. Sie können mit dem Clienttemporärer Warteschlangen kosteneffektivere, anwendungsverwaltete, temporäre Warteschlangen mithohem Durchsatz erstellen.

Der Client ordnet mehrere temporäre Warteschlangen—anwendungsverwaltete Warteschlangen, diebei Bedarf für einen bestimmten Prozess erstellt werden,— automatisch einer einzigen Amazon SQS-Warteschlange zu. Auf diese Weise kann Ihre Anwendung weniger API-Aufrufe durchführen und einenhöheren Durchsatz verzeichnen, wenn der Datenverkehr zu jeder temporären Warteschlange geringist. Wenn eine temporäre Warteschlange nicht mehr verwendet wird, bereinigt der Client die temporäreWarteschlange automatisch. Dies gilt auch dann, wenn einige Prozesse, die den Client nutzen, nichtordnungsgemäß heruntergefahren werden.

Im Folgenden werden die Vorteile von temporären Warteschlangen beschrieben:

• Sie dienen als einfache Kommunikationskanäle für bestimmte Threads oder Prozesse.• Sie können erstellt und gelöscht werden, ohne dass zusätzliche Kosten anfallen.

109


https://github.com/awslabs/amazon-sqs-java-temporary-queues-client


Amazon Simple Queue Service EntwicklerhandbuchVirtuelle Warteschlangen

• Sie sind API-kompatibel mit statischen (normalen) Amazon SQS-Warteschlangen. Dies bedeutet, dassvorhandener Code, mit dem Nachrichten gesendet und empfangen werden, Nachrichten an virtuelleWarteschlangen senden und von ihnen empfangen kann.

Topics

• Virtuelle Warteschlangen (p. 110)• Request-Response-Messaging-Muster (virtuelle Warteschlangen) (p. 111)• Beispielszenario: Verarbeiten einer Anmeldeanforderung (p. 111)

• Clientseitig (p. 111)• Serverseitig (p. 112)

• Bereinigen von Warteschlangen (p. 113)

Virtuelle WarteschlangenVirtuelle Warteschlangen sind lokale Datenstrukturen, die vom Client temporärer Warteschlangen erstelltwerden. Mit virtuellen Warteschlangen können Sie mehrere Ziele mit geringem Datenverkehr in einereinzigen Amazon SQS-Warteschlange zusammenfassen.

Note

Beim Erstellen einer virtuellen Warteschlange werden nur temporäre Datenstrukturen erstellten, indenen Konsumenten Nachrichten empfangen können. Da eine virtuelle Warteschlange keine API-Aufrufe an Amazon SQS sendet, entstehen für virtuelle Warteschlangen keine Kosten.

Die AmazonSQSVirtualQueuesClient-Wrapper-Klasse wurde um neue Unterstützung für Attributeim Zusammenhang mit virtuellen Warteschlangen erweitert. Um eine virtuelle Warteschlange erstellenzu können, müssen Sie die CreateQueue-API-Aktion mit dem Attribut HostQueueURL aufrufen. DiesesAttribut gibt die vorhandene Warteschlange an, in der die virtuellen Warteschlangen gehostet werden.

Die URL einer virtuellen Warteschlange hat das folgende Format.

https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue#MyVirtualQueueName

Wenn ein Produzent die API-Aktion SendMessage oder SendMessageBatch für die URL einer virtuellenWarteschlange aufruft, verfährt der Client temporärer Warteschlangen wie folgt:

1. Er extrahiert den Namen der virtuellen Warteschlange.2. Er fügt den Namen der virtuellen Warteschlange als zusätzliches Nachrichtenattribut an.3. Er sendet die Nachricht an die Host-Warteschlange.

Während der Produzent Nachrichten sendet, fragt ein Hintergrund-Thread die Host-Warteschlange abund sendet die empfangenen Nachrichten gemäß den entsprechenden Nachrichtenattributen an virtuelleWarteschlangen.

Während der Konsument die ReceiveMessage-API-Aktion für die URL einer virtuellen Warteschlangeaufruft, blockiert der Client temporärer Warteschlangen den Aufruf lokal, bis der Hintergrund-Thread eineNachricht in die virtuelle Warteschlange sendet. (Dieser Vorgang ist mit dem Vorabrufen von Nachrichtenim gepufferten asynchronen Client (p. 219) vergleichbar: eine einzelne API-Aktion kann für bis zu10 virtuelle Warteschlangen Nachrichten bereitstellen.) Wenn eine virtuelle Warteschlange gelöscht wird,werden alle clientseitigen Ressourcen entfernt, ohne Amazon SQS selbst aufzurufen.

Die AmazonSQSTemporaryQueuesClient-Klasse wandelt alle von ihr erstellten Warteschlangenautomatisch in temporäre Warteschlangen um. Sie erstellt außerdem Host-Warteschlangen mit

110

Amazon Simple Queue Service EntwicklerhandbuchRequest-Response-Messaging-Muster (virtuelle Warteschlangen)

denselben Warteschlangenattributen automatisch nach Bedarf. Den Namen dieser Warteschlangen istein konfigurierbares Präfix (standardmäßig __RequesterClientQueues__) gemeinsam, durch das sieals temporäre Warteschlangen identifiziert werden. Auf diese Weise kann der Client als Drop-In-Ersatzfungieren, durch den vorhandener Code optimiert wird, mit dem Warteschlangen erstellt und gelöschtwerden. Der Client umfasst auch die AmazonSQSRequester- und AmazonSQSResponder-Schnittstellen,die eine bidirektionale Kommunikation zwischen Warteschlangen ermöglichen.

Request-Response-Messaging-Muster (virtuelleWarteschlangen)Der häufigste Anwendungsfall für temporäre Warteschlangen ist das request-response-Messaging-Muster,bei dem ein Anforderer eine temporäre Warteschlange für den Empfang der einzelnen Antwortnachrichtenerstellt. Um zu vermeiden, dass für jede Antwortnachricht eine Amazon SQS-Warteschlange erstellt wird,können Sie mit dem Client temporärer Warteschlangen mehrere temporäre Warteschlangen ohne AmazonSQS-API-Aufrufe erstellen. Weitere Informationen finden Sie unter Implementieren von Request-Response-Systemen (p. 143).

Das folgende Diagramm zeigt eine geläufige Konfiguration mit diesem Muster.

Beispielszenario: Verarbeiten einerAnmeldeanforderungDas folgende Beispielszenario veranschaulicht, wie die AmazonSQSRequester- undAmazonSQSResponder-Schnittstellen zur Verarbeitung der Anmeldeanforderung eines Benutzersverwendet werden.

Clientseitigpublic class LoginClient {

111

Amazon Simple Queue Service EntwicklerhandbuchBeispielszenario: Verarbeiten einer Anmeldeanforderung

// Specify the Amazon SQS queue to which to send requests. private final String requestQueueUrl;

// Use the AmazonSQSRequester interface to create // a temporary queue for each response. private final AmazonSQSRequester sqsRequester = AmazonSQSRequesterClientBuilder.defaultClient();

private final LoginClient(String requestQueueUrl) { this.requestQueueUrl = requestQueueUrl; }

// Send a login request. public String login(String body) throws TimeoutException { SendMessageRequest request = new SendMessageRequest() .withMessageBody(body) .withQueueUrl(requestQueueUrl);

// If no response is received, in 20 seconds, // trigger the TimeoutException. Message reply = sqsRequester.sendMessageAndGetResponse(request, 20, TimeUnit.SECONDS);

return reply.getBody(); }}

Das Senden einer Anmeldeanforderung bewirkt Folgendes:

1. Erstellt eine temporäre Warteschlange.2. Es fügt die URL der temporären Warteschlange als Attribut an die Nachricht an.3. Es sendet die Nachricht.4. Es empfängt eine Antwort von der temporären Warteschlange.5. Es löscht die temporäre Warteschlange.6. Es gibt die Antwort zurück.

ServerseitigIm folgenden Beispiel wird davon ausgegangen, dass bei der Erstellung ein Thread zur Abfrage derWarteschlange und zum Aufruf der Methode handleLoginRequest() für jede Nachricht erstellt wird.Darüber hinaus handelt es sich bei doLogin() um eine angenommene Methode.

public class LoginServer {

// Specify the Amazon SQS queue to poll for login requests. private final String requestQueueUrl;

// Use the AmazonSQSResponder interface to take care // of sending responses to the correct response destination. private final AmazonSQSResponder sqsResponder = AmazonSQSResponderClientBuilder.defaultClient();

private final AmazonSQS(String requestQueueUrl) { this.requestQueueUrl = requestQueueUrl; }

// Process login requests from the client. public void handleLoginRequest(Message message) {

112

Amazon Simple Queue Service EntwicklerhandbuchBereinigen von Warteschlangen

// Process the login and return a serialized result. String response = doLogin(message.getBody());

// Extract the URL of the temporary queue from the message attribute // and send the response to the temporary queue. sqsResponder.sendResponseMessage(MessageContent.fromMessage(message), new MessageContent(response)); }}

Bereinigen von WarteschlangenUm sicherzustellen, dass Amazon SQS alle von virtuellen Warteschlangen beanspruchten Ressourcenim Arbeitsspeicher freigibt, wenn die Anwendung den Client für temporäre Warteschlangen nicht mehrbenötigt, sollte die Methode shutdown() aufgerufen werden. Sie können auch die Methode shutdown()der die AmazonSQSRequester-Schnittstelle verwenden.

Der Client temporärer Warteschlangen bietet auch eine Option, mit der sich verwaiste Host-Warteschlangen vermeiden lassen. Alle Warteschlangen, die innerhalb eines Zeitraums (standardmäßigfünf Minuten) einen API-Aufruf empfangen, werden vom Client mit der API-Aktion TagQueue als weiterhingenutzte Warteschlangen markiert.

Note

API-Aktionen, die für eine Warteschlange ausgeführt werden, markieren diese als nicht im Leerlaufbefindlich. Dazu gehört auch eine ReceiveMessage-Aktion, die keine Nachrichten zurückgibt.

Der Hintergrund-Thread verwendet die API-Aktionen ListQueues und ListTags, um alle Warteschlangemit dem konfigurierten Präfix zu überprüfen und alle Warteschlangen zu entfernen, die nichtschon mindestens fünf Minuten lang gekennzeichnet sind. Sollte ein Client nicht ordnungsgemäßheruntergefahren werden, können die anderen aktiven Clients ihn auf diese Weise bereinigen. Um einerVerdopplung des Arbeitsaufwands entgegenzuwirken, kommunizieren alle Clients mit demselben Präfixüber eine freigegebene, interne Arbeitswarteschlange, die nach dem Präfix benannt ist, miteinander.

Wenn Sie die AmazonSQSTemporaryQueuesClient-Klasse direkt verwenden, können Sie durchKonfigurieren des Warteschlangenattributs IdleQueueRetentionPeriodSeconds anpassen, wie langesich die Warteschlange im Leerlauf befinden darf, bevor sie von Amazon SQS gelöscht wird. Sowohl Host-Warteschlangen als auch virtuelle Warteschlangen unterstützen dieses Attribut.

Amazon SQS-Nachrichten-TimerMit Nachrichten-Timern können Sie einen Zeitraum festlegen, innerhalb dessen eine der Warteschlangehinzugefügte Nachricht unsichtbar ist. Wenn Sie beispielsweise eine Nachricht mit einem 45-Sekunden-Timer senden, wird die Nachricht die ersten 45 Sekunden in der Warteschlange nicht für Konsumentenangezeigt. Die standardmäßige (minimale) Verzögerung für eine Nachricht beträgt 0 Sekunden.Die maximale Größe ist 15 Minuten. Weitere Informationen über das Senden von Nachrichten mitAttributen mithilfe der AWS Management Console oder des AWS SDK for Java (und der AktionSetQueueAttributes) finden Sie unter Senden einer Nachricht mit einem Timer an eine Amazon SQS-Warteschlange (p. 40).

Note

FIFO-Warteschlangen unterstützen keine Timer für einzelne Nachrichten.

Um einen Verzögerungszeitraum für eine ganze Warteschlange statt nur für einzelne Nachrichtenfestzulegen, verwenden Sie Verzögerungswarteschlangen (p. 108). Der DelaySeconds-Wert für eineAmazon SQS-Verzögerungswarteschlange kann mit einem Nachrichten-Timer für einzelne Nachrichtenüberschrieben werden.

113


Amazon Simple Queue Service EntwicklerhandbuchVerwalten großer Nachrichten

Verwalten von großen Amazon SQS-Nachrichtenmit Amazon S3

Sie können Amazon S3 und Erweiterte Client Library für Java von Amazon SQS verwenden, um AmazonSQS-Nachrichten zu verwalten. Dies ist insbesondere zum Speichern und Abrufen von Nachrichtenmit einer Größe von bis zu 2 GB hilfreich. Wenn es für Ihre Anwendung nicht nötig ist, wiederholtWarteschlangen zu erstellen und inaktiv zu belassen oder große Datenmengen in einer Warteschlange zuspeichern, sollten Sie in Erwägung ziehen, Ihre Daten in Amazon S3 zu speichern.

Sie können die Erweiterte Client Library für Java von Amazon SQS-Bibliothek für Folgendes verwenden:

• Festlegen, ob Nachrichten grundsätzlich oder ab einer Nachrichtengröße über 256 KB in Amazon S3gespeichert werden.

• Senden einer Nachricht, die auf ein einzelnes in einem Amazon S3-Bucket gespeichertesNachrichtenobjekt verweist

• Abrufen des entsprechenden Nachrichtenobjekts aus einem Amazon S3-Bucket• Löschen des entsprechenden Nachrichtenobjekts aus einem Amazon S3-Bucket

Note

Für SDK für Java und Erweiterte Client Library für Java von Amazon SQS ist das J2SEDevelopment Kit 8.0 oder höher erforderlich.Sie können Erweiterte Client Library für Java von Amazon SQS verwenden, um Amazon SQS-Nachrichten mit Amazon S3 zu verwalten. Dies ist jedoch nicht möglich mit der AWS CLI, derAmazon SQS-Konsole, der Amazon SQS HTTP-API oder einem der AWSSDKs— außer SDK fürJava.

Funktionierendes Java-Beispiel für die Verwendungvon Amazon S3 für große Amazon SQS-NachrichtenVoraussetzungenFügen Sie dem Pfad für Ihre Java-Build-Klasse die Pakete amazon-sqs-java-extended-client-lib.jar, aws-java-sdk-sqs.jar und aws-java-sdk-s3.jar hinzu. Das folgende Beispiel zeigtdiese Abhängigkeiten in der pom.xml-Datei eines Maven-Projekts.

<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>amazon-sqs-java-extended-client-lib</artifactId> <version>1.0.1</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-sqs</artifactId> <version>LATEST</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-s3</artifactId> <version>LATEST</version> </dependency></dependencies>

114

https://aws.amazon.com/sdkforjava/

Amazon Simple Queue Service EntwicklerhandbuchFunktionierendes Java-Beispiel fürdie Verwendung von Amazon S3

SQSExtendedClientExample.javaIm folgenden Code-Beispiel wird ein Amazon S3-Bucket mit einem zufälligen Namen erstellt und eineLebenszyklusregel hinzugefügt, die Objekte nach 14 Tagen dauerhaft löscht. Als Nächstes erstellt derCode eine Warteschlange mit dem Namen MyQueue und sendet eine zufällige Nachricht mit mehr als 256KB an die Warteschlange. Die Nachricht wird im Amazon S3-Bucket gespeichert. Schließlich ruft der Codedie Nachricht ab, gibt Informationen über die Nachricht zurück und löscht die Nachricht, die Warteschlangeund den Bucket.


import com.amazon.sqs.javamessaging.AmazonSQSExtendedClient;import com.amazon.sqs.javamessaging.ExtendedClientConfiguration;import com.amazonaws.services.s3.AmazonS3;import com.amazonaws.services.s3.AmazonS3ClientBuilder;import com.amazonaws.services.s3.model.*;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;import org.joda.time.DateTime;import org.joda.time.format.DateTimeFormat;

import java.util.Arrays;import java.util.List;import java.util.UUID;

public class SQSExtendedClientExample {

// Create an Amazon S3 bucket with a random name. private final static String S3_BUCKET_NAME = UUID.randomUUID() + "-" + DateTimeFormat.forPattern("yyMMdd-hhmmss").print(new DateTime());

public static void main(String[] args) {

/* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();

/* * Set the Amazon S3 bucket name, and then set a lifecycle rule on the * bucket to permanently delete objects 14 days after each object's * creation date. */ final BucketLifecycleConfiguration.Rule expirationRule = new BucketLifecycleConfiguration.Rule(); expirationRule.withExpirationInDays(14).withStatus("Enabled"); final BucketLifecycleConfiguration lifecycleConfig =

115


Amazon Simple Queue Service EntwicklerhandbuchFunktionierendes Java-Beispiel fürdie Verwendung von Amazon S3

new BucketLifecycleConfiguration().withRules(expirationRule);

// Create the bucket and allow message objects to be stored in the bucket. s3.createBucket(S3_BUCKET_NAME); s3.setBucketLifecycleConfiguration(S3_BUCKET_NAME, lifecycleConfig); System.out.println("Bucket created and configured.");

/* * Set the Amazon SQS extended client configuration with large payload * support enabled. */ final ExtendedClientConfiguration extendedClientConfig = new ExtendedClientConfiguration() .withLargePayloadSupportEnabled(s3, S3_BUCKET_NAME);

final AmazonSQS sqsExtended = new AmazonSQSExtendedClient(AmazonSQSClientBuilder .defaultClient(), extendedClientConfig);

/* * Create a long string of characters for the message object which will * be stored in the bucket. */ int stringLength = 300000; char[] chars = new char[stringLength]; Arrays.fill(chars, 'x'); final String myLongString = new String(chars);

// Create a message queue for this example. final String QueueName = "MyQueue" + UUID.randomUUID().toString(); final CreateQueueRequest createQueueRequest = new CreateQueueRequest(QueueName); final String myQueueUrl = sqsExtended .createQueue(createQueueRequest).getQueueUrl(); System.out.println("Queue created.");

// Send the message. final SendMessageRequest myMessageRequest = new SendMessageRequest(myQueueUrl, myLongString); sqsExtended.sendMessage(myMessageRequest); System.out.println("Sent the message.");

// Receive the message. final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl); List<Message> messages = sqsExtended .receiveMessage(receiveMessageRequest).getMessages();

// Print information about the message. for (Message message : messages) { System.out.println("\nMessage received."); System.out.println(" ID: " + message.getMessageId()); System.out.println(" Receipt handle: " + message.getReceiptHandle()); System.out.println(" Message body (first 5 characters): " + message.getBody().substring(0, 5)); }

// Delete the message, the queue, and the bucket. final String messageReceiptHandle = messages.get(0).getReceiptHandle(); sqsExtended.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle)); System.out.println("Deleted the message.");

sqsExtended.deleteQueue(new DeleteQueueRequest(myQueueUrl)); System.out.println("Deleted the queue.");

116

Amazon Simple Queue Service EntwicklerhandbuchArbeiten mit JMS

deleteBucketAndAllContents(s3); System.out.println("Deleted the bucket."); }

private static void deleteBucketAndAllContents(AmazonS3 client) {

ObjectListing objectListing = client.listObjects(S3_BUCKET_NAME);

while (true) { for (S3ObjectSummary objectSummary : objectListing .getObjectSummaries()) { client.deleteObject(S3_BUCKET_NAME, objectSummary.getKey()); }

if (objectListing.isTruncated()) { objectListing = client.listNextBatchOfObjects(objectListing); } else { break; } }

final VersionListing list = client.listVersions( new ListVersionsRequest().withBucketName(S3_BUCKET_NAME));

for (S3VersionSummary s : list.getVersionSummaries()) { client.deleteVersion(S3_BUCKET_NAME, s.getKey(), s.getVersionId()); }

client.deleteBucket(S3_BUCKET_NAME); }}

Arbeiten mit JMS und Amazon SQSDas Java Messaging-Bibliothek von Amazon SQS ist eine JMS-Schnittstelle für Amazon SQS, über dieSie Amazon SQS in Anwendungen verwenden können, in denen JMS bereits implementiert ist. Mithilfe derSchnittstelle können Sie mit nur wenigen Codeänderungen Amazon SQS als JMS-Anbieter verwenden. InVerbindung mit der AWS SDK for Java können Sie mithilfe der Amazon SQS Java Messaging Library JMS-Verbindungen und -Sitzungen sowie Produzenten und Konsumenten erstellen, die Nachrichten an und vonAmazon SQS-Warteschlangen senden und empfangen.

Die Bibliothek unterstützt das Senden und Empfangen von Nachrichten an Warteschlangen (das JMS-Punkt-zu-Punkt-Modell) gemäß der JMS 1.1-Spezifikation. Sie unterstützt das synchrone Senden vonText-, Byte- und Objektnachrichten an Amazon SQS-Warteschlangen. Außerdem wird das synchrone undasynchrone Empfangen von Objekten unterstützt.

Weitere Informationen zu Funktionen des Java Messaging-Bibliothek von Amazon SQS, die die JMS 1.1-Spezifikation unterstützen, finden Sie unter Unterstützte JMS 1.1-Implementierungen (p. 139) und imAbschnitt mit den Amazon SQS häufig gestellten Fragen (FAQs).

Themen• -Anforderungen (p. 118)• Erste Schritte mit Java Messaging-Bibliothek von Amazon SQS (p. 118)• Verwenden von Amazon SQS Java Message Service (JMS) Client mit anderen Amazon SQS-

Clients (p. 124)• Funktionierendes Java-Beispiel für die Verwendung von JMS mit Amazon SQS Standard-

Warteschlangen (p. 125)• Unterstützte JMS 1.1-Implementierungen (p. 139)

117

http://docs.oracle.com/javaee/6/api/javax/jms/package-summary.html


Amazon Simple Queue Service Entwicklerhandbuch-Anforderungen

-AnforderungenFolgende Voraussetzungen müssen erfüllt sein, bevor Sie den Vorgang starten:

• SDK für Java

Es gibt zwei Möglichkeiten, SDK für Java in Ihr Projekt einzubinden:• Laden Sie SDK für Java herunter und installieren Sie es.• Verwenden Sie Maven, um Java Messaging-Bibliothek von Amazon SQS zu erhalten.

Note

SDK für Java ist als Abhängigkeit enthalten.Für SDK für Java und Erweiterte Client Library für Java von Amazon SQS ist das J2SEDevelopment Kit 8.0 oder höher erforderlich.

Weitere Informationen zum Herunterladen von SDK für Java finden Sie unter SDK für Java.• Java Messaging-Bibliothek von Amazon SQS

Wenn Sie Maven nicht verwenden, müssen Sie das Paket amazon-sqs-java-messaging-lib.jarzum Java-Erstellungspfad hinzufügen. Weitere Informationen zum Herunterladen der Bibliothek findenSie unter Java Messaging-Bibliothek von Amazon SQS.

Note

Java Messaging-Bibliothek von Amazon SQS bietet Unterstützung für Maven und das SpringFramework.Codebeispiele, die Maven, das Spring Framework und Java Messaging-Bibliothek von AmazonSQS verwenden, finden Sie unter Funktionierendes Java-Beispiel für die Verwendung von JMSmit Amazon SQS Standard-Warteschlangen (p. 125).

<dependency> <groupId>com.amazonaws</groupId> <artifactId>amazon-sqs-java-messaging-lib</artifactId> <version>1.0.4</version> <type>jar</type></dependency>

• Amazon SQSWarteschlange

Erstellen Sie eine Warteschlange mithilfe der AWS Management Console für Amazon SQS, derCreateQueue-API oder des integrierten Amazon SQS-Clients der Amazon SQS Java MessagingLibrary.• Weitere Informationen zum Erstellen einer Warteschlange mit Amazon SQS mithilfe der

AWS Management Console oder der CreateQueue-API finden Sie unter Erstellen einerWarteschlange (p. 16).

• Weitere Informationen zur Verwendung von Java Messaging-Bibliothek von Amazon SQS finden Sieunter Erste Schritte mit Java Messaging-Bibliothek von Amazon SQS (p. 118).

Erste Schritte mit Java Messaging-Bibliothek vonAmazon SQSVerwenden Sie für den Einstieg in JMS mit Amazon SQS die Codebeispiele in diesem Abschnitt. In denfolgenden Abschnitten erfahren Sie, wie Sie eine JMS-Verbindung und eine Sitzung erstellen sowie eineNachricht senden und empfangen.

118



https://github.com/awslabs/amazon-sqs-java-messaging-lib

http://maven.apache.org/

http://projects.spring.io/spring-framework/

http://projects.spring.io/spring-framework/

Amazon Simple Queue Service EntwicklerhandbuchErste Schritte mit Java Messaging-Bibliothek

Das integrierte Amazon SQS-Clientobjekt in Java Messaging-Bibliothek von Amazon SQS prüft, ob eineAmazon SQS-Warteschlange vorhanden ist. Ist dies nicht der Fall, wird sie vom Client erstellt.

Erstellen einer JMS-Verbindung1. Erstellen Sie eine Verbindungs-Factory und rufen Sie die Methode createConnection für die

Factory auf.

// Create a new connection factory with all defaults (credentials and region) set automaticallySQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.defaultClient() ); // Create the connection.SQSConnection connection = connectionFactory.createConnection();

Die Klasse SQSConnection erweitert javax.jms.Connection. In Verbindung mit denJMS-Standardverbindungsmethoden bietet SQSConnection zusätzliche Methoden wiegetAmazonSQSClient und getWrappedAmazonSQSClient. Mit beiden Methoden lassensich administrative Aufgaben wie das Erstellen neuer Warteschlangen ausführen, die in der JMS-Spezifikation nicht enthalten sind. Die Methode getWrappedAmazonSQSClient stellt jedoch aucheine integrierte Version des Amazon SQS-Client bereit, die von der aktuellen Verbindung verwendetwird. Der Wrapper wandelt alle Ausnahmen des Clients in eine JMSException um. So könnendiese von bestehendem Code, in dem Vorkommen von JMSException erwartet werden, einfacherverwendet werden.

2. Sie können die von getAmazonSQSClient und getWrappedAmazonSQSClient zurückgegebenenClientobjekte für administrative Aufgaben verwenden, die in der JMS-Spezifikation nicht enthalten sind(z. B. Erstellen einer neuen Amazon SQS-Warteschlange).

Wenn Ihr bestehender Code JMS-Ausnahmen erwartet, müssen Sie getWrappedAmazonSQSClientverwenden:

• Wenn Sie getWrappedAmazonSQSClient verwenden, wandelt das zurückgegebene Clientobjektalle Ausnahmen in JMS-Ausnahmen um.

• Wenn Sie getAmazonSQSClient verwenden, sind alle Ausnahmen Amazon SQS-Ausnahmen.

Erstellen einer Amazon SQS-WarteschlangeDas integrierte Clientobjekt prüft, ob eine Amazon SQS-Warteschlange vorhanden ist.

Ist dies nicht der Fall, wird sie vom Client erstellt. Ist bereits eine Warteschlange vorhanden, gibt dieFunktion nichts zurück. Weitere Informationen finden Sie im Abschnitt "Create the queue if needed" imBeispiel TextMessageSender.java (p. 127).

Erstellen Sie einer Standard-Warteschlange

// Get the wrapped clientAmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient(); // Create an SQS queue named MyQueue, if it doesn't already existif (!client.queueExists("MyQueue")) { client.createQueue("MyQueue");}

119


Erstellen Sie einer FIFO-Warteschlange

// Get the wrapped clientAmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();

// Create an Amazon SQS FIFO queue named MyQueue.fifo, if it doesn't already existif (!client.queueExists("MyQueue.fifo")) { Map<String, String> attributes = new HashMap<String, String>(); attributes.put("FifoQueue", "true"); attributes.put("ContentBasedDeduplication", "true"); client.createQueue(new CreateQueueRequest().withQueueName("MyQueue.fifo").withAttributes(attributes));}

Note

Der Name einer FIFO-Warteschlange muss mit dem Suffix .fifo enden.Weitere Informationen zum ContentBasedDeduplication-Attribut finden Sie unter Garantierteinmalige Verarbeitung (p. 89).

Synchrones Senden von Nachrichten1. Wenn die Verbindung und die zugrundeliegende Amazon SQS-Warteschlange bereit sind, erstellen

Sie eine nicht transaktionsorientierte JMS-Sitzung mit dem Modus AUTO_ACKNOWLEDGE.

// Create the nontransacted session with AUTO_ACKNOWLEDGE modeSession session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

2. Erstellen Sie zum Senden einer Textnachricht an die Warteschlange eine JMS-Warteschlangenidentität und einen Nachrichtenproduzenten.

// Create a queue identity and specify the queue name to the sessionQueue queue = session.createQueue("MyQueue"); // Create a producer for the 'MyQueue'MessageProducer producer = session.createProducer(queue);

3. Erstellen Sie eine Textnachricht und senden Sie sie an die Warteschlange.

• Um eine Nachricht an eine Standard-Warteschlange zu senden, müssen Sie keine weiterenParameter festlegen.

// Create the text messageTextMessage message = session.createTextMessage("Hello World!"); // Send the messageproducer.send(message);System.out.println("JMS Message " + message.getJMSMessageID());

• Um eine Nachricht an eine FIFO-Warteschlange zu senden, müssen Sie die Nachrichtengruppen-ID festlegen. Darüber hinaus können Sie eine Nachrichtendeduplizierungs-ID festlegen. WeitereInformationen finden Sie unter Wichtige Begriffe (p. 87).

// Create the text messageTextMessage message = session.createTextMessage("Hello World!");

// Set the message group IDmessage.setStringProperty("JMSXGroupID", "Default");

// You can also set a custom message deduplication ID

120


// message.setStringProperty("JMS_SQS_DeduplicationId", "hello");// Here, it's not needed because content-based deduplication is enabled for the queue

// Send the messageproducer.send(message);System.out.println("JMS Message " + message.getJMSMessageID());System.out.println("JMS Message Sequence Number " + message.getStringProperty("JMS_SQS_SequenceNumber"));

Synchrones Empfangen von Nachrichten1. Erstellen Sie zum Empfangen von Nachrichten einen Konsumenten für dieselbe Warteschlange und

rufen Sie die Methode start auf.

Sie können die Methode start für die Verbindung jederzeit aufrufen. Der Konsument beginnt jedocherst mit dem Abrufen von Nachrichten, wenn Sie die Methode aufrufen.

// Create a consumer for the 'MyQueue'MessageConsumer consumer = session.createConsumer(queue);// Start receiving incoming messagesconnection.start();

2. Rufen Sie die Methode receive mit einer Zeitbeschränkung von 1 Sekunde auf dem Konsumentenauf und geben Sie den Inhalt der empfangenen Nachricht aus.

• Nachdem Sie eine Nachricht aus einer Standard-Warteschlange abgerufen haben, können Sie aufden Inhalt der Nachricht zugreifen.

// Receive a message from 'MyQueue' and wait up to 1 secondMessage receivedMessage = consumer.receive(1000); // Cast the received message as TextMessage and display the textif (receivedMessage != null) { System.out.println("Received: " + ((TextMessage) receivedMessage).getText());}

• Nachdem Sie eine Nachricht aus einer FIFO-Warteschlange abgerufen haben, können Sieauf den Inhalt der Nachricht sowie auf andere FIFO-spezifische Nachrichtenattribute wie dieNachrichtengruppen-ID, die Nachrichtendeduplizierungs-ID und die Sequenznummer zugreifen.Weitere Informationen finden Sie unter Wichtige Begriffe (p. 87).

// Receive a message from 'MyQueue' and wait up to 1 secondMessage receivedMessage = consumer.receive(1000);

// Cast the received message as TextMessage and display the textif (receivedMessage != null) { System.out.println("Received: " + ((TextMessage) receivedMessage).getText()); System.out.println("Group id: " + receivedMessage.getStringProperty("JMSXGroupID")); System.out.println("Message deduplication id: " + receivedMessage.getStringProperty("JMS_SQS_DeduplicationId")); System.out.println("Message sequence number: " + receivedMessage.getStringProperty("JMS_SQS_SequenceNumber"));}

3. Schließen Sie die Verbindung und die Sitzung.

// Close the connection (and the session).connection.close();

121


Die Ausgabe sieht folgendermaßen oder ähnlich aus:

JMS Message ID:8example-588b-44e5-bbcf-d816example2Received: Hello World!

Note

Sie können das Spring Framework zum Initialisieren dieser Objekte verwenden.Weitere Informationen finden Sie unter SpringExampleConfiguration.xml,SpringExample.java. Informationen zu den anderen unterstützenden Klassen findenSie unter ExampleConfiguration.java und ExampleCommon.java im AbschnittFunktionierendes Java-Beispiel für die Verwendung von JMS mit Amazon SQS Standard-Warteschlangen (p. 125).

Umfassende Beispiele für das Senden und Empfangen von Objekten finden Sie unterTextMessageSender.java (p. 127) und SyncMessageReceiver.java (p. 128).

Asynchrones Empfangen von NachrichtenIm Beispiel unter Erste Schritte mit Java Messaging-Bibliothek von Amazon SQS (p. 118) wird eineNachricht an MyQueue gesendet und synchron empfangen.

Im folgenden Beispiel wird gezeigt, wie Nachrichten mithilfe eines Listeners asynchron empfangen werdenkönnen.

1. Implementieren Sie die MessageListener-Schnittstelle.

class MyListener implements MessageListener { @Override public void onMessage(Message message) { try { // Cast the received message as TextMessage and print the text to screen. System.out.println("Received: " + ((TextMessage) message).getText()); } catch (JMSException e) { e.printStackTrace(); } }}

Beim Empfang einer Nachricht wird die Methode onMessage der MessageListener-Schnittstelleaufgerufen. In dieser Implementierung des Listeners wird der in der Nachricht gespeicherte Textausgegeben.

2. Statt die Methode receive auf dem Konsumenten explizit aufzurufen, richten Sie den Nachrichten-Listener des Konsumenten auf einer Instance der MyListener-Implementierung ein. Der Haupt-Thread wartet eine Sekunde lang.

// Create a consumer for the 'MyQueue'.MessageConsumer consumer = session.createConsumer(queue); // Instantiate and set the message listener for the consumer.consumer.setMessageListener(new MyListener()); // Start receiving incoming messages.connection.start(); // Wait for 1 second. The listener onMessage() method is invoked when a message is received.Thread.sleep(1000);

122


Die restlichen Schritte sind identisch wie im Beispiel Erste Schritte mit Java Messaging-Bibliothek vonAmazon SQS (p. 118). Ein umfassendes Beispiel für einen asynchronen Konsumenten finden Sie unterAsyncMessageReceiver.java in den Funktionierendes Java-Beispiel für die Verwendung von JMS mitAmazon SQS Standard-Warteschlangen (p. 125).

Die Ausgabe für dieses Beispiel sieht in etwa wie folgt aus:

JMS Message ID:8example-588b-44e5-bbcf-d816example2Received: Hello World!

Verwenden des Client-BestätigungsmodusIn dem Beispiel in Erste Schritte mit Java Messaging-Bibliothek von Amazon SQS (p. 118) wird derAUTO_ACKNOWLEDGE-Modus verwendet, um jede empfangene Nachricht automatisch zu bestätigen (undsomit aus der zugrundeliegenden Amazon SQS-Warteschlange zu löschen).

1. Um die Nachrichten nach der Verarbeitung explizit zu bestätigen, müssen Sie die Sitzung imCLIENT_ACKNOWLEDGE-Modus erstellen.

// Create the non-transacted session with CLIENT_ACKNOWLEDGE mode.Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);

2. Zeigen Sie die Nachricht nach dem Empfangen an und bestätigen Sie sie explizit.

// Cast the received message as TextMessage and print the text to screen. Also acknowledge the message.if (receivedMessage != null) { System.out.println("Received: " + ((TextMessage) receivedMessage).getText()); receivedMessage.acknowledge(); System.out.println("Acknowledged: " + message.getJMSMessageID());}

Note

Wenn eine Nachricht in diesem Modus bestätigt wird, werden alle Nachrichten, die vordieser Nachricht empfangen wurden, ebenfalls implizit bestätigt. Wenn Sie beispielsweise10 Nachrichten empfangen haben und nur die 10. Nachricht bestätigen (in der Reihenfolge,in der die Nachrichten empfangen wurden) werden die vorherigen 9 Nachrichten ebenfallsbestätigt.

Die restlichen Schritte sind identisch wie im Beispiel Erste Schritte mit Java Messaging-Bibliothekvon Amazon SQS (p. 118). Ein umfassendes Beispiel für einen synchronen Konsumenten imClient-Bestätigungsmodus finden Sie unter SyncMessageReceiverClientAcknowledge.javain den Funktionierendes Java-Beispiel für die Verwendung von JMS mit Amazon SQS Standard-Warteschlangen (p. 125).

Die Ausgabe für dieses Beispiel sieht in etwa wie folgt aus:

JMS Message ID:4example-aa0e-403f-b6df-5e02example5Received: Hello World!Acknowledged: ID:4example-aa0e-403f-b6df-5e02example5

Verwenden des ungeordneten BestätigungsmodusWenn Sie den CLIENT_ACKNOWLEDGE-Modus verwenden, werden alle Nachrichten, die vor einer explizitbestätigten Nachricht empfangen wurden, automatisch bestätigt. Weitere Informationen finden Sie unterVerwenden des Client-Bestätigungsmodus (p. 123).

123

Amazon Simple Queue Service EntwicklerhandbuchVerwenden von JMS-Client mitanderen Amazon SQS-Clients

Java Messaging-Bibliothek von Amazon SQS stellt einen weiteren Bestätigungsmodus bereit. Wenn Sieden UNORDERED_ACKNOWLEDGE-Modus verwenden, müssen alle empfangenen Nachrichten unabhängigvon der Empfangsreihenfolge einzeln und explizit vom Client bestätigt werden. Erstellen Sie hierzu eineSitzung im UNORDERED_ACKNOWLEDGE-Modus.

// Create the non-transacted session with UNORDERED_ACKNOWLEDGE mode.Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE);

Die restlichen Schritte sind identisch wie im Beispiel Verwenden des Client-Bestätigungsmodus (p. 123).Ein umfassendes Beispiel für einen synchronen Konsumenten im UNORDERED_ACKNOWLEDGE-Modusfinden Sie unter SyncMessageReceiverUnorderedAcknowledge.java.

In diesem Beispiel sieht die Ausgabe in etwa wie folgt aus:

JMS Message ID:dexample-73ad-4adb-bc6c-4357example7Received: Hello World!Acknowledged: ID:dexample-73ad-4adb-bc6c-4357example7

Verwenden von Amazon SQS Java Message Service(JMS) Client mit anderen Amazon SQS-ClientsDie Verwendung von Amazon SQS Java Message Service (JMS) Client mit dem AWS-SDK begrenzt dieAmazon SQS-Nachrichtengröße auf 256 KB. Sie können jedoch mit einem beliebigen Amazon SQS-Clienteinen JMS-Anbieter erstellen. Verwenden Sie beispielsweise den JMS-Client mit dem Erweiterte ClientLibrary für Java von Amazon SQS, um eine Amazon SQS-Nachricht zu senden, die einen Verweis auf eineNachrichtennutzlast (bis zu 2 GB) in Amazon S3 enthält. Weitere Informationen finden Sie unter Verwaltenvon großen Amazon SQS-Nachrichten mit Amazon S3 (p. 114).

Im folgenden Java-Codebeispiel wird der JMS-Anbieter für den Erweiterte Client Library erstellt:

AmazonS3 s3 = new AmazonS3Client(credentials);Region s3Region = Region.getRegion(Regions.US_WEST_2);s3.setRegion(s3Region); // Set the Amazon S3 bucket name, and set a lifecycle rule on the bucket to// permanently delete objects a certain number of days after each object's creation date.// Next, create the bucket, and enable message objects to be stored in the bucket.BucketLifecycleConfiguration.Rule expirationRule = new BucketLifecycleConfiguration.Rule();expirationRule.withExpirationInDays(14).withStatus("Enabled");BucketLifecycleConfiguration lifecycleConfig = new BucketLifecycleConfiguration().withRules(expirationRule); s3.createBucket(s3BucketName);s3.setBucketLifecycleConfiguration(s3BucketName, lifecycleConfig);System.out.println("Bucket created and configured.");

// Set the SQS extended client configuration with large payload support enabled.ExtendedClientConfiguration extendedClientConfig = new ExtendedClientConfiguration() .withLargePayloadSupportEnabled(s3, s3BucketName); AmazonSQS sqsExtended = new AmazonSQSExtendedClient(new AmazonSQSClient(credentials), extendedClientConfig);Region sqsRegion = Region.getRegion(Regions.US_WEST_2);sqsExtended.setRegion(sqsRegion);

Im folgenden Java-Codebeispiel wird die Verbindungs-Factory erstellt:

// Create the connection factory using the environment variable credential provider.

124

Amazon Simple Queue Service EntwicklerhandbuchFunktionierendes Java-Beispiel für die Verwendung

von JMS mit Amazon SQS Standard-Warteschlangen

// Pass the configured Amazon SQS Extended Client to the JMS connection factory.SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), sqsExtended ); // Create the connection.SQSConnection connection = connectionFactory.createConnection();

Funktionierendes Java-Beispiel für die Verwendungvon JMS mit Amazon SQS Standard-WarteschlangenIn den folgenden Codebeispielen wird demonstriert, wie Sie JMS mit Amazon SQS Standard-Warteschlangen verwenden. Weitere Informationen zur Arbeit mit FIFO-Warteschlangen finden Sie unterErstellen Sie einer FIFO-Warteschlange (p. 120), Synchrones Senden von Nachrichten (p. 120) undSynchrones Empfangen von Nachrichten (p. 121). (Der synchrone Empfang von Nachrichten ist fürStandard- und FIFO-Warteschlangen identisch. Nachrichten in FIFO-Warteschlangen enthalten jedochmehr Attribute.)

ExampleConfiguration.javaIm folgenden Java-Codebeispiel werden der Standardwarteschlangenname, die Region und dieAnmeldeinformationen festgelegt, die in den anderen Java-Beispielen verwendet werden.


public class ExampleConfiguration { public static final String DEFAULT_QUEUE_NAME = "SQSJMSClientExampleQueue"; public static final Region DEFAULT_REGION = Region.getRegion(Regions.US_EAST_2); private static String getParameter( String args[], int i ) { if( i + 1 >= args.length ) { throw new IllegalArgumentException( "Missing parameter for " + args[i] ); } return args[i+1]; } /** * Parse the command line and return the resulting config. If the config parsing fails * print the error and the usage message and then call System.exit * * @param app the app to use when printing the usage string * @param args the command line arguments * @return the parsed config */

125



public static ExampleConfiguration parseConfig(String app, String args[]) { try { return new ExampleConfiguration(args); } catch (IllegalArgumentException e) { System.err.println( "ERROR: " + e.getMessage() ); System.err.println(); System.err.println( "Usage: " + app + " [--queue <queue>] [--region <region>] [--credentials <credentials>] "); System.err.println( " or" ); System.err.println( " " + app + " <spring.xml>" ); System.exit(-1); return null; } } private ExampleConfiguration(String args[]) { for( int i = 0; i < args.length; ++i ) { String arg = args[i]; if( arg.equals( "--queue" ) ) { setQueueName(getParameter(args, i)); i++; } else if( arg.equals( "--region" ) ) { String regionName = getParameter(args, i); try { setRegion(Region.getRegion(Regions.fromName(regionName))); } catch( IllegalArgumentException e ) { throw new IllegalArgumentException( "Unrecognized region " + regionName ); } i++; } else if( arg.equals( "--credentials" ) ) { String credsFile = getParameter(args, i); try { setCredentialsProvider( new PropertiesFileCredentialsProvider(credsFile) ); } catch (AmazonClientException e) { throw new IllegalArgumentException("Error reading credentials from " + credsFile, e ); } i++; } else { throw new IllegalArgumentException("Unrecognized option " + arg); } } } private String queueName = DEFAULT_QUEUE_NAME; private Region region = DEFAULT_REGION; private AWSCredentialsProvider credentialsProvider = new DefaultAWSCredentialsProviderChain(); public String getQueueName() { return queueName; } public void setQueueName(String queueName) { this.queueName = queueName; } public Region getRegion() { return region; } public void setRegion(Region region) { this.region = region; }

126



public AWSCredentialsProvider getCredentialsProvider() { return credentialsProvider; } public void setCredentialsProvider(AWSCredentialsProvider credentialsProvider) { // Make sure they're usable first credentialsProvider.getCredentials(); this.credentialsProvider = credentialsProvider; }}

TextMessageSender.javaIm folgenden Java-Codebeispiel wird ein Textnachrichtenproduzent erstellt.


public class TextMessageSender { public static void main(String args[]) throws JMSException { ExampleConfiguration config = ExampleConfiguration.parseConfig("TextMessageSender", args); ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer( session.createQueue( config.getQueueName() ) ); sendMessages(session, producer); // Close the connection. This closes the session automatically connection.close(); System.out.println( "Connection closed" ); }

127



private static void sendMessages( Session session, MessageProducer producer ) { BufferedReader inputReader = new BufferedReader( new InputStreamReader( System.in, Charset.defaultCharset() ) ); try { String input; while( true ) { System.out.print( "Enter message to send (leave empty to exit): " ); input = inputReader.readLine(); if( input == null || input.equals("" ) ) break; TextMessage message = session.createTextMessage(input); producer.send(message); System.out.println( "Send message " + message.getJMSMessageID() ); } } catch (EOFException e) { // Just return on EOF } catch (IOException e) { System.err.println( "Failed reading input: " + e.getMessage() ); } catch (JMSException e) { System.err.println( "Failed sending message: " + e.getMessage() ); e.printStackTrace(); } }}

SyncMessageReceiver.javaIm folgenden Java-Codebeispiel wird ein synchroner Nachrichtenkonsument erstellt.


public class SyncMessageReceiver {public static void main(String args[]) throws JMSException { ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiver", args); ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection();

128



// Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer( session.createQueue( config.getQueueName() ) );

connection.start(); receiveMessages(session, consumer);

// Close the connection. This closes the session automatically connection.close(); System.out.println( "Connection closed" );}

private static void receiveMessages( Session session, MessageConsumer consumer ) { try { while( true ) { System.out.println( "Waiting for messages"); // Wait 1 minute for a message Message message = consumer.receive(TimeUnit.MINUTES.toMillis(1)); if( message == null ) { System.out.println( "Shutting down after 1 minute of silence" ); break; } ExampleCommon.handleMessage(message); message.acknowledge(); System.out.println( "Acknowledged message " + message.getJMSMessageID() ); } } catch (JMSException e) { System.err.println( "Error receiving from SQS: " + e.getMessage() ); e.printStackTrace(); }}}

AsyncMessageReceiver.javaIm folgenden Java-Codebeispiel wird ein asynchroner Nachrichtenkonsument erstellt.


public class AsyncMessageReceiver { public static void main(String args[]) throws JMSException, InterruptedException { ExampleConfiguration config = ExampleConfiguration.parseConfig("AsyncMessageReceiver", args);

129



ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer( session.createQueue( config.getQueueName() ) ); ReceiverCallback callback = new ReceiverCallback(); consumer.setMessageListener( callback );

// No messages are processed until this is called connection.start(); callback.waitForOneMinuteOfSilence(); System.out.println( "Returning after one minute of silence" );

// Close the connection. This closes the session automatically connection.close(); System.out.println( "Connection closed" ); } private static class ReceiverCallback implements MessageListener { // Used to listen for message silence private volatile long timeOfLastMessage = System.nanoTime(); public void waitForOneMinuteOfSilence() throws InterruptedException { for(;;) { long timeSinceLastMessage = System.nanoTime() - timeOfLastMessage; long remainingTillOneMinuteOfSilence = TimeUnit.MINUTES.toNanos(1) - timeSinceLastMessage; if( remainingTillOneMinuteOfSilence < 0 ) { break; } TimeUnit.NANOSECONDS.sleep(remainingTillOneMinuteOfSilence); } }

@Override public void onMessage(Message message) { try { ExampleCommon.handleMessage(message); message.acknowledge(); System.out.println( "Acknowledged message " + message.getJMSMessageID() ); timeOfLastMessage = System.nanoTime(); } catch (JMSException e) { System.err.println( "Error processing message: " + e.getMessage() ); e.printStackTrace(); } } }

130



}

SyncMessageReceiverClientAcknowledge.javaIm folgenden Java-Codebeispiel wird ein synchroner Konsument im Client-Bestätigungsmodus erstellt.


/** * An example class to demonstrate the behavior of CLIENT_ACKNOWLEDGE mode for received messages. This example * complements the example given in {@link SyncMessageReceiverUnorderedAcknowledge} for UNORDERED_ACKNOWLEDGE mode. * * First, a session, a message producer, and a message consumer are created. Then, two messages are sent. Next, two messages * are received but only the second one is acknowledged. After waiting for the visibility time out period, an attempt to * receive another message is made. It's shown that no message is returned for this attempt since in CLIENT_ACKNOWLEDGE mode, * as expected, all the messages prior to the acknowledged messages are also acknowledged. * * This ISN'T the behavior for UNORDERED_ACKNOWLEDGE mode. Please see {@link SyncMessageReceiverUnorderedAcknowledge} * for an example. */public class SyncMessageReceiverClientAcknowledge { // Visibility time-out for the queue. It must match to the one set for the queue for this example to work. private static final long TIME_OUT_SECONDS = 1; public static void main(String args[]) throws JMSException, InterruptedException { // Create the configuration for the example ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiverClientAcknowledge", args); // Setup logging for the example ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection();

131



// Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session with client acknowledge mode Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); // Create the producer and consume MessageProducer producer = session.createProducer(session.createQueue(config.getQueueName())); MessageConsumer consumer = session.createConsumer(session.createQueue(config.getQueueName())); // Open the connection connection.start(); // Send two text messages sendMessage(producer, session, "Message 1"); sendMessage(producer, session, "Message 2"); // Receive a message and don't acknowledge it receiveMessage(consumer, false); // Receive another message and acknowledge it receiveMessage(consumer, true); // Wait for the visibility time out, so that unacknowledged messages reappear in the queue System.out.println("Waiting for visibility timeout..."); Thread.sleep(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS)); // Attempt to receive another message and acknowledge it. This results in receiving no messages since // we have acknowledged the second message. Although we didn't explicitly acknowledge the first message, // in the CLIENT_ACKNOWLEDGE mode, all the messages received prior to the explicitly acknowledged message // are also acknowledged. Therefore, we have implicitly acknowledged the first message. receiveMessage(consumer, true); // Close the connection. This closes the session automatically connection.close(); System.out.println("Connection closed."); } /** * Sends a message through the producer. * * @param producer Message producer * @param session Session * @param messageText Text for the message to be sent * @throws JMSException */ private static void sendMessage(MessageProducer producer, Session session, String messageText) throws JMSException { // Create a text message and send it producer.send(session.createTextMessage(messageText)); } /** * Receives a message through the consumer synchronously with the default timeout (TIME_OUT_SECONDS). * If a message is received, the message is printed. If no message is received, "Queue is empty!" is * printed.

132



* * @param consumer Message consumer * @param acknowledge If true and a message is received, the received message is acknowledged. * @throws JMSException */ private static void receiveMessage(MessageConsumer consumer, boolean acknowledge) throws JMSException { // Receive a message Message message = consumer.receive(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS)); if (message == null) { System.out.println("Queue is empty!"); } else { // Since this queue has only text messages, cast the message object and print the text System.out.println("Received: " + ((TextMessage) message).getText()); // Acknowledge the message if asked if (acknowledge) message.acknowledge(); } }}

SyncMessageReceiverUnorderedAcknowledge.javaIm folgenden Java-Codebeispiel wird ein synchroner Konsument im ungeordneten Bestätigungsmoduserstellt.


/** * An example class to demonstrate the behavior of UNORDERED_ACKNOWLEDGE mode for received messages. This example * complements the example given in {@link SyncMessageReceiverClientAcknowledge} for CLIENT_ACKNOWLEDGE mode. * * First, a session, a message producer, and a message consumer are created. Then, two messages are sent. Next, two messages * are received but only the second one is acknowledged. After waiting for the visibility time out period, an attempt to * receive another message is made. It's shown that the first message received in the prior attempt is returned again * for the second attempt. In UNORDERED_ACKNOWLEDGE mode, all the messages must be explicitly acknowledged no matter what * the order they're received. * * This ISN'T the behavior for CLIENT_ACKNOWLEDGE mode. Please see {@link SyncMessageReceiverClientAcknowledge} * for an example.

133



*/public class SyncMessageReceiverUnorderedAcknowledge { // Visibility time-out for the queue. It must match to the one set for the queue for this example to work. private static final long TIME_OUT_SECONDS = 1; public static void main(String args[]) throws JMSException, InterruptedException { // Create the configuration for the example ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiverUnorderedAcknowledge", args); // Setup logging for the example ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session with unordered acknowledge mode Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE); // Create the producer and consume MessageProducer producer = session.createProducer(session.createQueue(config.getQueueName())); MessageConsumer consumer = session.createConsumer(session.createQueue(config.getQueueName())); // Open the connection connection.start(); // Send two text messages sendMessage(producer, session, "Message 1"); sendMessage(producer, session, "Message 2"); // Receive a message and don't acknowledge it receiveMessage(consumer, false); // Receive another message and acknowledge it receiveMessage(consumer, true); // Wait for the visibility time out, so that unacknowledged messages reappear in the queue System.out.println("Waiting for visibility timeout..."); Thread.sleep(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS)); // Attempt to receive another message and acknowledge it. This results in receiving the first message since // we have acknowledged only the second message. In the UNORDERED_ACKNOWLEDGE mode, all the messages must // be explicitly acknowledged. receiveMessage(consumer, true); // Close the connection. This closes the session automatically connection.close();

134

System.out.println("Connection closed."); } /** * Sends a message through the producer. * * @param producer Message producer * @param session Session * @param messageText Text for the message to be sent * @throws JMSException */ private static void sendMessage(MessageProducer producer, Session session, String messageText) throws JMSException { // Create a text message and send it producer.send(session.createTextMessage(messageText)); } /** * Receives a message through the consumer synchronously with the default timeout (TIME_OUT_SECONDS). * If a message is received, the message is printed. If no message is received, "Queue is empty!" is * printed. * * @param consumer Message consumer * @param acknowledge If true and a message is received, the received message is acknowledged. * @throws JMSException */ private static void receiveMessage(MessageConsumer consumer, boolean acknowledge) throws JMSException { // Receive a message Message message = consumer.receive(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS)); if (message == null) { System.out.println("Queue is empty!"); } else { // Since this queue has only text messages, cast the message object and print the text System.out.println("Received: " + ((TextMessage) message).getText()); // Acknowledge the message if asked if (acknowledge) message.acknowledge(); } }}

SpringExampleConfiguration.xmlDas folgende XML-Codebeispiel ist eine Bean-Konfigurationsdatei für SpringExample.java (p. 136).

<!-- Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at

https://aws.amazon.com/apache2.0

or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

135



-->

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd "> <bean id="CredentialsProviderBean" class="com.amazonaws.auth.DefaultAWSCredentialsProviderChain"/> <bean id="ClientBuilder" class="com.amazonaws.services.sqs.AmazonSQSClientBuilder" factory-method="standard"> <property name="region" value="us-east-2"/> <property name="credentials" ref="CredentialsProviderBean"/> </bean> <bean id="ProviderConfiguration" class="com.amazon.sqs.javamessaging.ProviderConfiguration"> <property name="numberOfMessagesToPrefetch" value="5"/> </bean> <bean id="ConnectionFactory" class="com.amazon.sqs.javamessaging.SQSConnectionFactory"> <constructor-arg ref="ProviderConfiguration" /> <constructor-arg ref="ClientBuilder" /> </bean> <bean id="Connection" class="javax.jms.Connection" factory-bean="ConnectionFactory" factory-method="createConnection" init-method="start" destroy-method="close" /> <bean id="QueueName" class="java.lang.String"> <constructor-arg value="SQSJMSClientExampleQueue"/> </bean></beans>

SpringExample.javaIm folgenden Java-Codebeispiel wird die Bean-Konfigurationsdatei verwendet, um Ihre Objekte zuinitialisieren.

/* * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. *

136



*/ public class SpringExample { public static void main(String args[]) throws JMSException { if( args.length != 1 || !args[0].endsWith(".xml")) { System.err.println( "Usage: " + SpringExample.class.getName() + " <spring config.xml>" ); System.exit(1); } File springFile = new File( args[0] ); if( !springFile.exists() || !springFile.canRead() ) { System.err.println( "File " + args[0] + " doesn't exist or isn't readable."); System.exit(2); } ExampleCommon.setupLogging(); FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext( "file://" + springFile.getAbsolutePath() ); Connection connection; try { connection = context.getBean(Connection.class); } catch( NoSuchBeanDefinitionException e ) { System.err.println( "Can't find the JMS connection to use: " + e.getMessage() ); System.exit(3); return; } String queueName; try { queueName = context.getBean("QueueName", String.class); } catch( NoSuchBeanDefinitionException e ) { System.err.println( "Can't find the name of the queue to use: " + e.getMessage() ); System.exit(3); return; } if( connection instanceof SQSConnection ) { ExampleCommon.ensureQueueExists( (SQSConnection) connection, queueName ); } // Create the session Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer( session.createQueue( queueName) ); receiveMessages(session, consumer); // The context can be setup to close the connection for us context.close(); System.out.println( "Context closed" ); } private static void receiveMessages( Session session, MessageConsumer consumer ) { try { while( true ) { System.out.println( "Waiting for messages"); // Wait 1 minute for a message Message message = consumer.receive(TimeUnit.MINUTES.toMillis(1)); if( message == null ) { System.out.println( "Shutting down after 1 minute of silence" );

137



break; } ExampleCommon.handleMessage(message); message.acknowledge(); System.out.println( "Acknowledged message" ); } } catch (JMSException e) { System.err.println( "Error receiving from SQS: " + e.getMessage() ); e.printStackTrace(); } }}

ExampleCommon.javaIm folgenden Java-Codebeispiel wird geprüft, ob bereits eine Amazon SQS-Warteschlange vorhanden ist,und gegebenenfalls eine neue Warteschlange erstellt. Außerdem ist Beispiel-Code für die Protokollierungenthalten.


public class ExampleCommon { /** * A utility function to check the queue exists and create it if needed. For most * use cases this is usually done by an administrator before the application is run. */ public static void ensureQueueExists(SQSConnection connection, String queueName) throws JMSException { AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient(); /** * In most cases, you can do this with just a createQueue call, but GetQueueUrl * (called by queueExists) is a faster operation for the common case where the queue * already exists. Also many users and roles have permission to call GetQueueUrl * but don't have permission to call CreateQueue. */ if( !client.queueExists(queueName) ) { client.createQueue( queueName ); } } public static void setupLogging() { // Setup logging BasicConfigurator.configure(); Logger.getRootLogger().setLevel(Level.WARN); } public static void handleMessage(Message message) throws JMSException { System.out.println( "Got message " + message.getJMSMessageID() );

138

Amazon Simple Queue Service EntwicklerhandbuchUnterstützte JMS 1.1-Implementierungen

System.out.println( "Content: "); if( message instanceof TextMessage ) { TextMessage txtMessage = ( TextMessage ) message; System.out.println( "\t" + txtMessage.getText() ); } else if( message instanceof BytesMessage ){ BytesMessage byteMessage = ( BytesMessage ) message; // Assume the length fits in an int - SQS only supports sizes up to 256k so that // should be true byte[] bytes = new byte[(int)byteMessage.getBodyLength()]; byteMessage.readBytes(bytes); System.out.println( "\t" + Base64.encodeAsString( bytes ) ); } else if( message instanceof ObjectMessage ) { ObjectMessage objMessage = (ObjectMessage) message; System.out.println( "\t" + objMessage.getObject() ); } }}

Unterstützte JMS 1.1-ImplementierungenJava Messaging-Bibliothek von Amazon SQS unterstützt die folgenden JMS 1.1-Implementierungen.Weitere Informationen zu den unterstützten Funktionen und Fähigkeiten von Java Messaging-Bibliothekvon Amazon SQS finden Sie in den Amazon SQS-FAQs.

Unterstützte gängige Schnittstellen• Connection

• ConnectionFactory

• Destination

• Session

• MessageConsumer

• MessageProducer

Unterstützte Nachrichtentypen• ByteMessage

• ObjectMessage

• TextMessage

Unterstützte Nachrichtenbestätigungsmodi• AUTO_ACKNOWLEDGE

• CLIENT_ACKNOWLEDGE

• DUPS_OK_ACKNOWLEDGE

• UNORDERED_ACKNOWLEDGE

Note

Der UNORDERED_ACKNOWLEDGE-Modus ist nicht Bestandteil der JMS 1.1-Spezifikation. Mithilfedieses Modus kann ein JMS-Client in Amazon SQS Nachrichten explizit bestätigen.

139

http://docs.oracle.com/javaee/6/api/javax/jms/package-summary.html


Amazon Simple Queue Service EntwicklerhandbuchUnterstützte JMS 1.1-Implementierungen

JMS-definierte Kopfzeilen und reservierte EigenschaftenFür den Nachrichtenversand

Beim Senden von Nachrichten können Sie die folgenden Kopfzeilen und Eigenschaften für einzelneNachrichten festlegen:

• JMSXGroupID (erforderlich für FIFO-Warteschlangen, nicht zulässig für Standard-Warteschlangen)• JMS_SQS_DeduplicationId (optional für FIFO-Warteschlangen, nicht zulässig für Standard-

Warteschlangen)

Nach dem Senden von Nachrichten legt Amazon SQS die folgenden Kopfzeilen und Eigenschaften füreinzelne Nachrichten fest:

• JMSMessageID

• JMS_SQS_SequenceNumber (nur für FIFO-Warteschlangen)

Für den Nachrichtenempfang

Beim Empfang von Nachrichten legt Amazon SQS die folgenden Kopfzeilen und Eigenschaften für einzelneNachrichten fest:

• JMSDestination

• JMSMessageID

• JMSRedelivered

• JMSXDeliveryCount

• JMSXGroupID (nur für FIFO-Warteschlangen)• JMS_SQS_DeduplicationId (nur für FIFO-Warteschlangen)• JMS_SQS_SequenceNumber (nur für FIFO-Warteschlangen)

140

Amazon Simple Queue Service EntwicklerhandbuchEmpfehlungen für Standard- und FIFO-Warteschlangen

Bewährte Methoden für Amazon SQSDiese bewährten Methoden können Sie dabei unterstützen, Amazon SQS optimal zu nutzen.

Themen• Empfehlungen für Amazon SQS Standard- und FIFO (First-In-First-Out)-Warteschlangen (p. 141)• Zusätzliche Empfehlungen für Amazon SQS FIFO-Warteschlangen (p. 145)

Empfehlungen für Amazon SQS Standard- undFIFO (First-In-First-Out)-Warteschlangen

Die folgenden bewährten Methoden können Ihnen dabei helfen, mit Amazon SQS Kosten zu reduzierenund Nachrichten effizient zu verarbeiten.

Themen• Arbeiten mit Amazon SQS-Nachrichten (p. 141)• Reduzieren von Amazon SQS-Kosten (p. 144)• Von einer Amazon SQSStandard-Warteschlange in eine FIFO-Warteschlange wechseln (p. 144)

Arbeiten mit Amazon SQS-NachrichtenDie folgenden Richtlinien können Ihnen dabei helfen, mit Amazon SQS Nachrichten effizient zu verarbeiten.

Themen• Zeitnahe Verarbeitung von Nachrichten (p. 141)• Verarbeitung von Anforderungsfehlern (p. 142)• Langabfragen einrichten (p. 142)• Erfassung problematischer Nachrichten (p. 143)• Einrichtung der Aufbewahrungsdauer in der Warteschlange für unzustellbare Nachrichten (p. 143)• Vermeiden einer inkonsistenten Nachrichtenverarbeitung (p. 143)• Implementieren von Request-Response-Systemen (p. 143)

Zeitnahe Verarbeitung von NachrichtenDie Einstellung der Zeitbeschränkung für die Sichtbarkeit hängt davon ab, wie lange Ihre Anwendungbraucht, um eine Nachricht zu verarbeiten und zu löschen. Benötigt Ihre Anwendung beispielsweise 10Sekunden für die Verarbeitung einer Nachricht und Sie setzen die Zeitbeschränkung für die Sichtbarkeitauf 15 Minuten, müssen Sie relativ lange warten, bis Sie erneut versuchen können, die Nachricht zuverarbeiten, wenn der vorherige Versuch einer Verarbeitung fehlgeschlagen ist. Benötigt Ihre Anwendungalternativ 10 Sekunden für die Verarbeitung einer Nachricht, Sie setzen die Zeitbeschränkung für die

141

Amazon Simple Queue Service EntwicklerhandbuchArbeiten mit Nachrichten

Sichtbarkeit jedoch auf nur 2 Sekunden, wird eine duplizierte Nachricht von einem anderen Verbraucherempfangen, während der ursprüngliche Verbraucher die Nachricht noch verarbeitet.

Um sicherzustellen, dass ausreichend Zeit für die Verarbeitung von Nachrichten vorhanden ist, nutzen Sieeine der folgenden Strategien:

• Wenn Sie wissen (oder annähernd schätzen können), wie lange die Verarbeitung einer Nachricht dauert,erweitern Sie die Zeitbeschränkung für die Sichtbarkeit auf die maximale Zeit, die erforderlich ist, umdie Nachricht zu verarbeiten und zu löschen. Weitere Informationen finden Sie unter Konfigurieren derZeitbeschränkung für die Sichtbarkeit (p. 107) und Ändern der Zeitbeschränkung für die Sichtbarkeiteiner Nachricht (p. 108).

• Wenn Sie nicht wissen, wie lange es dauert, eine Nachricht zu verarbeiten, erstellen Sie einen heartbeatfür Ihren Verbraucherprozess: Geben Sie die anfängliche Zeitbeschränkung für die Sichtbarkeit an (z.B. 2 Minuten) und dann — solange Ihr Verbraucher noch an der Nachricht arbeitet — verlängern Sie dieZeitbeschränkung für die Sichtbarkeit jede Minute um 2 Minuten.

Note

Wenn Sie die Zeitbeschränkung für die Sichtbarkeit auf mehr als 12 Stunden erweitern müssen,empfiehlt sich die Verwendung von AWS Step Functions.

Verarbeitung von AnforderungsfehlernFür den Umgang mit Anforderungsfehlern nutzen Sie eine der folgenden Strategien:

• Wenn Sie ein AWS-SDK verwenden, steht Ihnen die automatische Wiederholungs- und Backoff-Logikbereits zur Verfügung. Weitere Informationen finden Sie unter Wiederholversuche bei Fehlern undexponentielles Backoff in AWS im Allgemeine Amazon Web Services-Referenz.

• Wenn Sie die AWS-SDK-Funktionen für Wiederholversuche und Backoff nicht verwenden, lassenSie eine Pause (z. B. 200 ms) zu, bevor Sie es erneut mit der Aktion ReceiveMessage versuchen,wenn keine Nachrichten eingehen, ein Timeout auftritt oder Sie eine Fehlermeldung von Amazon SQSerhalten. Für die nachfolgende Verwendung der Aktion ReceiveMessage, mit der dieselben Ergebnisseerzielt werden, lassen Sie eine längere Pause (z. B. 400 ms) zu.

Langabfragen einrichtenWenn die Wartezeit für die API-Aktion ReceiveMessage größer als 0 ist, ist die Langabfrage aktiviert.Mithilfe von Langabfragen können Sie die Kosten für die Verwendung von Amazon SQS reduzieren,indem Sie die Anzahl der leeren Antworten (wenn bei einer ReceiveMessage-Anfrage keine Nachrichtenvorhanden sind) und fälschlicherweise leeren Antworten (wenn Nachrichten vorhanden sind, diese abernicht in einer Antwort enthalten sind) eliminieren. Weitere Informationen finden Sie unter Amazon SQS-Kurz- und -Langabfragen (p. 100).

Um eine optimale Nachrichtenverarbeitung sicherzustellen, wenden Sie die folgenden Strategien an:

• In den meisten Fällen können Sie die ReceiveMessage-Wartezeit auf 20 Sekunden setzen. Wenn20 Sekunden für Ihre Anwendung zu lang ist, legen Sie eine kürzere ReceiveMessage-Wartezeit fest(mindestens 1 Sekunde). Wenn Sie kein AWS-SDK für den Zugriff auf Amazon SQS verwenden oder IhrAWS-SDK mit einer kürzeren Wartezeit konfiguriert haben, müssen Sie ggf. den Amazon SQS-Client soändern, dass längere Anfragen zulässig sind, oder eine kürzere Wartezeit für Langabfragen wählen.

• Wenn Sie Langabfragen für mehrere Warteschlangen implementieren, verwenden Sie einen Threadfür jede Warteschlange statt eines einzelnen Threads für alle Warteschlangen. Durch die Verwendungeines einzelnen Threads für jede Warteschlange kann Ihre Anwendung die Nachrichten in jeder derWarteschlangen verarbeiten, sobald diese verfügbar sind, während bei Verwendung eines einzelnen

142

https://aws.amazon.com/step-functions/

https://docs.aws.amazon.com/general/latest/gr/api-retries.html

https://docs.aws.amazon.com/general/latest/gr/api-retries.html



Amazon Simple Queue Service EntwicklerhandbuchArbeiten mit Nachrichten

Threads für die Abfrage mehrerer Warteschlangen dazu führen könnte, dass Ihre Anwendung dieNachrichten nicht verarbeiten kann, die in anderen Warteschlangen zur Verfügung stehen, währenddie Anwendung auf die Warteschlange wartet (bis zu 20 Sekunden), die keine verfügbaren Nachrichtenenthält.

Erfassung problematischer NachrichtenUm alle Nachrichten zu erfassen, die nicht verarbeitet werden können, und um die Richtigkeit derCloudWatch-Metriken sicherzustellen, konfigurieren Sie eine Warteschlange für unzustellbareNachrichten (p. 102).

• Die Redrive-Richtlinie leitet Nachrichten an eine Warteschlange für unzustellbare Nachrichten weiter,nachdem die Quell-Warteschlange eine Nachricht mehrfach nicht verarbeiten kann.

• Durch Verwenden einer Warteschlange für unzustellbare Nachrichten wird die Anzahl der Nachrichtenreduziert und das Risiko von Poison-Pill-Nachrichten gesenkt, d. h. Nachrichten, die empfangen, abernicht verarbeitet werden können.

• Wenn Sie eine Poison-Pill-Nachricht in eine Warteschlange stellen, kann dieApproximateAgeOfOldestMessage (p. 201) CloudWatch-Metrik durch ein falsches Alter derPoison-Pill-Nachricht verzerrt werden. Das Konfigurieren einer Warteschlange für unzustellbareNachrichten hilft, Fehlalarme bei der Verwendung dieser Metrik zu vermeiden.

Einrichtung der Aufbewahrungsdauer in der Warteschlange fürunzustellbare NachrichtenNachrichten laufen immer abhängig vom ursprünglichen Warteschlangenzeitstempel ab. Wenneine Nachricht in eine Warteschlange für unzustellbare Nachrichten (p. 102) verschoben wird, bleibtder Warteschlangenzeitstempel unverändert. Beispiel: Wenn eine Nachricht einen Tag lang in derursprünglichen Warteschlange verbleibt, dann in eine Warteschlange für unzustellbare Nachrichtenverschoben wird und der Aufbewahrungszeitraum für diese Warteschlange vier Tage beträgt, wird dieNachricht nach drei Tagen aus der Warteschlange für unzustellbare Nachrichten gelöscht. Daher sollteder Aufbewahrungszeitraum einer Warteschlange für unzustellbare Nachrichten immer länger sein als derAufbewahrungszeitraum der ursprünglichen Warteschlange.

Vermeiden einer inkonsistenten NachrichtenverarbeitungUm eine inkonsistente Verarbeitung von Nachrichten durch Standard-Warteschlangen zu vermeiden, legenSie die Anzahl der maximal zu empfangenden Nachrichten beim Konfigurieren einer Warteschlange fürunzustellbare Nachrichten möglichst nicht auf 1 fest.

Important

Sollten Sie die Anzahl der maximal zu empfangenden Nachrichten auf 1 einstellen, wird beijedem fehlgeschlagenen ReceiveMessage-Aufruf eine Nachricht in eine Warteschlange fürunzustellbare Nachrichten verschoben, ohne dass sie empfangen wird.

Implementieren von Request-Response-SystemenBeachten Sie beim Implementieren eines Request-Response- oder Remoteprozeduraufrufs (RPC)-Systems die folgenden bewährten Vorgehensweisen:

• Erstellen Sie keine Antwortwarteschlangen pro Nachricht. Erstellen Sie stattdessenAntwortwarteschlangen beim Start, pro Produzent und verwenden Sie eine Korrelations-ID für dasNachrichtenattribut zum Zuordnen von Antworten zu Anfragen.

143

Amazon Simple Queue Service EntwicklerhandbuchReduzieren von Kosten

• Lassen Sie Ihre Produzenten keine Antwortwarteschlangen freigeben. Dies kann dazu führen, dass einProduzent Antwortnachrichten erhält, die für einen anderen Produzenten vorgesehen sind.

Weitere Informationen zum Implementieren der request-response-Muster mit dem Clienttemporärer Warteschlangen finden Sie unter Request-Response-Messaging-Muster (virtuelleWarteschlangen) (p. 111).

Reduzieren von Amazon SQS-KostenDie folgenden bewährten Methoden können Ihnen dabei helfen, Kosten zu reduzieren und zusätzlichepotenzielle Kostensenkungen sowie eine nahezu sofortige Antwort zu nutzen.

Stapelverarbeitung von NachrichtenaktionenUm Kosten zu reduzieren, führen Sie Ihre Nachrichtenaktionen in der Stapelverarbeitung aus:

• Zum Senden, Empfangen und Löschen von Nachrichten und zum Ändern der Zeitbeschränkung für dieSichtbarkeit für mehrere Nachrichten mit einer einzelnen Aktion, verwenden Sie die Amazon SQS API-Stapelaktionen (p. 218).

• Um die clientseitige Pufferung mit der Anforderungsstapelverarbeitung zu kombinieren, verwenden SieLangabfragen zusammen mit dem gepufferten asynchronen Client (p. 219), der in AWS SDK for Javaenthalten ist.

Note

Gepufferter asynchroner Client von Amazon SQSunterstützt derzeit keine FIFO-Warteschlangen

Verwendung des geeigneten Abfragemodus• Mit der Langabfrage können Sie Nachrichten aus Ihrer Amazon SQS-Warteschlange nutzen, sobald

diese verfügbar sind.• Um die Verwendungskosten für Amazon SQS zu senken und die Anzahl der leeren

Empfangsvorgänge in einer leeren Warteschlange zu reduzieren, (Antworten auf die AktionReceiveMessage, mit der keine Nachrichten zurückgegeben werden), aktivieren Sie die Langabfrage.Weitere Informationen finden Sie unter Amazon SQS-Langabfrage (p. 100).

• Um die Effizienz beim Abfragen für mehrere Threads mit mehreren Empfangsvorgängen zu steigern,verringern Sie die Anzahl der Threads.

• Langabfragen sind Kurzabfragen in den meisten Fällen vorzuziehen.• Die Kurzabfrage gibt Antworten sofort zurück, auch wenn die abgefragte Amazon SQS-Warteschlange

leer ist.• Um die Anforderungen einer Anwendung zu erfüllen, die sofortige Antworten auf die AbfrageReceiveMessage erwartet, verwenden Sie die Kurzabfrage.

• Die Kurzabfrage wird mit denselben Kosten in Rechnung gestellt wie die Langabfrage.

Von einer Amazon SQSStandard-Warteschlange ineine FIFO-Warteschlange wechselnWenn Sie den Parameter DelaySeconds nicht für jede Nachricht angeben, können Sie zu einer FIFO-Warteschlange wechseln, indem Sie eine Nachrichtengruppen-ID für jede gesendete Nachricht angeben.

Weitere Informationen finden Sie unter Von einer Standard-Warteschlange in eine FIFO-Warteschlangewechseln (p. 89).

144

Amazon Simple Queue Service EntwicklerhandbuchZusätzliche Empfehlungen für FIFO-Warteschlangen

Zusätzliche Empfehlungen für Amazon SQS FIFO-Warteschlangen

Die folgenden bewährten Methoden können Ihnen dabei helfen, die Nachrichtendeduplizierungs-IDund Nachrichtengruppen-ID optimal einzusetzen. Weitere Informationen finden Sie in den AktionenSendMessage und SendMessageBatch im Amazon Simple Queue Service API Reference.

Themen• Verwenden der Amazon SQS Nachrichtendeduplizierungs-ID (p. 145)• Verwenden der Amazon SQS Nachrichtengruppen-ID (p. 146)• Verwenden der Amazon SQS Empfangsanforderungsversuch-ID (p. 147)

Verwenden der Amazon SQSNachrichtendeduplizierungs-IDDie Nachrichtendeduplizierungs-ID ist die Token, das für die Deduplizierung von gesendeten Nachrichtenverwendet wird Wenn eine Nachricht mit einer bestimmten Nachrichtendeduplizierungs-ID erfolgreichgesendet wurde, werden alle Nachrichten mit derselben Nachrichtendeduplizierungs-ID erfolgreichakzeptiert, aber nicht während des fünfminütigen Deduplizierungsintervalls übermittelt.

Note

Die Deduplizierung von Nachrichten wird auf die gesamte Warteschlange angewendet und nichtauf einzelne Nachrichtengruppen.Amazon SQS setzt die Nachverfolgung der Nachrichtendeduplizierungs-ID auch dann fort,nachdem die Nachricht empfangen und gelöscht wurde.

Bereitstellung der Nachrichtendeduplizierungs-IDDer Produzent sollte die Nachrichtendeduplizierungs-ID-Werte für jede gesendete Nachricht in denfolgenden Szenarien angeben:

• Nachrichten, die mit identischen Nachrichtentexten gesendet werden, die von Amazon SQS als eindeutigbehandelt werden müssen.

• Nachrichten, die mit identischen Inhalten, aber unterschiedlichen Nachrichtenattributen gesendet werden,die Amazon SQS als eindeutig behandeln muss.

• Nachrichten, die mit unterschiedlichen Inhalten (z. B. Wiederholungszählungen im Nachrichtentext)gesendet werden, die Amazon SQS als Duplikate behandeln muss.

Aktivieren der Deduplizierung für ein Single-Producer/Consumer-SystemWenn Sie über einen einzigen Produzenten und einen einzigen Konsumenten verfügen und dieNachrichten eindeutig sind, da eine anwendungsspezifische Nachrichten-ID im Nachrichtentext enthaltenist, wenden Sie die folgenden bewährten Methoden an:

• Aktivieren Sie die inhaltsbasierte Deduplizierung für die Warteschlange (jede Ihrer Nachrichten hat eineneindeutigen Text). Der Produzent kann die Nachrichtendeduplizierungs-ID weglassen.

• Obwohl der Konsument keine Empfangsanforderungsversuch-ID für jede Anforderung angeben muss,hat sich dies als Methode bewährt, da Wiederholungen nach Fehlschlägen schneller durchgeführtwerden können.

145




Amazon Simple Queue Service EntwicklerhandbuchVerwenden der Nachrichtengruppen-ID

• Sie können erneut versuchen, Anforderungen zu senden oder zu empfangen, da diese die Reihenfolgeder Nachrichten in FIFO-Warteschlangen nicht stören.

Entwürfe für Szenarien der Wiederherstellung nach AusfällenDer Deduplizierungsprozess in FIFO-Warteschlangen ist zeitkritisch. Bei der Konzeption Ihrer Anwendungstellen Sie sicher, dass sowohl der Produzent als auch der Konsument bei einem Client- oderNetzwerkausfalls wiederhergestellt werden kann.

• Der Produzent muss das Deduplizierungsintervall der Warteschlange kennen. Amazon SQS verfügt überein Deduplizierungsintervall von mindestens 5 Minuten. Wiederholungsversuche von SendMessage-Anforderungen nach Ablauf des Deduplizierungsintervalls können zu doppelten Nachrichten in derWarteschlange führen. Beispiel: Ein mobiles Gerät in einem Auto sendet Nachrichten, deren Reihenfolgewichtig ist. Wenn das Auto für einen bestimmten Zeitraum die Funkverbindung verliert, bevor eineBestätigung eingeht, kann ein Wiederholungsversuch der Anforderungen nach Wiederherstellung derFunkverbindung zu einem Duplikat führen.

• Der Konsument muss über eine Zeitbeschränkung für die Sichtbarkeit verfügen, die das Risikominimiert, dass Nachrichten nicht verarbeitet werden können, bevor die Zeitbeschränkung für dieSichtbarkeit abgelaufen ist. Sie können die Zeitbeschränkung für die Sichtbarkeit erweitern, während dieNachrichten verarbeitet werden, indem Sie die Aktion ChangeMessageVisibility aufrufen. Wenndie Zeitbeschränkung für die Sichtbarkeit jedoch abgelaufen ist, kann ein anderer Konsument sofortmit der Nachrichtenverarbeitung beginnen, was dazu führt, dass eine Nachricht mehrfach verarbeitetwird. Um dieses Szenario zu vermeiden, konfigurieren Sie eine Warteschlange für unzustellbareNachrichten (p. 102).

Arbeiten mit Zeitbeschränkungen für die SichtbarkeitUm eine optimale Leistung zu erzielen, legen Sie für die Zeitbeschränkung für die Sichtbarkeit (p. 106)einen größeren Wert als für das AWS-SDK-Timeout für Lesevorgänge fest. Dies gilt für die Verwendungder API-Aktion ReceiveMessage mit Kurzabfragen (p. 100) gleichermaßen wie mit Langabfragen (p. 100).

Verwenden der Amazon SQS Nachrichtengruppen-IDDie Nachrichtengruppen-ID ist die Tag, das festlegt, dass eine Nachricht zu einer bestimmtenNachrichtengruppe gehört. Nachrichten, die zur selben Nachrichtengruppe gehören, werden immer einzelnverarbeitet. In Bezug auf die Nachrichtengruppe wird eine strenge Reihenfolge eingehalten (Nachrichten,die zu verschiedenen Nachrichtengruppen gehören, können jedoch in anderer Reihenfolge verarbeitetwerden).

Interleaving mehrerer geordneter NachrichtengruppenUm mehrere geordnete Nachrichtengruppen innerhalb einer einzigen FIFO-Warteschlange zuverschränken, verwenden Sie Nachrichtengruppen-ID-Werte (z. B. Sitzungsdaten für mehrere Benutzer).In diesem Szenario können mehrere Konsumenten die Warteschlange verarbeiten, die Sitzungsdaten dereinzelnen Benutzer werden jedoch im FIFO-Verfahren verarbeitet.

Note

Wenn Nachrichten, die zu einer bestimmten Nachrichtengruppen-ID gehören, nicht sichtbarsind, können keine anderen Konsumenten Nachrichten mit derselben Nachrichtengruppen-IDverarbeiten.

146

Amazon Simple Queue Service EntwicklerhandbuchVerwenden der Empfangsanforderungsversuch-ID

Vermeidung der Verarbeitung von Duplikaten in einem Multiple-Producer/Consumer-SystemUm die Verarbeitung von doppelten Nachrichten in einem System mit mehreren Produzenten undKonsumenten, bei dem Durchsatz und Latenz wichtiger sind als die Reihenfolge, zu vermeiden, sollte derProduzent eine eindeutige Nachrichtengruppen-ID für jede Nachricht generieren.

Note

In diesem Szenario werden Duplikate verhindert. Die Reihenfolge der Nachrichten kann jedochnicht garantiert werden.Jedes Szenario mit mehreren Produzenten und Konsumenten erhöht das Risiko, versehentlicheine doppelte Nachricht zuzustellen, wenn ein Auftragnehmer die Nachricht nicht innerhalb derZeitbeschränkung für die Sichtbarkeit verarbeitet und die Nachricht einem anderen Auftragnehmerzur Verfügung gestellt wird.

Vermeiden eines großen Rückstaus an Nachrichten mit derselbenNachrichtengruppen-IDWenn Ihre Warteschlange einen großen Rückstau von 20 000 oder mehr Nachrichten mit derselbenNachrichtengruppen-ID aufweist, können FIFO-Warteschlangen möglicherweise keine Nachrichtenzurückgeben, die eine andere Nachrichtengruppen-ID aufweisen, aber zu einem späteren Zeitpunkt an dieWarteschlange gesendet wurden, bis Sie die Nachrichten aus dem Rückstau erfolgreich abgerufen haben.

Note

Ein Rückstau von Nachrichten mit derselben Nachrichtengruppen-ID kann aufgrund einesVerbrauchers entstehen, der eine Nachricht nicht erfolgreich verarbeiten kann. Probleme bei derNachrichtenverarbeitung können aufgrund eines Problems mit dem Inhalt einer Nachricht oderaufgrund eines technischen Problems mit dem Verbraucher auftreten.Um Nachrichten zu entfernen, die wiederholt nicht verarbeitet werden können, und um dieBlockierung der Verarbeitung anderer Nachrichten mit derselben Nachrichtengruppen-IDaufzuheben, sollten Sie eine Warteschlangenrichtlinie für unzustellbare Nachrichten (p. 102)einrichten.

Verwenden der Amazon SQSEmpfangsanforderungsversuch-IDDie Empfangsanforderungsversuch-ID ist die Token, das für die Deduplizierung von ReceiveMessage-Aufrufen verwendet wird

Während eines dauerhaften Netzwerkausfalls, der zu Verbindungsproblemen zwischen Ihrem SDK undAmazon SQS führt, hat es sich als Methode bewährt, die Empfangsanforderungsversuch-ID bereitzustellenund den Vorgang mit derselben Empfangsanforderungsversuch-ID erneut zu versuchen, wenn die SDK-Operation fehlschlägt.

147

Amazon Simple Queue Service EntwicklerhandbuchKontingente im Zusammenhang mit Warteschlangen

Amazon SQS-KontingenteIn diesem Thema werden Kontingente innerhalb von Amazon Simple Queue Service (Amazon SQS)aufgeführt.

Themen• Kontingente im Zusammenhang mit Warteschlangen (p. 148)• Kontingente im Zusammenhang mit Nachrichten (p. 149)• Kontingente im Zusammenhang mit Richtlinien (p. 151)

Kontingente im Zusammenhang mitWarteschlangen

In der folgenden Tabelle werden die Kontingente im Zusammenhang mit Warteschlangen aufgeführt.

Quota Beschreibung

Verzögerungswarteschlange Die standardmäßige (minimale) Verzögerung für eineWarteschlange beträgt 0 Sekunden. Die maximale Größe ist15 Minuten.

Aufgelistete Warteschlangen 1.000 Warteschlangen pro ListQueues-Anforderung.

Mitteilungsgruppen Die Zahl der Nachrichtengruppen in einer FIFO-Warteschlange ist nicht kontingentiert.

Nachrichten pro Warteschlange(Rückstand)

Eine Amazon SQS-Warteschlange kann unbegrenzt vieleNachrichten speichern.

Für die meisten Standard-Warteschlangen (je nachWarteschlangendatenverkehr und Nachrichtenrückstand)können höchstens etwa 120.000 Inflight-Nachrichten (voneinem Konsumenten aus einer Warteschlange empfangen,aber noch nicht aus der Warteschlange gelöscht.) enthaltensein. Wenn Sie dieses Kontingent erreichen, gibt AmazonSQS die Fehlermeldung OverLimit zurück. Um zuvermeiden, dass dieses Kontingent erreicht wird, solltenSie Nachrichten aus der Warteschlange löschen, nachdemsie verarbeitet wurden. Sie können auch die Anzahl derWarteschlangen erhöhen, die Sie zur Verarbeitung IhrerNachrichten verwenden. Um eine Kontingenterhöhunganzufordern, übermitteln Sie eine Support-Anforderung.

Nachrichten pro Warteschlange(während der Übertragung)

Für FIFO-Warteschlangen sind maximal 20 000 inÜbertragung befindliche Nachrichten zulässig (von einemKonsumenten aus einer Warteschlange empfangen, abernoch nicht aus der Warteschlange gelöscht.). Wenn Siedieses Kontingent erreichen, gibt Amazon SQS keineFehlermeldungen zurück.

Name der Warteschlange Ein Warteschlangenname kann bis zu 80 Zeichen haben.Folgende Zeichen sind zulässig: alphanumerische Zeichen,Bindestriche (-) und Unterstriche (_).

148



Amazon Simple Queue Service EntwicklerhandbuchKontingente im Zusammenhang mit Nachrichten

Quota Beschreibung

Note

Bei Warteschlangennamen ist die Groß- undKleinschreibung zu beachten (Test-queueund test-queue sind z. B. zwei verschiedeneWarteschlangen).

Der Name einer FIFO-Warteschlange muss mit demSuffix .fifo enden. Das Suffix wird für das 80-Zeichen-Kontingent für den Warteschlangennamenberücksichtigt. Um festzustellen, ob eine Warteschlange eineFIFO (p. 86)-Warteschlange ist, können Sie prüfen, ob derWarteschlangenname mit dem Suffix endet.

Wir raten davon ab, einer Warteschlange mehr als 50 Tagshinzuzufügen.

Das Tag Key ist erforderlich, aber das Tag Value ist optional.

Das Tag Key und das Tag Value unterscheiden zwischenGroß- und Kleinschreibung.

Das Tag Key und das Tag Value können alphanumerischenUnicode-Zeichen in UTF-8 und Leerzeichen enthalten. Diefolgenden Sonderzeichen sind zulässig:_ . : / = + - @

Die Tags Key oder Value dürfen nicht das reservierte Präfixaws: enthalten (Sie können keine Tagschlüssel oder -wertemit diesem Präfix löschen).

Die maximale Länge des Tags Key beträgt 128 Unicode-Zeichen in UTF-8. Das Tag Key darf nicht null oder leer sein.

Die maximale Länge des Tags Value beträgt 256 Unicode-Zeichen in UTF-8. Das Tag Value darf null oder leer sein.

Warteschlangen-Tag

Tagging-Aktionen sind auf 5 TPS pro AWS-Konto begrenzt.Wenn die Anwendung einen höheren Durchsatz benötigt,übermitteln Sie eine Anforderung.

Kontingente im Zusammenhang mit NachrichtenIn der folgenden Tabelle werden die Kontingente im Zusammenhang mit Nachrichten aufgeführt.

Quota Beschreibung

Mitteilungs-ID im Stapel Eine Mitteilungs-ID im Stapel kann bis zu 80 Zeichen haben.Folgende Zeichen sind zulässig: alphanumerische Zeichen,Bindestriche (-) und Unterstriche (_).

Nachrichtenattribute Eine Nachricht kann bis zu 10 Metadatenattribute enthalten.

Nachrichtenstapel Eine einzelne Nachrichtstapelanforderung kannmaximal 10 Nachrichten umfassen. WeitereInformationen finden Sie unter Konfigurieren von

149


Amazon Simple Queue Service EntwicklerhandbuchKontingente im Zusammenhang mit Nachrichten

Quota BeschreibungAmazonSQSBufferedAsyncClient (p. 220) im AbschnittAmazon SQS Stapel-Aktionen (p. 218).

Nachrichteninhalt Eine Nachricht kann nur XML, JSON und unformatierten Textenthalten. Die folgenden Unicode-Zeichen sind zulässig:#x9 | #xA | #xD | #x20 bis #xD7FF | #xE000 bis #xFFFD |#x10000 to #x10FFFF

Alle Zeichen, die nicht in diese Liste enthalten sind, werdenabgelehnt. Weitere Informationen finden Sie in der W3C-Spezifikation für Zeichen.

Nachrichtengruppen-ID Verwenden Sie Nachrichten aus dem Rückstau, um dasEntstehen eines großen Rückstaus an Nachrichten mitderselben Nachrichtengruppen-ID zu vermeiden (p. 147).

Nachrichtenspeicherung Standardmäßig wird eine Nachricht 4 Tage aufbewahrt. DieMindestdauer 60 Sekunden (1 Minute). Die Höchstdauer ist1 209 600 Sekunden (14 Tage).

Standard-Warteschlangen unterstützen eine fast unbegrenzteAnzahl an Transaktionen pro Sekunde (TPS) pro API-Aktion(SendMessage, ReceiveMessage oder DeleteMessage).

Nachrichtendurchsatz

• Mit Stapelverarbeitung (p. 218) unterstützen FIFO-Warteschlangen standardmäßig bis zu 3.000 Nachrichtenpro Sekunde (TPS) pro API-Aktion (SendMessage,ReceiveMessage oder DeleteMessage). Um eineKontingenterhöhung anzufordern, übermitteln Sie eineSupport-Anforderung.

• Ohne Stapelverarbeitung unterstützen FIFO-Warteschlangen bis zu 300 Nachrichten pro Sekunde undpro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage).

Nachrichten-Timer Die standardmäßige (minimale) Verzögerung für eineNachricht beträgt 0 Sekunden. Die maximale Größe ist15 Minuten.

Nachrichtengröße Die Mindestnachrichtengröße ist 1 Byte (1 Zeichen). Diemaximale Größe beträgt 262 144 Byte (256 KB).

Um Nachrichten mit mehr als 256 KB zu senden, könnenSie Erweiterte Client Library für Java von Amazon SQSverwenden. Diese Bibliothek erlaubt das Senden einerAmazon SQS-Nachricht, die auf eine Nachrichtennutzlast inAmazon S3 verweist. Die maximale Nutzlastgröße beträgt2 GB.

Zeitbeschränkung für die Sichtbarkeitvon Nachrichten

Die Standardzeitbeschränkung für die Sichtbarkeit einerNachricht beträgt 30 Sekunden. Das Minimum beträgt0 Sekunden. Der Höchstwert beträgt 12 Stunden.

Richtlinieninformationen Das Höchstkontingent beträgt 8 192 Byte, 20 Anweisungen,50 Prinzipale oder 10 Bedingungen. Weitere Informationenfinden Sie unter Kontingente im Zusammenhang mitRichtlinien (p. 151).

150

https://www.w3.org/TR/REC-xml/#charsets

https://www.w3.org/TR/REC-xml/#charsets



https://github.com/awslabs/amazon-sqs-java-extended-client-lib

Amazon Simple Queue Service EntwicklerhandbuchKontingente im Zusammenhang mit Richtlinien

Kontingente im Zusammenhang mit RichtlinienIn der folgenden Tabelle werden die Kontingente im Zusammenhang mit Richtlinien aufgeführt.

Name Maximum

Byte 8,192

Bedingungen 10

Prinzipale 50

Anweisungen 20

151

Amazon Simple Queue Service EntwicklerhandbuchAutomatisieren von Benachrichtigungen

mit CloudWatch-Ereignisse

Automatisierung und Fehlerbehebungvon Amazon SQS-Warteschlangen

Dieser Abschnitt enthält Informationen zur Automatisierung und Fehlerbehebung von Amazon SQS-Warteschlangen.

Themen• Automatisieren von Benachrichtigungen von AWS-Services an Amazon SQS mit CloudWatch-

Ereignisse (p. 152)• Fehlerbehebung von Amazon Simple Queue Service-Warteschlangen mit AWS X-Ray (p. 152)

Automatisieren von Benachrichtigungen vonAWS-Services an Amazon SQS mit CloudWatch-Ereignisse

Mit Amazon CloudWatch Events können Sie AWS-Services automatisieren und auf Systemereignissereagieren, z. B. Probleme mit der Anwendungsverfügbarkeit oder Ressourcenänderungen. Ereignisse vonAWS-Services werden für CloudWatch-Ereignisse nahezu in Echtzeit bereitgestellt. Sie können einfacheRegeln schreiben, um anzugeben, welche Ereignisse für Sie interessant sind und welche automatisiertenAktionen durchgeführt werden sollen, wenn sich für ein Ereignis eine Übereinstimmung mit einer Regelergibt.

CloudWatch-Ereignisse ermöglicht Ihnen die Festlegung zahlreicher -Ziele—, wie beispielsweise AmazonSQS Standard- und FIFO-Warteschlangen—, die Ereignisse im JSON-Format entgegennehmen. WeitereInformationen hierzu finden Sie im Benutzerhandbuch für Amazon CloudWatch Events.

Fehlerbehebung von Amazon Simple QueueService-Warteschlangen mit AWS X-Ray

AWS X-Ray erfasst Daten über Anforderungen, die von Ihrer Anwendung verarbeitet werden, undermöglicht Ihnen, Daten anzuzeigen und zu filtern, um potenzielle Probleme und Möglichkeiten zurOptimierung aufzudecken. Für jede verfolgte Clientanforderung für Ihre Anwendung sehen Sie detaillierteInformationen über die Anforderung, die Antwort und die Aufrufe, die Ihre Anwendung an nachgelagerteAWS-Ressourcen, -Mikroservices, -Datenbanken und HTTP-Web-APIs sendet.

Um AWS X-Ray-Ablaufverfolgungs-Header über Amazon SQS zu senden, können Sie einen der folgendenSchritte ausführen:

• Verwenden Sie X-Amzn-Trace-Id-Nachverfolgungs-Header.• Verwenden Sie das AWSTraceHeader-Nachrichtensystemattribut (p. 98).

Um Daten über Fehler und Latenz zu erfassen, müssen Sie den AmazonSQS-Client mit dem AWS X-Ray-SDK instrumentieren.

152

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/

https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-tracingheader

https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/index.html?com/amazonaws/services/sqs/AmazonSQSClient.html

https://docs.aws.amazon.com/xray-sdk-for-java/latest/javadoc/index.html

https://docs.aws.amazon.com/xray-sdk-for-java/latest/javadoc/index.html

Amazon Simple Queue Service EntwicklerhandbuchFehlerbehebung von Warteschlangen mit X-Ray

Mithilfe der AWS X-Ray-Konsole können Sie die Zuordnung der Verbindungen zwischen Amazon SQSund anderen von Ihrer Anwendung verwendeten Services anzeigen. Sie können mithilfe der Konsole auchMetriken, wie durchschnittliche Latenz- und Ausfallraten, anzuzeigen. Weitere Informationen finden Sieunter Amazon SQS und AWS X-Ray im AWS X-Ray-Entwicklerhandbuch.

153

https://docs.aws.amazon.com/xray/latest/devguide/xray-services-sqs.html

Amazon Simple Queue Service EntwicklerhandbuchDatenschutz

Sicherheit in Amazon SQSDieser Abschnitt enthält Informationen zur Amazon SQS-Sicherheit und -Authentifizierung sowie zurZugriffskontrolle und der Amazon SQSAccess Policy Language.

Themen• Datenschutz in Amazon SQS (p. 154)• Identitäts- und Zugriffsverwaltung in Amazon SQS (p. 163)• Protokollierung und Überwachung in Amazon SQS (p. 194)• Compliance-Validierung für Amazon SQS (p. 207)• Ausfallsicherheit in Amazon SQS (p. 207)• Infrastruktursicherheit in Amazon SQS (p. 208)• Bewährte Methoden für die Amazon SQS-Sicherheit (p. 208)

Datenschutz in Amazon SQSDie folgenden Abschnitte enthalten Informationen zum Datenschutz in Amazon SQS.

Themen• Datenverschlüsselung (p. 154)• Richtlinie für den Datenverkehr zwischen Netzwerken (p. 162)

DatenverschlüsselungDatenschutz bezieht sich auf Daten bei der Übertragung (auf dem Weg zu oder von Amazon SQS)sowie auf ruhende Daten (die in Amazon SQS-Rechenzentren auf Datenträgern gespeichert sind).Sie können Daten mithilfe von Secure Sockets Layer (SSL) oder einer clientseitigen Verschlüsselungwährend der Übertragung schützen. Sie können die gespeicherten Daten schützen, indem Sie eineVerschlüsselung Ihrer Nachrichten durch Amazon SQS anfordern, bevor Sie sie in ihren Rechenzentren aufdem Datenträger speichern. Sie können die Daten dann entschlüsseln, wenn die Nachrichten empfangenwerden.

Themen• Verschlüsselung im Ruhezustand (p. 154)• Schlüsselverwaltung (p. 157)

Verschlüsselung im RuhezustandServerseitige Verschlüsselung (SSE) ermöglicht Ihnen, vertrauliche Daten in verschlüsseltenWarteschlangen zu übermitteln. SSE schützt die Nachrichteninhalte in Warteschlangen mit Schlüsseln,die in AWS Key Management Service (AWS KMS) verwaltet werden. Weitere Informationen über dieVerwaltung von SSE mit der AWS Management Console oder der AWS SDK for Java (und der AktionenCreateQueue, SetQueueAttributes und GetQueueAttributes) finden Sie in den folgendenTutorials:

• Erstellen einer Amazon SQS-Warteschlange mit SSE (p. 20)• Konfigurieren von SSE für eine vorhandene Amazon SQS-Warteschlange (p. 62)• Aktivieren der Kompatibilität zwischen AWS-Services und verschlüsselten Warteschlangen (p. 160)

154




Amazon Simple Queue Service EntwicklerhandbuchDatenverschlüsselung

SSE verschlüsselt Nachrichten, sobald sie bei Amazon SQS eingehen. Die Nachrichten werdenverschlüsselt gespeichert. Amazon SQS entschlüsselt Nachrichten nur, wenn sie an einen autorisiertenKunden gesendet werden.

Important

Alle Anforderungen an Warteschlangen mit aktivierter SSE müssen HTTPS und Signature Version4 verwenden.Es ist nicht möglich, eine verschlüsselte Warteschlange (p. 154), die einen von AWS verwaltetenKunden-Masterschlüssel für Amazon SQS verwendet, mit einer Lambda-Funktion in einemanderen AWS-Konto zu verknüpfen.Einige Funktionen der AWS-Services, die Benachrichtigungen an Amazon SQS mithilfe derAktion AWS Security Token Service AssumeRole senden können, sind mit SSE kompatibel,funktionieren jedoch nur mit Standard-Warteschlangen:

• Auto Scaling-Lebenszyklus-Hooks• AWS Lambda-Warteschlangen für unzustellbare Nachrichten

Weitere Informationen zur Kompatibilität anderer Services mit verschlüsselten Warteschlangenfinden Sie unter Aktivieren der Kompatibilität zwischen AWS-Services und verschlüsseltenWarteschlangen (p. 160) und in der Dokumentation Ihres Services.

AWS KMS kombiniert sichere, hoch verfügbare Hard- und Software, um ein System für dieSchlüsselverwaltung bereitzustellen, das für die Cloud skaliert ist. Wenn Sie Amazon SQS mit AWS KMSverwenden, werden die Datenschlüssel (p. 156), mit denen Ihre Nachrichtendaten verschlüsselt werden,ebenfalls verschlüsselt und mit den Daten, die sie schützen, gespeichert.

Vorteile von AWS KMS:

• Sie können sog. Kundenmasterschlüssel (Customer Master Keys, CMKs) (p. 156) selbst erstellen undverwalten.

• Außerdem können Sie den von AWS verwalteten CMK für Amazon SQS verwenden, der für jedes Kontound jede Region eindeutig ist.

• Die Sicherheitsstandards von AWS KMS tragen dazu bei, dass Sie Ihre Compliance-Anforderungenbezüglich der Verschlüsselung erfüllen.

Weitere Informationen finden Sie unter Was ist AWS Key Management Service? im den WhitepapersAWS Key Management Service Developer Guide und Kryptographische Details zu AWS Key ManagementService

Themen• Verschlüsselungsumfang (p. 155)• Wichtige Begriffe (p. 156)

Verschlüsselungsumfang

SSE verschlüsselt den Nachrichtentext in einer Amazon SQS-Warteschlange.

Folgendes wird von SSE nicht verschlüsselt:

• Metadaten der Warteschlange (Name und Attribute)• Metadaten der Nachrichten (ID, Zeitstempel und Attribute)• Metriken pro Warteschlange

155



https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html



https://docs.aws.amazon.com/kms/latest/developerguide/overview.html

https://d0.awsstatic.com/whitepapers/KMS-Cryptographic-Details.pdf

https://d0.awsstatic.com/whitepapers/KMS-Cryptographic-Details.pdf


Durch die Verschlüsselung sind die Nachrichteninhalte für nicht autorisierte oder anonyme Benutzer nichtzugänglich. Dies wirkt sich nicht auf die normale Funktion von Amazon SQS aus:

• Eine Nachricht ist nur dann verschlüsselt, wenn sie gesendet wurde, nachdem die Verschlüsselung einerWarteschlange aktiviert wurde. Amazon SQS verschlüsselt keine Nachrichten, die sich bereits in derWarteschlange befinden.

• Verschlüsselte Nachrichten bleiben auch dann verschlüsselt, wenn die Verschlüsselung derWarteschlange deaktiviert wird.

Das Verschieben einer Nachricht in eine Warteschlange für unzustellbare Nachrichten (p. 102) wirkt sichnicht auf ihre Verschlüsselung aus:

• Wenn Amazon SQS eine Nachricht aus einer verschlüsselten Quellwarteschlange in eineunverschlüsselte Warteschlange für unzustellbare Nachrichten verschiebt, bleibt die Nachrichtverschlüsselt.

• Wenn Amazon SQS eine Nachricht aus einer unverschlüsselten Quellwarteschlange in eineverschlüsselte Warteschlange für unzustellbare Nachrichten verschiebt, bleibt die Nachrichtunverschlüsselt.

Wichtige Begriffe

Die folgenden wichtigen Begriffe vermitteln Ihnen ein besseres Verständnis für die Funktionalität von SSE.Detaillierte Beschreibungen finden Sie im Amazon Simple Queue Service API Reference.

Datenschlüssel

Der Datenverschlüsselungsschlüssel (Data Encryption Key, DEK), der dafür zuständig ist, den Inhaltvon Amazon SQS-Nachrichten zu verschlüsseln.

Weitere Informationen finden Sie unter Datenschlüssel im AWS Key Management Service DeveloperGuide und Envelope-Verschlüsselung im AWS-Verschlüsselungs-SDK-Entwicklerhandbuch.

Wiederverwendungszeitraum für den Datenschlüssel

Die Zeit in Sekunden, wie lange Amazon SQS einen Datenschlüssel wiederverwenden kann, umNachrichten vor dem erneuten Aufrufen von AWS KMS zu ver- oder entschlüsseln. Eine Ganzzahlstellt Sekunden dar, und zwar zwischen 60 Sekunden (1 Minute) und 86 400 Sekunden (24 Stunden).Der Standardwert ist 300 (5 Minuten). Weitere Informationen finden Sie unter Grundlegendes zumWiederverwendungszeitraum für den Datenschlüssel (p. 157).

Note

In dem unwahrscheinlichen Fall, dass AWS KMS nicht erreichbar ist, verwendet Amazon SQSden Datenschlüssel im Cache weiter, bis eine Verbindung wiederhergestellt ist.

Kundenmasterschlüssel-ID

Der Alias, Alias ARN, die Schlüssel-ID oder der Schlüssel-ARN eines von AWS verwaltetenKundenmasterschlüssels (CMK) oder ein benutzerdefinierter CMK — in Ihrem Konto oder in einemanderen Konto. Während der Alias des von AWS verwalteten CMK für Amazon SQS immer alias/aws/sqs ist, kann der Alias eines benutzerdefinierten CMK beispielsweise alias/MyAlias lauten.Sie können diese CMKs zum Schutz der Nachrichten in Amazon SQS-Warteschlangen verwenden.

Note


AWS verwalteten CMK für Amazon SQS. Informationen zum Erstellen benutzerdefinierter

156


https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys

https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/how-it-works.html#envelope-encryption


CMKs finden Sie unter Erstellen von Schlüsseln im AWS Key Management ServiceDeveloper Guide.



Sie können CMKs erstellen, die Richtlinien, die die Verwendung von CMKs steuern, definieren und dieCMK-Nutzung mithilfe des Abschnitts Customer managed keys (Benutzerverwaltete Schlüssel) derAWS KMS-Konsole oder die AWS KMS-Aktion CreateKey überprüfen. Weitere Informationen findenSie unter Kundenmasterschlüssel (CMKs) und Erstellen von Schlüsseln im AWS Key ManagementService Developer Guide. Weitere Beispiele für CMK-IDs finden Sie unter KeyId im AWS KeyManagement Service API Reference. Weitere Informationen zum Suchen von CMK-IDs finden Sieunter Die Schlüssel-ID und den ARN finden im AWS Key Management Service Developer Guide.

Important

Für AWS KMS fallen zusätzliche Gebühren an. Weitere Informationen finden SieunterEinschätzen der AWS KMS-Kosten (p. 158) und AWS Key Management Service –Preise.

SchlüsselverwaltungDie folgenden Abschnitte enthalten Informationen zum Arbeiten mit Schlüsseln, die in AWS KeyManagement Service (AWS KMS) verwaltet werden.

Themen• Grundlegendes zum Wiederverwendungszeitraum für den Datenschlüssel (p. 157)• Einschätzen der AWS KMS-Kosten (p. 158)• Konfigurieren von AWS KMS-Berechtigungen (p. 159)• AWS KMS Fehler (p. 161)

Grundlegendes zum Wiederverwendungszeitraum für den Datenschlüssel

Amazon SQS nutzt einen einzelnen Kundenmasterschlüssel (entweder den von AWS verwaltetenCMK für Amazon SQS oder einen benutzerdefinierten CMK), um eine Envelope-Verschlüsselung undEntschlüsselung von mehreren Amazon SQS-Nachrichten während des Wiederverwendungszeitraumsfür den Datenschlüssel bereitzustellen. Um den Wiederverwendungszeitraum für denDatenschlüssel (p. 156) optimal zu nutzen, beachten Sie Folgendes:

• Ein kürzerer Wiederverwendungszeitraum bietet mehr Sicherheit, führt aber zu mehr Aufrufen von AWSKMS, wofür nach dem kostenlosen Kontingent Gebühren anfallen können.

• Obwohl der Datenschlüssel für die Verschlüsselung und Entschlüsselung separat zwischengespeichertwird, gilt der Wiederverwendungszeitraum für beide Kopien des Datenschlüssels.

• Prinzipale (AWS-Konten oder IAM-Benutzer) teilen keine Datenschlüssel (Nachrichten von eindeutigenPrinzipalen erhalten immer eindeutige Datenschlüssel). Daher ist das Volumen der Aufrufe von AWSKMS ein Vielfaches der Anzahl eindeutiger Prinzipale, die während des Wiederverwendungszeitraumsverwendet werden:• Wenn Sie Nachrichten mit der Aktion SendMessage oder SendMessageBatch senden, ruft Amazon

SQS den AWS KMS in der Regel mithilfe der Aktionen GenerateDataKey und Decrypt einmal proWiederverwendungszeitraum des Datenschlüssels auf.

157


https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html

https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys


https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters

https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn

https://aws.amazon.com/kms/pricing

https://aws.amazon.com/kms/pricing

https://docs.aws.amazon.com/kms/latest/developerguide/workflow.html#envelope_encryption

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Principal


Note

Für jeden Datenschlüssel, den AWS KMS generiert, ruft SSE die Aktion Decrypt auf, um dieIntegrität des Datenschlüssels vor dem Verwenden zu überprüfen.

• Wenn Sie Nachrichten mit der Aktion ReceiveMessage erhalten, ruft Amazon SQS die AWS KMSDecrypt-Aktion in der Regel einmal pro Wiederverwendungszeitraum des Datenschlüssels auf.

Einschätzen der AWS KMS-Kosten

Um Ihre Ausgaben besser zu planen und Ihre AWS-Rechnung besser zu verstehen, müssen Sie wissen,wie oft Amazon SQS Ihren Kundenmasterschlüssel (CMK) verwendet.

Note

Mit der nachstehenden Formel erhalten Sie eine gute Vorstellung davon, welche Kosten aufSie zukommen. Allerdings können die tatsächlichen Kosten aufgrund der verteilten Struktur vonAmazon SQS höher liegen.

Zur Berechnung der Anzahl der API-Anfragen (R) pro Warteschlange verwenden Sie folgende Formel:

R = B / D * (2 * P + C)

B ist der Abrechnungszeitraum (in Sekunden).

D ist der Zeitraum für die Wiederverwendung des Datenschlüssels (p. 156) (in Sekunden).

P ist die Anzahl der produzierenden Prinzipale, die Nachrichten an die Amazon SQS-Warteschlangesenden.

C ist die Anzahl der konsumierenden Prinzipale, die Nachrichten aus der Amazon SQS-Warteschlangeerhalten.

Important

Für produzierende Prinzipale entstehen in der Regel doppelt so hohe Kosten wie fürkonsumierende Prinzipale. Weitere Informationen finden Sie unter Grundlegendes zumWiederverwendungszeitraum für den Datenschlüssel (p. 157)Die Kosten erhöhen sich, wenn der Produzent und der Verbraucher unterschiedliche IAM-Benutzer haben.

Es folgen Beispielberechnungen: Preisinformationen finden Sie unter AWS Key Management Service-Preise.

Beispiel 1: Berechnung der Anzahl der AWS KMS-API-Aufrufe für 2 Prinzipale und1 Warteschlange

In diesem Beispiel wird Folgendes angenommen:

• Der Abrechnungszeitraum ist 1. bis 31. Januar (2 678 400 Sekunden).• Der Wiederverwendungszeitraum für den Datenschlüssel ist auf 5 Minuten (300 Sekunden) eingestellt.• Es ist 1 Warteschlange vorhanden.• Es gibt 1 produzierenden und 1 konsumierenden Prinzipal.

2,678,400 / 300 * (2 * 1 + 1) = 26,784

158

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Principal

https://aws.amazon.com/kms/pricing/

https://aws.amazon.com/kms/pricing/


Beispiel 2: Berechnung der Anzahl der AWS KMS-API-Aufrufe für mehrere Produzenten undKonsumenten sowie 2 Warteschlangen

In diesem Beispiel wird Folgendes angenommen:

• Der Abrechnungszeitraum ist 1. bis 28. Februar (2 419 200 Sekunden).• Der Wiederverwendungszeitraum für den Datenschlüssel ist auf 24 Stunden (86 400 Sekunden)

eingestellt.• Es gibt 2 Warteschlangen.• Die erste Warteschlange hat 3 produzierende Prinzipale und 1 konsumierenden Prinzipal.• Die zweite Warteschlange hat 5 produzierende und 2 konsumierende Prinzipale.

(2,419,200 / 86,400 * (2 * 3 + 1)) + (2,419,200 / 86,400 * (2 * 5 + 2)) = 532

Konfigurieren von AWS KMS-BerechtigungenBevor Sie SSE verwenden können, müssen Sie AWS KMS-Schlüsselrichtlinien konfigurieren, um eineVerschlüsselung von Warteschlangen und eine Verschlüsselung sowie Entschlüsselung von Nachrichtenzu ermöglichen. Beispiele und weitere Informationen zu AWS KMS-Berechtigungen finden Sie unterAWS KMS API-Berechtigungen: Referenztabelle für Aktionen und Ressourcen im AWS Key ManagementService Developer Guide.

Note

Sie können Berechtigungen für KMS-Schlüssel auch mit IAM-Richtlinien verwalten. WeitereInformationen finden Sie unter Verwenden von IAM-Richtlinien mit AWS KMS.Sie können globale Berechtigungen zum Senden und Empfangen von Amazon SQS konfigurieren.Für AWS KMS ist jedoch eine explizite Benennung des vollständigen ARN von CMKs inbestimmten Regionen im Abschnitt Resource der IAM-Richtlinie erforderlich.Für jeden Datenschlüssel, den AWS KMS generiert, ruft SSE die Aktion Decrypt auf, um dieIntegrität des Datenschlüssels vor dem Verwenden zu überprüfen.

Sie müssen auch sicherstellen, dass die Schlüsselrichtlinien des Kundenhauptschlüssels (Customer MasterKey, CMK) die erforderlichen Berechtigungen zulassen. Geben Sie dazu die Namen der Prinzipale an, dieverschlüsselte Nachrichten in Amazon SQS als Benutzer in der CMK-Schlüsselrichtlinie produzieren undverbrauchen.

Alternativ können Sie die erforderlichen AWS KMS-Aktionen und den CMK ARN in einer IAM-Richtlinieangeben, die den Prinzipalen zugewiesen ist, die verschlüsselte Nachrichten in Amazon SQS produzierenund konsumieren. Weitere Informationen finden Sie unter Verwalten des Zugriffs auf AWS KMS CMKs imAWS Key Management Service Developer Guide.

Zulassen, dass ein Benutzer einzelne Nachrichten oder Nachrichtenstapel mit SSE an eineWarteschlange sendet

Der Produzent muss über die Berechtigungen kms:GenerateDataKey und kms:Decrypt für denKundenmasterschlüssel (CMK) verfügen. Für jeden Datenschlüssel, den AWS KMS generiert, ruft SSE dieAktion Decrypt auf, um die Integrität des Datenschlüssels vor dem Verwenden zu überprüfen.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ],

159


https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html

https://docs.aws.amazon.com/kms/latest/developerguide/control-access-overview.html#managing-access


"Resource": "arn:aws:kms:us-east-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab" }, { "Effect": "Allow", "Action": [ "sqs:SendMessage", "sqs:SendMessageBatch" ], "Resource": "arn:aws:sqs:*:123456789012:MyQueue" }]}

Zulassen, dass ein Benutzer Nachrichten mit SSE von einer Warteschlange empfängt

Der Konsument muss über die Berechtigung kms:Decrypt für alle Kundenmasterschlüssel (CMK)verfügen, die für die Verschlüsselung von Nachrichten in der angegebenen Warteschlange verwendetwerden. Für jeden Datenschlüssel, den AWS KMS generiert, ruft SSE die Aktion Decrypt auf, um dieIntegrität des Datenschlüssels vor dem Verwenden zu überprüfen. Wenn es sich um eine Warteschlangefür unzustellbare Nachrichten (p. 102) handelt, muss der Konsument zusätzlich über die kms:Decrypt-Berechtigung für jeden CMK verfügen, mit dem die Nachrichten in der Quellwarteschlange verschlüsseltwerden.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "kms:Decrypt" ], "Resource": "arn:aws:kms:us-east-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab" }, { "Effect": "Allow", "Action": [ "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:*:123456789012:MyQueue" }]}

Kompatibilität zwischen Ereignisquellen aus AWS Services und verschlüsselten Warteschlangenermöglichen

Mehrere AWS-Dienste senden Ereignisse an Amazon SQS-Warteschlangen. Damit diese Ereignisquellenmit verschlüsselten Warteschlangen arbeiten können, müssen Sie die folgenden Schritte ausführen:

1. Verwenden Sie ein kundenverwaltetes CMK. Weitere Informationen finden Sie unter Erstellen vonSchlüsseln im AWS Key Management Service Developer Guide.

2. Um zu ermöglichen, dass der AWS-Service über die Berechtigungen kms:GenerateDataKey* undkms:Decrypt verfügt, fügen Sie die folgende Aussage zur CMK-Richtlinie hinzu.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": { "Service": "service.amazonaws.com" }, "Action": [ "kms:GenerateDataKey*", "kms:Decrypt"

160




], "Resource": "*" }]}

Ereignisquelle Prinzipal

Amazon CloudWatch Events events.amazonaws.com

Amazon S3-Ereignisbenachrichtigungen s3.amazonaws.com

Amazon SNS-Themenabonnements sns.amazonaws.com

3. Erstellen einer neuen SSE-Warteschlange (p. 20) oder Konfigurieren einer vorhandenen SSE-Warteschlange (p. 62) mit dem ARN Ihres CMK.

4. Stellen Sie der verschlüsselten Warteschlange den ARN der Ereignisquelle zur Verfügung.

AWS KMS Fehler

Wenn Sie mit Amazon SQS und AWS KMS arbeiten, können Fehler auftreten. Die folgende Listebeschreibt die Fehler und möglichen Lösungen.

KMSAccessDeniedException

Der Verschlüsselungstext verweist auf einen Schlüssel, der nicht vorhanden ist oder auf den Siekeinen Zugriff haben.

HTTP Status Code: 400KMSDisabledException

Die Anforderung wurde abgelehnt, da der angegebene CMK nicht aktiviert ist.

HTTP Status Code: 400KMSInvalidStateException

Die Anforderung wurde abgelehnt, da der Status der angegebenen Ressource für diese Anforderungungültig ist. Weitere Informationen finden Sie im Abschnitt über die Auswirkungen des Schlüsselstatusauf die Verwendung eines Kundenmasterschlüssels im AWS Key Management Service DeveloperGuide.

HTTP Status Code: 400KMSNotFoundException

Die Anforderung wurde abgelehnt, da die angegebene Entity oder Ressource nicht gefunden wurde.

HTTP Status Code: 400KMSOptInRequired

Die AWS-Zugriffsschlüssel-ID benötigt ein Abonnement für den Service.

HTTP Status Code: 403KMSThrottlingException

Die Anforderung wurde aufgrund der Drosselung von Anforderungen abgelehnt. Weitere Informationenzur Ablehnung finden Sie unter Limits im AWS Key Management Service Developer Guide.

HTTP Status Code: 400

161

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html


https://docs.aws.amazon.com/sns/latest/dg/sns-tutorial-create-subscribe-endpoint-to-topic.html

https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html

https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html

https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second

Amazon Simple Queue Service EntwicklerhandbuchRichtlinie für den Datenverkehr zwischen Netzwerken

Richtlinie für den Datenverkehr zwischen NetzwerkenEin Amazon Virtual Private Cloud (Amazon VPC)-Endpunkt für Amazon SQS ist eine logische Entitätinnerhalb einer VPC, die ausschließlich Verbindungen mit Amazon SQS zulässt. Die VPC leitet Anfragenan Amazon SQS weiter und die Antworten zurück an die VPC. In den folgenden Abschnitten finden SieInformationen zum Arbeiten mit VPC-Endpunkten und zum Erstellen von VPC-Endpunktrichtlinien.

Themen• Amazon Virtual Private Cloud-Endpunkte für Amazon SQS (p. 162)• Erstellen einer Amazon VPC-Endpunktrichtlinie für Amazon SQS (p. 162)

Amazon Virtual Private Cloud-Endpunkte für Amazon SQSWenn Sie Amazon VPC zum Hosten von AWS-Ressourcen verwenden, können Sie eine Verbindungzwischen der VPC und Amazon SQS einrichten. Sie können diese Verbindung zum Senden vonNachrichten an Ihre Amazon SQS-Warteschlangen ganz ohne das öffentliche Internet verwenden.

Mit Amazon VPC können Sie AWS-Ressourcen in einem benutzerdefinierten virtuellen Netzwerk starten.Mit einer VPC können Sie Netzwerkeinstellungen, wie IP-Adressbereich, Subnetze, Routing-Tabellenund Netzwerk-Gateways, steuern. Weitere Informationen zu VPCs finden Sie unter Amazon VPCBenutzerhandbuch.

Um Ihre VPC mit Amazon SQS zu verbinden, müssen Sie zunächst einen Schnittstellen-VPC-Endpunktdefinieren, der eine Verbindung zwischen Ihrer VPC mit anderen AWS-Services ermöglicht. Der Endpunktbietet eine zuverlässige, skalierbare Konnektivität mit Amazon SQS, ohne dass ein Internet-Gateway,eine NAT-Instance (Network Address Translation) oder eine VPN-Verbindung erforderlich ist. WeitereInformationen finden Sie unter Senden einer Nachricht an eine Amazon SQS-Warteschlange über AmazonVirtual Private Cloud (p. 43) und Zugriffsverweigerung, wenn dieser nicht von einem VPC-Endpunkt auserfolgt (p. 189) in diesem Handbuch und unter Schnittstellen-VPC-Endpunkte (AWS PrivateLink) imAmazon VPC Benutzerhandbuch.

Important

• Sie können Amazon Virtual Private Cloud nur mit HTTPS-Amazon SQS-Endpunktenverwenden.

• Wenn Sie Amazon SQS zum Senden von Nachrichten aus Amazon VPC konfigurieren, müssenSie privates DNS aktivieren und Endpunkte im Format sqs.us-east-2.amazonaws.comangeben.

• Ein privates DNS unterstützt keine Legacy-Endpunkte wie queue.amazonaws.com oder us-east-2.queue.amazonaws.com.

Erstellen einer Amazon VPC-Endpunktrichtlinie für Amazon SQSSie können eine Richtlinie für Amazon VPC-Endpunkte für Amazon SQS erstellen, in der Sie Folgendesangeben:

• Prinzipal, der die Aktionen ausführen kann• Die Aktionen, die ausgeführt werden können.• Die Ressourcen, für die Aktionen ausgeführt werden können.

Weitere Informationen finden Sie unter Zugriffskontrolle auf Services mit VPC-Endpunkten im Amazon VPCBenutzerhandbuch.

162

https://docs.aws.amazon.com/vpc/latest/userguide/

https://docs.aws.amazon.com/vpc/latest/userguide/

https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html

https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html

Amazon Simple Queue Service EntwicklerhandbuchIdentitäts- und Zugriffsverwaltung

Im folgenden Beispiel für eine VPC-Endpunktrichtlinie wird angegeben, dass der IAM-Benutzer MyUserNachrichten an die Amazon SQS-Warteschlange MyQueue senden darf.

{ "Statement": [{ "Action": ["sqs:SendMessage"], "Effect": "Allow", "Resource": "arn:aws:sqs:us-east-2:123456789012:MyQueue", "Principal": { "AWS": "arn:aws:iam:123456789012:user/MyUser" } }]}

Folgendes wird abgelehnt:

• Andere Amazon SQS-API-Aktionen, z. B. sqs:CreateQueue und sqs:DeleteQueue.• Andere IAM-Benutzer und -Regeln, die versuchen, diesen VPC-Endpunkt zu verwenden.• MyUser – Senden von Nachrichten an eine andere Amazon SQS-Warteschlange.

Note

Der IAM-Benutzer kann nach wie vor andere Amazon SQS-API-Aktionen von außerhalb der VPCverwenden. Weitere Informationen finden Sie unter Zugriffsverweigerung, wenn dieser nicht voneinem VPC-Endpunkt aus erfolgt (p. 189).

Identitäts- und Zugriffsverwaltung in Amazon SQSFür den Zugriff auf Amazon SQS werden Anmeldeinformationen benötigt, die AWS zur AuthentifizierungIhrer Anforderungen verwenden kann. Diese Anmeldeinformationen müssen über Berechtigungen für denZugriff auf AWS-Ressourcen, wie beispielsweise eine Amazon SQS-Warteschlange und Nachrichten,verfügen. In den folgenden Abschnitten erfahren Sie, wie Sie Ihre Ressourcen mithilfe von AWS Identityand Access Management (IAM) und Amazon SQS schützen können, indem Sie den Zugriff daraufkontrollieren.

Themen• Authentifizierung (p. 163)• Zugriffskontrolle (p. 165)• Übersicht über die Zugriffsverwaltung in Amazon SQS (p. 165)• Verwenden von identitätsbasierten Richtlinien mit Amazon SQS (p. 171)• Verwenden benutzerdefinierter Richtlinien mit der Amazon SQS Access Policy Language (p. 180)• Verwenden von temporären Sicherheitsanmeldeinformationen mit Amazon SQS (p. 190)• Amazon SQS-API-Berechtigungen: Referenztabelle für Aktionen und Ressourcen (p. 191)

AuthentifizierungSie können mit einer der folgenden Identitäten auf AWS zugreifen:

• Stammbenutzer des AWS-Kontos – Wenn Sie ein AWS-Konto neu erstellen, enthält es zunächst nureine einzelne Anmeldeidentität, die über Vollzugriff auf sämtliche AWS-Services und -Ressourcenim Konto verfügt. Diese Identität wird als Root-Benutzer des AWS-Kontos bezeichnet. Um aufes zuzugreifen, müssen Sie sich mit der E-Mail-Adresse und dem Passwort anmelden, die zurErstellung des Kontos verwendet wurden. Wir raten ausdrücklich davon ab, den Root-Benutzer für

163



Amazon Simple Queue Service EntwicklerhandbuchAuthentifizierung

Alltagsaufgaben einschließlich administrativen Aufgaben zu verwenden. Bleiben Sie stattdessen beider bewährten Methode, den Root-Benutzer nur zu verwenden, um Ihren ersten IAM-Benutzer zuerstellen. Anschließend legen Sie die Anmeldedaten für den Root-Benutzer an einem sicheren Ort abund verwenden ihn nur, um einige Konto- und Service-Verwaltungsaufgaben durchzuführen.

• IAM-Benutzer – Ein IAM-Benutzer ist eine Identität in Ihrem AWS-Konto mit bestimmtenbenutzerdefinierten Berechtigungen (z. B. die Berechtigung zum Erstellen von a queue in AmazonSQS). Sie können einen IAM-Benutzernamen und ein Passwort für die Anmeldung bei sicherenAWS-Webseiten verwenden. Dazu zählen beispielsweise die AWS Management Console, AWS-Diskussionsforen und das AWS Support Center.

Zusätzlich zu einem Benutzernamen und Passwort können Sie Zugriffsschlüssel für jeden Benutzererstellen. Verwenden Sie diese Schlüssel, wenn Sie über eines der verschiedenen SDKs oder über dieAWS Command Line Interface (CLI) programmgesteuert auf AWS-Services zugreifen. Das SDK und dieCLI-Tools verwenden die Zugriffsschlüssel, um Ihre Anfrage verschlüsselt zu signieren. Wenn Sie keineAWS-Tools verwenden, müssen Sie die Anforderung selbst signieren. Amazon SQS supportsSignatureVersion 4 ein Protokoll für die Authentifizierung eingehender API-Anfragen. Weitere Informationen zurAuthentifizierung von Anfragen finden Sie unter Signature Version 4-Signaturprozess im AWS GeneralReference.

• IAM-Rolle – Eine IAM-Rolle ist eine IAM-Identität, die Sie in Ihrem Konto mit bestimmten Berechtigungen

erstellen können. Eine IAM-Rolle ist einem IAM-Benutzer insofern sehr ähnlich, weil es sich hierbeium eine AWS-Identität mit Berechtigungsrichtlinien handelt, die festlegen, welche Aktionen dieIdentität in AWS ausführen kann und welche nicht. Eine Rolle ist jedoch nicht einer einzigen Personzugeordnet, sondern kann von allen Personen angenommen werden, die diese Rolle benötigen. EinerRolle sind außerdem keine standardmäßigen, langfristigen Anmeldeinformationen (Passwörter oderZugriffsschlüssel) zugeordnet. Wenn Sie eine Rolle annehmen, erhalten Sie stattdessen temporäreAnmeldeinformationen für Ihre Rollensitzung. IAM-Rollen mit temporären Anmeldeinformationen sind infolgenden Situationen hilfreich:

• Zugriff für verbundene Benutzer – Statt einen IAM-Benutzer zu erstellen, können Sie vorhandene

Identitäten von AWS Directory Service, aus Ihrem Unternehmens-Benutzerverzeichnis oder von einemWeb-Identitätsanbieter verwenden. Diese werden als verbundene Benutzer bezeichnet. AWS weisteinem verbundenen Benutzer eine Rolle zu, wenn der Zugriff über einen Identitätsanbieter angefordertwird. Weitere Informationen zu verbundenen Benutzern finden Sie unter Verbundene Benutzer undRollen im IAM-Benutzerhandbuch.

• Zugriff auf AWS-Services: – Eine Servicerolle ist eine IAM-Rolle, die ein Service übernimmt, um

Aktionen in Ihrem Konto für Sie auszuführen. Beim Einrichten einiger AWS-Serviceumgebungenmüssen Sie eine Rolle für den zu übernehmenden Service definieren. Diese Servicerolle muss alle fürden Service erforderlichen Berechtigungen für den Zugriff auf die AWS-Ressourcen, die erforderlichsind, enthalten. Servicerollen unterscheiden sich von Service zu Service, aber viele erlauben Ihnen,Ihre Berechtigungen auszuwählen, solange Sie die dokumentierten Anforderungen für diesen Serviceerfüllen. Service-Rollen bieten nur Zugriff innerhalb Ihres Kontos und können nicht genutzt werden,um Zugriff auf Services in anderen Konten zu erteilen. Sie können eine Servicerolle in IAM erstellen,ändern und löschen. Sie können beispielsweise eine Rolle erstellen, mit der Amazon Redshift inIhrem Namen auf einen Amazon S3-Bucket zugreifen und Daten aus diesem Bucket in einen AmazonRedshift-Cluster laden kann. Weitere Informationen finden Sie unter Erstellen einer Rolle zumDelegieren von Berechtigungen an einen AWS-Service im IAM-Benutzerhandbuch.

• Anwendungen, die auf Amazon EC2 ausgeführt werden: – Sie können eine IAM-Rolle nutzen,

um temporäre Anmeldeinformationen für Anwendungen zu verwalten, die auf einer EC2-

164

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

https://console.aws.amazon.com/

https://forums.aws.amazon.com/

https://forums.aws.amazon.com/

https://console.aws.amazon.com/support/home#/

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html

https://aws.amazon.com/tools/#sdk

https://aws.amazon.com/cli/


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

Amazon Simple Queue Service EntwicklerhandbuchZugriffskontrolle

Instance ausgeführt werden und AWS CLI- oder AWS-API-Anforderungen durchführen. Das istempfehlenswerter als Zugriffsschlüssel innerhalb der EC2 Instance zu speichern. Erstellen Sie einInstance-Profil, das an die Instance angefügt ist, um eine AWS-Rolle einer EC2-Instance zuzuweisenund die Rolle für sämtliche Anwendungen der Instance bereitzustellen. Ein Instance-Profil enthältdie Rolle und ermöglicht, dass Programme, die in der EC2-Instance ausgeführt werden, temporäreAnmeldeinformationen erhalten. Weitere Informationen finden Sie unter Verwenden einer IAM-Rollezum Erteilen von Berechtigungen für Anwendungen, die auf Amazon EC2-Instances ausgeführtwerden im IAM-Benutzerhandbuch.

ZugriffskontrolleAmazon SQS verfügt über ein eigenes ressourcenbasiertes Berechtigungssystem. Dieses verwendetRichtlinien, die in derselben Sprache geschrieben sind wie die AWS Identity and Access Management(IAM)-Richtlinien. Das bedeutet, dass Sie mit Amazon SQS- und IAM-Richtlinien ähnliche Ziele erreichenkönnen.

Note

Es ist wichtig zu verstehen, dass alle AWS-Konten ihre Berechtigungen an Benutzer, die ihrenKonten angehören, delegieren können. Der kontenübergreifende Zugriff ermöglicht Ihnen dengemeinsamen Zugriff auf AWS-Ressourcen, ohne zusätzliche Benutzer verwalten zu müssen.Weitere Informationen über die Verwendung des kontenübergreifenden Zugriffs finden Sie unterEnabling Cross-Account Access im IAM-Benutzerhandbuch.Kontoübergreifende Berechtigungen gelten nicht für die folgenden Aktionen:

• AddPermission

• CreateQueue

• DeleteQueue

• ListQueues

• ListQueueTags

• RemovePermission

• SetQueueAttributes

• TagQueue

• UntagQueue

Derzeit unterstützt Amazon SQS nur einen eingeschränkten Teilbereich der Bedingungsschlüssel,die in IAM verfügbar sind. Weitere Informationen finden Sie unter Referenztabelle für Aktionen undRessourcen (p. 191).

Übersicht über die Zugriffsverwaltung in Amazon SQSJede AWS-Ressource ist Eigentum eines AWS-Kontos und die Berechtigungen für die Erstellung einerRessource oder den Zugriff darauf werden durch Berechtigungsrichtlinien geregelt. Ein Kontoadministratorkann IAM-Identitäten (d. h. Benutzern, Gruppen und Rollen) Berechtigungsrichtlinien zuweisen. MancheServices (wie Amazon SQS) unterstützen auch die Zuweisung von Berechtigungsrichtlinien zu Ressourcen.

Note

Ein Kontoadministrator (oder Administratorbenutzer) ist ein Benutzer mitAdministratorberechtigungen. Weitere Informationen finden Sie unter Bewährte Methoden für IAMim IAM-Benutzerhandbuch.

Beim Erteilen von Berechtigungen geben Sie an, wer die Berechtigungen erhält, für welche Ressourcen dieBerechtigungen gelten und welche Aktionen an dieser Ressource gestattet werden sollen.

165

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html



https://docs.aws.amazon.com/IAM/latest/UserGuide/Delegation.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_AddPermission.html


https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html



https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_RemovePermission.html




https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys


https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html

Amazon Simple Queue Service EntwicklerhandbuchÜbersicht

Themen• Amazon Simple Queue Service-Ressourcen und -Operationen (p. 166)• Grundlegendes zum Eigentum an Ressourcen (p. 166)• Verwalten des Zugriffs auf Ressourcen (p. 167)• Angeben der Richtlinienelemente: Aktionen, Effekte, Ressourcen und Prinzipale (p. 170)• Angeben von Bedingungen in einer Richtlinie (p. 170)

Amazon Simple Queue Service-Ressourcen und -OperationenIn Amazon SQS ist die einzige Ressource die Warteschlange. In einer Richtlinie identifizieren Sie dieRessource, für welche die Richtlinie gilt, mithilfe eines Amazon-Ressourcennamens (ARN). Der folgendenRessource ist ein eindeutiger ARN zugewiesen:

Ressourcentyp ARN-Format

Warteschlange arn:aws:sqs:region:account_id:queue_name

Es folgen Beispiele des ARN-Formats für Warteschlangen:

• Ein ARN für eine Warteschlange mit dem Namen my_queue in der Region USA Ost (Ohio) für das AWS-Konto 123456789012:

arn:aws:sqs:us-east-2:123456789012:my_queue

• Ein ARN für eine Warteschlange mit dem Namen my_queue in den verschiedenen Regionen, die vonAmazon SQS unterstützt werden:

arn:aws:sqs:*:123456789012:my_queue

• Eine ARN, der * oder ? als Platzhalter für den Warteschlangennamen verwendet. In den folgendenBeispielen entspricht der ARN allen Warteschlangen mit dem Präfix my_prefix_:

arn:aws:sqs:*:123456789012:my_prefix_*

Sie können den ARN-Wert für eine vorhandene Warteschlange abrufen, indem Sie die AktionGetQueueAttributes aufrufen. Der Wert des QueueArn-Attributs ist der ARN der Warteschlange.Weitere Informationen zu ARNs finden Sie unter IAMARNs im IAM-Benutzerhandbuch.

Amazon SQS bietet eine Reihe von Aktionen für die Arbeit mit der Warteschlangenressource. WeitereInformationen finden Sie unter Referenztabelle für Aktionen und Ressourcen (p. 191).

Grundlegendes zum Eigentum an RessourcenDas AWS-Konto ist Eigentümer aller Ressourcen, die innerhalb des Kontos erstellt werden, unabhängigdavon, wer sie erstellt. Genauer gesagt ist das AWS-Konto der Prinzipal-Entität (d. h. das Root-Konto,ein IAM-Benutzer oder eine IAM-Rolle), welche die Ressourcenerstellungsanforderung authentifiziert, derRessourceneigentümer. Die Funktionsweise wird anhand der folgenden Beispiele deutlich:

• Wenn Sie die Root-Konto-Anmeldeinformationen für Ihr AWS-Konto verwenden, um eine Amazon SQS-Warteschlange zu erstellen, ist Ihr AWS-Konto der Eigentümer der Ressource (in Amazon SQS ist dieRessource die Amazon SQS-Warteschlange).

166


https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns


• Wenn Sie in Ihrem IAM-Konto einen AWS-Benutzer einrichten und diesem Berechtigungen zumErstellen einer Warteschlange erteilen, kann der Benutzer die Warteschlange erstellen. Eigentümer derWarteschlangenressource ist jedoch das AWS-Konto, zu dem der Benutzer gehört.

• Wenn Sie in Ihrem IAM-Konto eine AWS-Rolle mit Berechtigungen zum Erstellen einer AmazonSQS-Warteschlange einrichten, kann jeder, der die Rolle übernimmt, eine Warteschlange erstellen.Eigentümer der Warteschlangenressource ist immer das AWS-Konto, zu dem die Rolle gehört.

Verwalten des Zugriffs auf RessourcenEine Berechtigungsrichtlinie beschreibt die Berechtigungen, die Konten erteilt werden. Im folgendenAbschnitt werden die verfügbaren Optionen zum Erstellen von Berechtigungsrichtlinien erläutert.

Note

Dieser Abschnitt behandelt die Verwendung von IAM im Zusammenhang mit Amazon SQS.Er enthält keine detaillierten Informationen über den IAM-Service. Eine umfassende IAM-Dokumentation finden Sie im Thema Was ist IAM? im IAM-Benutzerhandbuch. Informationen überdie IAM-Richtliniensyntax und Beschreibungen finden Sie in der AWS IAM Policy Reference (AWSIAM-Richtlinienreferenz) im IAM-Benutzerhandbuch.

Richtlinien, die einer IAM-Identität zugeordnet sind, werden als identitätsbasierte Richtlinien (IAM-Richtlinien) bezeichnet, während Richtlinien, die einer Ressource zugeordnet sind, als ressourcenbasierteRichtlinien bezeichnet werden.

Identitätsbasierte Richtlinien (IAM-Richtlinien und Amazon SQS-Richtlinien)

Es gibt zwei Möglichkeiten, Ihren Benutzern Berechtigungen für Ihre Amazon SQS-Warteschlangen zuerteilen: das Amazon SQS-Richtliniensystem und das IAM-Richtliniensystem. Sie können entweder einesder Systeme oder beide verwenden, um Benutzern oder Rollen Richtlinien anzufügen. In den meistenFällen erzielen Sie mit beiden Systemen dasselbe Ergebnis. Sie können z. B. Folgendes tun:

• Einem Benutzer oder einer Gruppe in Ihrem Konto eine Berechtigungsrichtlinie zuweisen – Wenn Sieeinem Benutzer Berechtigungen zur Erstellung einer Amazon SQS-Warteschlange erteilen möchten,können Sie dem Benutzer oder der Gruppe, zu der er gehört, eine Berechtigungsrichtlinie zuweisen.

• Einem Benutzer in einem anderen AWS-Konto eine Berechtigungsrichtlinie zuweisen – zum Erteilen vonBenutzerberechtigungen zum Erstellen einer Amazon SQS-Warteschlange fügen Sie einem Benutzer ineinem anderen AWS-Konto eine Amazon SQS-Berechtigungsrichtlinie an.

Kontoübergreifende Berechtigungen gelten nicht für die folgenden Aktionen:• AddPermission

• CreateQueue

• DeleteQueue

• ListQueues

• ListQueueTags



• TagQueue

• UntagQueue

• Einer Rolle eine Berechtigungsrichtlinie zuweisen (kontoübergreifende Berechtigungen erteilen) – Siekönnen einer IAM-Rolle eine identitätsbasierte Berechtigungsrichtlinie zuweisen, um kontoübergreifendeBerechtigungen zu erteilen. Beispielsweise kann der Administrator in AWS-Konto A eine Rolle erstellen,um einem anderen AWS-Konto B (oder einem AWS-Service) kontoübergreifende Berechtigungen zuerteilen. Dazu geht er folgendermaßen vor:

167


https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html












• Der Administrator von Konto A erstellt eine IAM-Rolle und weist ihr eine Berechtigungsrichtlinie zu, —die der Rolle Berechtigungen für Ressourcen in Konto A— erteilt.

• Der Administrator von Konto A weist der Rolle eine Vertrauensrichtlinie zu, die Konto B als denPrinzipal identifiziert, der die Rolle übernehmen kann.

• Administrator von Konto B delegiert die Berechtigung zur Übernahme der Rolle an Benutzer inKonto B. So können Benutzer in Konto B Warteschlangen in Konto A erstellen bzw. darauf zugreifen.

Note

Wenn Sie einem AWS-Service die Berechtigung zum Annehmen der Rolle erteilen möchten,kann es sich bei dem Prinzipal in der Vertrauensrichtlinie auch um einen AWS-Service-Prinzipal handeln.

Weitere Informationen zum Delegieren von Berechtigungen mithilfe von IAM finden Sie unter AccessManagement im IAM-Benutzerhandbuch.

Amazon SQS arbeitet zwar mit IAM-Richtlinien, verfügt jedoch über eine eigene Richtlinieninfrastruktur. Siekönnen eine Amazon SQS-Richtlinie mit einer Warteschlange verwenden, um anzugeben, welche AWS-Konten Zugriff auf die Warteschlange haben. Sie können die Art des Zugriffs sowie Bedingungen festlegen(z. B. eine Bedingung, mit der Berechtigungen für SendMessage und für ReceiveMessage erteilt werden,wenn die Anforderung vor dem 31. Dezember 2010 gestellt wurde). Die spezifischen Aktionen, für dieSie Berechtigungen erteilen können, gelten für eine Untergruppe der gesamten Liste der Amazon SQS-Aktionen. Wenn Sie eine Amazon SQS-Richtlinie schreiben und * angeben, um „alle Amazon SQS-Aktionen zu erlauben“, bedeutet dies, dass alle Aktionen dieser Untergruppe von einzelnen Benutzernausgeführt werden können.

Das folgende Diagramm veranschaulicht das Konzept einer dieser grundlegenden Amazon SQS-Richtlinien, die für die Untergruppe der Aktionen gelten. Die Richtlinie gilt für queue_xyz und erteilt AWS-Konto 1 und AWS-Konto 2 Berechtigungen zum Verwenden der zulässigen Aktionen in der angegebenenWarteschlange.

Note

Die Ressource in der Richtlinie wird als 123456789012/queue_xyz angegeben, wobei123456789012 die AWS-Konto-ID des Kontos ist, dem die Warteschlange gehört.

Seit der Einführung von IAM und der Konzepte Benutzer und Amazon-Ressourcennamen (ARNs) gibt eseinige Änderungen in Bezug auf die SQS-Richtlinien. Im folgenden Diagramm und in der Tabelle werdendie Änderungen beschreiben.

168




Weitere Informationen zum Erteilen von Berechtigungen für Benutzer in verschiedenen Konten finden Sieunter Tutorial: Delegieren von Zugriff für AWS-Konten mithilfe von IAM-Rollen im IAM-Benutzerhandbuch.

Die Untergruppe der Aktionen in * wurde erweitert. Eine Liste zulässiger Aktionen finden Sie unterReferenztabelle für Aktionen und Ressourcen (p. 191).

Sie können die Ressource mithilfe des Amazon-Ressourcennamens (ARN) angeben. Dies entsprichtdem standardmäßigen Verfahren zum Festlegen von Ressourcen in IAM-Richtlinien. Weitere Informationenzum ARN-Format für Amazon SQS-Warteschlangen finden Sie unter Amazon Simple Queue Service-Ressourcen und -Operationen (p. 166).

Entsprechend der AWS-Richtlinie im vorherigen Diagramm kann z. B. jeder Benutzer, der über dieSicherheitsanmeldeinformationen für AWS-Konto 1 oder queue_xyz-Konto 2 verfügt, auf Amazon SQSzugreifen. Außerdem haben die Benutzer Bob und Susan in Ihrem eigenen AWS-Konto (Benutzer-ID123456789012) Zugriff auf die Warteschlange.

Vor der Einführung von IAM übertrug Amazon SQS automatisch die vollständige Kontrolle überdie Warteschlange auf den jeweiligen Ersteller der Warteschlange (d. h. Zugriff auf alle möglichenAmazon SQS-Aktionen für diese Warteschlange). Dies trifft nur noch zu, wenn der Ersteller AWS-Sicherheitsanmeldeinformationen verwendet. Jeder Benutzer, der über Berechtigungen zum Erstellen einerWarteschlange verfügt, muss zudem Berechtigungen zur Verwendung anderer Amazon SQS-Aktionenhaben, um Aktionen für die erstellten Warteschlangen ausführen zu können.

Es folgt ein Beispiel für eine Richtlinie, mit der ein Benutzer zwar alle Amazon SQS-Aktionen verwendenkann, jedoch für Warteschlangen, deren Namen mit dem Präfix der Literalzeichenfolge bob_queue_versehen sind.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:123456789012:bob_queue_*" }]

169

https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html


}

Weitere Informationen finden Sie unter Verwenden von identitätsbasierten Richtlinien mit AmazonSQS (p. 171) und Identitäten (Benutzer, Gruppen und Rollen) im IAM-Benutzerhandbuch.

Angeben der Richtlinienelemente: Aktionen, Effekte, Ressourcenund PrinzipaleFür jede Amazon Simple Queue Service-Ressource (p. 166) definiert der Service eine Reihe von -Aktionen. Zur Erteilung von Berechtigungen für diese Aktionen definiert Amazon SQS eine Reihe vonAktionen, die Sie in einer Richtlinie angeben können.

Note

Für das Durchführen einer Aktion können Berechtigungen für mehrere Aktionen erforderlich sein.Bei der Erteilung von Berechtigungen für bestimmte Aktionen geben Sie auch die Ressource an,für die die Aktionen zugelassen oder verweigert werden.

Grundlegende Richtlinienelemente:

• Ressource – In einer Richtlinie wird der Amazon-Ressourcenname (ARN) zur Identifizierung derRessource verwendet, für die die Richtlinie gilt.

• Aktion – Mit Aktionsschlüsselwörtern geben Sie die Ressourcenaktionen an, die Sie zulassen oderverweigern möchten. Die sqs:CreateQueue-Berechtigung erteilt dem Benutzer zum BeispielBerechtigungen zum Ausführen der Amazon Simple Queue Service CreateQueue-Aktion.

• Auswirkung – Die von Ihnen festgelegte Auswirkung, wenn ein Benutzer die jeweilige Aktion anfordert— entweder "Allow" (Zugriffserlaubnis) oder "Deny" (Zugriffsverweigerung). Wenn Sie den Zugriff aufeine Ressource nicht ausdrücklich gestatten (""), wird er automatisch verweigert. Sie können den Zugriffauf eine Ressource auch explizit verweigern. So können Sie sicherstellen, dass Benutzer nicht daraufzugreifen können, auch wenn der Zugriff durch eine andere Richtlinie gestattet wird.

• Prinzipal – In identitätsbasierten Richtlinien (IAM-Richtlinien) ist der Benutzer, dem die Richtliniezugewiesen ist, automatisch der Prinzipal. In ressourcenbasierten Richtlinien müssen Sie den Benutzer,das Konto, den Service oder die sonstige Entität angeben, die die Berechtigungen erhalten soll (gilt nurfür ressourcenbasierte Richtlinien).

Weitere Informationen zur Amazon SQS-Richtliniensyntax und entsprechende Beschreibungen enthält dieAWS IAM-Richtlinienreferenz im IAM-Benutzerhandbuch.

Eine Tabelle mit allenAmazon Simple Queue Service -Aktionen und den Ressourcen, für welche diesegelten, finden Sie unter Referenztabelle für Aktionen und Ressourcen (p. 191).

Angeben von Bedingungen in einer RichtlinieBeim Erteilen von Berechtigungen können Sie mithilfe der Amazon SQS Access Policy Language dieBedingungen angeben, wann die Richtlinie wirksam werden soll. Beispielsweise kann festgelegt werden,dass eine Richtlinie erst ab einem bestimmten Datum gilt. Weitere Informationen zum Angeben vonBedingungen in einer Richtliniensyntax finden Sie im Thema Bedingung im IAM-Benutzerhandbuch.

Bedingungen werden mithilfe vordefinierter Bedingungsschlüssel formuliert. Für Amazon SQS gibt eskeine speziellen Bedingungsschlüssel. Stattdessen können Sie die AWS-weiten Bedingungsschlüssel mitAmazon SQS verwenden. Derzeit unterstützt Amazon SQS nur einen eingeschränkten Teilbereich der inIAM verfügbaren Bedingungsschlüssel:

• aws:CurrentTime

• aws:EpochTime

• aws:SecureTransport

170

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html



https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition



Amazon Simple Queue Service EntwicklerhandbuchVerwenden identitätsbasierter Richtlinien

• aws:SourceArn

Note

This condition ensures that AWS services grant access only on behalf of resources that yourAWS account owns. You can't specify the ARN of an IAM role as source ARN, because an IAMrole is neither a source nor a service.

• aws:SourceIP

• aws:UserAgent

• aws:MultiFactorAuthAge

• aws:MultiFactorAuthPresent

• aws:RequestTag

• aws:sourceVpce

• aws:TagKeys

• aws:TokenAge

Verwenden von identitätsbasierten Richtlinien mitAmazon SQSIn diesem Thema finden Sie Beispiele für identitätsbasierte Richtlinien, in denen ein Kontoadministrator denIAM-Identitäten (Benutzern, Gruppen und Rollen) Berechtigungsrichtlinien zuweisen kann.

Important

Wir empfehlen Ihnen, zunächst die einführenden Themen zu lesen, in denen die Grundkonzepteund für Sie verfügbaren Optionen zum Verwalten des Zugriffs auf Ihre Amazon Simple QueueService-Ressourcen erläutert werden. Weitere Informationen finden Sie unter Übersicht über dieVerwaltung von Zugriffsberechtigungen (p. 165).Mit Ausnahme von ListQueues unterstützen alle Amazon SQS-Aktionen Berechtigungen aufRessourcenebene. Weitere Informationen finden Sie unter Referenztabelle für Aktionen undRessourcen (p. 191).

Themen• Verwenden von Amazon SQS- und IAM-Richtlinien (p. 171)• Erforderliche Berechtigungen für die Verwendung der Amazon SQS-Konsole (p. 173)• AWSVon AWS verwaltete (vordefinierte) Richtlinien für Amazon SQS (p. 173)• Grundlegende Beispiele von IAM-Richtlinien für Amazon SQS (p. 174)• Grundlegende Beispiele von Amazon SQS-Richtlinien (p. 176)

Verwenden von Amazon SQS- und IAM-RichtlinienEs gibt zwei Möglichkeiten, Ihren Benutzern Berechtigungen für Ihre Amazon SQS-Ressourcen zu erteilen:das Amazon SQS-Richtliniensystem und das IAM-Richtliniensystem. Sie können entweder das eine oderdas andere oder beide Systeme verwenden. In den meisten Fällen erzielen Sie mit beiden Systemendasselbe Ergebnis.

Die folgende Abbildung zeigt eine IAM-Richtlinie und eine entsprechende Amazon SQS-Richtlinie.Die IAM-Richtlinie erteilt die Berechtigungen für die Amazon SQS-Aktionen ReceiveMessage undSendMessage für die Warteschlange mit dem Namen queue_xyz in Ihrem AWS-Konto. Die Richtlinieist den Benutzern Bob und Susan zugewiesen (diese Benutzer verfügen über die in der Richtlinieangegebenen Berechtigungen). Diese Amazon SQS-Richtlinie erteilt Bob und Susan Berechtigungen zumAusführen der Aktionen ReceiveMessage und SendMessage für dieselbe Warteschlange.

171


Note

Das folgende Beispiel veranschaulicht einfache Richtlinien ohne Bedingungen. Sie können einebestimmte Bedingung in einer der Richtlinien angeben und erhalten dasselbe Ergebnis.

Es gibt einen großen Unterschied zwischenIAM- und Amazon SQS-Richtlinien: Im Gegensatz zum AmazonSQS-Richtliniensystem können Sie mit dem AWS-Richtliniensystem Berechtigungen für andere IAM-Konten erteilen.

Sie entscheiden, wie Sie beide Systeme zum Verwalten von Berechtigungen verwenden. Die folgendenBeispiele zeigen, wie die beiden Richtliniensysteme zusammenarbeiten.

• Im ersten Beispiel verfügt Bob sowohl über eine IAM- als auch eine Amazon SQS-Richtlinie, die für seinKonto gelten. Die IAM-Richtlinie erteilt seinem Konto die Berechtigung für die Aktion ReceiveMessagefür queue_xyz, während die Amazon SQS-Richtlinie sein Konto berechtigt, die Aktion SendMessage fürdieselbe Warteschlange auszuführen. Das folgende Diagramm verdeutlicht das Konzept.

Wenn Bob eine ReceiveMessage-Anforderung an queue_xyz sendet, lässt die IAM-Richtlinie dieAktion zu. Wenn Bob eine SendMessage-Anforderung an queue_xyz sendet, lässt die Amazon SQS-Richtlinie die Aktion zu.

• Im zweiten Beispiel missbraucht Bob seinen Zugriff auf queue_xyz, sodass es nötig wird, seinengesamten Zugriff auf die Warteschlange zu verweigern Der einfachste Weg ist, eine Richtlinie

172


hinzuzufügen, die ihm den Zugriff auf alle Aktionen für die Warteschlange verweigert. Diese Richtliniesetzt die beiden anderen außer Kraft, da ein explizites deny ein allowimmer überschreibt. WeitereInformationen zur Richtlinienauswertungslogik finden Sie unter Verwenden benutzerdefinierter Richtlinienmit der Amazon SQS Access Policy Language (p. 180). Das folgende Diagramm verdeutlicht dasKonzept.

Sie können der Amazon SQS-Richtlinie auch eine Anweisung hinzufügen, die Bob alle Zugriffe auf dieWarteschlange verweigert. Es hat die gleiche Auswirkung wie das Hinzufügen einer IAM-Richtlinie,die Bob den Zugriff auf die Warteschlange verweigert. Beispiele von Richtlinien, die Amazon SQS-Aktionen und Ressourcen abdecken, finden Sie unter Grundlegende Beispiele von Amazon SQS-Richtlinien (p. 176). Weitere Informationen zum Erstellen von Amazon SQS-Richtlinien finden Sie unterVerwenden benutzerdefinierter Richtlinien mit der Amazon SQS Access Policy Language (p. 180).

Erforderliche Berechtigungen für die Verwendung der AmazonSQS-KonsoleEin Benutzer, der mit der Amazon SQS-Konsole arbeiten möchte, muss über die Mindestmenge anBerechtigungen verfügen, die es ihm erlauben, die Amazon SQS-Warteschlangen im AWS-Konto desBenutzers zu verwenden. Beispielsweise muss der Benutzer über die Berechtigung zum Aufruf der AktionListQueues verfügen, um Warteschlangen aufzulisten, oder über die Berechtigung zum Aufruf der AktionCreateQueue, um Warteschlangen erstellen zu können. Zusätzlich zu den Amazon SQS-Berechtigungenerfordert die Konsole zum Abonnieren einer Amazon SQS-Warteschlange für ein Amazon SNS-ThemaBerechtigungen für Amazon SNS-Aktionen.

Wenn Sie eine IAM-Richtlinie erstellen, die strenger ist als die mindestens erforderlichen Berechtigungen,funktioniert die Konsole möglicherweise nicht wie vorgesehen für Benutzer mit dieser IAM-Richtlinie.

Sie müssen keine Mindestkonsolenberechtigungen für Benutzer zulassen, die nur Aufrufe für die AWS CLIoder Amazon SQS-Aktionen durchführen.

AWSVon AWS verwaltete (vordefinierte) Richtlinien für AmazonSQSAWS deckt viele häufige Anwendungsfälle ab durch die Bereitstellung von eigenständigen, von AWSverwalteten IAM-Richtlinien. Diese von AWS verwalteten Richtlinien erleichtern das Arbeiten mit den

173


Berechtigungen durch die Erteilung der für häufige Anwendungsfälle erforderlichen Berechtigungen.Weitere Informationen finden Sie unter AWS-verwaltete Richtlinien im IAM-Benutzerhandbuch.

Die folgenden von AWS verwalteten Richtlinien, die Sie Benutzern in Ihrem Konto anfügen können, geltenspeziell für Amazon SQS:

• AmazonSQSReadOnlyAccess – Gewährt schreibgeschützten Zugriff auf Amazon SQS-Warteschlangenmithilfe der AWS Management Console.

• AmazonSQSFullAccess – Gewährt vollständigen Zugriff auf Amazon SQS-Warteschlangen mithilfe derAWS Management Console.

Sie können verfügbare Richtlinien in der IAM-Konsole suchen und prüfen. Außerdem können Sie eigene,benutzerdefinierte IAM-Richtlinien erstellen, um Berechtigungen für Amazon SQS-Aktionen und -Warteschlangen zu gewähren. Die benutzerdefinierten Richtlinien können Sie dann den IAM-Benutzernoder -Gruppen zuweisen, die Berechtigungen benötigen.

Grundlegende Beispiele von IAM-Richtlinien für Amazon SQSDie folgenden Beispiele bieten eine Einführung in Amazon SQS-Berechtigungsrichtlinien.

Note

Wenn Sie Lebenszyklus-Hooks für Amazon EC2 Auto Scaling konfigurieren, müssen Sie keineRichtlinie schreiben, um Nachrichten an eine Amazon SQS-Warteschlange zu senden. WeitereInformationen finden Sie unter Amazon EC2 Auto Scaling-Lebenszyklus-Hooks im Amazon EC2-Benutzerhandbuch für Linux-Instances.

Beispiel 1: Einem Benutzer das Erstellen von Warteschlangen erlauben

Im folgenden Beispiel wird eine Richtlinie für den Benutzer Bob erstellt, mit der er zwar auf alleAmazon SQS-Aktionen zugreifen kann, aber nur mit Warteschlangen, deren Namen mit dem Präfix derLiteralzeichenfolge alice_queue_ versehen sind.

Amazon SQS gewährt dem Ersteller einer Warteschlange nicht automatisch Berechtigungen zumVerwenden der Warteschlange. Daher müssen wir Bob explizit Berechtigungen zum Verwenden allerAmazon SQS-Aktionen zusätzlich zur Aktion CreateQueue in der IAM-Richtlinie erteilen.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:123456789012:alice_queue_*" }]}

Beispiel 2: Entwicklern erlauben, Nachrichten in eine gemeinsame Warteschlangezu schreiben

Im folgenden Beispiel erstellen wir eine Gruppe für Entwickler und fügen eine Richtlinie an, mit der dieGruppe die Amazon SQS SendMessage-Aktion verwenden kann, allerdings nur mit der Warteschlange, diezu dem angegebenen AWS-Konto gehört und den Namen MyCompanyQueue trägt.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow",

174

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies



"Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:*:123456789012:MyCompanyQueue" }]}

Sie können * anstelle von SendMessage verwenden, um die folgenden Aktionen auf einenPrinzipal auf einer gemeinsamen Warteschlange zu gewähren: ChangeMessageVisibility,DeleteMessageGetQueueAttributes, GetQueueUrl, ReceiveMessage und SendMessage.

Note

Obwohl * den von den anderen Berechtigungstypen bereitgestellten Zugriff beinhaltet, werdenBerechtigungen von Amazon SQS als separat betrachtet. Es ist beispielsweise möglich, einemBenutzer sowohl die Berechtigung * als auch die Berechtigung SendMessage zu erteilen, obwohlein * den von SendMessage bereitgestellten Zugriff gewährt.Dieses Konzept gilt auch, wenn Sie eine Berechtigung entfernen. Wenn einem Prinzipal lediglicheine *-Berechtigung gewährt wurde, verfügt er durch die Anforderung zum Entfernen einerSendMessage-Berechtigung nicht ausschließlich über eine alles außer-Berechtigung. Stattdessenhat die Anforderung keine Auswirkungen, da der Prinzipal keine explizite SendMessage-Berechtigung besitzt. Wenn dem Prinzipal lediglich die ReceiveMessage-Berechtigung erteiltwerden soll, fügen Sie die ReceiveMessage-Berechtigung hinzu und entfernen Sie die *-Berechtigung.

Beispiel 3: Managern erlauben, die allgemeine Größe von Warteschlangenabzurufen

Im folgenden Beispiel erstellen wir eine Gruppe für Manager und fügen eine Richtlinie an, mit der dieGruppe die Amazon SQS GetQueueAttributes-Aktion mit allen Warteschlangen verwenden kann, diezu dem angegebenen AWS-Konto gehört.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:GetQueueAttributes", "Resource": "*" }]}

Beispiel 4: Einem Partner erlauben, Nachrichten an eine bestimmteWarteschlange zu senden

Sie können diese Aufgabe mit einer Amazon SQS- oder einer IAM-Richtlinie ausführen. Wenn Ihr Partnerüber ein AWS-Konto verfügt, empfiehlt sich die Verwendung einer Amazon SQS-Richtlinie. Jeder Benutzerim Unternehmen des Partners, der über die AWS-Sicherheitsanmeldeinformationen verfügt, kann jedochNachrichten an die Warteschlange senden. Wenn Sie den Zugriff auf einen bestimmten Benutzer odereine Anwendung beschränken möchten, müssen Sie den Partner wie einen Benutzer in Ihrem eigenenUnternehmen behandeln und eine IAM-Richtlinie anstelle einer Amazon SQS-Richtlinie verwenden.

Dieses Beispiel führt die folgenden Aktionen aus:

1. Erstellt eine Gruppe namens WidgetCo, um das Unternehmen des Partners darzustellen.2. Erstellt einen Benutzer für den jeweiligen Benutzer oder die Anwendung des Unternehmens des

Partners, der bzw. die Zugriff erfordert.3. Fügen Sie den Benutzer zur Gruppe hinzu.4. Fügt eine Richtlinie an, mit der die Gruppe nur Zugriff auf die Aktion SendMessage ausschließlich für

die Warteschlange mit dem Namen WidgetPartnerQueue erhält.

175


{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:*:123456789012:WidgetPartnerQueue" }]}

Grundlegende Beispiele von Amazon SQS-RichtlinienDieser Abschnitt zeigt Richtlinienbeispiele für allgemeine Amazon SQS-Anwendungsfälle.

Während Sie dem Benutzer die Richtlinien zuweisen, können Sie die Konsole verwenden, um dieAuswirkungen der einzelnen Richtlinien zu überprüfen. Zunächst verfügt der Benutzer über keineBerechtigungen und kann in der Konsole keine Aktionen ausführen. Während Sie dem Benutzer Richtlinienzuweisen, können Sie überprüfen, ob der Benutzer die verschiedenen Aktionen in der Konsole ausführenkann.

Note

Wir empfehlen die Verwendung von zwei Browserfenstern: In dem ersten erteilen SieBerechtigungen und in dem zweiten können Sie sich mit den Anmeldeinformationen desBenutzers bei der AWS Management Console anmelden, um die Berechtigungen zu überprüfen,während Sie sie dem Benutzer erteilen.

Beispiel 1: Einem AWS-Konto eine Berechtigung erteilenIm folgenden Beispiel wird der AWS-Kontonummer 111122223333 die SendMessage-Berechtigung fürdie Warteschlange mit dem Namen 444455556666/queue1 in der Region USA Ost (Ohio) erteilt.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_SendMessage", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ] }, "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:us-east-2:444455556666:queue1" }] }

Beispiel 2: Einem AWS-Konto zwei Berechtigungen erteilenIm folgenden Beispiel werden der AWS-Kontonummer 111122223333 die Berechtigungen SendMessageund ReceiveMessage für die Warteschlange mit dem Namen 444455556666/queue1 erteilt.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_Send_Receive", "Effect": "Allow", "Principal": { "AWS": [

176


"111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:*:444455556666:queue1" }]}

Beispiel 3: Zwei AWS-Konten alle Berechtigungen erteilenIm folgenden Beispiel wird zwei verschiedenen AWS-Konten (111122223333 und 444455556666) dieBerechtigung für alle Aktionen erteilt, für die Amazon SQS gemeinsamen Zugriff auf die Warteschlange mitdem Namen 123456789012/queue1 in der Region USA Ost (Ohio) zulässt.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AllActions", "Effect": "Allow", "Principal": { "AWS": [ "111122223333", "444455556666" ] }, "Action": "sqs:*", "Resource": "arn:aws:sqs:us-east-2:123456789012:queue1" }]}

Beispiel 4: Einer Rolle und einem Benutzernamen kontenübergreifendeBerechtigungen erteilenIm folgenden Beispiel wird role1 und username1 mit der AWS-Kontonummer 111122223333 einekontenübergreifende Berechtigung für alle Aktionen erteilt, für die Amazon SQS gemeinsamen Zugriff aufdie Warteschlange mit dem Namen 123456789012/queue1 in der Region USA Ost (Ohio) zulässt.

Kontoübergreifende Berechtigungen gelten nicht für die folgenden Aktionen:

• AddPermission

• CreateQueue

• DeleteQueue

• ListQueues

• ListQueueTags



• TagQueue

• UntagQueue

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{

177











"Sid":"Queue1_AllActions", "Effect": "Allow", "Principal": { "AWS": [ "arn:aws:iam::111122223333:role/role1", "arn:aws:iam::111122223333:user/username1" ] }, "Action": "sqs:*", "Resource": "arn:aws:sqs:us-east-2:123456789012:queue1" }]}

Beispiel 5: Allen Benutzern eine Berechtigung erteilenMit der folgenden Beispielrichtlinie wird allen Benutzern (anonymen Benutzern) die BerechtigungReceiveMessage für die Warteschlange mit dem Namen 111122223333/queue1 erteilt.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AnonymousAccess_ReceiveMessage", "Effect": "Allow", "Principal": "*", "Action": "sqs:ReceiveMessage", "Resource": "arn:aws:sqs:*:111122223333:queue1" }]}

Beispiel 6: Allen Benutzern eine zeitlich begrenzte Berechtigung erteilenDas folgende Beispiel gewährt die Berechtigung ReceiveMessage allen Benutzern (anonymen Benutzern)der Warteschlange mit dem Namen 111122223333/queue1, aber nur zwischen 12:00 Uhr und 15:00 Uhram 31. Januar 2009.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AnonymousAccess_ReceiveMessage_TimeLimit", "Effect": "Allow", "Principal": "*", "Action": "sqs:ReceiveMessage", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "DateGreaterThan" : { "aws:CurrentTime":"2009-01-31T12:00Z" }, "DateLessThan" : { "aws:CurrentTime":"2009-01-31T15:00Z" } } }]}

Beispiel 7: Allen Benutzern in einem CIDR-Bereich sämtliche BerechtigungenerteilenDas folgende Beispiel erteilt allen Benutzern (anonymen Benutzern) die Berechtigung zur Nutzung allermöglichen Amazon SQS-Aktionen, die für die Warteschlange mit dem Namen 111122223333/queue1

178


geteilt werden können, aber nur, wenn die Anforderung aus dem CIDR-Bereich 192.168.143.0/24kommt.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AnonymousAccess_AllActions_WhitelistIP", "Effect": "Allow", "Principal": "*", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "IpAddress" : { "aws:SourceIp":"192.168.143.0/24" } } }]}

Beispiel 8: Berechtigungen für Benutzer in verschiedenen CIDR-Bereichen auf dieWhitelist und Sperrliste setzen

Die folgende Beispielrichtlinie enthält zwei Anweisungen:

• Die erste Anweisung gewährt allen Benutzer (anonymen Benutzern) im CIDR-Bereich192.168.143.0/24 (mit Ausnahme von 192.168.143.188) die Berechtigung zur Verwendung derAktion SendMessage für die Warteschlange mit dem Namen 111122223333/queue1.

• Die zweite Anweisung setzt alle Benutzer (anonyme Benutzer) im CIDR-Bereich 10.1.2.0/24 für dieNutzung der Warteschlange auf die Sperrliste.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AnonymousAccess_SendMessage_IPLimit", "Effect": "Allow", "Principal": "*", "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "IpAddress" : { "aws:SourceIp":"192.168.143.0/24" }, "NotIpAddress" : { "aws:SourceIp":"192.168.143.188/32" } } }, { "Sid":"Queue1_AnonymousAccess_AllActions_IPLimit_Deny", "Effect": "Deny", "Principal": "*", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "IpAddress" : { "aws:SourceIp":"10.1.2.0/24" } } }]

179

Amazon Simple Queue Service EntwicklerhandbuchVerwenden benutzerdefinierter Richtlinien

mit der Access Policy Language

}

Verwenden benutzerdefinierter Richtlinien mit derAmazon SQS Access Policy LanguageWenn Sie Amazon SQS-Zugriff nur auf Basis einer AWS-Konto-ID und grundlegenden Berechtigungen(z. B. für SendMessage oder ReceiveMessage) zulassen möchten, müssen Sie keine eigenen Richtlinienschreiben. Sie können einfach die Amazon SQS-Aktion AddPermission verwenden.

Wenn Sie den Zugriff unter bestimmten Bedingungen (wie beispielsweise die Zeit desAnforderungseingangs oder die IP-Adresse des Anforderers) ausdrücklich ablehnen oder zulassenmöchten, müssen Sie eigene Amazon SQS-Richtlinien schreiben und diese in das AWS-System mithilfeder Amazon SQSSetQueueAttributes-Aktion hochladen.

Themen• Amazon SQS-Zugriffskontrollarchitektur (p. 180)• Prozess-Workflow für die Amazon SQS-Zugriffskontrolle (p. 181)• Amazon SQS Access Policy Language Die wichtigsten Konzepte (p. 181)• Amazon SQS Access Policy Language Auswertungslogik (p. 183)• Beziehungen zwischen expliziten und standardmäßigen Zugriffsverweigerungen in Amazon SQS

Access Policy Language (p. 185)• Benutzerdefinierte Amazon SQS Access Policy Language-Beispiele (p. 187)

Amazon SQS-ZugriffskontrollarchitekturDas folgende Diagramm beschreibt die Zugriffskontrolle für Ihre Amazon SQS-Ressourcen.

Sie selbst als Ressourceneigentümer.

180






Ihre Ressourcen, die in einem AWS-Service (z. B. Amazon SQS-Warteschlangen) enthalten sind.

Ihre Richtlinien. Es empfiehlt sich eine Richtlinie pro Ressource. Der AWS-Service selbst stellt eine APIbereit, mit der Sie Ihre Richtlinien hochladen und verwalten können.

-Anforderer und deren eingehende Anforderungen an den AWS-Service.

Der access policy language-Auswertungscode. Dies ist der Codesatz im AWS-Service, mit demeingehende Anforderungen hinsichtlich der zutreffenden Richtlinien ausgewertet werden und bestimmtwird, ob dem Anforderer Zugriff auf die Ressource gewährt wird.

Prozess-Workflow für die Amazon SQS-ZugriffskontrolleDas folgende Diagramm beschreibt den allgemeinen Workflow der Zugriffskontrolle mit Amazon SQSaccess policy language.

Sie schreiben eine Amazon SQS-Richtlinie für Ihre Warteschlange.

Sie laden Ihre Richtlinien in AWS hoch. Der AWS-Service stellt eine API bereit, mit der Sie IhreRichtlinien hochladen können. Sie verwenden beispielsweise die Amazon SQS SetQueueAttributes-Aktion zum Hochladen einer Richtlinie für eine bestimmte Amazon SQS-Warteschlange.

Jemand sendet eine Anforderung zur Verwendung Ihrer Amazon SQS-Warteschlange.

Amazon SQS prüft alle verfügbaren Amazon SQS-Richtlinien und bestimmt, welche zutreffend sind.

Amazon SQS bewertet die Richtlinien und bestimmt, ob der Anforderer Ihre Warteschlange verwendendarf.

Basierend auf dem Ergebnis der Richtlinienauswertung gibt Amazon SQS entweder einen Accessdenied-Fehler an den Anforderer zurück oder verarbeitet die Anforderung.

Amazon SQS Access Policy Language Die wichtigsten KonzepteZum Schreiben Ihrer eigenen Richtlinien müssen Sie mit JSON und einer Reihe von wichtigen Konzeptenvertraut sein.

Zugriffserlaubnis

Das Ergebnis einer statement (p. 183), bei der Auswirkung (p. 182) auf allow festgelegt ist.

181

http://json.org/



Aktion

Die Aktivität, zu der Prinzipal (p. 183) berechtigt ist, in der Regel eine Anforderung an AWS.Standardmäßige Ablehnung

Das Ergebnis einer statement (p. 183), die weder über die Einstellung Zugriffserlaubnis (p. 181)noch explicit-deny (p. 182) verfügt.

Bedingung

Jede Einschränkung oder jedes Detail zu einer Berechtigung (p. 182). Bedingungen sind in der Regelauf das Datum, die Uhrzeit und IP-Adressen bezogen.

Auswirkung

Das Ergebnis, die die statement (p. 183) einer Richtlinie (p. 182) zu Auswertungszeit zurückgebensoll. Sie geben den Wert deny oder allow an, wenn Sie die Richtlinienanweisung schreiben. Beider Richtlinienauswertung sind drei Ergebnisse möglich: Standardmäßige Ablehnung (p. 182),Zugriffserlaubnis (p. 181) und explicit-deny (p. 182).

explicit-deny

Das Ergebnis einer statement (p. 183), bei der Auswirkung (p. 182) auf deny festgelegt ist.Auswertung

Der Prozess, mit dem Richtlinie (p. 182) ermittelt, ob eine eingehende Anforderung basierend aufeiner Amazon SQS verweigert oder erlaubt werden soll.

Aussteller

Der Benutzer, der eine Richtlinie (p. 182) erstellt, um einer Ressource Berechtigungen zu erteilen.Der Aussteller ist definitionsgemäß immer der Eigentümer der Ressource. AWS gestattet AmazonSQS-Benutzern nicht, Richtlinien für Ressourcen zu erstellen, deren Eigentümer sie nicht sind.

Schlüssel

Das besondere Merkmal, das die Grundlage für die Einschränkung des Zugriffs bildet.Berechtigung

Das Konzept, den Zugriff auf eine Ressource mit einer Bedingung (p. 182) und einemSchlüssel (p. 182) zuzulassen oder abzulehnen.

Richtlinie

Das Dokument dient als Container für eine oder mehrere Anweisungen (p. 183).

Amazon SQS verwendet die Richtlinie, um zu bestimmen, ob einem Benutzer der Zugriff auf eineRessource gewährt werden soll.

182



Prinzipal

Der Benutzer, der die Berechtigung (p. 182) in der Richtlinie (p. 182) erhält.Ressource

Das Objekt, auf das die Prinzipal (p. 183)-Anforderungen zugreifen.statement

Die formelle Beschreibung einer einzelnen Berechtigung, die im access policy language als Teil einesumfassenderen Richtlinie (p. 182)-Dokuments verfasst wird.

Anforderer

Der Benutzer, der eine Anforderung für den Zugriff auf eine Ressource (p. 183) sendet.

Amazon SQS Access Policy Language AuswertungslogikZum Zeitpunkt der Auswertung bestimmt Amazon SQS, ob eine Anforderung von einem anderen Benutzerals dem Ressourceneigentümer zugelassen oder abgelehnt werden soll. Die Auswertungslogik unterliegtmehreren Grundregeln:

• Standardmäßig werden alle Anforderungen zur Verwendung Ihrer Ressourcen, die nicht von Ihnenstammen, verweigert.

• Ein Zugriffserlaubnis (p. 181) setzt jedes Standardmäßige Ablehnung (p. 182) außer Kraft.• Ein explicit-deny (p. 182) setzt jedes allow außer Kraft.• Es spielt keine Rolle, in welcher Reihenfolge die Richtlinien ausgewertet werden.

Im folgenden Diagramm wird detailliert beschrieben, wie Amazon SQS Entscheidungen im Hinblick aufZugriffsberechtigungen trifft.

183



Die Entscheidung beginnt mit default-deny.

Es werden alle Richtlinien ausgewertet, die auf die Anforderung anwendbar sind (basierend auf derRessource, dem Prinzipal, der Aktion und den Bedingungen). Es spielt keine Rolle, in welcher Reihenfolgeder Durchführungscode die Richtlinien auswertet.

Der Durchführungscode sucht nach einer explicit-deny-Anweisung, die für die Anforderung geltenkönnte. Wird eine Anweisung gefunden, gibt der Durchführungscode die Entscheidung deny zurück und derProzess wird beendet.

184



Wenn keine explicit-deny-Anweisung gefunden wird, wird nach allow-Anweisungen gesucht, die aufdie Anfrage zutreffen können. Wenn auch nur eine explizite Zugriffserlaubnis gefunden wird, wird allowzurückgegeben und der Prozess beendet (der Service setzt die Verarbeitung der Anforderung fort).

Wenn keine allow-Anweisung gefunden wird, ist die endgültige Entscheidung deny (da es kein explicit-deny bzw. allow gab, gilt dies als default-deny).

Beziehungen zwischen expliziten und standardmäßigenZugriffsverweigerungen in Amazon SQS Access Policy LanguageWenn eine Amazon SQS-Richtlinie nicht direkt auf eine Anforderung anwendbar ist, führt dies im Ergebniszu einer Standardmäßige Ablehnung (p. 182). Wenn ein Benutzer z. B. die Berechtigung zur Nutzung vonAmazon SQS anfordert, aber die einzige für den Benutzer anwendbare Richtlinie DynamoDB verwendenkann, ist das Ergebnis default-deny.

Wenn eine Bedingung in einer Anweisung nicht erfüllt ist, hat die Anforderung default-deny zur Folge.Wenn alle Bedingungen einer Anweisung erfüllt sind, hat dies für diese Anforderung abhängig vomWert des Elements in der Richtlinie entweder Zugriffserlaubnis (p. 181) oder zur Folge. explicit-deny (p. 182)Auswirkung (p. 182) In Richtlinien ist nicht festgelegt, was geschieht, wenn eineBedingung nicht erfüllt ist, daher ist das Ergebnis in diesem Fall default-deny. Angenommen, Sie möchtenAnforderungen, die aus der Antarktis stammen, ablehnen. Sie erstellen die Richtlinie A1, um Zugriff nurdann zu gewähren, wenn Anforderungen von außerhalb der Antarktis kommen. Die Amazon SQS-Richtlinieist in der folgenden Abbildung dargestellt.

Wenn ein Benutzer eine Anforderung aus den USA sendet, wird die Bedingung erfüllt (die Anforderungstammt nicht aus der Antarktis), und die Anforderung hat allow zur Folge. Wenn ein Benutzer allerdingseine Anforderung aus der Antarktis sendet, ist die Bedingung nicht erfüllt und die Anforderung führtstandardmäßig zu default-deny. Sie können das Ergebnis von default-deny ändern, indem Sie Richtlinie A2erstellen, die einer Anforderung den Zugriff ausdrücklich verweigert, wenn sie aus der Antarktis stammt.Diese Richtlinie ist in der folgenden Abbildung dargestellt.

185



Wenn ein Benutzer eine Anforderung aus der Antarktis sendet, ist die Bedingung erfüllt und dieAnforderung führt zu explicit-deny.

Der Unterschied zwischen default-deny und explicit-deny ist wichtig, da allow zwar eine standardmäßigeAblehnung, aber keine explizite Zugriffsverweigerung außer Kraft setzen kann. Beispiel: Richtlinie B lässtAnforderungen zu, wenn sie am 1. Juni 2010 eingehen. Das folgende Diagramm vergleicht die Kombinationdieser Richtlinie mit Richtlinie A1 und Richtlinie A2.

In Szenario 1 liefert Richtlinie A1 das Ergebnis default-deny und Richtlinie B allow, weil die RichtlinieAnforderungen zulässt, die am 1. Juni 2010 eingehen. Das allow aus Richtlinie B überschreibt default-denyaus Richtlinie A1 und die Anforderung wird zugelassen.

In Szenario 2 hat Richtlinie B2 explicit-deny und Richtlinie B allow zur Folge. Das allow aus Richtlinie B wirddurch explicit-deny aus Richtlinie A2 überschrieben und die Anforderung wird abgelehnt.

186



Benutzerdefinierte Amazon SQS Access Policy Language-BeispieleNachfolgend sind Beispiele typischer Amazon SQS-Zugriffsrichtlinien aufgeführt.

Beispiel 1: Einem Konto eine Berechtigung erteilen

Das folgende Amazon SQS-Richtlinienbeispiel erteilt dem AWS-Konto 111122223333-Berechtigung zumSenden und Empfangen von queue2, deren Eigentümer das AWS-Konto 444455556666 ist.

{ "Version": "2012-10-17", "Id": "UseCase1", "Statement" : [{ "Sid": "1", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2" }]}

Beispiel 2: Einem oder mehreren Konten eine Berechtigung erteilen

Das folgende Amazon SQS-Richtlinienbeispiel erteilt einem oder mehreren AWS-Konten Zugriff aufWarteschlangen, deren Eigentümer Ihr Konto für einen bestimmten Zeitraum ist. Es ist erforderlich,diese Richtlinie zu erstellen und in Amazon SQS mit der Aktion SetQueueAttributes hochzuladen,da die Aktion AddPermission bei der Zugriffserteilung für eine Warteschlange keine Angabe einerZeitbeschränkung erlaubt.

{ "Version": "2012-10-17", "Id": "UseCase2", "Statement" : [{ "Sid": "1", "Effect": "Allow", "Principal": { "AWS": [ "111122223333", "444455556666" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2", "Condition": { "DateLessThan": { "AWS:CurrentTime": "2009-06-30T12:00Z" } } }]

187





}

Beispiel 3: Berechtigung für Anforderungen von Amazon EC2-Instances erteilen

Das folgende Amazon SQS-Richtlinienbeispiel erteilt den Zugriff auf Anforderungen, die von AmazonEC2-Instances stammen. Dieses Beispiel basiert auf dem Beispiel "Einem oder mehreren Konten eineBerechtigung erteilen (p. 187)": Es beschränkt den Zugriff auf die Zeit vor dem 30. Juni 2009 12.00 Uhr(UTC) und auf den IP-Adressbereich 203.0.113.0/24. Es ist erforderlich, diese Richtlinie zu erstellenund in Amazon SQS mit der Aktion SetQueueAttributes hochzuladen, da die Aktion AddPermissionbei der Zugriffserteilung für eine Warteschlange keine Angabe einer IP-Adressbeschränkung erlaubt.

{ "Version": "2012-10-17", "Id": "UseCase3", "Statement" : [{ "Sid": "1", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2", "Condition": { "DateLessThan": { "AWS:CurrentTime": "2009-06-30T12:00Z" }, "IpAddress": { "AWS:SourceIp": "203.0.113.0/24" } } }]}

Beispiel 4: Zugriff für ein bestimmtes Konto verweigern

Das folgende Amazon SQS-Richtlinienbeispiel verweigert einem bestimmten AWS-Konto den Zugriffauf Ihre Warteschlange. Dieses Beispiel basiert auf dem Beispiel "Einem Konto eine Berechtigungerteilen (p. 187)": Es verweigert den Zugriff für das angegebene AWS-Konto. Es ist erforderlich, dieseRichtlinie zu erstellen und in Amazon SQS mit der Aktion SetQueueAttributes hochzuladen, da dieAktion AddPermission keine Zugriffsverweigerung für eine Warteschlange erlaubt (sie lässt nur dieErteilung des Zugriffs auf eine Warteschlange zu).

{ "Version": "2012-10-17", "Id": "UseCase4", "Statement" : [{ "Sid": "1", "Effect": "Deny", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage"

188







], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2" }]}

Beispiel 5: Zugriffsverweigerung, wenn dieser nicht von einem VPC-Endpunkt auserfolgt

Im folgenden Beispiel einer Amazon SQS-Richtlinie wird der Zugriff auf queue1 eingeschränkt:111122223333 kann die Aktionen SendMessage und ReceiveMessage nur über die VPC-Endpunkt-ID vpce-1a2b3c4d (anhand der aws:sourceVpce-Bedingung angegeben) ausführen. WeitereInformationen finden Sie unter Amazon Virtual Private Cloud-Endpunkte für Amazon SQS (p. 162).

Note

• Die aws:sourceVpce-Bedingung benötigt keine ARN für die VPC-Endpunkt-Ressource,sondern nur die VPC-Endpunkt-ID.

• Sie können das folgende Beispiel so abändern, dass alle Aktionen auf einen spezifischenVPC-Endpunkt eingeschränkt werden, indem Sie in der zweiten Anweisung alle Amazon SQS-Aktionen (sqs:*) verweigern. Durch eine solche Richtlinienanweisung würde jedoch festgelegt,dass alle Aktionen (einschließlich von zum Ändern von Warteschlangen-Berechtigungenerforderlichen administrativen Aktionen) über den spezifischen, in der Richtlinie definiertenVPC-Endpunkt erfolgen müssen; hierdurch würde dem Benutzer in der Zukunft das Ändern vonWarteschlangen-Berechtigungen unmöglich gemacht.

{ "Version": "2012-10-17", "Id": "UseCase5", "Statement": [{ "Sid": "1", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws::sqs:us-east-2:111122223333:queue1" }, { "Sid": "2", "Effect": "Deny", "Principal": "*", "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws::sqs:us-east-2:111122223333:queue1", "Condition": { "StringNotEquals": { "aws:sourceVpce": "vpce-1a2b3c4d" } } } ]}

189



Amazon Simple Queue Service EntwicklerhandbuchUsing Temporary Security Credentials

Verwenden von temporärenSicherheitsanmeldeinformationen mit Amazon SQSIAM ermöglicht Ihnen nicht nur das Erstellen von IAM-Benutzern mit eigenenSicherheitsanmeldeinformationen, sondern auch die Gewährung temporärerSicherheitsanmeldeinformationen für jeden beliebigen Benutzer, um auf Ihre AWS-Services und -Ressourcen zuzugreifen. Sie können Benutzer, die über AWS-Konten (IAM-Benutzer) verfügen, verwalten.Sie können auch Benutzer für Ihr System verwalten, die nicht über AWS-Konten verfügen (verbundeneBenutzer). Außerdem können Anwendungen, die Sie für den Zugriff auf Ihre AWS-Ressourcen erstellen,auch als "Benutzer" betrachtet werden.

Sie können diese temporären Sicherheitsanmeldeinformationen für das Erstellen von Anforderungen anAmazon SQS verwenden. Die API-Bibliotheken berechnen anhand dieser Anmeldeinformationen dennotwendigen Signaturwert, um Ihre Anfrage zu authentifizieren. Wenn Sie beim Senden von Anfragenabgelaufene Anmeldeinformationen verwenden, lehnt Amazon SQS die Anfrage ab.

Note

Sie können keine Richtlinie auf der Basis von temporären Anmeldeinformationen festlegen.

Voraussetzungen1. Verwenden Sie IAM zum Erstellen von temporären Sicherheitsanmeldeinformationen:

• Sicherheits-Token• Access Key ID• Secret Access Key

2. Bereiten Sie die zu signierende Zeichenfolge mit der temporären Zugriffsschlüssel-ID und demSicherheits-Token vor.

3. Verwenden Sie den temporären geheimen Zugriffsschlüssel anstelle Ihres eigenen geheimenZugriffsschlüssels, um Ihre Abfrage-API-Anforderung zu signieren.

Note

Wenn Sie die signierte Abfrage-API senden, verwenden Sie die temporäre Zugriffsschlüssel-IDanstelle Ihrer eigenen Zugriffsschlüssel-ID und schließen Sie das Sicherheits-Token ein. WeitereInformationen zum IAM-Support von temporären Sicherheitsanmeldeinformationen finden Sieunter Granting Temporary Access to Your AWS Resources im IAM-Benutzerhandbuch.

So rufen Sie eine Amazon SQS-Abfrage-API-Aktion mittemporären Sicherheitsanmeldeinformationen auf1. Fordern Sie ein temporäres Sicherheits-Token mit AWS Identity and Access Management an. Weitere

Informationen finden Sie unter Creating Temporary Security Credentials to Enable Access for IAMUsers im IAM-Benutzerhandbuch.

IAM gibt ein Sicherheits-Token, eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüsselzurück.

2. Bereiten Sie Ihre Abfrage mit der temporären Zugriffsschlüssel-ID anstelle Ihrer eigenenZugriffsschlüssel-ID vor und schließen Sie das Sicherheits-Token ein. Signieren Sie Ihre Anforderungmit dem temporären geheimen Zugriffsschlüssel anstelle Ihres eigenen Zugriffsschlüssels.

3. Senden Sie die signierte Abfragezeichenfolge mit der temporären Zugriffsschlüssel-ID und demSicherheits-Token.

190

https://docs.aws.amazon.com/IAM/latest/UserGuide/TokenBasedAuth.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/CreatingSessionTokens.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/CreatingSessionTokens.html

Amazon Simple Queue Service EntwicklerhandbuchReferenztabelle für API-Berechtigungen

Das folgende Beispiel zeigt, wie Sie temporäre Sicherheitsanmeldeinformationen zum Authentifiziereneiner Amazon SQS-Anforderung verwenden. Die Struktur von AUTHPARAMS hängt von derSignatur der API-Anforderung ab. Weitere Informationen finden Sie unter Signieren von AWS-API-Anforderungen in der Allgemeinen Referenz zu Amazon Web Services.

https://sqs.us-east-2.amazonaws.com/?Action=CreateQueue&DefaultVisibilityTimeout=40&QueueName=MyQueue&Attribute.1.Name=VisibilityTimeout&Attribute.1.Value=40&Expires=2020-12-18T22%3A52%3A43PST&SecurityToken=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Version=2012-11-05&AUTHPARAMS

Das folgende Beispiel verwendet temporäre Sicherheitsanmeldeinformationen, um zwei Nachrichtenmit der SendMessageBatch-Aktion zu senden.

https://sqs.us-east-2.amazonaws.com/?Action=SendMessageBatch&SendMessageBatchRequestEntry.1.Id=test_msg_001&SendMessageBatchRequestEntry.1.MessageBody=test%20message%20body%201&SendMessageBatchRequestEntry.2.Id=test_msg_002&SendMessageBatchRequestEntry.2.MessageBody=test%20message%20body%202&SendMessageBatchRequestEntry.2.DelaySeconds=60&Expires=2020-12-18T22%3A52%3A43PST&SecurityToken=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY&AWSAccessKeyId=AKIAI44QH8DHBEXAMPLE&Version=2012-11-05&AUTHPARAMS

Amazon SQS-API-Berechtigungen: Referenztabelle fürAktionen und RessourcenWenn Sie Zugriffskontrolle (p. 165) einrichten und Berechtigungsrichtlinien erstellen, die Sie einer IAM-Identität anfügen können, verwenden Sie die folgende Tabelle als Referenz. In der Liste sind sämtlicheAmazon Simple Queue Service-Aktionen sowie die zugehörigen Aktionen und AWS-Ressourcen, für dieSie Berechtigungen erteilen können, aufgeführt.

Die Aktionen geben Sie im Feld Action und den Wert für die Ressource im Feld Resource der Richtliniean. Um eine Aktion anzugeben, verwenden Sie das Präfix sqs: gefolgt vom Namen der Aktion (z. B.sqs:CreateQueue).

Derzeit unterstützt Amazon SQS nur einen eingeschränkten Teilbereich der in IAM verfügbarenBedingungsschlüssel:

• aws:CurrentTime

• aws:EpochTime

• aws:SecureTransport

• aws:SourceArn

191

https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html





Note

This condition ensures that AWS services grant access only on behalf of resources that yourAWS account owns. You can't specify the ARN of an IAM role as source ARN, because an IAMrole is neither a source nor a service.

• aws:SourceIP

• aws:UserAgent

• aws:MultiFactorAuthAge

• aws:MultiFactorAuthPresent

• aws:RequestTag

• aws:sourceVpce

• aws:TagKeys

• aws:TokenAge

Amazon Simple Queue Service-API und erforderliche Berechtigungen für Aktionen

AddPermission

Aktion(en): sqs:AddPermission

Ressource: arn:aws:sqs:region:account_id:queue_nameChangeMessageVisibility

Aktion(en): sqs:ChangeMessageVisibility

Ressource: arn:aws:sqs:region:account_id:queue_nameChangeMessageVisibilityBatch

Aktion(en): sqs:ChangeMessageVisibilityBatch

Ressource: arn:aws:sqs:region:account_id:queue_nameCreateQueue

Aktion(en): sqs:CreateQueue

Ressource: arn:aws:sqs:region:account_id:queue_nameDeleteMessage

Aktion(en): sqs:DeleteMessage

Ressource: arn:aws:sqs:region:account_id:queue_nameDeleteMessageBatch

Aktion(en): sqs:DeleteMessageBatch

Ressource: arn:aws:sqs:region:account_id:queue_nameDeleteQueue

Aktion(en): sqs:DeleteQueue

Ressource: arn:aws:sqs:region:account_id:queue_nameGetQueueAttributes

Aktion(en): sqs:GetQueueAttributes

192






https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessageBatch.html




Ressource: arn:aws:sqs:region:account_id:queue_nameGetQueueUrl

Aktion(en): sqs:GetQueueUrl

Ressource: arn:aws:sqs:region:account_id:queue_nameListDeadLetterSourceQueues

Aktion(en): sqs:ListDeadLetterSourceQueues

Ressource: arn:aws:sqs:region:account_id:queue_nameListQueues

Aktion(en): sqs:ListQueues

Ressource: arn:aws:sqs:region:account_id:queue_nameListQueueTags

Aktion(en): sqs:ListQueueTags

Ressource: arn:aws:sqs:region:account_id:queue_namePurgeQueue

Aktion(en): sqs:PurgeQueue

Ressource: arn:aws:sqs:region:account_id:queue_nameReceiveMessage

Aktion(en): sqs:ReceiveMessage

Ressource: arn:aws:sqs:region:account_id:queue_nameRemovePermission

Aktion(en): sqs:RemovePermission

Ressource: arn:aws:sqs:region:account_id:queue_nameSendMessage und SendMessageBatch

Aktion(en): sqs:SendMessage

Ressource: arn:aws:sqs:region:account_id:queue_nameSetQueueAttributes

Aktion(en): sqs:SetQueueAttributes

Ressource: arn:aws:sqs:region:account_id:queue_nameTagQueue

Aktion(en): sqs:TagQueue

Ressource: arn:aws:sqs:region:account_id:queue_nameUntagQueue

Aktion(en): sqs:UntagQueue

193

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListDeadLetterSourceQueues.html



https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_PurgeQueue.html








Amazon Simple Queue Service EntwicklerhandbuchProtokollieren und überwachen

Ressource: arn:aws:sqs:region:account_id:queue_name

Protokollierung und Überwachung in Amazon SQSDieser Abschnitt enthält Informationen zur Protokollierung und Überwachung von Amazon SQS-Warteschlangen.

Themen• Protokollieren von Amazon SQS API-Aufrufen mithilfe von AWS CloudTrail (p. 194)• Überwachen von Amazon SQS-Warteschlangen mit CloudWatch (p. 198)

Protokollieren von Amazon SQS API-Aufrufen mithilfevon AWS CloudTrailAmazon SQS ist in AWS CloudTrail integriert, einen Service, der die Amazon SQS-Aufrufe aufzeichnet,die ein Benutzer, eine Rolle oder der AWS-Service durchführen. CloudTrail erfasst API-Aufrufe, die mitAmazon SQS-Warteschlangen zu tun haben, als Ereignisse, einschließlich von Aufrufen von der AmazonSQS-Konsole und Codeaufrufen von Amazon SQS-APIs. Weitere Informationen über CloudTrail finden Sieim AWS CloudTrail User Guide.

Note

Die CloudTrail-Protokollierung wird für Standard- und für FIFO-Warteschlangen unterstützt.

Anhand der von CloudTrail erfassten Informationen können Sie eine bestimmte Anforderung an eineAmazon SQS-API, die IP-Adresse des Anforderers, die Identität des Anforderers, das Datum und dieUhrzeit der Anforderung usw. identifizieren. Wenn Sie einen Trail (Pfad) konfigurieren, können Sie diekontinuierliche Lieferung von CloudTrail-Ereignissen an einen Amazon S3-Bucket aktivieren. Wenn Siekeinen Trail konfigurieren, können Sie die neuesten Ereignisse im Ereignisverlauf in der CloudTrail-Konsoleanzeigen. Weitere Informationen finden Sie unter Übersicht zum Erstellen eines Trail im AWS CloudTrailUser Guide.

Amazon SQS-Informationen in CloudTrailBeim Erstellen Ihres AWS-Kontos wird CloudTrail aktiviert. Die in Amazon SQS auftretenden unterstütztenAktivitäten werden als CloudTrail-Ereignis zusammen mit anderen AWS-Serviceereignissen imEreignisverlauf aufgezeichnet. Sie können die neuesten Ereignisse für Ihr AWS-Konto anzeigen,durchsuchen und herunterladen. Weitere Informationen finden Sie unter Anzeigen von Ereignissen mit demCloudTrail-Ereignisverlauf im AWS CloudTrail User Guide.

Ein Trail ermöglicht CloudTrail die Übermittlung von Protokolldateien an einen Amazon S3-Bucket. Siekönnen einen Trail erstellen, um eine fortlaufende Aufzeichnung von Ereignissen in Ihrem AWS-Konto zupflegen. Wenn Sie einen Pfad in der AWS Management Console anlegen, gilt dieser standardmäßig für alleAWS-Regionen. Der Pfad protokolliert Ereignisse aus allen AWS-Regionen und stellt die Protokolldateienin dem angegebenen Amazon S3-Bucket bereit. Sie können auch andere AWS-Services konfigurieren,um die in den CloudTrail-Protokollen erfassten Ereignisdaten weiter zu analysieren und entsprechend zuagieren. Weitere Informationen finden Sie unter den folgenden Themen im AWS CloudTrail User Guide:

• In CloudTrail unterstützte Services und Integrationen• Konfigurieren von Amazon SNS-Benachrichtigungen für CloudTrail• Empfangen von CloudTrail-Protokolldateien aus mehreren Regionen

194

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html



https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html

Amazon Simple Queue Service EntwicklerhandbuchProtokollieren von API-Aufrufen mithilfe von CloudTrail

• Empfangen von CloudTrail-Protokolldateien von mehreren Konten

Amazon SQS unterstützt die Protokollierung der folgenden Aktionen:

• AddPermission

• CreateQueue

• DeleteQueue

• PurgeQueue



• TagQueue

• UntagQueue

Jedes Ereignis oder jeder Protokolleintrag enthält Informationen über den Ersteller der Anforderung. Mitdiesen Informationen können Sie Folgendes bestimmen:

• Wurde die Anforderung mit Root- oder IAM-Benutzeranmeldeinformationen ausgeführt?• Wurde die Anforderung mit temporären Sicherheitsanmeldeinformationen für eine Rolle oder einen

verbundenen Benutzer ausgeführt?• Wurde die Anforderung von einem anderen AWS-Service ausgeführt?

Weitere Informationen finden Sie unter CloudTrail userIdentity-Element im AWS CloudTrail User Guide.

Beispiel für Amazon SQS-ProtokolldateieinträgeCloudTrail-Protokolldateien enthalten einen oder mehrere Protokolleinträge. Jeder Eintrag besteht ausmehreren Ereignissen im JSON-Format. Ein Protokolleintrag stellt eine einzelne Anforderung aus einerbeliebigen Quelle dar und enthält unter anderem Informationen über die angeforderte Aktion, etwaigeParameter und das Datum und die Uhrzeit der Aktion. Die Protokolleinträge sind nicht zwangsläufig in einerbestimmten Reihenfolge aufgeführt. Sie sind also kein geordnetes Stacktrace der öffentlichen API-Aufrufe.

AddPermission

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag für einen AddPermission-API-Aufruf.

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Alice", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Alice" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "AddPermission", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.0", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "actions": [

195

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html









https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html


"SendMessage" ], "AWSAccountIds": [ "123456789012" ], "label": "MyLabel", "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ] }

CreateQueue

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag für einen CreateQueue-API-Aufruf.

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Alejandro", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Alejandro" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "CreateQueue", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.1", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "queueName": "MyQueue" }, "responseElements": { "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ] }

DeleteQueue

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag für einen DeleteQueue-API-Aufruf.

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Carlos", "accountId": "123456789012",

196


"accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Carlos" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "DeleteQueue", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.2", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ] }

RemovePermission

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag für einen RemovePermission-API-Aufruf.

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Jane", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Jane" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "RemovePermission", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.3", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "label": "label", "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ] }

SetQueueAttributes

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag für SetQueueAttributes:

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser",

197

Amazon Simple Queue Service EntwicklerhandbuchÜberwachen von Warteschlangen mit CloudWatch

"principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Maria", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Maria" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "SetQueueAttributes", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.4", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "attributes": { "VisibilityTimeout": "100" }, "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ] }

Überwachen von Amazon SQS-Warteschlangen mitCloudWatchAmazon SQS und Amazon CloudWatch sind integriert, sodass Sie mit CloudWatch Metriken für IhreAmazon SQS-Warteschlangen anzeigen und analysieren können. Sie können die Metriken IhrerWarteschlangen über die Amazon SQS-Konsole (p. 199), die CloudWatch-Konsole (p. 199), per AWSCLI (p. 200) oder per CloudWatch-API (p. 200) anzeigen und analysieren. Außerdem können SieCloudWatch-Alarme (p. 201) für Amazon SQS-Metriken festlegen.

CloudWatch-Metriken für Ihre Amazon SQS-Warteschlangen werden automatisch gesammelt undalle 5 Minuten per Push an CloudWatch übertragen. Diese Metriken werden für alle Warteschlangengesammelt, die die CloudWatch-Richtlinien für Aktivität erfüllen. CloudWatch betrachtet eineWarteschlange für bis zu sechs Stunden als aktiv, wenn sie Nachrichten enthält oder eine Aktion daraufzugreift.

Note

• Für die Amazon SQS-Metriken in CloudWatch fallen keine Gebühren an. Sie werden imRahmen des Amazon SQS-Service bereitgestellt.

• Die CloudWatch-Metrik über eine Minute für Amazon SQS ist derzeit nur in den folgendenRegionen verfügbar:• USA Ost (Ohio)• Europa (Irland)• Europa (Stockholm)• Asien-Pazifik (Tokio)

• CloudWatch-Metriken werden für Standard- und FIFO-Warteschlangen unterstützt

Themen• Zugriff auf CloudWatch-Metriken für Amazon SQS (p. 199)• Erstellen von CloudWatch-Alarmen für Amazon SQS-Metriken (p. 201)• Verfügbare CloudWatch-Metriken für Amazon SQS (p. 201)

198


Zugriff auf CloudWatch-Metriken für Amazon SQSAmazon SQS und Amazon CloudWatch sind integriert, sodass Sie mit CloudWatch Metriken für IhreAmazon SQS-Warteschlangen anzeigen und analysieren können. Sie können die Metriken IhrerWarteschlangen über die Amazon SQS-Konsole (p. 199), die CloudWatch-Konsole (p. 199), per AWSCLI (p. 200) oder per CloudWatch-API (p. 200) anzeigen und analysieren. Außerdem können SieCloudWatch-Alarme (p. 201) für Amazon SQS-Metriken festlegen.

Amazon SQS-Konsole

1. Melden Sie sich bei der Amazon SQS-Konsole an.2. Aktivieren Sie in der Liste der Warteschlangen die Kontrollkästchen für die Warteschlangen, auf deren

Metriken Sie zugreifen möchten. Sie können Metriken für bis zu 10 Warteschlangen anzeigen.3. Wählen Sie die Registerkarte Monitoring aus.

Im Bereich SQS metrics werden verschiedene Diagramme angezeigt.4. Wenn Sie wissen möchten, was ein bestimmtes Diagramm darstellt, zeigen Sie mit der Maus auf

neben dem gewünschten Diagramm. Weitere Informationen finden Sie auch unter VerfügbareCloudWatch-Metriken für Amazon SQS (p. 201).

5. Um den Zeitraum für alle Diagramme gleichzeitig zu ändern, wählen Sie für Time Range dengewünschten Zeitraum aus (z. B. Last Hour).

6. Zum Anzeigen zusätzlicher Statistiken für ein einzelnes Diagramm wählen Sie das Diagramm aus.7. Wählen Sie im Dialogfeld CloudWatch Monitoring Details (Überwachungsdetails) eine Statistic

(Statistik) aus (z. B. Sum (Summe)). Eine Liste der unterstützten Statistiken finden Sie unterVerfügbare CloudWatch-Metriken für Amazon SQS (p. 201).

8. Zum Ändern des Zeitraums und Zeitintervalls, die ein einzelnes Diagramm anzeigt (z. B. einenZeitraum der letzten 24 Stunden anstelle der letzten 5 Minuten oder einen Zeitraum für jede Stundeanstatt alle 5 Minuten) wählen Sie bei aktivem Diagrammdialogfeld für Time Range den gewünschtenZeitraum aus (z. B. Last 24 Hours). Wählen Sie für Period den gewünschten Zeitraum innerhalb desangegebenen Zeitraums aus (z. B. 1 Hour). Wenn Sie mit dem Diagramm fertig sind, klicken Sie aufClose.

9. (Optional) Um mit zusätzlichen CloudWatch-Funktionen zu arbeiten, wählen Sie auf der RegisterkarteMonitoring (Überwachung) die Option View all CloudWatch metrics (Alle Metriken anzeigen) aus undfolgen Sie dann den Anweisungen unter Amazon CloudWatch-Konsole (p. 199).

Amazon CloudWatch-Konsole

1. Melden Sie sich bei der CloudWatch-Konsole an.2. Wählen Sie im Navigationsbereich Metrics aus.3. Wählen Sie den Namespace der SQS-Metrik aus.

4. Wählen Sie die Metrikdimension Queue Metrics aus.

199


https://console.aws.amazon.com/cloudwatch/


5. Sie können Ihre Amazon SQS-Metriken jetzt analysieren:

• Verwenden Sie die Spaltenüberschrift, um die Metriken zu sortieren.• Um eine Metrik grafisch darzustellen, müssen Sie das Kontrollkästchen neben der Metrik aktivieren.• Um nach Metrik zu filtern, wählen Sie den Metriknamen und anschließend Add to search (Zu Suche

hinzufügen) aus.

Weitere Informationen und zusätzliche Optionen finden Sie unter Darstellen von Metriken in grafischerForm und Verwenden vonAmazon CloudWatchDashboards im Amazon CloudWatch-Benutzerhandbuch.

AWS Command Line InterfaceFür den Zugriff auf Amazon SQS-Metriken mithilfe der AWS CLI führen Sie den Befehl get-metric-statistics aus.

Weitere Informationen finden Sie unter Abrufen von Statistiken für eine Metrik im Amazon CloudWatch-Benutzerhandbuch.

CloudWatch APIFür den Zugriff auf Amazon SQS-Metriken mithilfe der CloudWatch-API verwenden Sie dieGetMetricStatistics-Aktion.

200

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph_metrics.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph_metrics.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html

https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/get-metric-statistics.html

https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/get-metric-statistics.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/getting-metric-statistics.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html


Weitere Informationen finden Sie unter Abrufen von Statistiken für eine Metrik im Amazon CloudWatch-Benutzerhandbuch.

Erstellen von CloudWatch-Alarmen für Amazon SQS-MetrikenMit CloudWatch können Sie Alarme basierend auf einem Metrikschwellenwert auslösen. Sie könnenbeispielsweise einen Alarm für die NumberOfMessagesSent-Metrik erstellen. Beispiel: Wenn in einerStunde mehr als 100 Nachrichten an die MyQueue-Warteschlange gesendet werden, wird eine E-Mail-Benachrichtigung gesendet. Weitere Informationen finden Sie unter Erstellen von Amazon CloudWatch-Alarmen im Amazon CloudWatch-Benutzerhandbuch.

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die CloudWatch-Konsole unterhttps://console.aws.amazon.com/cloudwatch/.

2. Wählen Sie Alarms und dann Create Alarm.3. Wählen Sie im Abschnitt Select Metric (Metrik auswählen) im Dialogfeld Create Alarm (Alarm erstellen)

die Optionen Browse Metrics (Metrik durchsuchen) und SQSaus.4. Wählen Sie für SQS > Queue Metrics (SQS > Warteschlangenmetriken) QueueName und Metric

Name (Metrikname), für die Sie einen Alarm festlegen möchten, und klicken Sie dann auf Next(Weiter). Eine Liste der verfügbaren Metriken finden Sie unter Verfügbare CloudWatch-Metriken fürAmazon SQS (p. 201).

Im folgenden Beispiel handelt es sich bei der Auswahl um einen Alarm für dieNumberOfMessagesSent-Metrik der MyQueue-Warteschlange. Der Alarm wird ausgelöst, wenn dieAnzahl der gesendeten Nachrichten 100 überschreitet.

5. Gehen Sie im Abschnitt Define Alarm (Alarm festlegen) des Dialogfelds Create Alarm (Alarm erstellen)wie folgt vor:

a. Geben Sie im Feld Alarm Threshold (Alarmschwellenwert) Name und Description (Beschreibung)für den Alarm ein.

b. Legen Sie is auf > 100 fest.c. Setzen Sie for (für) auf den Wert 1 out of 1 datapoints (1 von 1 Datenpunkten).d. Setzen Sie unter Alarm preview (Alarmvorschau) Period (Zeitraum) auf 1 Hour (1 Stunde).e. Setzen Sie Statistic (Statistik) auf Standard, Sum (Summe).f. Setzen Sie unter Actions (Aktionen) Whenever this alarm (Wann immer dieser Alarm ausgegeben

wird) auf State is ALARM (Status lautet ALARM).

Wenn Sie möchten, dass CloudWatch eine Benachrichtigung sendet, sobald der Alarm ausgelöstwird, wählen Sie ein vorhandenes Amazon SNS-Thema aus oder wählen Sie New List (NeueListe) und geben Sie die E-Mail-Adressen durch Kommas getrennt ein.

Note

Wenn Sie ein neues Amazon SNS-Thema erstellen, müssen die E-Mail-Adressenverifiziert werden, bevor die Empfänger Benachrichtigungen erhalten. Wenn es zu einerÄnderung des Alarmstatus kommt, bevor die E-Mail-Adressen überprüft wurden, werdendie Benachrichtigungen nicht versendet.

6. Wählen Sie Create Alarm aus.

Der Alarm ist erstellt.

Verfügbare CloudWatch-Metriken für Amazon SQSAmazon SQS sendet die folgenden Metriken an CloudWatch.

201

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/getting-metric-statistics.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html

https://console.aws.amazon.com/cloudwatch/


Note

Bei Standard-Warteschlangen ist das Ergebnis aufgrund der verteilten Architektur von AmazonSQS ein ungefährer Wert. In den meisten Fällen sollte der Wert etwa der tatsächlichen Anzahl derNachrichten in der Warteschlange entsprechen.Bei FIFO-Warteschlangen ist das Ergebnis ein exakter Wert.

Amazon SQS-Metriken

Der AWS/SQS-Namespace enthält die folgenden Metriken.

Metrik Beschreibung

ApproximateAgeOfOldestMessage Das ungefähre Alter der ältesten nichtgelöschten Mitteilung in der Warteschlange.

Note

• Wenn die Warteschlangeüber eine Redrive-Richtlinieverfügt, wird die Nachricht nachder konfigurierten maximalenAnzahl von Empfängenin eine Warteschlange fürunzustellbare Nachrichten (p. 102)verschoben. Wenn die Nachrichtin die Warteschlange fürunzustellbare Nachrichtenverschoben wird, steht dieApproximateAgeOfOldestMessage-Metrik der Warteschlange fürunzustellbare Nachrichtenfür den Zeitpunkt, zu dem dieNachricht in die Warteschlangefür unzustellbare Nachrichtenverschoben wurde (nicht denursprünglichen Zeitpunkt, an demdie Nachricht gesendet wurde).

• Wenn eine Warteschlange überkeine Redrive-Richtlinie verfügt,wird die Nachricht zurück in dieWarteschlange verschoben,nachdem sie dreimal (oderhäufiger) empfangen, abernicht verarbeitet wurde, und dieApproximateAgeOfOldestMessage-Metrik verweist auf diezweitälteste Nachricht, die nichtmehr als dreimal empfangenwurde.

• Da eine einzelne Poison-Pill-Nachricht (mehrfach empfangen,aber nie gelöscht) diese Metrikverzerren kann, ist das Altereiner Poison-Pill-Nachricht erstin der Metrik enthalten, wenn die

202


Metrik BeschreibungPoison-Pill-Nachricht erfolgreichverbraucht wurde.

Berichtkriterien: Ein Wert ungleich null wirdgemeldet, wenn die Warteschlange aktivist (p. 198).

Einheiten: Sekunden

Gültige Statistiken: Durchschnitt, Minimum,Maximum, Summe, Datenstichproben (wirdals SampleCount in der Amazon SQS-Konsole angezeigt)

ApproximateNumberOfMessagesDelayed Anzahl der Mitteilungen in derWarteschlange, die verzögert sind und nichtsofort gelesen werden können. Dies kannvorkommen, wenn die Warteschlange alsVerzögerungswarteschlange konfiguriertist oder eine Nachricht mit einemVerzögerungsparameter gesendet wurde.


Einheiten: Anzahl


ApproximateNumberOfMessagesNotVisible Maximale Anzahl der in Übertragungbefindlichen Mitteilungen. Die Mitteilungenbefinden sich in Übertragung, wenn siean einen Client gesendet, aber noch nichtgelöscht worden sind oder noch nicht dasEnde ihres Sichtbarkeitsfensters erreichthaben.


Einheiten: Anzahl


203


Metrik Beschreibung

ApproximateNumberOfMessagesVisible Anzahl der Mitteilungen, die von derWarteschlange abgerufen werden können.


Einheiten: Anzahl


NumberOfEmptyReceives Anzahl der ReceiveMessage-API-Aufrufe,die keine Mitteilung zurückgegeben haben.


Einheiten: Anzahl


204


Metrik Beschreibung

NumberOfMessagesDeleted Die Anzahl der Nachrichten, die aus derWarteschlange gelöscht wurden.


Einheiten: Anzahl

Gültige Statistiken: Durchschnitt, Minimum,Maximum, Summe, Datenstichproben (wirdals SampleCount in der Amazon SQS-Konsole angezeigt)Amazon SQS gibt dieNumberOfMessagesDeleted-Metrikfür jeden erfolgreichen Löschvorgangaus, der eine gültige Empfangsmitteilungverwendet, einschließlich doppelterLöschvorgänge. Folgende Szenarienkönnen zu einem höheren Metrikwert vonNumberOfMessagesDeleted führen alserwartet:

• Aufruf der Aktion DeleteMessage fürverschiedene Empfangs-Mitteilungen,die zu derselben Mitteilung gehören:Wenn die Mitteilung nicht verarbeitetwird, bevor die Zeitbeschränkung für dieSichtbarkeit abläuft, ist die Mitteilungfür andere Verbraucher verfügbar, diediese verarbeiten und erneut löschenkönnen. Dabei wird der Wert der MetrikNumberOfMessagesDeleted erhöht.

• Aufruf der Aktion DeleteMessage fürdieselbe Empfangs-Mitteilung: Wenn dieMitteilung verarbeitet und gelöscht wird,Sie aber die Aktion DeleteMessageerneut unter Verwendung derselbenEmpfangs-Mitteilung aufrufen, wird einErfolgsstatus zurückgegeben und der Wertder Metrik NumberOfMessagesDeletederhöht.

205

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-message-identifiers.html#receipt-handle

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html


Metrik Beschreibung

NumberOfMessagesReceived Anzahl der Mitteilungen, die infolge vonAufrufen der ReceiveMessage-Aktionzurückgegeben worden sind.


Einheiten: Anzahl


NumberOfMessagesSent Anzahl der einer Warteschlangehinzugefügten Mitteilungen.


Einheiten: Anzahl


SentMessageSize Größe der einer Warteschlangehinzugefügten Mitteilungen.


Einheiten: Byte


Note

SentMessageSize ist erst dann alsMetrik in der CloudWatch-Konsoleverfügbar, wenn mindestens eineMitteilung an die entsprechendeWarteschlange gesendet wurde.

Dimensionen für Amazon SQS-Metriken

Die einzige Dimension, die Amazon SQS an CloudWatch sendet, ist QueueName. Dies bedeutet, dass alleverfügbaren Statistiken nach QueueName gefiltert werden.

206

Amazon Simple Queue Service EntwicklerhandbuchCompliance-Validierung

Compliance-Validierung für Amazon SQSExterne Prüfer bewerten die Sicherheit und Compliance von Amazon SQS im Rahmen mehrerer AWS-Compliance-Programme, einschließlich der folgenden:

• Payment Card Industry Data Security Standard (PCI DSS)• Health Insurance Portability and Accountability Act (HIPAA)

Eine Liste der AWS-Services im Bereich bestimmter Compliance-Programme finden Sie unter AWS-Services im Bereich nach Compliance-Programm. Allgemeine Informationen finden Sie unter AWS-Compliance-Programme.

Die Auditberichte von Drittanbietern lassen sich mit AWS Artifact herunterladen. Weitere Informationenfinden Sie unter Herunterladen von Berichten in AWS Artifact.

Ihre Verantwortung in Bezug auf die Compliance bei der Verwendung von Amazon SQS wird durch dieVertraulichkeit Ihrer Daten, die Compliance-Ziele Ihres Unternehmens und die geltenden Gesetze undVorschriften bestimmt. AWS stellt die folgenden Ressourcen zur Unterstützung bei Compliance-Fragenbereit:

• Kurzanleitungen für Sicherheit und Compliance – In diesen Bereitstellungsleitfäden finden Sie wichtigeÜberlegungen zur Architektur sowie die einzelnen Schritte zur Bereitstellung von sicherheits- undCompliance-orientierten Basisumgebungen in AWS.

• Whitepaper zur Erstellung einer Architektur mit HIPAA-konformer Sicherheit und Compliance – DiesesWhitepaper beschreibt, wie Unternehmen mithilfe von AWS HIPAA-konforme Anwendungen erstellen.

• AWS-Compliance-Ressourcen – Diese Arbeitsbücher und Leitfäden könnten für Ihre Branche und IhrenStandort relevant sein.

• Auswertung von Ressourcen mit Regeln im AWS Config-Entwicklerhandbuch – Der AWS Config- Servicebewertet, wie gut Ihre Ressourcenkonfigurationen mit internen Praktiken, Branchenrichtlinien undVorschriften übereinstimmen.

• AWS Security Hub: Dieser AWS-Service liefert einen umfassenden Überblick über den Sicherheitsstatusin AWS. So können Sie die Compliance mit den Sicherheitsstandards in der Branche und den bewährtenMethoden abgleichen.

Ausfallsicherheit in Amazon SQSIm Zentrum der globalen AWS-Infrastruktur stehen die AWS-Regionen und -Availability Zones(Verfügbarkeitszonen, AZs). AWS-Regionen stellen mehrere physisch getrennte und isolierte AvailabilityZones bereit, die über hoch redundante Netzwerke mit niedriger Latenz und hohen Durchsätzen verbundensind. Mithilfe von Availability Zones können Sie Anwendungen und Datenbanken erstellen und ausführen,die automatisch Failover zwischen Zonen ausführen, ohne dass es zu Unterbrechungen kommt. AvailabilityZones sind besser hoch verfügbar, fehlertoleranter und skalierbarer als herkömmliche Infrastrukturen miteinem oder mehreren Rechenzentren. Weitere Informationen über AWS-Regionen und -Availability Zonesfinden Sie unter Globale AWS-Infrastruktur.

Neben der globalen AWS-Infrastruktur, bietet Amazon SQS verteilte Warteschlangen.

Verteilte WarteschlangenEs gibt drei Hauptkomponenten in einem verteilten Messaging-System: die Komponenten des verteiltenSystems, die Warteschlange (auf Amazon SQS-Server verteilt) und die Nachrichten in der Warteschlange.

207

http://aws.amazon.com/compliance/services-in-scope/

http://aws.amazon.com/compliance/services-in-scope/

http://aws.amazon.com/compliance/programs/

http://aws.amazon.com/compliance/programs/

https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html

http://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance

https://d0.awsstatic.com/whitepapers/compliance/AWS_HIPAA_Compliance_Whitepaper.pdf

http://aws.amazon.com/compliance/resources/

https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html

https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html

http://aws.amazon.com/about-aws/global-infrastructure/

Amazon Simple Queue Service EntwicklerhandbuchSicherheit der Infrastruktur

Im folgenden Szenario ist Ihr System mit mehreren Komponenten dargestellt, die Nachrichten an dieWarteschlange senden und aus der Warteschlange empfangen. Die Warteschlange (die die Nachrichten Abis E enthält) speichert die Nachrichten redundant auf mehreren Amazon SQS-Servern.

Infrastruktursicherheit in Amazon SQSAls verwalteter Service ist Amazon SQS durch die globalen Verfahren zur Gewährleistung derNetzwerksicherheit von AWS geschützt, die im Whitepaper Amazon Web Services: Übersicht über dieSicherheitsprozesse beschrieben werden.

Sie greifen mithilfe von AWS veröffentlichten API-Aufrufe über das Netzwerk auf Amazon SQS zu. Clientsmüssen Transport Layer Security (TLS) 1.0 oder höher unterstützen. Wir empfehlen TLS 1.2 oder höher.Clients müssen außerdem Cipher Suites mit PFS (Perfect Forward Secrecy) wie DHE (Ephemeral Diffie-Hellman) oder ECDHE (Elliptic Curve Ephemeral Diffie-Hellman) unterstützen.

Anforderungen müssen mit einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel signiert sein,die mit einem IAM-Prinzipal verknüpft sind. Alternativ können Sie die AWS Security Token Service (AWSSTS) verwenden, um temporäre Anmeldeinformationen für Signaturanforderungen zu generieren.

Sie können API-Aktionen von jedem Netzwerkstandort aus aufrufen. Amazon SQS unterstützt jedochressourcenbasierte Zugriffsrichtlinien, die Einschränkungen auf der Basis der Quell-IP-Adresse enthaltenkönnen. Sie können auch Amazon SQS-Richtlinien verwenden, um den Zugriff von bestimmten AmazonVPC-Endpunkten oder bestimmten VPCs aus zu steuern. Damit wird der Netzwerkzugriff auf eineangegebene Amazon SQS-Warteschlange ausschließlich effizient von der spezifischen VPC innerhalb desAWS-Netzwerks isoliert. Weitere Informationen finden Sie unter Zugriffsverweigerung, wenn dieser nichtvon einem VPC-Endpunkt aus erfolgt (p. 189).

Bewährte Methoden für die Amazon SQS-SicherheitAWS bietet viele Sicherheitsfunktionen für Amazon SQS, die Sie im Kontext Ihrer eigenenSicherheitsrichtlinie überprüfen sollten.

Note

Die spezifischen Implementierungshinweise sind für häufige Anwendungsfälle undImplementierungen vorgesehen. Wir empfehlen Ihnen, diese bewährten Methoden im KontextIhres spezifischen Anwendungsfalls, der Architektur und des Bedrohungsmodells zu betrachten.

208

https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf

https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf

https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html

Amazon Simple Queue Service EntwicklerhandbuchVorbeugende bewährte Methoden

Vorbeugende bewährte MethodenIm Folgenden werden die bewährten Methoden für vorbeugende Sicherheit für Amazon SQS beschrieben.

Themen• Sicherstellen, dass Warteschlangen nicht öffentlich zugänglich sind (p. 209)• Implementieren der geringstmöglichen Zugriffsrechte (p. 209)• IAM-Rollen für Anwendungen und AWS-Services verwenden, die Amazon SQS-Zugriff

erfordern (p. 210)• Serverseitige Verschlüsselung implementieren (p. 210)• Verschlüsselung von Daten während der Übertragung erzwingen (p. 210)• Die Verwendung von VPC-Endpunkten für den Zugriff auf Amazon SQS erwägen (p. 210)

Sicherstellen, dass Warteschlangen nicht öffentlich zugänglichsindSofern es nicht ausdrücklich für Sie erforderlich ist, dass eine beliebiger Benutzer im Internet Ihre AmazonSQS-Warteschlange lesen oder darin schreiben kann, sollten Sie sicherstellen, dass Ihre Warteschlangenicht öffentlich zugänglich ist (für alle Personen auf der Welt oder für jeden authentifizierten AWS-Benutzerzugänglich).

• Vermeiden Sie das Erstellen von Richtlinien mit auf "" festgelegtem Principal.• Vermeiden Sie die Verwendung eines Platzhalters (*). Benennen Sie stattdessen einen oder mehrere

bestimmte Benutzer.

Implementieren der geringstmöglichen ZugriffsrechteWenn Sie Berechtigungen erteilen, entscheiden Sie, wer sie erhält, für welche Warteschlangen dieBerechtigungen gelten, und welche bestimmten API-Aktionen für diese Warteschlangen zugelassenwerden. Die Implementierung von geringsten Privilegien ist wichtig, um Sicherheitsrisiken zu verringern unddie Auswirkungen von Fehlern oder böswilligen Absichten zu reduzieren.

Folgen Sie den standardmäßigen Sicherheitshinweisen zur Erteilung von geringsten Privilegien. Das heißt:erteilen Sie nur die Berechtigungen, die zum Ausführen einer bestimmten Aufgabe erforderlich sind. Siekönnen dies mithilfe einer Kombination mehrerer Sicherheitsrichtlinien implementieren.

Amazon SQS verwendet das Producer-Consumer-Modell, für das drei Arten von Benutzerkontenzugrifferforderlich sind:

• Administratoren – Zugriff auf das Erstellen, Ändern und Löschen von Warteschlangen. Administratorensteuern auch Warteschlangenrichtlinien.

• Producer – Zugriff auf das Senden von Nachrichten an Warteschlangen.• Consumer – Zugriff auf das Empfangen und Löschen von Nachrichten aus Warteschlangen.

Weitere Informationen finden Sie in den folgenden Abschnitten:

• Identitäts- und Zugriffsverwaltung in Amazon SQS (p. 163)• Referenztabelle für Aktionen und Ressourcen (p. 191)• Verwenden benutzerdefinierter Richtlinien mit der Amazon SQS Access Policy Language (p. 180)

209


IAM-Rollen für Anwendungen und AWS-Services verwenden, dieAmazon SQS-Zugriff erfordernFür Anwendungen oder AWS-Services, z. B. damit Amazon EC2 auf Amazon SQS-Warteschlangenzugreifen kann, müssen gültige AWS-Anmeldeinformationen in deren AWS-API-Anforderungenverwendet werden. Da diese Anmeldeinformationen nicht automatisch rotiert werden, sollten Sie AWS-Anmeldeinformationen nicht direkt in der Anwendung oder in der EC2-Instance speichern.

Sie sollten mithilfe einer IAM-Rolle temporäre Anmeldeinformationen für Anwendungen und Servicesverwalten, die Zugriff auf Amazon SQS benötigen. Wenn Sie eine Rolle verwenden, müssen Sie keinelangfristigen Anmeldeinformationen (wie Benutzername, Passwort und Zugriffsschlüssel) an eine EC2-Instance und einen AWS-Service wie AWS Lambda ausgeben. Stattdessen stellt die Rolle temporäreBerechtigungen bereit, die von den Anwendungen beim Aufrufen von anderen AWS-Ressourcen genutztwerden können.

Weitere Informationen finden Sie unter IAM-Rollen und allgemeine Szenarien für Rollen: Benutzer,Anwendungen und Dienste im IAM-Benutzerhandbuch.

Serverseitige Verschlüsselung implementierenProbleme durch Datenlecks lassen sich verringern, indem Sie die Verschlüsselung im Ruhezustandverwenden. Dabei verschlüsseln Sie Ihre Nachrichten mithilfe eines Schlüssels, der an einemanderen Speicherort gespeichert ist als Ihre Nachrichten. Serverseitige Verschlüsselung (SSE) bietetDatenverschlüsselung im Ruhezustand. Amazon SQS verschlüsselt Ihre Daten auf Nachrichtenebene beider Speicherung und entschlüsselt die Nachrichten für Sie bei Zugriff darauf. SSE verwendet Schlüssel,die in AWS Key Management Service verwaltet werden. Solange Sie Ihre Anfrage authentifizieren undZugriffsberechtigungen haben, gibt es keinen Unterschied zwischen dem Zugriff auf verschlüsselte undunverschlüsselte Warteschlangen.

Weitere Informationen finden Sie unter Verschlüsselung im Ruhezustand (p. 154) undSchlüsselverwaltung (p. 157).

Verschlüsselung von Daten während der Übertragung erzwingenOhne HTTPS (TLS) kann ein netzwerkbasierter Angreifer mithilfe eines Angriffs wie Man-in-the-Middleden Datenverkehr im Netzwerk absehen oder ihn manipulieren. Erlauben Sie nur verschlüsselteVerbindungen über HTTPS (TLS) unter Verwendung deraws:SecureTransport-Bedingung in derWarteschlangenrichtlinie, um zu erzwingen, dass Anforderungen SSL verwenden.

Die Verwendung von VPC-Endpunkten für den Zugriff aufAmazon SQS erwägenVerwenden Sie bei Warteschlangen, mit denen eine Interaktion erforderlich ist, die jedoch dem Internetabsolut nicht zugänglich gemacht werden dürfen, VPC-Endpunkte, um den Zugriff nur auf die Hostsinnerhalb einer bestimmten VPC in die Warteschlange festzulegen. Mit Warteschlangenrichtlinien könnenSie den Zugriff auf Warteschlangen von bestimmten Amazon VPC-Endpunkten oder von bestimmten VPCsaus steuern.

Amazon SQS-VPC-Endpunkte unterstützen die Steuern den Zugriffs auf Ihre Nachrichten:

• Sie können steuern, welche Anfragen, Benutzer oder Gruppen durch einen spezifischen VPC-Endpunkterlaubt sind.

• Mithilfe einer Warteschlangenrichtlinie können Sie steuern, welche VPCs oder VPC-Endpunkte Zugriffauf Ihre Warteschlange haben.

210

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html#Conditions_Boolean


Weitere Informationen finden Sie unter Amazon Virtual Private Cloud-Endpunkte für AmazonSQS (p. 162) und Erstellen einer Amazon VPC-Endpunktrichtlinie für Amazon SQS (p. 162).

211

Amazon Simple Queue Service EntwicklerhandbuchErstellen von Query API-Anforderungen

Arbeiten mit Amazon SQS-APIsDieser Abschnitt enthält Informationen über das Erstellen von Amazon SQS-Endpunkten, die Durchführungvon Query API-Anforderungen mithilfe der Methoden GET und POST und die Verwendung von Batch-API-Aktionen. Weitere Informationen über Amazon SQS -Aktionen,einschließlich Parametern, Fehlern,Beispielen und Datentypen, finden Sie unter Amazon Simple Queue Service API Reference.

Für den Zugriff auf Amazon SQS unter Verwendung unterschiedlichster Programmiersprachen können Sieauch AWS SDKs verwenden, die die folgende automatische Funktionalität enthalten:

• Kryptographisches Signieren Ihrer Serviceanfragen• Wiederholen von Anfragen• Umgang mit Fehlerreaktionen

Weitere Informationen zum Befehlszeilen-Tool finden Sie in den Amazon SQS-Abschnitten der AWS CLI-Befehlsreferenz und im AWS-Tools für PowerShell Cmdlet Reference.

Themen• Erstellen von Query API-Anforderungen (p. 212)• Amazon SQS Stapel-Aktionen (p. 218)

Erstellen von Query API-AnforderungenIn diesem Abschnitt erfahren Sie, wie Sie einen Amazon SQS-Endpunkt erstellen, GET- und POST-Anforderungen durchführen und die Antworten interpretieren.

Themen• Einen Endpunkt erstellen (p. 212)• Eine GET-Anforderung durchführen (p. 213)• Eine POST-Anforderung durchführen (p. 213)• Authentifizieren von Anforderungen (p. 214)• Antworten interpretieren (p. 217)

Einen Endpunkt erstellenFür die Arbeit mit Amazon SQS-Warteschlangen müssen Sie einen Endpunkt erstellen. WeitereInformationen über regionsspezifische Amazon SQS-Endpunkte finden Sie unter Allgemeine Amazon WebServices-Referenz.

Jeder Amazon SQS-Endpunkt ist unabhängig. Wenn z. B. bei zwei Warteschlangen mit dem identischenNamen MyQueue eine über Endpunkt sqs.us-east-2.amazonaws.com und die andere über Endpunktsqs.eu-west-2.amazonaws.com verfügt, nutzen die beiden Warteschlangen keine Daten gemeinsam.

Das folgende Beispiel zeigt einen Endpunkt, der eine Anforderung zum Erstellen einer Warteschlange stellt.

212


https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Types.html


https://aws.amazon.com/tools/#sdk




https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region

Amazon Simple Queue Service EntwicklerhandbuchEine GET-Anforderung durchführen

https://sqs.eu-west-2.amazonaws.com/ ?Action=CreateQueue&DefaultVisibilityTimeout=40&QueueName=MyQueue&Version=2012-11-05&AUTHPARAMS

Note

Bei den Namen der Warteschlange und den Warteschlangen-URLs muss die Groß- undKleinschreibung beachtet werden.Die Struktur von AUTHPARAMS hängt von der Signatur der API-Anforderung ab. WeitereInformationen finden Sie unter Signieren von AWS-API-Anforderungen in der AllgemeinenReferenz zu Amazon Web Services.

Eine GET-Anforderung durchführenEine Amazon SQS GET-Anforderung ist als URL mit den folgenden Komponenten aufgebaut:

• Endpunkt – Die Ressource, für die die Anforderung ausgeführt wird, (der Warteschlangenname und dieURL (p. 94)), z. B.: https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue

• Aktion – Die -Aktion, die Sie am Endpunkt durchführen möchten. Ein Fragezeichen (?) trennt denEndpunkt von der Aktion, z. B.: ?Action=SendMessage&MessageBody=Your%20Message%20Text

• Parameter – Beliebige Anforderungsparameter, — jeder Parameter ist durch ein kaufmännisches Und-Zeichen (&) getrennt, – zum Beispiel: &Version=2012-11-05&AUTHPARAMS

Im Folgenden finden Sie ein Beispiel für eine GET-Anforderung, die eine Nachricht an eine Amazon SQS-Warteschlange sendet.

https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue?Action=SendMessage&MessageBody=Your%20message%20text&Version=2012-11-05&AUTHPARAMS

Note

Bei den Namen der Warteschlange und den Warteschlangen-URLs muss die Groß- undKleinschreibung beachtet werden.Da es sich bei GET-Anforderungen um URLs handelt, müssen Sie für alle Parameterwerte eineURL-Codierung durchführen. Da in URLs jedoch keine Leerzeichen zulässig sind, wird für jedeLeerstelle eine URL-Codierung in %20 durchgeführt. (Für den Rest des Beispiels wurde zumZweck der besseren Lesbarkeit keine URL-Codierung durchgeführt.)

Eine POST-Anforderung durchführenAmazon SQS POST-Anforderungen senden Abfrageparameter als Formular im Rumpf einer HTTP-Anforderung.

Es folgt ein Beispiel eines HTTP-Headers mit der Einstellung application/x-www-form-urlencodedfür Content-Type.

POST /123456789012/MyQueue HTTP/1.1Host: sqs.us-east-2.amazonaws.com

213



Amazon Simple Queue Service EntwicklerhandbuchAuthentifizieren von Anforderungen

Content-Type: application/x-www-form-urlencoded

Auf den Header folgt eine form-urlencoded POST-Anforderung, die eine Nachricht an eine AmazonSQS-Warteschlange sendet. Jeder Parameter ist durch ein kaufmännisches Und (&) vom Text getrennt.

Action=SendMessage&MessageBody=Your+Message+Text&Expires=2020-10-15T12%3A00%3A00Z&Version=2012-11-05&AUTHPARAMS

Note

Nur der Content-Type HTTP-Header ist erforderlich. Der AUTHPARAMS ist für die GET-Anforderung derselbe.Der HTTP-Client fügt abhängig von der HTTP-Version des Clients möglicherweise weitereElemente zur HTTP-Anforderung hinzu.

Authentifizieren von AnforderungenAuthentifizierung bezeichnet den Prozess der Identifizierung und Überprüfung des Absenders einerAnforderung. Während der ersten Phase der Authentifizierung überprüft AWS die Identität des Produzentenund ob der Produzent für die Verwendung von AWS registriert ist (weitere Informationen finden Sie unterErstellen eines AWS-Kontos (p. 4) und Erstellen eines IAM-Benutzers (p. 4)). Danach folgt AWS demfolgenden Verfahren:

1. Der Produzent (Absender) erhält die notwendigen Anmeldeinformationen.2. Der Produzent sendet eine Anforderung mit den Anmeldeinformationen an den Konsumenten

(Empfänger).3. Der Konsument überprüft anhand der Anmeldeinformationen, ob der Produzent die Anforderung

gesendet hat.4. Es tritt einer der beiden folgenden Fälle ein:

• Wenn die Authentifizierung erfolgreich durchgeführt wurde, wird die Anforderung vom Konsumentenverarbeitet.

• Wenn die Authentifizierung fehlschlägt, wird die Anforderung vom Verbraucher abgelehnt und eswird eine Fehlermeldung zurückgegeben.

Themen• Grundlegender Authentifizierungsprozess mit HMAC-SHA (p. 214)• Teil 1: Die Anforderung vom Benutzer (p. 215)• Teil 2: Die Antwort von AWS (p. 216)

Grundlegender Authentifizierungsprozess mit HMAC-SHABeim Zugriff auf Amazon SQS mit der Abfrage-API müssen Sie die folgenden Elemente angeben, um dieAnforderung zu authentifizieren:

• Die AWS-Zugriffsschlüssel-ID, mittels der Ihr AWS-Konto identifiziert wird, das AWS zum Suchen Ihresgeheimen Zugriffsschlüssels verwendet.

• Die HMAC-SHA-Anforderungssignatur, die anhand Ihres geheimen Zugriffsschlüssels berechnet wird(eines freigegebenen Schlüssels, der nur Ihnen und AWS bekannt ist — weitere Informationen finden

214

https://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2

https://aws.amazon.com/


Sie unter RFC2104). Das AWS SDK übernimmt die Signatur. Wenn Sie jedoch eine Abfrageanforderungüber HTTP oder HTTPS senden, müssen Sie in jede Abfrageanforderung eine Signatur einschließen.

1. Ableiten eines Signature Version 4-Signaturschlüssels. Weitere Informationen finden Sie unterAbleiten des Signaturschlüssels mit Java.

Note

Amazon SQS unterstützt Signature Version 4, das gegenüber bisherigen Versionenverbesserte SHA256-basierte Sicherheit und Leistung bietet. Wenn Sie neue Anwendungenerstellen, die Amazon SQS nutzen, verwenden Sie Signature Version 4.

2. Codieren Sie die Anforderungssignatur mit Base64. Das folgende Java-Codebeispiel führt folgendeSchritte aus:

package amazon.webservices.common;

// Define common routines for encoding data in AWS requests.public class Encoding {

/* Perform base64 encoding of input bytes. * rawData is the array of bytes to be encoded. * return is the base64-encoded string representation of rawData. */ public static String EncodeBase64(byte[] rawData) { return Base64.encodeBytes(rawData); }}

• Der Zeitstempel (oder die Ablaufzeit) der Anforderung. Der Zeitstempel, den Sie in der Anforderungverwenden, muss ein dateTime-Objekt mit dem vollständigen Datum, einschließlich Stunden, Minutenund Sekunden, sein. Beispiel: 2007-01-31T23:59:59Z Obwohl dies nicht erforderlich ist, empfehlenwird, die Angabe des Objekts in der UTC-Zeitzone (Greenwich Mean Time).

Note

Stellen Sie sicher, dass Ihre Serverzeit richtig eingestellt ist. Falls Sie einen Zeitstempel(anstelle einer Ablaufzeit) angeben, läuft die Anforderung automatisch 15 Minuten nach derangegebenen Zeit ab (Anforderungen werden von AWS nicht verarbeitet, wenn der Zeitstempelmehr als 15 Minuten vor der aktuellen AWS-Serverzeit liegt).Falls Sie .NET verwenden, dürfen Sie keine extrem spezifischen Zeitstempel senden (daunterschiedlich interpretiert wird, nach welchem Zeitraum die Anforderung verworfen werdensollte). In diesem Fall sollten Sie manuell dateTime-Objekte mit einer Genauigkeit von nichtmehr als einer Millisekunde erstellen.

Teil 1: Die Anforderung vom BenutzerEs folgt der Prozess, dem Sie zum Authentifizieren von AWS-Anforderungen anhand einer HMAC-SHA-Signatur folgen müssen.

215

http://www.faqs.org/rfcs/rfc2104.html

https://aws.amazon.com/code/

https://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-java

http://www.w3.org/TR/xmlschema-2/#dateTime

http://www.w3.org/TR/xmlschema-2/#dateTime


1. Erstellen einer Anfrage an AWS.2. Berechnen Sie eine verschlüsselte Hash-Signatur (HMAC-SHA) für die Nachrichtenauthentifizierung

anhand des geheimen Zugriffsschlüssels.3. Integrieren Sie die Signatur und Ihre Zugriffsschlüssel-ID in die Anforderung, und senden Sie die

Anforderung an AWS.

Teil 2: Die Antwort von AWSAWS beginnt als Antwort mit dem folgenden Prozess.

216

Amazon Simple Queue Service EntwicklerhandbuchAntworten interpretieren

1. AWS sucht anhand der Zugriffsschlüssel-ID den geheimen Zugriffsschlüssel.2. AWS erstellt eine Signatur anhand der Anforderungsdaten und des geheimen Zugriffsschlüssels

und verwendet dabei den gleichen Algorithmus, den Sie zum Berechnen der in der Anforderungenthaltenen Signatur verwendet haben.

3. Es tritt einer der beiden folgenden Fälle ein:

• Wenn die von AWS generierte Signatur mit der in der Anforderung gesendeten Signaturübereinstimmt, stuft AWS die Anforderung als authentisch ein.

• Falls der Vergleich fehlschlägt, wird die Anforderung verworfen, und AWS gibt eine Fehlermeldungzurück.

Antworten interpretierenAmazon SQS gibt als Antwort auf eine Aktionsanforderung eine XML-Datenstruktur mit den Ergebnissender Anforderung zurück. Weitere Informationen finden Sie unter den jeweiligen Aktionen im Amazon SimpleQueue Service API Reference.

Themen• Struktur einer Antwort bei Erfolg (p. 217)• Struktur einer Antwort bei Fehlschlagen (p. 218)

Struktur einer Antwort bei ErfolgWenn die Anforderung erfolgreich ist, wird das Hauptantwortelement nach der Aktion mit dem ZusatzResponse (ActionNameResponse) benannt.

217



Amazon Simple Queue Service EntwicklerhandbuchStapelaktionen

Dieses Element enthält die folgenden untergeordneten Elemente:

• ActionNameResult – Enthält ein aktionsspezifisches Element. Das Element CreateQueueResultenthält das Element QueueUrl, das wiederum die URL der erstellten Warteschlange enthält.

• ResponseMetadata –Enthält das RequestId, das wiederum die UUID der Anforderung enthält.

Nachfolgend finden Sie ein Beispiel für eine Antwort bei Erfolg im XML-Format:

<CreateQueueResponse xmlns=https://sqs.us-east-2.amazonaws.com/doc/2012-11-05/ xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xsi:type=CreateQueueResponse> <CreateQueueResult> <QueueUrl>https://sqs.us-east-2.amazonaws.com/770098461991/queue2</QueueUrl> </CreateQueueResult> <ResponseMetadata> <RequestId>cb919c0a-9bce-4afe-9b48-9bdf2412bb67</RequestId> </ResponseMetadata></CreateQueueResponse>

Struktur einer Antwort bei FehlschlagenWenn eine Anforderung fehlschlägt, gibt Amazon SQS immer das Haupt-Antwort-ElementErrorResponse zurück. Dieses Element enthält ein Error- und ein RequestId-Element.

Das Element Error enthält die folgenden untergeordneten Elemente:

• Type –Gibt an, ob es sich bei dem Fehler um einen Produzenten- oder einen Konsumentenfehlerhandelt.

• Code – Gibt den Typ des Fehlers an.• Message – Gibt die Fehlerbedingung in einem lesbaren Format an.• Detail – (Optional) Gibt zusätzliche Details zu dem Fehler an.

Das Element RequestId enthält die UUID der Anforderung.

Nachfolgend finden Sie ein Beispiel für eine Antwort bei Fehlschlagen im XML-Format:

<ErrorResponse> <Error> <Type>Sender</Type> <Code>InvalidParameterValue</Code> <Message> Value (quename_nonalpha) for parameter QueueName is invalid. Must be an alphanumeric String of 1 to 80 in length. </Message> </Error> <RequestId>42d59b56-7407-4c4a-be0f-4c88daeea257</RequestId></ErrorResponse>

Amazon SQS Stapel-AktionenUm Kosten zu senken oder mit einem einzigen Aktion bis zu 10 Nachrichten gleichzeitig zu bearbeiten,können Sie die folgenden Aktionen verwenden:

• SendMessageBatch

218


Amazon Simple Queue Service EntwicklerhandbuchAktivieren clientseitiger Pufferung undStapelverarbeitung von Anforderungen

• DeleteMessageBatch

• ChangeMessageVisibilityBatch

Sie können mithilfe der Abfrage-API oder eines AWS-SDK, von dem Amazon SQS-Stapelaktionenunterstützt werden, die Stapelfunktionalität nutzen.

Note

Die Gesamtgröße aller in einem einzigen Aufruf an SendMessageBatch gesendeten Nachrichtendarf 262 144 Bytes (256 KB) nicht überschreiten.Sie können für SendMessageBatch, DeleteMessageBatch oderChangeMessageVisibilityBatch keine Berechtigungen explizit zuweisen.Durch das Festlegen der Berechtigungen für SendMessage, DeleteMessage oderChangeMessageVisibility werden auch die Berechtigungen für die entsprechendenStapelversionen dieser Aktionen festgelegt.Die Amazon SQS-Konsole unterstützt keine Stapelaktionen.

Themen• Aktivieren clientseitiger Pufferung und Stapelverarbeitung von Anforderungen (p. 219)• Erhöhen des Durchsatzes mit horizontaler Skalierung und Aktionsstapelverarbeitung (p. 223)

Aktivieren clientseitiger Pufferung undStapelverarbeitung von AnforderungenDie AWS SDK for Java enthält den AmazonSQSBufferedAsyncClient, der auf Amazon SQSzugreift. Dieser Client ermöglicht eine einfachere Stapelverarbeitung von Anforderungen mittelsclientseitiger Pufferung — wobei vom Client durchgeführte Aufrufe zunächst gepuffert und anschließend alsStapelanforderung an Amazon SQS gesendet werden.

Mit der clientseitigen Pufferung können bis zu 10 Anforderungen zwischengespeichert und alsStapelanforderung gesendet werden. Dadurch werden Ihre Kosten für die Verwendung von Amazon SQSgesenkt und die Anzahl der gesendeten Anforderungen verringert. AmazonSQSBufferedAsyncClientpuffert synchrone und asynchrone Aufrufe. Als Stapel verarbeitete Anforderungen und dieUnterstützung für langes Abrufen (p. 100) können ebenfalls zu einem erhöhten Durchsatz beitragen.Weitere Informationen finden Sie unter Erhöhen des Durchsatzes mit horizontaler Skalierung undAktionsstapelverarbeitung (p. 223).

Da AmazonSQSBufferedAsyncClient die gleiche Schnittstelle implementiert wieAmazonSQSAsyncClient, sollte die Migration von AmazonSQSAsyncClient zuAmazonSQSBufferedAsyncClient in der Regel lediglich minimale Änderungen an Ihrem vorhandenenCode erfordern.

Note

Gepufferter asynchroner Client von Amazon SQSunterstützt derzeit keine FIFO-Warteschlangen

Themen• Verwenden von AmazonSQSBufferedAsyncClient (p. 219)• Konfigurieren von AmazonSQSBufferedAsyncClient (p. 220)

Verwenden von AmazonSQSBufferedAsyncClientBevor Sie beginnen, führen Sie die Schritte in Amazon SQS einrichten (p. 4) aus.

219





Sie können basierend auf AmazonSQSAsyncClient einen neuen AmazonSQSBufferedAsyncClienterstellen, z. B.:

// Create the basic Amazon SQS async clientfinal AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient(); // Create the buffered clientfinal AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);

Nachdem Sie den neuen AmazonSQSBufferedAsyncClient erstellt haben, können Sie ihn verwenden,um mehrere Anforderungen an Amazon SQS zu senden (wie mit dem AmazonSQSAsyncClient),beispielsweise:

final CreateQueueRequest createRequest = new CreateQueueRequest().withQueueName("MyQueue"); final CreateQueueResult res = bufferedSqs.createQueue(createRequest); final SendMessageRequest request = new SendMessageRequest();final String body = "Your message text" + System.currentTimeMillis();request.setMessageBody( body );request.setQueueUrl(res.getQueueUrl()); final SendMessageResult sendResult = bufferedSqs.sendMessageAsync(request); final ReceiveMessageRequest receiveRq = new ReceiveMessageRequest() .withMaxNumberOfMessages(1) .withQueueUrl(queueUrl);final ReceiveMessageResult rx = bufferedSqs.receiveMessage(receiveRq);

Konfigurieren von AmazonSQSBufferedAsyncClientAmazonSQSBufferedAsyncClient ist mit Einstellungen vorkonfiguriert, die für die meistenAnwendungsfälle verwendet werden können. Sie können AmazonSQSBufferedAsyncClient weiterkonfigurieren, z. B.:

1. Erstellen Sie eine Instance der Klasse QueueBufferConfig mit den erforderlichenKonfigurationsparametern.

2. Stellen Sie die Instance dem AmazonSQSBufferedAsyncClient-Konstruktor zur Verfügung.

// Create the basic Amazon SQS async clientfinal AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient(); final QueueBufferConfig config = new QueueBufferConfig() .withMaxInflightReceiveBatches(5) .withMaxDoneReceiveBatches(15); // Create the buffered clientfinal AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync, config);

QueueBufferConfig-Konfigurationsparameter

Parameter Standardwert Beschreibung

longPoll true Wenn longPoll auf truefestgelegt ist, versuchtAmazonSQSBufferedAsyncClient,Nachrichten durch langesAbrufen abzurufen.

220



longPollWaitTimeoutSeconds 20 s Die maximale Dauer(in Sekunden), die einReceiveMessage-Aufruf beimWarten auf das Auftauchenvon Nachrichten in derWarteschlange auf dem Serverblockiert wird, bevor er miteinem leeren Empfangsergebniszurückkehrt.

Note

Wenn langes Abrufendeaktiviert ist, hat dieseEinstellung hat keineAuswirkungen.

maxBatchOpenMs 200 ms Die maximale Dauer (inMillisekunden), die einausgehender Aufruf auf andereAufrufe desselben Typs wartet,mit denen er Nachrichtendesselben Typs zu einem Stapelzusammenfasst.

Je höher die Einstellung, destoweniger Stapel sind erforderlich,um dieselbe Anzahl an Aufgabenauszuführen (der erste Aufrufeines Stapels muss jedoch längerin der Warteschlange warten).

Wenn Sie diesen Parameter auf0 einstellen, warten gesendeteAnforderungen nicht auf andereAnforderungen, wodurch dieStapelverarbeitung effektivdeaktiviert wird.

maxBatchSize 10 Anforderungen pro Stapel Die maximale Anzahl vonNachrichten, die in einereinzelnen Stapelanforderungzusammengefasst werden.Je höher die Einstellung,desto weniger Stapel müssendie gleiche Anzahl vonAnforderungen ausführen.

Note

10 Anforderungen proStapel ist der maximalzulässige Wert fürAmazon SQS.

221



maxBatchSizeBytes 256 KB Die maximale Größe einesNachrichtenstapels in Bytes, dieder Client versucht, an AmazonSQS zu senden.

Note

256 KB ist der maximalzulässige Wert fürAmazon SQS.

maxDoneReceiveBatches 10 Stapel Die maximale Anzahl vonEmpfangsstapeln, dieAmazonSQSBufferedAsyncClientvorab abruft und clientseitigspeichert.

Je höher die Einstellung, destomehr Empfangsanforderungenkönnen erfüllt werden, ohnedass ein Aufruf des AmazonSQS-Servers gestartet werdenmuss (je mehr Nachrichtenjedoch vorab abgerufen werden,desto länger bleiben sie imPuffer, was bedeutet, dassderen Zeitbeschränkung für dieSichtbarkeit abläuft).

Note

0 gibt an, dass dasgesamte Vorabrufen vonNachrichten deaktiviertist und Nachrichten nurbei Bedarf abgerufenwerden.

maxInflightOutboundBatches 5 Stapel Die maximale Anzahl deraktiven ausgehenden Stapel, diegleichzeitig verarbeitet werdenkönnen.

Je höher die Einstellung, destoschneller können ausgehendeStapel gesendet werden (inAbhängigkeit von anderenKontingenten, z. B. durch CPUoder Bandbreite) und destomehr Threads werden vonAmazonSQSBufferedAsyncClientverbraucht.

222

Amazon Simple Queue Service EntwicklerhandbuchErhöhen des Durchsatzes mit horizontalerSkalierung und Aktionsstapelverarbeitung


maxInflightReceiveBatches 10 Stapel Die maximale Anzahl der aktivenEmpfangsstapel, die gleichzeitigverarbeitet werden können.

Je höher die Einstellung,desto mehr Nachrichtenkönnen empfangen werden(in Abhängigkeit von anderenKontingenten, z. B. durch CPUoder Bandbreite) und destomehr Threads werden vonAmazonSQSBufferedAsyncClientverbraucht.

Note

0 gibt an, dass dasgesamte Vorabrufen vonNachrichten deaktiviertist und Nachrichten nurbei Bedarf abgerufenwerden.

visibilityTimeoutSeconds -1 Wenn dieser Parameterauf einen positiven Wertungleich null festgelegt ist,überschreibt die hier festgelegteZeitbeschränkung für dieSichtbarkeit diejenige, die fürdie Warteschlange festgelegt ist,über die Nachrichten abgerufenwerden.

Note

-1 gibt an, dass dieStandardeinstellungfür die Warteschlangeausgewählt ist.Sie können alsZeitbeschränkung fürdie Sichtbarkeit nicht 0festlegen.

Erhöhen des Durchsatzes mit horizontaler Skalierungund AktionsstapelverarbeitungAmazon SQS-Warteschlangen können einen sehr hohen Durchsatz erzielen. Standard-Warteschlangenunterstützen eine fast unbegrenzte Anzahl an Transaktionen pro Sekunde (TPS) pro API-Aktion(SendMessage, ReceiveMessage oder DeleteMessage). Mit Stapelverarbeitung (p. 218) unterstützenFIFO-Warteschlangen standardmäßig bis zu 3.000 Nachrichten pro Sekunde (TPS) pro API-Aktion(SendMessage, ReceiveMessage oder DeleteMessage). Um eine Kontingenterhöhung anzufordern,übermitteln Sie eine Support-Anforderung. Ohne Stapelverarbeitung unterstützen FIFO-Warteschlangen

223



bis zu 300 Nachrichten pro Sekunde und pro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage).

Um einen hohen Durchsatz zu erreichen, müssen Sie Nachrichtenproduzenten und -konsumentenhorizontal skalieren (durch Hinzufügen weiterer Produzenten und Konsumenten).

Themen• Horizontale Skalierung (p. 224)• Stapelverarbeitung von Aktionen (p. 225)• Funktionierendes Java-Beispiel für einzelne Operationsanforderungen und

Stapelanforderungen (p. 225)

Horizontale SkalierungDa Sie über ein HTTP-Anfrage-Antwort-Protokoll auf Amazon SQS zugreifen, beschränkt dieAnforderungslatenz (der Zeitraum zwischen dem Initiieren einer Anforderung und dem Empfangen einerAntwort) den Durchsatz, den Sie über einen einzelnen Thread über eine einzelne Verbindung erzielenkönnen. Wenn beispielsweise der Mittelwert der Latenz eines auf Amazon EC2 basierenden Clients zuAmazon SQS in derselben Region ca. 20 ms beträgt, liegt der Mittelwert des maximalen Durchsatzes voneinem einzelnen Thread über eine einzelne Verbindung bei 50 Operationen pro Sekunde.

Horizontale Skalierung bedeutet, dass die Anzahl Ihrer Nachrichtenproduzenten (die SendMessage-Anforderungen erstellen) und Konsumenten (die ReceiveMessage- und DeleteMessage-Anforderungenerstellen) erhöht wird, um den Gesamtdurchsatz der Warteschlange zu steigern. Sie können auf drei Artenhorizontal skalieren:

• Erhöhen der Anzahl der Threads pro Client• Hinzufügen weiterer Clients• Erhöhen der Anzahl der Threads pro Client und Hinzufügen weiterer Clients

Wenn Sie weitere Clients hinzufügen, erzielen Sie eine wesentliche lineare Steigerung des Durchsatzesder Warteschlange. Wenn Sie die Anzahl der Clients beispielsweise verdoppeln, verdoppeln Sie auch denDurchsatz.

Note

Wenn Sie eine horizontale Skalierung durchführen, müssen Sie sicherstellen, dass die verwendeteAmazon SQS-Warteschlange über ausreichend Verbindungen oder Threads verfügt, umdie Anzahl der gleichzeitigen Nachrichtenproduzenten und -konsumenten zu unterstützen,die Anforderungen senden und empfangen. Instances der AWS SDK for Java-Klasse vonAmazonSQSClient verwalten beispielsweise standardmäßig maximal 50 Verbindungen mitAmazon SQS. Um zusätzliche gleichzeitige Produzenten und Konsumenten zu erstellen,müssen Sie die maximal zulässige Anzahl von Produzenten- und Konsumenten-Threads für einAmazonSQSClientBuilder-Objekt anpassen, z. B.:

final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard() .withClientConfiguration(new ClientConfiguration() .withMaxConnections(producerCount + consumerCount)) .build();

Für AmazonSQSAsyncClient müssen Sie außerdem sicherstellen, dass ausreichend Threadsverfügbar sind.

224




https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/sqs/AmazonSQSClient.html

https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/sqs/AmazonSQSAsyncClient.html


Stapelverarbeitung von AktionenMit der Stapelverarbeitung wird in den einzelnen Roundtrips an den Service mehr Arbeit ausgeführt(z. B. das Senden mehrerer Nachrichten mit einer einzelnen SendMessageBatch-Anforderung).Die Amazon SQS-Stapelaktionen sind SendMessageBatch, DeleteMessageBatch undChangeMessageVisibilityBatch. Um die Stapelverarbeitung zu nutzen, ohne Ihre Produzenten undKonsumenten zu ändern, können Sie den Gepufferter asynchroner Client von Amazon SQS (p. 219)verwenden.

Note

Da mit ReceiveMessage 10 Nachrichten gleichzeitig verarbeitet werden können, wird keineReceiveMessageBatch-Aktion ausgeführt.

Die Stapelverarbeitung verteilt die Latenz der Stapelaktion über mehrere Nachrichten in einerStapelanforderung, anstatt die gesamte Latenz für eine einzelne Nachricht (z. B. eine SendMessage-Anforderung) zu akzeptieren. Da jeder Roundtrip mehr Arbeit verrichtet, nutzen StapelanforderungenThreads und Verbindungen effektiver und verbessern somit den Durchsatz.

Sie können die Stapelverarbeitung mit der horizontalen Skalierung kombinieren, um einenDurchsatz mit weniger Threads, Verbindungen und Anforderungen zu bieten, als dies bei einzelnenNachrichtenanforderungen der Fall ist. Mit Amazon SQS-Aktionen im Stapel können Sie bis zu10 Nachrichten gleichzeitig senden, empfangen oder löschen. Da in Amazon SQS Gebühren nachAnforderung berechnet werden, kann die Stapelverarbeitung wesentlich zur Verringerung der Kostenbeitragen.

Mit der Stapelverarbeitung kann eine gewisse Komplexität für Ihre Anwendung einhergehen (z. B. muss dieAnwendung Nachrichten vor der Übermittlung sammeln oder gelegentlich länger auf eine Antwort warten).Die Stapelverarbeitung kann in folgenden Fällen jedoch weiterhin effektiv sein:

• Ihre Anwendung erstellt in kurzer Zeit viele Nachrichten, sodass es niemals zu einer sehr langenVerzögerung kommt.

• Anders als typische Nachrichtenproduzenten, die Nachrichten als Antwort auf Ereignisse sendenmüssen, die sie nicht steuern können, ruft ein Nachrichtenkonsument Nachrichten nach eigenemErmessen aus einer Warteschlange ab.

Important

Eine Stapelanforderung kann erfolgreich ausgeführt werden, auch wenn einzelne Nachrichtenim Stapel fehlgeschlagen sind. Überprüfen Sie nach einer Stapelanforderung stets, ob einzelneNachrichten nicht zugestellt werden konnten, und führen Sie diese bei Bedarf erneut aus.

Funktionierendes Java-Beispiel für einzelneOperationsanforderungen und StapelanforderungenVoraussetzungenFügen Sie dem Pfad für Ihre Java-Build-Klasse die Pakete aws-java-sdk-sqs.jar, aws-java-sdk-ec2.jar und commons-logging.jar hinzu. Das folgende Beispiel zeigt diese Abhängigkeiten in derpom.xml-Datei eines Maven-Projekts.

<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-sqs</artifactId> <version>LATEST</version> </dependency>

225







<dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-ec2</artifactId> <version>LATEST</version> </dependency> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>LATEST</version> </dependency></dependencies>

SimpleProducerConsumer.javaDas nachstehende Java-Code-Beispiel veranschaulicht ein einfaches Produzent-Konsument-Muster. DerHaupt-Thread ruft eine Reihe von Produzenten- und Konsumenten-Threads auf, die 1-KB-Nachrichtenfür eine bestimmte Zeit verarbeiten. Dieses Beispiel enthält Produzenten und Konsumenten, die einzelneOperationsanforderungen senden, und solche, die Stapelanforderungen senden.


import com.amazonaws.AmazonClientException;import com.amazonaws.ClientConfiguration;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;

import java.math.BigInteger;import java.util.ArrayList;import java.util.List;import java.util.Random;import java.util.Scanner;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicBoolean;import java.util.concurrent.atomic.AtomicInteger;

/** * Start a specified number of producer and consumer threads, and produce-consume * for the least of the specified duration and 1 hour. Some messages can be left * in the queue because producers and consumers might not be in exact balance. */public class SimpleProducerConsumer {

// The maximum runtime of the program. private final static int MAX_RUNTIME_MINUTES = 60; private final static Log log = LogFactory.getLog(SimpleProducerConsumer.class);

public static void main(String[] args) throws InterruptedException {

226




System.out.print("Enter the number of producers: "); final int producerCount = input.nextInt();

System.out.print("Enter the number of consumers: "); final int consumerCount = input.nextInt();

System.out.print("Enter the number of messages per batch: "); final int batchSize = input.nextInt();

System.out.print("Enter the message size in bytes: "); final int messageSizeByte = input.nextInt();

System.out.print("Enter the run time in minutes: "); final int runTimeMinutes = input.nextInt();

/* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see Creating * Service Clients in the AWS SDK for Java Developer Guide. */ final ClientConfiguration clientConfiguration = new ClientConfiguration() .withMaxConnections(producerCount + consumerCount);

final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard() .withClientConfiguration(clientConfiguration) .build();

final String queueUrl = sqsClient .getQueueUrl(new GetQueueUrlRequest(queueName)).getQueueUrl();

// The flag used to stop producer, consumer, and monitor threads. final AtomicBoolean stop = new AtomicBoolean(false);

// Start the producers. final AtomicInteger producedCount = new AtomicInteger(); final Thread[] producers = new Thread[producerCount]; for (int i = 0; i < producerCount; i++) { if (batchSize == 1) { producers[i] = new Producer(sqsClient, queueUrl, messageSizeByte, producedCount, stop); } else { producers[i] = new BatchProducer(sqsClient, queueUrl, batchSize, messageSizeByte, producedCount, stop); } producers[i].start(); }

// Start the consumers. final AtomicInteger consumedCount = new AtomicInteger(); final Thread[] consumers = new Thread[consumerCount]; for (int i = 0; i < consumerCount; i++) { if (batchSize == 1) { consumers[i] = new Consumer(sqsClient, queueUrl, consumedCount, stop); } else { consumers[i] = new BatchConsumer(sqsClient, queueUrl, batchSize, consumedCount, stop); } consumers[i].start();

227


}

// Start the monitor thread. final Thread monitor = new Monitor(producedCount, consumedCount, stop); monitor.start();

// Wait for the specified amount of time then stop. Thread.sleep(TimeUnit.MINUTES.toMillis(Math.min(runTimeMinutes, MAX_RUNTIME_MINUTES))); stop.set(true);

// Join all threads. for (int i = 0; i < producerCount; i++) { producers[i].join(); }

for (int i = 0; i < consumerCount; i++) { consumers[i].join(); }

monitor.interrupt(); monitor.join(); }

private static String makeRandomString(int sizeByte) { final byte[] bs = new byte[(int) Math.ceil(sizeByte * 5 / 8)]; new Random().nextBytes(bs); bs[0] = (byte) ((bs[0] | 64) & 127); return new BigInteger(bs).toString(32); }

/** * The producer thread uses {@code SendMessage} * to send messages until it is stopped. */ private static class Producer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final AtomicInteger producedCount; final AtomicBoolean stop; final String theMessage;

Producer(AmazonSQS sqsQueueBuffer, String queueUrl, int messageSizeByte, AtomicInteger producedCount, AtomicBoolean stop) { this.sqsClient = sqsQueueBuffer; this.queueUrl = queueUrl; this.producedCount = producedCount; this.stop = stop; this.theMessage = makeRandomString(messageSizeByte); }

/* * The producedCount object tracks the number of messages produced by * all producer threads. If there is an error, the program exits the * run() method. */ public void run() { try { while (!stop.get()) { sqsClient.sendMessage(new SendMessageRequest(queueUrl, theMessage)); producedCount.incrementAndGet(); } } catch (AmazonClientException e) { /* * By default, AmazonSQSClient retries calls 3 times before

228


* failing. If this unlikely condition occurs, stop. */ log.error("Producer: " + e.getMessage()); System.exit(1); } } }

/** * The producer thread uses {@code SendMessageBatch} * to send messages until it is stopped. */ private static class BatchProducer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final int batchSize; final AtomicInteger producedCount; final AtomicBoolean stop; final String theMessage;

BatchProducer(AmazonSQS sqsQueueBuffer, String queueUrl, int batchSize, int messageSizeByte, AtomicInteger producedCount, AtomicBoolean stop) { this.sqsClient = sqsQueueBuffer; this.queueUrl = queueUrl; this.batchSize = batchSize; this.producedCount = producedCount; this.stop = stop; this.theMessage = makeRandomString(messageSizeByte); }

public void run() { try { while (!stop.get()) { final SendMessageBatchRequest batchRequest = new SendMessageBatchRequest().withQueueUrl(queueUrl);

final List<SendMessageBatchRequestEntry> entries = new ArrayList<SendMessageBatchRequestEntry>(); for (int i = 0; i < batchSize; i++) entries.add(new SendMessageBatchRequestEntry() .withId(Integer.toString(i)) .withMessageBody(theMessage)); batchRequest.setEntries(entries);

final SendMessageBatchResult batchResult = sqsClient.sendMessageBatch(batchRequest); producedCount.addAndGet(batchResult.getSuccessful().size());

/* * Because SendMessageBatch can return successfully, but * individual batch items fail, retry the failed batch items. */ if (!batchResult.getFailed().isEmpty()) { log.warn("Producer: retrying sending " + batchResult.getFailed().size() + " messages"); for (int i = 0, n = batchResult.getFailed().size(); i < n; i++) { sqsClient.sendMessage(new SendMessageRequest(queueUrl, theMessage)); producedCount.incrementAndGet(); } } } } catch (AmazonClientException e) { /*

229


* By default, AmazonSQSClient retries calls 3 times before * failing. If this unlikely condition occurs, stop. */ log.error("BatchProducer: " + e.getMessage()); System.exit(1); } } }

/** * The consumer thread uses {@code ReceiveMessage} and {@code DeleteMessage} * to consume messages until it is stopped. */ private static class Consumer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final AtomicInteger consumedCount; final AtomicBoolean stop;

Consumer(AmazonSQS sqsClient, String queueUrl, AtomicInteger consumedCount, AtomicBoolean stop) { this.sqsClient = sqsClient; this.queueUrl = queueUrl; this.consumedCount = consumedCount; this.stop = stop; }

/* * Each consumer thread receives and deletes messages until the main * thread stops the consumer thread. The consumedCount object tracks the * number of messages that are consumed by all consumer threads, and the * count is logged periodically. */ public void run() { try { while (!stop.get()) { try { final ReceiveMessageResult result = sqsClient .receiveMessage(new ReceiveMessageRequest(queueUrl));

if (!result.getMessages().isEmpty()) { final Message m = result.getMessages().get(0); sqsClient.deleteMessage(new DeleteMessageRequest(queueUrl, m.getReceiptHandle())); consumedCount.incrementAndGet(); } } catch (AmazonClientException e) { log.error(e.getMessage()); } } } catch (AmazonClientException e) { /* * By default, AmazonSQSClient retries calls 3 times before * failing. If this unlikely condition occurs, stop. */ log.error("Consumer: " + e.getMessage()); System.exit(1); } } }

/** * The consumer thread uses {@code ReceiveMessage} and {@code * DeleteMessageBatch} to consume messages until it is stopped.

230


*/ private static class BatchConsumer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final int batchSize; final AtomicInteger consumedCount; final AtomicBoolean stop;

BatchConsumer(AmazonSQS sqsClient, String queueUrl, int batchSize, AtomicInteger consumedCount, AtomicBoolean stop) { this.sqsClient = sqsClient; this.queueUrl = queueUrl; this.batchSize = batchSize; this.consumedCount = consumedCount; this.stop = stop; }

public void run() { try { while (!stop.get()) { final ReceiveMessageResult result = sqsClient .receiveMessage(new ReceiveMessageRequest(queueUrl) .withMaxNumberOfMessages(batchSize));

if (!result.getMessages().isEmpty()) { final List<Message> messages = result.getMessages(); final DeleteMessageBatchRequest batchRequest = new DeleteMessageBatchRequest() .withQueueUrl(queueUrl);

final List<DeleteMessageBatchRequestEntry> entries = new ArrayList<DeleteMessageBatchRequestEntry>(); for (int i = 0, n = messages.size(); i < n; i++) entries.add(new DeleteMessageBatchRequestEntry() .withId(Integer.toString(i)) .withReceiptHandle(messages.get(i) .getReceiptHandle())); batchRequest.setEntries(entries);

final DeleteMessageBatchResult batchResult = sqsClient .deleteMessageBatch(batchRequest); consumedCount.addAndGet(batchResult.getSuccessful().size());

/* * Because DeleteMessageBatch can return successfully, * but individual batch items fail, retry the failed * batch items. */ if (!batchResult.getFailed().isEmpty()) { final int n = batchResult.getFailed().size(); log.warn("Producer: retrying deleting " + n + " messages"); for (BatchResultErrorEntry e : batchResult .getFailed()) {

sqsClient.deleteMessage( new DeleteMessageRequest(queueUrl, messages.get(Integer .parseInt(e.getId())) .getReceiptHandle()));

consumedCount.incrementAndGet(); } } } }

231


} catch (AmazonClientException e) { /* * By default, AmazonSQSClient retries calls 3 times before * failing. If this unlikely condition occurs, stop. */ log.error("BatchConsumer: " + e.getMessage()); System.exit(1); } } }

/** * This thread prints every second the number of messages produced and * consumed so far. */ private static class Monitor extends Thread { private final AtomicInteger producedCount; private final AtomicInteger consumedCount; private final AtomicBoolean stop;

Monitor(AtomicInteger producedCount, AtomicInteger consumedCount, AtomicBoolean stop) { this.producedCount = producedCount; this.consumedCount = consumedCount; this.stop = stop; }

public void run() { try { while (!stop.get()) { Thread.sleep(1000); log.info("produced messages = " + producedCount.get() + ", consumed messages = " + consumedCount.get()); } } catch (InterruptedException e) { // Allow the thread to exit. } } }}

Überwachen von Volume-Metriken aus der Beispielausführung

Amazon SQS erstellt automatisch Volume-Metriken für gesendete, empfangene und gelöschteNachrichten. Auf diese und andere Metriken können Sie über die Registerkarte Monitoring (Überwachung)für Ihre Warteschlange oder in der CloudWatch-Konsole zugreifen.

Note

Nach dem Starten der Warteschlange kann es bis zu 15 Minuten dauern, bis die Metrikenverfügbar sind.

232

https://console.aws.amazon.com/cloudwatch/home


Verwandte Amazon SQS-RessourcenDie folgende Tabelle enthält verwandte Ressourcen, die für die Arbeit mit diesem Service nützlich sind.

Ressource Beschreibung

Amazon Simple Queue Service APIReference

Beschreibungen der Aktionen, Parameter und Datentypensowie eine Liste von Fehlern, die der Service zurückgibt.

Amazon SQS im AWS CLI CommandReference

Beschreibungen der AWS CLI-Befehle, die Sie für die Arbeitmit Warteschlangen verwenden können.

Regionen und Endpunkte Informationen zu Amazon SQS-Regionen und -Endpunkten

Produktseite Hauptwebsite für Informationen zu Amazon SQS

Diskussionsforum Ein Community-Forum, das für Entwickler eingerichtet wurde,um technische Fragen zu Amazon SQS zu klären.

Informationen zu AWS Premium Support Die Hauptwebsite mit Informationen zu AWS PremiumSupport ist ein persönlicher und reaktionsschnellerSupportkanal. Er bietet Ihnen Hilfe beim Konfigurieren und beider Verwendung von Anwendungen auf AWS InfrastructureServices.

233





https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region

https://aws.amazon.com/sqs


https://aws.amazon.com/premiumsupport/


Amazon SQS VersionshinweiseDie folgende Tabelle listet neu eingeführte und verbesserte Amazon SQS-Funktionen auf. WeitereInformationen über Änderungen an Amazon Simple Queue Service-Entwicklerhandbuch finden Sie unterAmazon SQS Dokumentverlauf (p. 241).

Datum Neu eingeführte Funktion

25. November 2019 • Die CloudWatch-Metrik über eine Minute für Amazon SQS ist derzeit nur in denfolgenden Regionen verfügbar:• USA Ost (Ohio)• Europa (Irland)• Europa (Stockholm)• Asien-Pazifik (Tokio)

Weitere Informationen finden Sie unter Verfügbare CloudWatch-Metriken fürAmazon SQS (p. 201).

• Sie können die in einer FIFO eingehenden Warteschlange Nachrichten sokonfigurieren, dass eine Lambda-Funktion ausgelöst wird. Weitere Informationenfinden Sie unter Konfigurieren in einer Amazon SQS-Warteschlange eingehenderNachrichten so, dass sie eine Lambda-Funktion auslösen (p. 56).

10. Oktober 2019 FIFO (First-In-First-Out)-Warteschlangen sind ab in der Region Naher Osten(Bahrain) verfügbar. Weitere Informationen zur Funktionsweise von FIFO-Warteschlangen und zu den ersten Schritten finden Sie unter Amazon SQS FIFO(First-In-First-Out)-Warteschlangen (p. 86).

5. September 2019 Sie können Nachrichten in den Regionen AWS GovCloud (USA Ost) und AWSGovCloud (US-West) aus Amazon Virtual Private Cloud an Ihre Amazon SQS-Warteschlangen senden. Weitere Informationen finden Sie unter Amazon VirtualPrivate Cloud-Endpunkte für Amazon SQS (p. 162).

28. August 2019 • Sie können mithilfe von AWS X-Ray Fehler bei Nachrichten beheben, die überAmazon SQS-Warteschlangen weitergeleitet werden. Weitere Informationenfinden Sie unter Fehlerbehebung von Amazon Simple Queue Service-Warteschlangen mit AWS X-Ray (p. 152).

• Mit Nachrichtensystemattribute können Sie AWS X-Ray-Ablaufverfolgungs-Header über Amazon SQS senden. Weitere Informationen finden Sie unterAmazon SQS-Nachrichtensystemattribute (p. 98). Diese Version fügt denMessageSystemAttribute-Anforderungsparameter zu den API-AktionenSendMessage und SendMessageBatch, das AWSTraceHeader-Attribut zurReceiveMessage-API-Aktion und den MessageSystemAttributeValue-Datentyp hinzu.

22. August 2019 • Sie können einen einzelnen Amazon SQS-API-Aufruf, eine AWS-SDK-Funktionoder einen AWS CLI-Befehl verwenden, um gleichzeitig eine Warteschlange zuerstellen und deren Tags anzugeben. Weitere Informationen finden Sie unterAmazon SQS Kostenzuordnungs-Tags (p. 99) und im Anfrageparameter Tag derCreateQueue-API-Aktion.

• Amazon SQS unterstützt die AWS-Schlüssel aws:TagKeys undaws:RequestTag. Weitere Informationen finden Sie unter Referenztabelle fürAktionen und Ressourcen (p. 191).

234




https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_MessageSystemAttributeValue.html




25. Juli 2019 Temporäre Warteschlangen helfen Ihnen, Entwicklungszeit und Entwicklungskosteneinzusparen, wenn Sie gängige Nachrichtenmuster, wie z. B. request-response, verwenden. Sie können mit dem Client temporärer Warteschlangenkosteneffektivere, anwendungsverwaltete, temporäre Warteschlangen mithohem Durchsatz erstellen. Weitere Informationen finden Sie unter TemporäreWarteschlangen in Amazon SQS (p. 109).

20. Juni 2019 Server-side encryption (SSE) für Amazon SQS ist jetzt in der Region AWSGovCloud (USA Ost) verfügbar. Weitere Informationen zur serverseitigenVerschlüsselung und zu den ersten Schritten bei ihrer Verwendung finden Sie unterVerschlüsselung im Ruhezustand (p. 154).

15. Mai 2019 FIFO (First-In-First-Out)-Warteschlangen sind ab in den Regionen Asien-Pazifik(Hongkong), China (Peking), AWS GovCloud (USA Ost) und AWS GovCloud(US-West) verfügbar. Weitere Informationen zur Funktionsweise von FIFO-Warteschlangen und zu den ersten Schritten finden Sie unter Amazon SQS FIFO(First-In-First-Out)-Warteschlangen (p. 86).

4. April 2019 Sie können Amazon VPC-Endpunktrichtlinien für Amazon SQS erstellen. WeitereInformationen finden Sie unter Erstellen einer Amazon VPC-Endpunktrichtlinie fürAmazon SQS (p. 162).

Important

• Sie können Amazon Virtual Private Cloud nur mit HTTPS-Amazon SQS-Endpunkten verwenden.

• Wenn Sie Amazon SQS zum Senden von Nachrichten aus Amazon VPCkonfigurieren, müssen Sie privates DNS aktivieren und Endpunkte imFormat sqs.us-east-2.amazonaws.com angeben.

• Ein privates DNS unterstützt keine Legacy-Endpunkte wiequeue.amazonaws.com oder us-east-2.queue.amazonaws.com.

14. März 2019 FIFO (First-In-First-Out) Warteschlangen sind verfügbar in den Regionen Europa(Stockholm) und China (Ningxia). Weitere Informationen zur Funktionsweise vonFIFO-Warteschlangen und zu den ersten Schritten finden Sie unter Amazon SQSFIFO (First-In-First-Out)-Warteschlangen (p. 86).

7. Februar 2019 FIFO (First-In-First-Out)-Warteschlangen sind ab in den Regionen USA Ost (Ohio),USA Ost (Nord-Virginia), USA West (Nordkalifornien), USA West (Oregon), Asien-Pazifik (Mumbai), Asien-Pazifik (Seoul), Asien-Pazifik (Singapur), Asien-Pazifik(Sydney), Asien-Pazifik (Tokio), Kanada (Zentral), Europa (Frankfurt), Europa(Irland), Europa (London), Europa (Paris) und Südamerika (São Paulo). verfügbar.Weitere Informationen zur Funktionsweise von FIFO-Warteschlangen und zuden ersten Schritten finden Sie unter Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86).

13. Dezember2018

Sie können von Amazon Virtual Private Cloud Nachrichten zu Ihren Amazon SQS-Warteschlangen senden. Weitere Informationen finden Sie unter Amazon VirtualPrivate Cloud-Endpunkte für Amazon SQS (p. 162) und Senden einer Nachricht aneine Amazon SQS-Warteschlange über Amazon Virtual Private Cloud (p. 43).

8. November 2018 FIFO (First-In-First-Out) Warteschlangen sind verfügbar in den RegionenAsien-Pazifik (Sydney) und Asien-Pazifik (Tokio). Weitere Informationen zurFunktionsweise von FIFO-Warteschlangen und zu den ersten Schritten finden Sieunter Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86).

235




28. August 2018 Server-side encryption (SSE) für Amazon SQS ist jetzt in der Region AWSGovCloud (US-West) verfügbar. Weitere Informationen zur serverseitigenVerschlüsselung und zu den ersten Schritten bei ihrer Verwendung finden Sie unterVerschlüsselung im Ruhezustand (p. 154).

27. September2018

FIFO (First-In-First-Out) Warteschlangen sind verfügbar in den RegionenAsien-Pazifik (Sydney) und Asien-Pazifik (Tokio). Weitere Informationen zurFunktionsweise von FIFO-Warteschlangen und zu den ersten Schritten finden Sieunter Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86).

28. Juni 2018 Sie können eingehende Nachrichten so konfigurieren, dass sie eine Lambda-Funktion auslösen. Weitere Informationen finden Sie unter Konfigurieren in einerAmazon SQS-Warteschlange eingehender Nachrichten so, dass sie eine Lambda-Funktion auslösen (p. 56).

Note

• Warteschlange und Lambda-Funktion müssen sich in derselben AWS-Region befinden.

• Sie können jeweils nur eine Warteschlange mit einer oder mehrerenLambda-Funktionen verknüpfen.

• Es ist nicht möglich, eine verschlüsselte Warteschlange (p. 154), dieeinen von AWS verwalteten Kunden-Masterschlüssel für Amazon SQSverwendet, mit einer Lambda-Funktion in einem anderen AWS-Konto zuverknüpfen.

24. Mai 2018 Server-side encryption (SSE) für Amazon SQS ist in allen kommerziellenRegionen verfügbar, in denen Amazon SQS verfügbar ist, außer in Regionenin China. Weitere Informationen zur serverseitigen Verschlüsselung und zuden ersten Schritten bei ihrer Verwendung finden Sie unter Verschlüsselung imRuhezustand (p. 154).

20. März 2018 Amazon CloudWatch Events kann Amazon SQS FIFO-Warteschlangen alsZiele verwenden. Weitere Informationen finden Sie unter Automatisieren vonBenachrichtigungen von AWS-Services an Amazon SQS mit CloudWatch-Ereignisse (p. 152).

23. Januar 2018 Amazon S3-Ereignisbenachrichtigungen sind mit Amazon SQS SSEkompatibel. Weitere Informationen finden Sie im aktualisierten AbschnittAktivieren der Kompatibilität zwischen AWS-Services und verschlüsseltenWarteschlangen (p. 160).

2. Januar 2018 Die folgenden Funktionen von AWS-Services sind mit Amazon SQS SSEkompatibel:

• Amazon CloudWatch-Ereignisbenachrichtigungen• Amazon SNS-Themenabonnements

19. Oktober 2017 Sie können die Kostenzuordnung nachverfolgen, indem Sie Metadaten-Tags fürAmazon SQS-Warteschlangen hinzufügen, aktualisieren, entfernen und auflisten.Dazu verwenden Sie die Aktionen TagQueue, UntagQueue und ListQueueTagssowie die AWS Management Console. Weitere Informationen finden Sie unterAmazon SQS Kostenzuordnungs-Tags (p. 99) und im Hinzufügen, Aktualisierenund Entfernen von Tags für eine Amazon SQS-Warteschlange (p. 28)-Tutorial.

236


https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html

https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html






1. September 2017 Die vollständige Reihe der Amazon SQS-Aktionen wird in der Liste Actions(Aktionen) im Dialogfeld Add a Permission to MyQueue (MyQueue eineBerechtigung hinzufügen) angezeigt. Weitere Informationen finden Sie im TutorialHinzufügen von Berechtigungen zu einer Amazon SQS-Warteschlange (p. 25).

14. Juni 2017 FIFO (First-In-First-Out) Warteschlangen sind verfügbar in der Region USAOst (Nord-Virginia). Weitere Informationen zur Funktionsweise von FIFO-Warteschlangen und zu den ersten Schritten finden Sie unter Amazon SQS FIFO(First-In-First-Out)-Warteschlangen (p. 86).

8. Juni 2017 FIFO (First-In-First-Out) Warteschlangen sind verfügbar in der Region Europa(Irland). Weitere Informationen zur Funktionsweise von FIFO-Warteschlangen undzu den ersten Schritten finden Sie unter Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86).

23. Mai 2017 Server-side encryption (SSE) für Amazon SQS ist jetzt in der Region USAOst (Nord-Virginia) verfügbar. Weitere Informationen zur serverseitigenVerschlüsselung und zu den ersten Schritten finden Sie unter Verschlüsselung imRuhezustand (p. 154).

19. Mai 2017 • Sie können den Erweiterte Client Library für Java von Amazon SQS zusammenmit Amazon SQS Java Message Service (JMS) Client verwenden.

• Java Messaging-Bibliothek von Amazon SQS wurde in 1.0.3 aktualisiert.Weitere Informationen finden Sie unter Arbeiten mit JMS und AmazonSQS (p. 117).

• Der Abschnitt Arbeiten mit JMS und Amazon SQS (p. 117) wurde aktualisiert.

1. Mai 2017 AWS hat sein HIPAA-Compliance-Programm erweitert, sodass es Amazon SQS alseinen HIPAA-fähigen Service enthält.

237

https://aws.amazon.com/compliance/hipaa-compliance/



28. April 2017 Server-side encryption (SSE) für Amazon SQS ist in den Regionen USA Ost(Ohio) und USA West (Oregon) verfügbar. SSE ermöglicht Ihnen, den Inhalt vonNachrichten in Amazon SQS-Warteschlangen unter Verwendung von in AWS KeyManagement Service (AWS KMS) verwalteten Schlüsseln zu schützen. WeitereInformationen zur serverseitigen Verschlüsselung und zu den ersten Schrittenfinden Sie unter Verschlüsselung im Ruhezustand (p. 154). Tutorials finden Sieunter:

• Erstellen einer Amazon SQS-Warteschlange mit SSE (p. 20)• Konfigurieren von SSE für eine vorhandene Amazon SQS-Warteschlange (p. 62)

SSE fügt den Aktionen KmsMasterKeyId, KmsDataKeyReusePeriodSecondsund CreateQueue die Attribute GetQueueAttributes undSetQueueAttributes hinzu.

Important

Einige Funktionen der AWS-Services, die Benachrichtigungen an AmazonSQS mithilfe der Aktion AWS Security Token Service AssumeRolesenden können, sind mit SSE kompatibel, funktionieren jedoch nur mitStandard-Warteschlangen:


Weitere Informationen zur Kompatibilität anderer Services mitverschlüsselten Warteschlangen finden Sie unter Aktivierender Kompatibilität zwischen AWS-Services und verschlüsseltenWarteschlangen (p. 160) und in der Dokumentation Ihres Services.

24. April 2017 • Erweiterte Client Library für Java von Amazon SQS und Amazon SQS JavaMessage Service (JMS) Client unterstützen FIFO-Warteschlangen.

• Java Messaging-Bibliothek von Amazon SQS wurde in 1.0.2 aktualisiert.• Der Abschnitt Arbeiten mit JMS und Amazon SQS (p. 117) wurde aktualisiert.

28. März 2017 AWS CloudFormation ermöglicht Ihnen, FIFO-Warteschlangen zu erstellen. DasTutorial AWS CloudFormation (p. 19) wurde hinzugefügt.

238









17. November2016

FIFO (First-In-First-Out)-Warteschlangen oder Standard-Warteschlangen (andererName für vorhandene Warteschlangen) sind verfügbare in den Regionen USA West(Oregon) und USA Ost (Ohio). Weitere Informationen zur Funktionsweise von FIFO-Warteschlangen und zu den ersten Schritten finden Sie hier:

• Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86)• Von einer Standard-Warteschlange in eine FIFO-Warteschlange wechseln (p. 89)• Zusätzliche Empfehlungen für Amazon SQS FIFO-Warteschlangen (p. 145)

Überarbeitete Amazon SQS-Tutorials finden Sie hier:

• Erstellen einer Amazon SQS-Warteschlange (p. 16)• Senden einer Nachricht an eine Amazon SQS-Warteschlange (p. 30)• Empfangen und Löschen einer Nachricht aus einer Amazon SQS-

Warteschlange (p. 47)

Mit FIFO-Warteschlangen werden die folgenden API-Funktionen hinzugefügt:

• die Attribute FifoQueue und ContentBasedDeduplication für die AktionenCreateQueue, GetQueueAttributes und SetQueueAttributes

• die Anforderungsparameter MessageDeduplicationId undMessageGroupId für die Aktionen SendMessage und SendMessageBatchsowie Attribute für die Aktion ReceiveMessage

• der Anforderungsparameter ReceiveRequestAttemptId für die AktionReceiveMessage

• der Antwortparameter SequenceNumber für die Aktionen SendMessage undSendMessageBatch sowie das Attribut SequenceNumber für die AktionReceiveMessage

Important

Ab 17. November 2016 veröffentlicht Amazon SQS keine WSDL mehr.Der Gepufferter asynchroner Client von Amazon SQS unterstützt derzeitkeine FIFO-Warteschlangen.Einige AWS oder externe Services, die Benachrichtigungen an AmazonSQS senden, sind eventuell nicht mit FIFO-Warteschlangen kompatibel,obwohl Sie eine FIFO-Warteschlange als Ziel festlegen können.Die folgenden Funktionen von AWS-Services sind derzeit nicht mit FIFO-Warteschlangen kompatibel:

• Amazon S3-Ereignisbenachrichtigungen• Auto Scaling-Lebenszyklus-Hooks• AWS IoT-Regelaktionen• AWS Lambda-Warteschlangen für unzustellbare Nachrichten

Weitere Informationen zur Kompatibilität anderer Services mit FIFO-Warteschlangen finden Sie in der Servicedokumentation.FIFO-Warteschlangen unterstützen keine Timer für einzelne Nachrichten.

239





https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatchRequestEntry.html




https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatchResultEntry.html




https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html




31. August 2016 Mit der ApproximateAgeOfOldestMessage CloudWatch-Metrik können Siedas ungefähre Alter der ältesten, nicht gelöschten Nachricht in der Warteschlangeermitteln. Weitere Informationen finden Sie unter Verfügbare CloudWatch-Metrikenfür Amazon SQS (p. 201).

12. Februar 2016 Sie können CloudWatch-Metriken in der Amazon SQS-Konsole jeweils für bis zu10 Warteschlangen anzeigen. Weitere Informationen finden Sie unter Überwachenvon Amazon SQS-Warteschlangen mit CloudWatch (p. 198).

27. Oktober 2015 Das Erweiterte Client Library für Java von Amazon SQS ermöglicht Ihnen dieVerwaltung von Amazon SQS-Nachrichten mit Amazon S3. Weitere Informationenfinden Sie unter Verwalten von großen Amazon SQS-Nachrichten mit AmazonS3 (p. 114) im Amazon Simple Queue Service-Entwicklerhandbuch.

29. Dezember2014

Amazon SQS ermöglicht die Nutzung von Java Message Service (JMS)mit Amazon SQS-Warteschlangen. Weitere Informationen finden Sie unterArbeiten mit JMS und Amazon SQS (p. 117) im Amazon Simple Queue Service-Entwicklerhandbuch.

8. Dezember 2014 Mit Amazon SQS können Sie Nachrichten in einer Warteschlange mithilfe derPurgeQueue-Aktion löschen. Weitere Informationen finden Sie unter PurgeQueueim Amazon Simple Queue Service API Reference.

16. Juli 2014 Amazon SQS ermöglicht Ihnen, mit AWS CloudTrail-Aktionen zu protokollieren.Weitere Informationen finden Sie unter Protokollieren von Amazon SQS API-Aufrufen mithilfe von AWS CloudTrail (p. 194).

6. Mai 2014 Amazon SQS bietet Unterstützung für Nachrichtenattribute. Weitere Informationenfinden Sie unter Amazon SQS-Nachrichtenattribute (p. 95).

29. Januar 2014 Amazon SQS bietet Unterstützung für Warteschlangen für unzustellbareNachrichten. Weitere Informationen finden Sie unter Amazon SQSWarteschlangefür unzustellbare Nachrichten (p. 102).

21. November2012

Sie können eine Amazon SQS-Warteschlange für ein Amazon SNS-Thema mithilfeder Amazon SQS-Konsole abonnieren. Weitere Informationen finden Sie unterAbonnieren einer Amazon SQS-Warteschlange für ein Amazon SNS-Thema (p. 53).

5. November 2012 Die 2012-11-05 API-Version Amazon SQS unterstützt nun Signature Version 4,die ein höheres Maß an Sicherheit und Leistung bietet. Weitere Informationen zuSignature Version 4 finden Sie unter Grundlegender Authentifizierungsprozess mitHMAC-SHA (p. 214).

5. November 2012 AWS SDK for Java enthält einen gepufferten asynchronen Client,AmazonSQSBufferedAsyncClient, für den Zugriff auf Amazon SQS. Dieserneue Client ermöglicht eine einfachere Stapelverarbeitung von Anforderungen,indem die clientseitige Pufferung aktiviert wird, wobei vom Client durchgeführteAufrufe zunächst gepuffert und anschließend als Stapelverarbeitungsanforderungan Amazon SQS gesendet werden. Weitere Informationen zur clientseitigenPufferung und Stapelverarbeitung von Anforderungen finden Sie unter Aktivierenclientseitiger Pufferung und Stapelverarbeitung von Anforderungen (p. 219).

5. November 2012 Die 2012-11-05 API-Version von Amazon SQS unterstützt jetzt Langabfragen. Mitder Langabfrage kann Amazon SQS eine bestimmte Zeit warten, bis eine Nachrichtverfügbar wird, anstatt eine leere Antwort zurückzugeben, wenn keine Nachrichtverfügbar ist. Weitere Informationen zu Langabfragen finden Sie unter AmazonSQS-Kurz- und -Langabfragen (p. 100).

240


Amazon Simple Queue Service EntwicklerhandbuchDokumentverlauf

Amazon SQS DokumentverlaufDie folgende Tabelle listete Änderungen am Amazon Simple Queue Service-Entwicklerhandbuch auf.Weitere Informationen über neu in Amazon SQS eingeführte und verbesserte Funktionen finden Sie unterAmazon SQS Versionshinweise (p. 234).

Datum Aktualisierung der Dokumentation

18. Dezember2019

• Die folgenden Abschnitte wurden hinzugefügt:• Datenschutz in Amazon SQS (p. 154)• Datenverschlüsselung (p. 154)• Protokollierung und Überwachung in Amazon SQS (p. 194)• Compliance-Validierung für Amazon SQS (p. 207)• Ausfallsicherheit in Amazon SQS (p. 207)• Infrastruktursicherheit in Amazon SQS (p. 208)• Bewährte Methoden für die Amazon SQS-Sicherheit (p. 208)

• Die folgenden Abschnitte wurden umbenannt:• Verschlüsselung im Ruhezustand (p. 154)• Schlüsselverwaltung (p. 157)• Richtlinie für den Datenverkehr zwischen Netzwerken (p. 162)• Identitäts- und Zugriffsverwaltung in Amazon SQS (p. 163)• Übersicht über die Verwaltung von Zugriffsberechtigungen (p. 165)• Verwenden von identitätsbasierten Richtlinien mit Amazon SQS (p. 171)• Amazon SQS-Automatisierung und -Fehlerbehebung (p. 152)

9. 2019. Dezember2019

Der Abschnitt Amazon SQS-Kontingente (p. 148) wurde umbenannt.

27. November 2019 Die im Abschnitt Konfigurieren in einer Amazon SQS-Warteschlange eingehenderNachrichten so, dass sie eine Lambda-Funktion auslösen (p. 56) aufgeführtenVoraussetzungen wurden korrigiert.

25. November 2019 Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Warteschlangenname und URL (p. 94)• Verfügbare CloudWatch-Metriken für Amazon SQS (p. 201)

8. November 2019 Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Aktivieren der Kompatibilität zwischen AWS-Services und verschlüsseltenWarteschlangen (p. 160)

• Amazon SQS-Metriken (p. 202) (ApproximateAgeOfOldestMessage)

7. November 2019 In diesem Handbuch wurde durchgängig der folgende Hinweis hinzugefügt:

Important

• Sie können Amazon Virtual Private Cloud nur mit HTTPS-Amazon SQS-Endpunkten verwenden.

• Wenn Sie Amazon SQS zum Senden von Nachrichten aus Amazon VPCkonfigurieren, müssen Sie privates DNS aktivieren und Endpunkte imFormat sqs.us-east-2.amazonaws.com angeben.

241


Datum Aktualisierung der Dokumentation• Ein privates DNS unterstützt keine Legacy-Endpunkte wiequeue.amazonaws.com oder us-east-2.queue.amazonaws.com.

29. Oktober 2019 • Die Informationen im Abschnitt Amazon SQS-Informationen in CloudTrail (p. 194)wurden überarbeitet.

• Die folgende Anweisung in diesem Handbuch wurde überarbeitet: Standard-Warteschlangen unterstützen eine fast unbegrenzte Anzahl an Transaktionenpro Sekunde (TPS) pro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage).

24. Oktober 2019 Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Zulassen, dass ein Benutzer einzelne Nachrichten oder Nachrichtenstapel mitSSE an eine Warteschlange sendet (p. 159)

• Zulassen, dass ein Benutzer Nachrichten mit SSE von einer Warteschlangeempfängt (p. 160)

16. Oktober 2019 Der Abschnitt Aktivieren der Kompatibilität zwischen AWS-Services undverschlüsselten Warteschlangen (p. 160) wurde neu geschrieben.

10. Oktober 2019 • Dem Abschnitt Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86)wurde die folgende Anweisung hinzugefügt: Amazon SNS ist zurzeit nicht mitFIFO-Warteschlangen kompatibel.

• Die folgende Anweisung in diesem Handbuch wurde hinzugefügt: Die Zahl derNachrichtengruppen in einer FIFO-Warteschlange ist nicht kontingentiert.

7. Oktober 2019 • Die Informationen im Abschnitt Kontingente im Zusammenhang mitNachrichten (p. 149) wurden überarbeitet.

• Das JSON-Beispiel im Abschnitt Erstellen einer Amazon VPC-Endpunktrichtliniefür Amazon SQS (p. 162) wurde korrigiert.

3. Oktober 2019 • Die Informationen im Abschnitt Grundlegende Beispiele von IAM-Richtlinien fürAmazon SQS (p. 174) wurden überarbeitet.

• Dokumentierte Berichtkriterien im Abschnitt Amazon SQS-Metriken (p. 202).• Die Beschreibung der ApproximateAgeOfOldestMessage-Metrik im Abschnitt

Amazon SQS-Metriken (p. 202) wurde neu geschrieben.

1. Oktober 2019 Die Informationen im Abschnitt Identitätsbasierte Richtlinien (IAM-Richtlinien undAmazon SQS-Richtlinien) (p. 167) wurden überarbeitet.

24. September2019

Dem Abschnitt Konfigurieren von AWS KMS-Berechtigungen (p. 159) wurdedie folgende Anweisung hinzugefügt: Für jeden Datenschlüssel, den AWS KMSgeneriert, ruft SSE die Aktion Decrypt auf, um die Integrität des Datenschlüsselsvor dem Verwenden zu überprüfen.

18. September2019

• Der Abschnitt Vermeiden eines großen Rückstaus an Nachrichten mit derselbenNachrichtengruppen-ID (p. 147) wurde erstellt.

• Abschnitt Kontingente im Zusammenhang mit Nachrichten (p. 149) wurde einNachrichtengruppen-ID-Kontingent hinzugefügt.

242



16. September2019

Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Arbeiten mit Amazon SQS-APIs (p. 212)• Abrufen von Nachrichten durch Kurzabfragen (p. 100)• Fehlerbehebung: NumberOfMessagesSent und NumberOfMessagesReceived für

eine Warteschlange für unzustellbare Nachrichten stimmen nicht überein (p. 105)• Erstellen eines Amazon VPC-Endpunkts für Amazon SQS (p. 46)• Funktionierendes Java-Beispiel für die Verwendung von JMS mit Amazon SQS

Standard-Warteschlangen (p. 125)

10. September2019

Die folgende Anweisung in diesem Handbuch wurde überarbeitet: Diestandardmäßige (minimale) Verzögerung für eine Nachricht beträgt 0 Sekunden.Die maximale Größe ist 15 Minuten.

29. August 2019 Die Informationen im Abschnitt Kompatibilität (p. 90) wurden überarbeitet.

28. August 2019 • Der Abschnitt Amazon SQS-Automatisierung und -Fehlerbehebung (p. 152)wurde umbenannt.

• Die folgenden Abschnitte wurden hinzugefügt:• Fehlerbehebung von Amazon Simple Queue Service-Warteschlangen mit AWS

X-Ray (p. 152)• Nachrichtenmetadaten (p. 95)• Amazon SQS-Nachrichtensystemattribute (p. 98)

20. August 2019 Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Amazon SQS-Metriken (p. 202)• Identitätsbasierte Richtlinien (IAM-Richtlinien und Amazon SQS-

Richtlinien) (p. 167)


• Funktionsweise von Warteschlangen für unzustellbare Nachrichten (p. 102)• Warteschlangenname und URL (p. 94)

7. August 2019 Dem Abschnitt Kontingente im Zusammenhang mit Warteschlangen (p. 148) wurdedie folgende Anweisung hinzugefügt: Eine Amazon SQS-Warteschlange kannunbegrenzt viele Nachrichten speichern.


• Datentypen für das Nachrichtenattribut (p. 96)• Amazon SQS-Kurz- und -Langabfragen (p. 100)• Unterschiede zwischen Lang- und Kurzabfragen (p. 101)

31. Juli 2019 Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Verwenden von identitätsbasierten Richtlinien mit Amazon SQS (p. 171)• Grundlegende Beispiele von IAM-Richtlinien für Amazon SQS (p. 174)• Grundlegende Beispiele von Amazon SQS-Richtlinien (p. 176)• Angeben von Bedingungen in einer Richtlinie (p. 170)

243




• Hinzufügen von Berechtigungen zu einer Amazon SQS-Warteschlange (p. 25)• Amazon SQS Access Policy Language Die wichtigsten Konzepte (p. 181)• So wird ein einzelnes Amazon SQS-Nachrichtenattribut verschlüsselt (p. 98)• Erste Schritte mit Amazon SQS (p. 8)

29. Juli 2019 • Die Informationen in den folgenden Abschnitten wurden überarbeitet:• Implementieren von Request-Response-Systemen (p. 143)• Request-Response-Messaging-Muster (virtuelle Warteschlangen) (p. 111)

• Der Abschnitt Arbeiten mit Zeitbeschränkungen für die Sichtbarkeit (p. 146)wurde hinzugefügt.

26. Juli 2019 Die folgende Anweisung in diesem Handbuch wurde korrigiert: MitStapelverarbeitung (p. 218) unterstützen FIFO-Warteschlangen standardmäßigbis zu 3.000 Nachrichten pro Sekunde (TPS) pro API-Aktion (SendMessage,ReceiveMessage oder DeleteMessage). Um eine Kontingenterhöhunganzufordern, übermitteln Sie eine Support-Anforderung.

15. Juli 2019 Der Abschnitt Temporäre Warteschlangen in Amazon SQS (p. 109) wurdehinzugefügt.


• Amazon SQS Standard-Warteschlangen (p. 83)• Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86)

22. Juni 2019 Behebung eines fehlerhaften Links im Abschnitt Wie sehen meine ersten Schrittemit Amazon SQS aus? (p. 3).

30. Mai 2019 Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Beziehungen zwischen expliziten und standardmäßigen Zugriffsverweigerungenin Amazon SQS Access Policy Language (p. 185)

• Verschlüsselung im Ruhezustand (p. 154)


• Konfigurieren von SSE für eine vorhandene Amazon SQS-Warteschlange (p. 62)• So konfigurieren Sie eine Verzögerungswarteschlange und senden, empfangen

und löschen Nachrichten (p. 79)• Amazon SQS-Metriken (p. 202)


• Konfigurieren in einer Amazon SQS-Warteschlange eingehender Nachrichten so,dass sie eine Lambda-Funktion auslösen (p. 56)

• Amazon SQS-Zugriffskontrollarchitektur (p. 180)

4. April 2019 Der Abschnitt Erstellen einer Amazon VPC-Endpunktrichtlinie für AmazonSQS (p. 162) wurde hinzugefügt.

244




26. März 2019 Die Informationen in den folgenden Abschnitten wurden überarbeitet:

• Kontingente im Zusammenhang mit Warteschlangen (p. 148)• Kontingente im Zusammenhang mit Richtlinien (p. 151)

15. März 2019 Die Informationen im Abschnitt Wichtige Begriffe (p. 156) wurden überarbeitet.

14. März 2019 • Der Abschnitt Zugriffsverweigerung, wenn dieser nicht von einem VPC-Endpunktaus erfolgt (p. 189) wurde hinzugefügt.

• Der Inhalt in den folgenden Abschnitten wurde aktualisiert:• Erste Schritte mit Amazon SQS (p. 8)• Senden einer Nachricht an eine Amazon SQS-Warteschlange über Amazon

Virtual Private Cloud (p. 43)

22. Januar 2019 • Dem Abschnitt Konfigurieren in einer Amazon SQS-Warteschlange eingehenderNachrichten so, dass sie eine Lambda-Funktion auslösen (p. 56) wurde diefolgende Anweisung hinzugefügt: Wenn Sie eine verschlüsselte Warteschlangemit einer Lambda-Funktion verknüpfen, Lambda jedoch keine Nachrichtenabfragt, fügen Sie Ihrer Lambda-Rolle die Berechtigung kms:Decrypt hinzu.

• Die Informationen im Abschnitt Voraussetzungen (p. 56) wurden präzisiert.

21. Januar 2019 Die Java-Code-Beispiele im Abschnitt Erstellen einer Amazon SQS-Warteschlangemit SSE (p. 20) wurden korrigiert.

18. Januar 2019 • Die folgende Formulierung im gesamten Handbuch wurde verdeutlicht: OhneStapelverarbeitung unterstützen FIFO-Warteschlangen bis zu 300 Nachrichtenpro Sekunde und pro API-Aktion (SendMessage, ReceiveMessage oderDeleteMessage).

• Die Informationen in den folgenden Abschnitten wurden korrigiert:• Erstellen von CloudWatch-Alarmen für Amazon SQS-Metriken (p. 201)• Konfigurieren in einer Amazon SQS-Warteschlange eingehender Nachrichten

so, dass sie eine Lambda-Funktion auslösen (p. 56)

13. Dezember2018

Die folgenden Abschnitte wurden hinzugefügt:

• Amazon Virtual Private Cloud-Endpunkte für Amazon SQS (p. 162)• Senden einer Nachricht an eine Amazon SQS-Warteschlange über Amazon

Virtual Private Cloud (p. 43)

3. Dezember 2018 Die POST-Beispielanforderung im Abschnitt Eine POST-Anforderungdurchführen (p. 213) wurde korrigiert.

3. Oktober 2018 Die Beispiel-IP-Adresse im Abschnitt Berechtigung für Anforderungen von AmazonEC2-Instances erteilen (p. 188) wurde korrigiert.

25. September2018

Die Informationen in den folgenden Abschnitten wurden korrigiert:

• SetQueueAttributes (p. 197)• Empfangen und Löschen einer Nachricht aus einer Amazon SQS-

Warteschlange (p. 47)

245



4. September 2018 • Die Informationen in den folgenden Abschnitten wurden korrigiert:• Aktivieren der Kompatibilität zwischen AWS-Services und verschlüsselten

Warteschlangen (p. 160)• Funktionsweise von Warteschlangen für unzustellbare Nachrichten (p. 102)

• Die Einleitung im Abschnitt Abonnieren einer Amazon SQS-Warteschlange für einAmazon SNS-Thema (p. 53) wurde präzisiert.

• Außerdem wurde die folgende Anweisung in Bezug auf die Zeitbeschränkungfür die Sichtbarkeit (p. 106) in diesem Handbuch überarbeitet: DieStandardzeitbeschränkung für die Sichtbarkeit einer Nachricht beträgt 30Sekunden. Das Minimum beträgt 0 Sekunden. Der Höchstwert beträgt 12Stunden.

• Der Abschnitt In Übertragung befindliche Nachrichten (p. 107) wurde neugeschrieben.

28. August 2018 Der Abschnitt Verschlüsselung im Ruhezustand (p. 154) wurde aktualisiert.

27. August 2018 Die Informationen im Abschnitt Referenztabelle für Aktionen undRessourcen (p. 191) wurden korrigiert.

22. August 2018 Der Abschnitt Protokollieren von Amazon SQS API-Aufrufen mithilfe von AWSCloudTrail (p. 194) wurde neu geschrieben.

21. August 2018 Überarbeitung der Attributtabelle im Abschnitt Für die Verarbeitung von AmazonSQS-Nachrichten erforderliche Ressourcen (p. 98).

20. August 2018 Den Abschnitten Amazon SQSWarteschlange für unzustellbareNachrichten (p. 102) und Konfigurieren einer Amazon SQS-Warteschlange fürunzustellbare Nachrichten (p. 69) wurde der folgende Hinweis hinzugefügt: WennSie eine Warteschlange als Quellwarteschlange bestimmen, wird nicht automatischeine Warteschlange für unzustellbare Nachrichten erstellt. Sie müssen zuersteine normale Standard- oder FIFO-Warteschlange erstellen, bevor Sie sie alsWarteschlange für unzustellbare Nachrichten bestimmen.

15. August 2018 Dem Abschnitt Amazon SQS-Kurz- und -Langabfragen (p. 100) wurdeder folgende Hinweis hinzugefügt: Sie können überprüfen, dasseine Warteschlange leer ist, wenn Sie eine lange Abfrage ausführenund die Metriken ApproximateNumberOfMessagesDelayed,ApproximateNumberOfMessagesNotVisible undApproximateNumberOfMessagesVisible mindestens 1 Minute, nachdem dieProduzenten aufhören, Nachrichten zu senden, gleich 0 sind (wenn die Metadatender Warteschlange schließlich konsistent werden). Weitere Informationen finden Sieunter Verfügbare CloudWatch-Metriken für Amazon SQS (p. 201).

7. August 2018 Die Informationen im Abschnitt In Übertragung befindliche Nachrichten (p. 107)wurden präzisiert.

25. Juli 2018 • Der Abschnitt Erstellen von CloudWatch-Alarmen für Amazon SQS-Metriken (p. 201) wurde neu geschrieben und veraltete Screenshots wurdenentfernt.

• Der Abschnitt Zugriff auf CloudWatch-Metriken für Amazon SQS (p. 199) wurdeumbenannt.

246



6. Juli 2018 Die folgenden Aussagen in diesem Handbuch wurden überarbeitet:

• Zeitbeschränkung für die Sichtbarkeit (p. 106): Die Standardzeitbeschränkungfür die Sichtbarkeit einer Nachricht beträgt 30 Sekunden. Das Minimum beträgt0 Sekunden. Der Höchstwert beträgt 12 Stunden.

• Nachrichten-Timer (p. 113): Die standardmäßige (minimale) Verzögerung für eineNachricht beträgt 0 Sekunden. Die maximale Größe ist 15 Minuten.

• Verzögerungswarteschlangen (p. 108): Die standardmäßige (minimale)Verzögerung für eine Warteschlange beträgt 0 Sekunden. Die maximale Größeist 15 Minuten.

5. Juli 2018 Der folgende Hinweis zur ApproximateAgeOfOldestMessage-Metrik wurde demMitteilungs-IDVerfügbare CloudWatch-Metriken für Amazon SQS (p. 201)-Abschnitthinzugefügt: Bei Warteschlangen für unzustellbare Nachrichten (p. 102) weist derWert ApproximateAgeOfOldestMessage auf die längste Zeit hin, die sich eineNachricht in der Warteschlange befindet.

3. Juli 2018 • Die Links für das Einreichen von Support-Anfragen wurden im gesamtenHandbuch korrigiert.

• Geringfügige Fehler im Abschnitt Amazon SQS-Tutorials (p. 16) wurdenkorrigiert.

28. Juni 2018 Die Anleitung Konfigurieren in einer Amazon SQS-Warteschlange eingehenderNachrichten so, dass sie eine Lambda-Funktion auslösen (p. 56) erstellt.

26. Juni 2018 Die Informationen im Abschnitt Funktionsweise von Warteschlangen fürunzustellbare Nachrichten (p. 102) wurden korrigiert.

11. Juni 2018 • Die folgenden Informationen wurden Abschnitt Kontingente im Zusammenhangmit Nachrichten (p. 149) hinzugefügt: eine Mitteilungs-ID im Stapel kann bis zu80 Zeichen haben. Folgende Zeichen sind zulässig: alphanumerische Zeichen,Bindestriche (-) und Unterstriche (_).

• Die Informationen im Abschnitt Verwenden vonAmazonSQSBufferedAsyncClient (p. 219) wurden korrigiert und präzisiert.

5. Juni 2018 Zusätzlich zu den GitHub-, HTML-, PDF- und Kindle-Versionen sind dieVersionshinweise für Amazon Simple Queue Service-Entwicklerhandbuch als RSS-Feed verfügbar.

29. Mai 2018 • Verbesserung des Java-Beispiels in den folgenden Abschnitten:• SQSExtendedClientExample.java (p. 115)• SimpleProducerConsumer.java (p. 226)

24. Mai 2018 Der Abschnitt Verschlüsselung im Ruhezustand (p. 154) wurde aktualisiert.

247




22. Mai 2018 • Korrektur der Informationen in allen Abschnitten über Java-Abhängigkeiten.• Die folgende Anweisung wurde überarbeitet: Für die meisten

Standard-Warteschlangen (je nach Warteschlangendatenverkehr undNachrichtenrückstand) können höchstens etwa 120.000 Inflight-Nachrichten(von einem Konsumenten aus einer Warteschlange empfangen, aber noch nichtaus der Warteschlange gelöscht.) enthalten sein. Wenn Sie dieses Kontingenterreichen, gibt Amazon SQS die Fehlermeldung OverLimit zurück. Um zuvermeiden, dass dieses Kontingent erreicht wird, sollten Sie Nachrichten aus derWarteschlange löschen, nachdem sie verarbeitet wurden. Sie können auch dieAnzahl der Warteschlangen erhöhen, die Sie zur Verarbeitung Ihrer Nachrichtenverwenden. Um eine Kontingenterhöhung anzufordern, übermitteln Sie eineSupport-Anforderung.

15. Mai 2018 Die Informationen im Abschnitt Zeitnahe Verarbeitung von Nachrichten (p. 141)wurden präzisiert.

10. Mai 2018 • Die Anleitung Senden einer Nachricht mit einem Timer an eine Amazon SQS-Warteschlange (p. 40) erstellt.

• Den Abschnitt So senden Sie eine Nachricht mit einem Timer an eineWarteschlange (p. 43) mit Java-Beispielcode erstellt.

• Verwandte Tutorials in Abschnitte gruppiert:• Erstellen von Amazon SQS-Warteschlangen (p. 16)• Senden von Nachrichten an Amazon SQS-Warteschlangen (p. 30)• Konfigurieren von Amazon SQS-Warteschlangen (p. 62)

9. Mai 2018 Der Abschnitt Amazon SQS-Nachrichten-Timer (p. 113) wurde neu geschrieben.

8. Mai 2018 • Der Abschnitt Amazon SQS-Verzögerungswarteschlangen (p. 108) wurde neugeschrieben.

• Die Anleitung Konfigurieren einer Amazon SQS-Verzögerungswarteschlange (p. 77) erstellt.

• Die folgenden Abschnitte wurden mit Java-Beispielcode erstellt:• So konfigurieren Sie eine Verzögerungswarteschlange (p. 78)• So konfigurieren Sie eine Verzögerungswarteschlange und senden,

empfangen und löschen Nachrichten (p. 79)

3. Mai 2018 • Die folgenden Abschnitte wurden mit Java-Beispielcode erstellt:• Konfigurieren einer Zeitbeschränkung für eine Warteschlange (p. 74)• Konfigurieren der Zeitbeschränkung für die Sichtbarkeit für eine einzelne

Nachricht oder mehrere Nachrichten und Nachrichten senden, empfangen undlöschen (p. 76)

• Verbesserung des Java-Beispielcodes in den folgenden Abschnitten:• SQSSimpleJavaClientExample.java (p. 84)• SQSFIFOJavaClientExample.java (p. 91)• SQSLongPollingExample.java (p. 67)• SQSDeadLetterQueueExample.java (p. 71)

2. Mai 2018 • Korrektur und Klärung der Informationen im Abschnitt Amazon SQSZeitbeschränkung für die Sichtbarkeit (p. 106).

• Die Anleitung Konfigurieren der Zeitbeschränkung für die Sichtbarkeit für eineAmazon SQS-Warteschlange (p. 73) erstellt.

248





1. Mai 2018 Korrektur und Klärung der Informationen im Abschnitt Kontingente imZusammenhang mit Warteschlangen (p. 148).

25. April 2018 • Die in den folgenden Abschnitten enthaltenen Informationen wurden präzisiertund korrigiert:• Konfigurieren einer Langabfrage für eine Amazon SQS-Warteschlange (p. 66)• IDs für Amazon SQS Standard- und FIFO-Warteschlangen (p. 94)• Erste Schritte mit Amazon SQS (p. 8)

• In diesem Handbuch wurde durchgängig der folgende Hinweis hinzugefügt:

Kontoübergreifende Berechtigungen gelten nicht für die folgenden Aktionen:• AddPermission

• CreateQueue

• DeleteQueue

• ListQueues

• ListQueueTags



• TagQueue

• UntagQueue

• Korrektur eines kleineren Fehlers im Java-Beispiel im AbschnittSQSLongPollingExample.java (p. 67).

24. April 2018 • Der Abschnitt Amazon SQS-Kurz- und -Langabfragen (p. 100) wurde neugeschrieben.

• Die Anleitung Konfigurieren einer Langabfrage für eine Amazon SQS-Warteschlange (p. 66) erstellt.

• Der Abschnitt Langabfragen einrichten (p. 142) wurde erstellt.

23. April 2018 Der Abschnitt Zeitnahe Verarbeitung von Nachrichten (p. 141) wurde neugeschrieben.

11. April 2018 • Veraltete Informationen aus den folgenden Abschnitten entfernt undQuerverweise zu verwandten Tutorials hinzugefügt:• Amazon SQS Standard-Warteschlangen (p. 83)• Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86)• Amazon SQSWarteschlange für unzustellbare Nachrichten (p. 102)• Amazon SQS Kostenzuordnungs-Tags (p. 99)• Verschlüsselung im Ruhezustand (p. 154)

• Die folgenden Abschnitte wurden neu strukturiert:• Verwalten von großen Amazon SQS-Nachrichten mit Amazon S3 (p. 114)• Erstellen von Query API-Anforderungen (p. 212)• Amazon SQS Stapel-Aktionen (p. 218)

249












10. April 2018 • Den Abschnitt So konfigurieren Sie eine Warteschlange für unzustellbareNachrichten (p. 71) mit Java-Beispielcode erstellt.

• Die folgenden Abschnitte wurden neu strukturiert:• Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86)• Arbeiten mit Amazon SQS-Nachrichten (p. 141)• Reduzieren von Amazon SQS-Kosten (p. 144)• Zusätzliche Empfehlungen für Amazon SQS FIFO-Warteschlangen (p. 145)

• Die folgenden Abschnitte wurden neu geschrieben:• Nachrichtenreihenfolge (p. 87)• So konfigurieren Sie eine Warteschlange für unzustellbare Nachrichten und

senden, empfangen und löschen eine Nachricht (p. 72)

9. April 2018 • Die folgenden Abschnitte wurden neu geschrieben:• Unterschiede zwischen Lang- und Kurzabfragen (p. 101)• Amazon SQS-Verzögerungswarteschlangen (p. 108)

• Query-API-Beispiele für die folgenden Konzepte zur Amazon Simple QueueService API Reference: verschoben• Amazon SQSWarteschlange für unzustellbare Nachrichten (p. 102)• Amazon SQS-Kurz- und -Langabfragen (p. 100)• Amazon SQS-Verzögerungswarteschlangen (p. 108)• Amazon SQS-Nachrichten-Timer (p. 113)

6. April 2018 • Die folgenden Abschnitte wurden neu geschrieben:• Amazon SQS Access Policy Language Auswertungslogik (p. 183)• Beziehungen zwischen expliziten und standardmäßigen

Zugriffsverweigerungen in Amazon SQS Access Policy Language (p. 185)• Verwenden von temporären Sicherheitsanmeldeinformationen mit Amazon

SQS (p. 190)• Die folgenden Abschnitte wurden neu strukturiert:

• Verwenden von identitätsbasierten Richtlinien mit Amazon SQS (p. 171)• Verwenden benutzerdefinierter Richtlinien mit der Amazon SQS Access Policy

Language (p. 180)

5. April 2018 • Java-Beispiele (p. 38) zur Senden einer Nachricht mit Attributen an eine AmazonSQS-Warteschlange (p. 34)-Anleitung hinzugefügt.

• Der Abschnitt Berechnung des MD5-Nachrichtendigests fürNachrichtenattribute (p. 97) wurde neu geschrieben.

• Die Anweisungen für das Java-Beispiel (p. 29) in der Hinzufügen, Aktualisierenund Entfernen von Tags für eine Amazon SQS-Warteschlange (p. 28)-Anleitungkorrigiert.

4. April 2018 • Die Anleitung Senden einer Nachricht mit Attributen an eine Amazon SQS-Warteschlange (p. 34) erstellt.

• Die folgenden Abschnitte wurden neu geschrieben:• Nachrichtenattributkomponenten (p. 96)• Datentypen für das Nachrichtenattribut (p. 96)• Nächste Schritte (p. 15) (Erste Schritte)

250





29. März 2018 Dem Abschnitt Berechnung des MD5-Nachrichtendigests fürNachrichtenattribute (p. 97) wurde der folgende Hinweis hinzugefügt:Berücksichtigen Sie bei der Berechnung des MD5 Fügen Sie immerbenutzerdefinierte Datentypsuffixe in die MD5-Nachrichtendigest immer die Suffixeder benutzerdefinierten Datentypen.

27. März 2018 • Erstellen Sie den Abschnitt Wie sehen meine ersten Schritte mit Amazon SQSaus? (p. 3).

• Den Abschnitt Lebenszyklus einer Nachricht (p. 81) neu geschrieben undverschoben.

• Die folgenden Abschnitte zur besseren Lesbarkeit neu strukturiert:• Bewährte Methoden für Amazon SQS (p. 141)• Funktionsweise von Amazon SQS (p. 80)

26. März 2018 • Implementieren von Request-Response-Systemen (p. 143) wurde dem AbschnittBewährte Methoden für Amazon SQS (p. 141) hinzugefügt.

• Den Abschnitt Was sind die größten Vorteile von Amazon SQS? (p. 1)umgeschrieben, um Informationen über kürzlich veröffentlichte Funktionen neugeschrieben.

• Die Inhalte des Abschnitts "Amazon SQS-Voraussetzungen" in vorhandenenAbschnitten umgestaltet und den Abschnitt entfernt.• Erläuterungen zum Abschnitt Löschen einer Amazon SQS-

Warteschlange (p. 60) hinzugefügt.• Die Einführung zum Abschnitt Verwalten von großen Amazon SQS-

Nachrichten mit Amazon S3 (p. 114) wurde präzisiert.

23. März 2018 • Der Abschnitt Was ist Amazon Simple Queue Service? (p. 1) wurdeumstrukturiert und neu geschrieben.

• Der Abschnitt Wie unterscheidet sich Amazon SQS von Amazon MQ oderAmazon SNS? (p. 2) wurde hinzugefügt.

• Der Abschnitt Grundlegende Amazon SQS-Architektur (p. 80) wurde verschoben.

22. März 2018 • Der Abschnitt Amazon SQS-Automatisierung und -Fehlerbehebung (p. 152)wurde umbenannt.

• Der Abschnitt Automatisieren von Benachrichtigungen von AWS-Services anAmazon SQS mit CloudWatch-Ereignisse (p. 152) wurde erstellt.

• Die Titel der Beispiele im Abschnitt Konfigurieren von AWS KMS-Berechtigungen (p. 159) wurden präzisiert.

251



20. März 2018 • Die folgenden Aussagen im gesamten Handbuch verdeutlicht: Eine AmazonSQS-Nachricht hat drei grundlegende Status:1. Von einem Produzenten an eine Warteschlange gesendet.2. Aus der Warteschlange von einem Konsumenten entgegengenommen.3. Aus der Warteschlange gelöscht.

Eine Nachricht wird als gespeichert betrachtet, wenn sie von einem Produzentenan eine Warteschlange gesendet, aber noch nicht von einem Konsumentenaus der Warteschlange empfangen. ist (d. h. zwischen den Status 1 und 2). DieAnzahl der gespeicherten Nachrichten ist nicht kontingentiert. Eine Nachrichtbefindet sich in Übertragung, wenn sie von einem Konsumenten aus einerWarteschlange empfangen, aber noch nicht aus der Warteschlange gelöscht. ist(d. h. sie befindet sich zwischen den Status 2 und 3). Die Anzahl der Nachrichtenin Übertragung ist kontingentiert.

• Unnötige Screenshots wurden entfernt und die Erläuterung der Diagramme inden Abschnitten Amazon SQS-Tutorials (p. 16), Funktionsweise von AmazonSQS (p. 80) und Sicherheit in Amazon SQS (p. 154) wurde verbessert.

• Eine Präambel wurde dem Abschnitt Amazon SQS-Warteschlangen- und-Nachrichten-IDs (p. 93) hinzugefügt und es wurde präzisiert, welchenWarteschlangentypen verschiedene Amazon SQS-IDs entsprechen.

• Informationen wurden korrigiert und präzisiert und die Syntaxmarkierung in denAbschnitten Protokollieren von Amazon SQS API-Aufrufen mithilfe von AWSCloudTrail (p. 194) und Sicherheit in Amazon SQS (p. 154) wurde korrigiert.

19. März 2018 In den Abschnitten Kontingente im Zusammenhang mit Richtlinien (p. 151) undHinzufügen von Berechtigungen zu einer Amazon SQS-Warteschlange (p. 25)wurde präzisiert, dass eine Amazon SQS-Richtlinie maximal 7 Aktionen aufweisenkann.

14. März 2018 • Die Screenshots im gesamten Handbuch wurden für eine bessereBenutzerfreundlichkeit aktualisiert und optimiert.

• Die Navigation wurde in allen Anleitungen verbessert.

13. März 2018 Der Durchsatz für FIFO-Warteschlangen (in Stapeln und nicht in Stapeln) wurde imgesamten Handbuch präzisiert.

2. März 2018 • Hinzufügen der Berechtigungen sqs:ListQueueTags, sqs:TagQueueund sqs:UntagQueue zum Abschnitt Referenztabelle für Aktionen undRessourcen (p. 191).

• Die Berechtigungen für die folgenden API-Aktionen wurden präzisiert:• ChangeMessageVisibilityBatch (sqs:ChangeMessageVisibility)• DeleteMessageBatch (sqs:DeleteMessage)• SendMessageBatch (sqs:SendMessage)

28. Februar 2018 Korrektur der Bildanzeige in GitHub.

252






27. Februar 2018 Amazon Simple Queue Service-Entwicklerhandbuch steht zusätzlich zu HTML-,PDF- und Kindle-Format auf GitHub zur Verfügung. Um Feedback zu hinterlassen,wählen Sie in der oberen rechten Ecke das GitHub-Symbol.

26. Februar 2018 • Regionen wurden in allen Regionen konsistent gemacht.• Optimierte Links zu der AWS-Konsole und den Produkt-Webseiten.

23. Februar 2018 • Der Abschnitt Erstellen von Query API-Anforderungen (p. 212) wurde neugeschrieben.

• Die Java-Code-Beispiele im Abschnitt Aktivieren clientseitiger Pufferung undStapelverarbeitung von Anforderungen (p. 219) wurde korrigiert.

• http:// wurde in allen Beispielen für Amazon SQS-Endpunkte durchhttps:// ersetzt.

21. Februar 2018 • Das Java-Code-Beispiel im Abschnitt Verwenden vonAmazonSQSBufferedAsyncClient (p. 219) wurde korrigiert.

• Die Informationen im Abschnitt Nachrichten aus einer Amazon SQS-Warteschlange löschen (p. 58) wurden präzisiert.

20. Februar 2018 • Die Informationen im Abschnitt Von einer Standard-Warteschlange in eine FIFO-Warteschlange wechseln (p. 89) wurden präzisiert.

• Optimierung des Java-Code-Beispiels in den folgenden Abschnitten:• AWS SDK for Java (p. 18)• Erstellen einer Amazon SQS-Warteschlange mit SSE anhand der AWS SDK

for Java (p. 22)• Konfigurieren von SSE für eine Amazon SQS-Warteschlange anhand der AWS

SDK for Java (p. 64)• AWS SDK for Java (p. 25)• AWS SDK for Java (p. 33)• AWS SDK for Java (p. 51)• AWS SDK for Java (p. 70)• AWS SDK for Java (p. 29)

19. Februar 2018 Optimierung des Beispiel-Java-Codes und Korrektur der pom.xml-Voraussetzungen in den folgenden Abschnitten:

• Funktionierendes Java-Beispiel für die Verwendung von Amazon S3 für großeAmazon SQS-Nachrichten (p. 114)

• Funktionierendes Java-Beispiel für Standard-Warteschlangen (p. 84)• Funktionierendes Java-Beispiel für FIFO-Warteschlangen (p. 91)

16. Februar 2018 Vereinfachung des Beispiel-Java-Codes und Hinzufügen der pom.xml-Voraussetzungen in den folgenden Abschnitten:

• Funktionierendes Java-Beispiel für Standard-Warteschlangen (p. 84)• Funktionierendes Java-Beispiel für FIFO-Warteschlangen (p. 91)

253



15. Februar 2018 Der Abschnitt Verwandte Amazon SQS-Ressourcen (p. 233) wurde aktualisiert.

14. Februar 2018 • Die Informationen im Abschnitt Abrufen von Nachrichten durchKurzabfragen (p. 100) wurden präzisiert.

• Der Abschnitt Amazon SQS-Kontingente (p. 148) wurde umstrukturiert.

13. Februar 2018 • Die folgende Anweisung geklärt: Sie können keine Tags zu einer neuenWarteschlange hinzufügen, wenn Sie diese mit der AWS Management Consoleerstellen (Sie können Tags hinzufügen, nachdem die Warteschlange erstelltwurde). Sie können jedoch jederzeit mithilfe der Amazon SQS-AktionenWarteschlangen-Tags hinzufügen, aktualisieren oder entfernen.

• Die Informationen in den Abschnitten Einrichten der Zeitbeschränkung für dieSichtbarkeit (p. 107) und Zeitnahe Verarbeitung von Nachrichten (p. 141) wurdenkorrigiert und präzisiert.

• Der Abschnitt Verwandte Amazon SQS-Ressourcen (p. 233) wurde aktualisiert.• Der Abschnitt Bitte geben Sie uns Feedback (p. 3) wurde hinzugefügt.

9. Februar 2018 • Das Java-Beispiel im Abschnitt Funktionierendes Java-Beispiel für einzelneOperationsanforderungen und Stapelanforderungen (p. 225) wurde unabhängiggemacht und die Voraussetzung pom.xml wurde hinzugefügt.

• Es wurde eine Erläuterung für die -Überwachung der Beispielausführung (p. 232)hinzugefügt.

8. Februar 2018 Das Java-Beispiel im Abschnitt Funktionierendes Java-Beispiel für einzelneOperationsanforderungen und Stapelanforderungen (p. 225) wurde neugeschrieben.

7. Februar 2018 Die folgenden Abschnitte wurden neu geschrieben:

• Erhöhen des Durchsatzes mit horizontaler Skalierung undAktionsstapelverarbeitung (p. 223)

6. Februar 2018 Die folgenden Abschnitte wurden neu geschrieben:

• Amazon SQS Stapel-Aktionen (p. 218)• Aktivieren clientseitiger Pufferung und Stapelverarbeitung von

Anforderungen (p. 219)

5. Februar 2018 Die Informationen im Abschnitt Konfigurieren einer Amazon SQS-Warteschlange fürunzustellbare Nachrichten (p. 69) wurden präzisiert.

1. Februar 2018 • Die Informationen im Abschnitt FIFO-Bereitstellungslogik (p. 88) wurdenpräzisiert.

• Die Code-Beispiele in den folgenden Abschnitten wurden —korrigiert undumbenannt—:• Funktionierendes Java-Beispiel für Standard-Warteschlangen (p. 84)• Funktionierendes Java-Beispiel für FIFO-Warteschlangen (p. 91)• Funktionierendes Java-Beispiel für die Verwendung von Amazon S3 für große

Amazon SQS-Nachrichten (p. 114)• Funktionierendes Java-Beispiel für die Verwendung von JMS mit Amazon SQS

Standard-Warteschlangen (p. 125)

254



31. Januar 2018 Die Informationen in den folgenden Abschnitten wurden präzisiert:

• Entwicklern erlauben, Nachrichten in eine gemeinsame Warteschlange zuschreiben (p. 174)

• Amazon SQS Stapel-Aktionen (p. 218)• Funktionsweise von Warteschlangen für unzustellbare Nachrichten (p. 102)

30. Januar 2018 Die folgenden Abschnitte wurden neu geschrieben:

• Grundlegender Authentifizierungsprozess mit HMAC-SHA (p. 214)• Antworten interpretieren (p. 217)

29. Januar 2018 Die folgenden Abschnitte wurden neu geschrieben:

• Erstellen von Query API-Anforderungen (p. 212)• Einen Endpunkt erstellen (p. 212)• Eine GET-Anforderung durchführen (p. 213)• Authentifizieren von Anforderungen (p. 214)

25. Januar 2018 • Im gesamten Handbuch wurden Links zur Erläuterung hinzugefügt, warum Client-Konstruktoren im AWS SDK für Java im diesem Handbuch veraltet sind. WeitereInformationen finden Sie unter Erstellen einer serviceverknüpften Rolle im AWSSDK for Java Developer Guide.

• Die folgende Aussage im Abschnitt Überwachen von Amazon SQS-Warteschlangen mit CloudWatch (p. 198) wurde präzisiert:

Die CloudWatch-Metrik über eine Minute für Amazon SQS ist derzeit nur in denfolgenden Regionen verfügbar:• USA Ost (Ohio)• Europa (Irland)• Europa (Stockholm)• Asien-Pazifik (Tokio)

24. Januar 2018 Im gesamten Handbuch wurde der Wortlaut für Amazon SQS-Aktionen präzisiert.

22. Januar 2018 Der Abschnitt Aktivieren der Kompatibilität zwischen AWS-Services undverschlüsselten Warteschlangen (p. 160) wurde hinzugefügt.

19. Januar 2018 Die Informationen im Abschnitt Funktionsweise von Warteschlangen fürunzustellbare Nachrichten (p. 102) wurden präzisiert.

255

http://aws.amazon.com/blogs/developer/client-constructors-now-deprecated/





18. Januar 2018 • Der Code im Abschnitt the section called “Erstellen einer JMS-Verbindung” (p. 119) wurde neu geschrieben, um den veraltetenAmazonSQSClient-Konstruktor durch AmazonSQSClientBuilder zuersetzen. Verwenden Sie die folgende Syntax, um eine neue Verbindungs-Factory mit allen Standardeinstellungen (wie Anmeldeinformationen und Region)festzulegen:

final SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.defaultClient());

• Der Code im Abschnitt Horizontale Skalierung (p. 224) wurde neu geschrieben.Verwenden Sie die folgende Syntax, um die maximal zulässige Anzahl vonProduzenten- und Konsumenten-Threads für ein AmazonSQSClientBuilderObjekt anzupassen:

final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard() .withClientConfiguration(new ClientConfiguration() .withMaxConnections(producerCount + consumerCount)) .build();

17. Januar 2018 • Der Code in den Abschnitten Funktionierendes Java-Beispiel für Standard-Warteschlangen (p. 84) und Funktionierendes Java-Beispiel für FIFO-Warteschlangen (p. 91) wurde neu geschrieben und vereinfacht, um denveralteten AmazonSQSClient-Konstruktor durch AmazonSQSClientBuilderzu ersetzen. Verwenden Sie die folgende Syntax, um eine neue Instance desBuilder mit allen Standardeinstellungen (wie Anmeldeinformationen und Region)festzulegen:

final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

• Der Code im Abschnitt Funktionierendes Java-Beispiel für die Verwendung vonAmazon S3 für große Amazon SQS-Nachrichten (p. 114) wurde neu geschriebenund vereinfacht, um den veralteten AmazonS3Client-Konstruktor durchAmazonS3ClientBuilder zu ersetzen.

final AmazonSQS s3 = AmazonS3ClientBuilder.defaultClient();

16. Januar 2018 • Im gesamten Handbuch wurden weitere Querverweise zu Nachrichten-ID (p. 94)und Empfangs-Mitteilung (p. 94) hinzugefügt.

• Der Abschnitt Verwalten von großen Amazon SQS-Nachrichten mit AmazonS3 (p. 114) wurde neu geschrieben.

256







15. Januar 2018 • In den Abschnitten Verwalten von großen Amazon SQS-Nachrichten mit AmazonS3 (p. 114) und Arbeiten mit JMS und Amazon SQS (p. 117) die folgendeErklärung verdeutlicht: Für SDK für Java und Erweiterte Client Library für Javavon Amazon SQS ist das J2SE Development Kit 8.0 oder höher erforderlich.

• Unterabschnitte für den Abschnitte Bewährte Methoden für Amazon SQS (p. 141)hinzugefügt und den Inhalt verdeutlicht und neu angeordnet.

• Zum Abschnitt Einrichtung der Aufbewahrungsdauer in der Warteschlange fürunzustellbare Nachrichten (p. 143) wurde die folgende Erläuterung hinzugefügt:

Nachrichten laufen immer abhängig vom ursprünglichenWarteschlangenzeitstempel ab. Wenn eine Nachricht in eine Warteschlangefür unzustellbare Nachrichten (p. 102) verschoben wird, bleibt derWarteschlangenzeitstempel unverändert. Beispiel: Wenn eine Nachrichteinen Tag lang in der ursprünglichen Warteschlange verbleibt, dann in eineWarteschlange für unzustellbare Nachrichten verschoben wird und derAufbewahrungszeitraum für diese Warteschlange vier Tage beträgt, wird dieNachricht nach drei Tagen aus der Warteschlange für unzustellbare Nachrichtengelöscht. Daher sollte der Aufbewahrungszeitraum einer Warteschlange fürunzustellbare Nachrichten immer länger sein als der Aufbewahrungszeitraum derursprünglichen Warteschlange.

• Die Informationen im Abschnitt Funktionsweise von Warteschlangen fürunzustellbare Nachrichten (p. 102) wurden präzisiert.

• Abschnitt Amazon SQS Zeitbeschränkung für die Sichtbarkeit (p. 106) wurdedie folgende Erläuterung hinzugefügt: Die Standardzeitbeschränkung fürdie Sichtbarkeit einer Nachricht beträgt 30 Sekunden. Das Minimum beträgt0 Sekunden. Der Höchstwert beträgt 12 Stunden.

3. Januar 2018 Der Durchsatz für FIFO-Warteschlangen wurde im gesamten Handbuch weiterpräzisiert.

7. Dezember 2017 • Dem Abschnitt Verwenden von identitätsbasierten Richtlinien mit AmazonSQS (p. 171) wurde der folgende Hinweis hinzugefügt: Mit Ausnahme vonListQueues unterstützen alle Amazon SQS-Aktionen Berechtigungen aufRessourcenebene. Weitere Informationen finden Sie unter Referenztabelle fürAktionen und Ressourcen (p. 191).

• Video „Einführung von Amazon Simple Queue Service (SQS) FIFO-Warteschlangen im Abschnitt Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86) hinzugefügt.

• Das Video „Einführung in Amazon Simple Queue Service (SQS) – ServerseitigeVerschlüsselung“ wurde zum Abschnitt Verschlüsselung im Ruhezustand (p. 154)hinzugefügt.

• Das Video „Einführung in Kostenzuordnungs-Tags für Amazon Simple QueueService (SQS)“ wurde zum Abschnitt Amazon SQS Kostenzuordnungs-Tags (p. 99) hinzugefügt.

257




6. Dezember 2017 • Im Abschnitt Bewährte Methoden für Amazon SQS (p. 141) wurdevorgeschlagen, Step Functions anstelle von Amazon SWF zu verwenden, wenndie Zeitbeschränkung für die Sichtbarkeit auf mehr als 12 Stunden erweitertwerden muss.

• Die folgende Erklärung im Abschnitt Kontingente im Zusammenhang mitNachrichten (p. 149) wurde präzisiert: Die Standardzeitbeschränkung fürdie Sichtbarkeit einer Nachricht beträgt 30 Sekunden. Das Minimum beträgt0 Sekunden. Der Höchstwert beträgt 12 Stunden.

• Dem Abschnitt Abonnieren einer Amazon SQS-Warteschlange für ein AmazonSNS-Thema (p. 53) wurde der folgende Hinweis hinzugefügt: Wenn sich IhreAmazon SQS-Warteschlange und das Amazon SNS-Thema in verschiedenenAWS-Konten befinden, muss der Besitzer des Themas das Abonnement zuerstbestätigen. Weitere Informationen erhalten Sie unter Confirm the Subscription(Bestätigen des Abonnements) im Entwicklerhandbuch für Amazon SimpleNotification Service.

• Dem Abschnitt Wichtige Begriffe (p. 87) wurde der folgende Hinweis hinzugefügt:Amazon SQS setzt die Nachverfolgung der Nachrichtendeduplizierungs-ID auchdann fort, nachdem die Nachricht empfangen und gelöscht wurde.

• Die Informationen in den Abschnitten Erstellen von Query API-Anforderungen (p. 212) und Überwachen von Amazon SQS-Warteschlangen mitCloudWatch (p. 198) wurden präzisiert und neu angeordnet.

1. Dezember 2017 Die Informationen im Abschnitt Überwachen von Amazon SQS-Warteschlangen mitCloudWatch (p. 198) wurden präzisiert und neu angeordnet.

30. Oktober 2017 • Inhaltsverzeichnis korrigiert und neu organisiert.• Der Abschnitt Amazon SQS Zeitbeschränkung für die Sichtbarkeit (p. 106) wurde

neu geschrieben.

27. Oktober 2017 Verbesserung der Erklärung des Durchsatzes für FIFO-Warteschlangen imAbschnitt Amazon SQS FIFO (First-In-First-Out)-Warteschlangen (p. 86).

29. September2017

Dem Abschnitt Erhöhen des Durchsatzes mit horizontaler Skalierung undAktionsstapelverarbeitung (p. 223) wurde ein Hinweis zu Gepufferter asynchronerClient von Amazon SQS hinzugefügt.

19. September2017

Die Diagramme im Abschnitt Verwenden von Amazon SQS- und IAM-Richtlinien (p. 171) wurden korrigiert.

29. August 2017 Die Informationen im Abschnitt Ändern der Zeitbeschränkung für die Sichtbarkeit füreine Nachricht (p. 108) wurden präzisiert.

17. August 2017 Die Berechtigungen für die API-Aktionen SendMessage und SendMessageBatchunter Referenztabelle für Aktionen und Ressourcen (p. 191) wurden präzisiert.

15. August 2017 Die Informationen über Warteschlangen für unzustellbare Nachrichten imAbschnitt Empfehlungen für Amazon SQS Standard- und FIFO (First-In-First-Out)-Warteschlangen (p. 141) wurden aktualisiert.

9. August 2017 • Java Messaging-Bibliothek von Amazon SQS wurde in 1.0.4 aktualisiert.Weitere Informationen finden Sie unter Arbeiten mit JMS und AmazonSQS (p. 117).


258

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToHttp.html#SendMessageToHttp.confirm



27. Juli 2017 Der veraltete AmazonSQSClient-Konstruktor wurde inAmazonSQSClientBuilder geändert und die entsprechendeRegionsspezifikation im Abschnitt Funktionierendes Java-Beispiel für Standard-Warteschlangen (p. 84) überarbeitet.

25. Juli 2017 Der Durchsatz für Standard- und FIFO-Warteschlangen wurde im gesamtenHandbuch weiter geklärt.

20. Juli 2017 Die Kompatibilität zwischen Amazon SQS SSE-Warteschlangen und AWS sowieDrittanbieter-Service-Funktionen wurde im gesamten Handbuch präzisiert:

Einige Funktionen der AWS-Services, die Benachrichtigungen an Amazon SQSmithilfe der Aktion AWS Security Token Service AssumeRole senden können, sindmit SSE kompatibel, funktionieren jedoch nur mit Standard-Warteschlangen:


Weitere Informationen zur Kompatibilität anderer Services mit verschlüsseltenWarteschlangen finden Sie unter Aktivieren der Kompatibilität zwischen AWS-Services und verschlüsselten Warteschlangen (p. 160) und in der DokumentationIhres Services.

23. Juni 2017 Die Informationen im Abschnitt Kontingente im Zusammenhang mitNachrichten (p. 149) wurden korrigiert.

20. Juni 2017 Die Informationen im Abschnitt Amazon SQSWarteschlange für unzustellbareNachrichten (p. 102) wurden präzisiert.

2. Juni 2017 • Der Abschnitt Amazon SQSWarteschlange für unzustellbare Nachrichten (p. 102)wurde umstrukturiert und aktualisiert.

• Der Abschnitt Konfigurieren einer Amazon SQS-Warteschlange für unzustellbareNachrichten (p. 69) wurde erstellt.

1. Juni 2017 Der Abschnitt Was ist Amazon Simple Queue Service? (p. 1) wurde aktualisiert.

24. Mai 2017 • Der Abschnitt Arbeiten mit JMS und Amazon SQS (p. 117) wurde umstrukturiert.• Der Abschnitt Verwenden von JMS-Client mit anderen Amazon SQS-

Clients (p. 124) wurde erstellt.

23. Mai 2017 Server-side encryption (SSE) für Amazon SQS ist jetzt in der Region USAOst (Nord-Virginia) verfügbar. Weitere Informationen zur serverseitigenVerschlüsselung und zu den ersten Schritten finden Sie unter Verschlüsselung imRuhezustand (p. 154).

19. Mai 2017 • Sie können den Erweiterte Client Library für Java von Amazon SQS zusammenmit Amazon SQS Java Message Service (JMS) Client verwenden.

• Java Messaging-Bibliothek von Amazon SQS wurde in 1.0.3 aktualisiert.Weitere Informationen finden Sie unter Arbeiten mit JMS und AmazonSQS (p. 117).


25. April 2017 Der Abschnitt Amazon SQS-Kurz- und -Langabfragen (p. 100) wurde umstrukturiertund aktualisiert.

259







6. Februar 2017 Der Abschnitt Authentifizierung und Zugriffskontrolle (p. 163) wurde aktualisiert.

16. Dezember2016

Das Amazon Simple Queue ServiceHandbuch Erste Schritte mit wurdezurückgezogen und Teile des Inhalts wurden in die folgenden Abschnitte diesesHandbuchs integriert:

• Amazon SQS einrichten (p. 4)• Erste Schritte mit Amazon SQS (p. 8)• Amazon SQS-Tutorials (p. 16)

2. Dezember 2016 Der Abschnitt Authentifizierung und Zugriffskontrolle (p. 163) wurde umstrukturiertund aktualisiert.

2. November 2016 Der Abschnitt Amazon SQS-Tutorials (p. 16) wurde umbenannt.

27. Mai 2016 Der Abschnitt Bewährte Methoden für Amazon SQS (p. 141) wurde hinzugefügt.

12. Mai 2016 Der Abschnitt Amazon SQS-Kontingente (p. 148) wurde hinzugefügt.

7. Dezember 2015 Screenshots der Amazon SQS-Konsole wurden aktualisiert.

4. August 2014 Die Informationen über Zugriffsschlüssel wurden aktualisiert. Weitere Informationenfinden Sie unter Authentifizieren von Anforderungen (p. 214).

260


AWS-GlossarDie aktuelle AWS-Terminologie finden Sie im AWS-Glossar im AWS General Reference.

261

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

amazon simple queue service - entwicklerhandbuch · amazon mq ist ein verwalteter message...

Documents