Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# RabbitMQ-Tutorials
Die folgenden Tutorials zeigen, wie Sie RabbitMQ in Amazon MQ konfigurieren und verwenden. Weitere Informationen zum Arbeiten mit unterstützten Clientbibliotheken in einer Vielzahl von Programmiersprachen wie Node.js, Python, .NET und mehr finden Sie unter[RabbitMQ-Tutorials](https://www.rabbitmq.com/getstarted.html)im*Handbuch „RabbitMQ“*.
**Topics**
+ [Bearbeiten von Broker-Einstellungen](amazon-mq-rabbitmq-editing-broker-preferences.md)
+ [Verwenden von Python Pika mit Amazon MQ for RabbitMQ](amazon-mq-rabbitmq-pika.md)
+ [Auflösen der Synchronisierung von RabbitMQ angehaltener Warteschlangensynchronisierung](rabbitmq-queue-sync.md)
+ [Reduzierung der Anzahl der Verbindungen und Kanäle](reducing-connections-and-channels.md)
+ [Schritt 2: Connect eine JVM-basierte Anwendung mit Ihrem Broker](#rabbitmq-connect-jvm-application)
+ [Connect your Amazon MQ for RabbitMQ broker to Lambda](#rabbitmq-connect-to-lambda)
+ [Verwenden der OAuth 2.0-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ](oauth-tutorial.md)
+ [Verwenden der IAM-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ](rabbitmq-iam-tutorial.md)
+ [Verwenden der LDAP-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ](rabbitmq-ldap-tutorial.md)
+ [Verwendung der HTTP-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ](rabbitmq-http-tutorial.md)
+ [Verwendung der SSL-Zertifikatsauthentifizierung für Amazon MQ für RabbitMQ](rabbitmq-ssl-tutorial.md)
+ [Verwendung von mTLS für AMQP- und Management-Endpunkte](rabbitmq-mtls-tutorial.md)
+ [Ihre JMS-Anwendung verbinden](rabbitmq-tutorial-jms.md)
# Bearbeiten von Broker-Einstellungen
Sie können Ihre Broker-Einstellungen bearbeiten, z. B. die Aktivierung oder Deaktivierung CloudWatch von Protokollen mithilfe von. AWS-Managementkonsole
## RabbitMQ-Broker-Optionen bearbeiten
1. Melden Sie sich bei der [Amazon MQ-Konsole](https://console.aws.amazon.com/amazon-mq/) an.
1. Wählen Sie in der Brokerliste Ihren Broker aus (z. B. **MyBroker**) und klicken Sie dann auf **Bearbeiten**.
1. Wählen Sie auf der *MyBroker* Seite **Bearbeiten** im Abschnitt **Spezifikationen** eine **Broker-Engine-Version oder einen **Broker-Instance-Typ**** aus.
1. Klicken Sie im Abschnitt **CloudWatch Protokolle** auf die Umschaltfläche, um allgemeine Protokolle zu aktivieren oder zu deaktivieren. Keine weiteren erforderlichen Schritte.
**Anmerkung**
Für RabbitMQ-Broker verwendet Amazon MQ automatisch eine Service-Linked Role (SLR), um allgemeine Protokolle zu veröffentlichen. CloudWatch Weitere Informationen finden Sie unter [Verwendung von serviceverknüpften Rollen für Amazon MQ](using-service-linked-roles.md).
Amazon MQ unterstützt keine Überwachungsprotokollierung für RabbitMQ-Broker.
1. Konfigurieren Sie im Abschnitt **Maintenance** (Wartung) den Wartungszeitplan für Ihren Broker:
**Um den Broker auf neue Versionen zu aktualisieren, sobald diese AWS veröffentlicht werden, wählen Sie Automatische Upgrades für Nebenversionen aktivieren.** Automatische Upgrades werden während der*-Wartungsfenster*definiert durch den Wochentag, die Tageszeit (im 24-Stunden-Format) und die Zeitzone (standardmäßig UTC).
1. Wählen Sie **Schedule modifications** (Änderungen planen).
**Anmerkung**
Wenn Sie nur **Enable automatic minor versions** (Automatische kleinere Aktualisierungen aktivieren) wählen, wechselt die Schaltfläche zu **Save** (Speichern), da kein Neustart des Brokers erforderlich ist.
Ihre Einstellungen werden zu der angegebenen Zeit auf Ihren Broker angewendet.
# Verwenden von Python Pika mit Amazon MQ for RabbitMQ
Das folgende Tutorial zeigt, wie Sie einen [Python-Pika](https://github.com/pika/pika)-Client mit TLS einrichten können, der für die Verbindung zu einem Amazon-MQ-for-RabbitMQ-Broker konfiguriert ist. Pika ist eine Python-Implementierung des AMQP-0-9-1-Protokolls für RabbitMQ. Dieses Tutorial führt Sie durch die Installation von Pika, das Deklarieren einer Warteschlange, das Einrichten eines Herausgebers zum Senden von Nachrichten an die Standard-Exchange des Brokers und das Einrichten eines Verbrauchers für den Empfang von Nachrichten aus der Warteschlange.
**Topics**
+ [Voraussetzungen](#amazon-mq-rabbitmq-pika-prerequisites)
+ [Berechtigungen](#amazon-mq-rabbitmq-pika-permissions)
+ [Schritt eins: Erstellen Sie einen einfachen Python-Pika-Client](#amazon-mq-rabbitmq-pika-basic-client)
+ [Schritt zwei: Erstellen Sie einen Herausgeber und senden Sie eine Nachricht](#amazon-mq-rabbitmq-pika-publisher-basic-publish)
+ [Schritt drei: Erstellen Sie einen Verbraucher und erhalten Sie eine Nachricht](#amazon-mq-rabbitmq-pika-consumer-basic-get)
+ [Schritt vier: (Optional) Richten Sie eine Ereignisschleife ein und konsumieren Sie Nachrichten](#amazon-mq-rabbitmq-pika-consumer-basic-consume)
+ [Als nächstes](#amazon-mq-rabbitmq-pika-whats-next)
## Voraussetzungen
Um die Schritte dieses Tutorials auszuführen, benötigen Sie Folgendes:
+ Einen Amazon-MQ-for-RabbitMQ-Broker. Weitere Informationen finden Sie unter [Erstellen eines Amazon-MQ-for-RabbitMQ-Brokers](getting-started-rabbitmq.md#create-rabbitmq-broker).
+ [Python 3](https://www.python.org/downloads/) für Ihr Betriebssystem installieren.
+ [Pika](https://pika.readthedocs.io/en/stable/) mithilfe von Python `pip` installiert. Öffnen Sie zum Installieren von Pika ein neues Terminalfenster und führen Sie Folgendes aus.
```
$ python3 -m pip install pika
```
## Berechtigungen
Für dieses Tutorial benötigen Sie mindestens einen Amazon-MQ-for-RabbitMQ-Brokerbenutzer mit der Berechtigung, an einen Vhost zu schreiben und von ihm zu lesen. In der folgenden Tabelle werden die erforderlichen Mindestberechtigungen als Muster für reguläre Ausdrücke (Regexp) beschrieben.
| Tags (Markierungen) | Konfigurieren von regexp | REGEXP-Schreiben | Lesen Sie regexp |
| --- | --- | --- | --- |
| none | | .\$1 | .\$1 |
Die aufgelisteten Benutzerberechtigungen bieten dem Benutzer nur Lese- und Schreibberechtigungen, ohne Zugriff auf das Management-Plug-In zu gewähren, um Verwaltungsvorgänge für den Broker auszuführen. Sie können Berechtigungen weiter einschränken, indem Sie regexp-Muster bereitstellen, die den Zugriff des Benutzers auf bestimmte Warteschlangen einschränken. Zum Beispiel, wenn Sie das Lese-regexp-Muster auf `^[hello world].*` ändern, hat der Benutzer nur die Berechtigung, aus Warteschlangen zu lesen, die mit `hello world` starten.
Weitere Informationen zum Erstellen von RabbitMQ-Benutzern und zum Verwalten von Benutzer-Tags und -Berechtigungen finden Sie unter[Amazon MQ für RabbitMQ-Broker-Benutzer](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Schritt eins: Erstellen Sie einen einfachen Python-Pika-Client
Um eine Python-Pika-Client-Basisklasse zu erstellen, die einen Konstruktor definiert und den SSL-Kontext bereitstellt, der für die TLS-Konfiguration erforderlich ist, wenn Sie mit einem Amazon-MQ-for-RabbitMQ-Broker interagieren, machen Sie folgendes.
1. Öffnen Sie ein neues Terminalfenster, erstellen Sie ein neues Verzeichnis für Ihr Projekt und navigieren Sie zum Verzeichnis.
```
$ mkdir pika-tutorial
$ cd pika-tutorial
```
1. Erstellen Sie eine neue Datei, `basicClient.py`, die folgenden Python-Code enthält.
```
import ssl
import pika
class BasicPikaClient:
def __init__(self, rabbitmq_broker_id, rabbitmq_user, rabbitmq_password, region):
# SSL Context for TLS configuration of Amazon MQ for RabbitMQ
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
ssl_context.set_ciphers('ECDHE+AESGCM:!ECDSA')
url = f"amqps://{rabbitmq_user}:{rabbitmq_password}@{rabbitmq_broker_id}.mq.{region}.amazonaws.com:5671"
parameters = pika.URLParameters(url)
parameters.ssl_options = pika.SSLOptions(context=ssl_context)
self.connection = pika.BlockingConnection(parameters)
self.channel = self.connection.channel()
```
Sie können jetzt zusätzliche Klassen für Ihren Herausgeber und Verbraucher definieren, die von `BasicPikaClient` erben.
## Schritt zwei: Erstellen Sie einen Herausgeber und senden Sie eine Nachricht
Gehen Sie wie folgt vor, um einen Herausgeber zu erstellen, der eine Warteschlange deklariert und eine einzelne Nachricht sendet.
1. Kopieren Sie den Inhalt des folgenden Codebeispiels und speichern Sie es lokal als `publisher.py` im selben Verzeichnis, das Sie im vorherigen Schritt erstellt haben.
```
from basicClient import BasicPikaClient
class BasicMessageSender(BasicPikaClient):
def declare_queue(self, queue_name):
print(f"Trying to declare queue({queue_name})...")
self.channel.queue_declare(queue=queue_name)
def send_message(self, exchange, routing_key, body):
channel = self.connection.channel()
channel.basic_publish(exchange=exchange,
routing_key=routing_key,
body=body)
print(f"Sent message. Exchange: {exchange}, Routing Key: {routing_key}, Body: {body}")
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Initialize Basic Message Sender which creates a connection
# and channel for sending messages.
basic_message_sender = BasicMessageSender(
"",
"",
"",
""
)
# Declare a queue
basic_message_sender.declare_queue("hello world queue")
# Send a message to the queue.
basic_message_sender.send_message(exchange="", routing_key="hello world queue", body=b'Hello World!')
# Close connections.
basic_message_sender.close()
```
Die `BasicMessageSender`-Klasse erbt von `BasicPikaClient` und implementiert zusätzliche Methoden zum Deklarieren einer Warteschlange, zum Senden einer Nachricht an die Warteschlange und zum Schließen von Verbindungen. Das Codebeispiel leitet eine Nachricht an den Standardaustausch weiter, wobei ein Routing-Schlüssel dem Namen der Warteschlange entspricht.
1. Unter `if __name__ == "__main__":`, ersetzen Sie die Parameter, die an die `BasicMessageSender`-constructor-Anweisung weitergegeben werden mit den folgenden Informationen.
+ **``** - Die eindeutige ID, die Amazon MQ für die Broker-Instance generiert. Sie können die ID von Ihrem Broker ARN analysieren. Beispielsweise angesichts der folgenden ARN, `arn:aws:mq:us-east-2:123456789012:broker:MyBroker:b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`, wäre die Broker-ID `b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`.
+ **``** – Der Benutzername für einen Broker-Benutzer mit ausreichenden Berechtigungen zum Schreiben von Nachrichten an den Broker.
+ **``** – Das Passwort für einen Broker-Benutzer mit ausreichenden Berechtigungen zum Schreiben von Nachrichten an den Broker.
+ **``**— Die AWS Region, in der Sie Ihren Amazon MQ for RabbitMQ Broker erstellt haben. Beispiel, `us-west-2`.
1. Führen Sie den folgenden Befehl im selben Verzeichnis aus, in dem Sie `publisher.py` erstellt haben.
```
$ python3 publisher.py
```
Wenn der Code erfolgreich ausgeführt wird, wird die folgende Meldung in Ihrem Terminalfenster angezeigt.
```
Trying to declare queue(hello world queue)...
Sent message. Exchange: , Routing Key: hello world queue, Body: b'Hello World!'
```
## Schritt drei: Erstellen Sie einen Verbraucher und erhalten Sie eine Nachricht
Gehen Sie wie folgt vor, um einen Verbraucher zu erstellen, der eine einzelne Nachricht aus der Warteschlange empfängt.
1. Kopieren Sie den Inhalt des folgenden Codebeispiels und speichern Sie es lokal als `consumer.py` im selben Verzeichnis.
```
from basicClient import BasicPikaClient
class BasicMessageReceiver(BasicPikaClient):
def get_message(self, queue):
method_frame, header_frame, body = self.channel.basic_get(queue)
if method_frame:
print(method_frame, header_frame, body)
self.channel.basic_ack(method_frame.delivery_tag)
return method_frame, header_frame, body
else:
print('No message returned')
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection
# and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
basic_message_receiver.get_message("hello world queue")
# Close connections.
basic_message_receiver.close()
```
Ähnlich wie der Herausgeber, den Sie im vorherigen Schritt erstellt haben, `BasicMessageReceiver` erbt `BasicPikaClient` und implementiert zusätzliche Methoden zum Empfangen einer einzelnen Nachricht und zum Schließen von Verbindungen.
1. In der `if __name__ == "__main__":`-Anweisung, ersetzen Sie die Parameter, die an den `BasicMessageReceiver`-Constructor weitergegeben werden mit Ihren Informationen.
1. Führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus.
```
$ python3 consumer.py
```
Wenn der Code erfolgreich ausgeführt wird, werden der Nachrichtentext und die Header einschließlich des Routing-Schlüssels in Ihrem Terminalfenster angezeigt.
```
b'Hello World!'
```
## Schritt vier: (Optional) Richten Sie eine Ereignisschleife ein und konsumieren Sie Nachrichten
Um mehrere Nachrichten aus einer Warteschlange zu konsumieren, verwenden Sie Pikas [https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume](https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume)-Methode und eine Callback-Funktion wie nachfolgend dargestellt
1. In `consumer.py`, fügen Sie die folgende Methodendefinition zur `BasicMessageReceiver`-Klasse hinzu.
```
def consume_messages(self, queue):
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
self.channel.basic_consume(queue=queue, on_message_callback=callback, auto_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
self.channel.start_consuming()
```
1. In `consumer.py`, unter `if __name__ == "__main__":`, rufen Sie die `consume_messages`-Methode auf, die Sie im vorherigen Schritt definiert haben.
```
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
# basic_message_receiver.get_message("hello world queue")
# Consume multiple messages in an event loop.
basic_message_receiver.consume_messages("hello world queue")
# Close connections.
basic_message_receiver.close()
```
1. Führen Sie `consumer.py` erneut aus, und falls dies erfolgreich ist, werden die Nachrichten in der Warteschlange in Ihrem Terminalfenster angezeigt.
```
[*] Waiting for messages. To exit press CTRL+C
[x] Received b'Hello World!'
[x] Received b'Hello World!'
...
```
## Als nächstes
+ Weitere Informationen zu anderen unterstützten RabbitMQ-Clientbibliotheken finden Sie in der [RabbitMQ-Client-Dokumentation](https://www.rabbitmq.com/clients.html) auf der RabbitMQ-Website.
# Auflösen der Synchronisierung von RabbitMQ angehaltener Warteschlangensynchronisierung
In einem Amazon MQ für RabbitMQ [Cluster-Bereitstellung](rabbitmq-broker-architecture.md#rabbitmq-broker-architecture-cluster), werden Nachrichten, die in jeder Warteschlange veröffentlicht werden, über drei Broker-Knoten repliziert. Diese Replikation, bezeichnet als *Spiegelung*, bietet Hochverfügbarkeit (HA) für RabbitMQ-Broker. Warteschlangen in einer Clusterbereitstellung bestehen aus einem*Haupt*Replikat auf einem Knoten und einem oder mehreren*Mirror*. Jeder Vorgang, der auf eine gespiegelte Warteschlange angewendet wird, einschließlich der Warteschlange, wird zuerst auf die Hauptwarteschlange angewendet und dann über ihre Spiegelungen repliziert.
Betrachten Sie beispielsweise eine gespiegelte Warteschlange, die über drei Knoten repliziert wird: den Hauptknoten (`main`) und zwei Spiegeln (`mirror-1`und`mirror-2`) enthalten. Wenn alle Nachrichten in dieser gespiegelten Warteschlange erfolgreich an alle Spiegelungen weitergegeben werden, wird die Warteschlange synchronisiert. Wenn ein Knoten (`mirror-1`) für ein Zeitintervall nicht verfügbar ist, ist die Warteschlange noch funktionsfähig und kann weiterhin Nachrichten in die Warteschlange einlegen. Damit die Warteschlange synchronisiert werden kann, werden Nachrichten, die in`main`WHILE`mirror-1`nicht verfügbar ist, muss repliziert werden`mirror-1`.
Weitere Informationen zum Spiegelung finden Sie unter [Klassische gespiegelte Warteschlangen](https://www.rabbitmq.com/ha.html) auf der RabbitMQ-Website.
**Wartung und Warteschlangensynchronisierung**
Während [Wartungsfenstern](amazon-mq-rabbitmq-editing-broker-preferences.md#rabbitmq-edit-current-configuration-console) führt Amazon MQ alle Wartungsarbeiten jeweils einen Knoten aus, um sicherzustellen, dass der Broker betriebsbereit bleibt. Daher müssen Warteschlangen möglicherweise synchronisiert werden, wenn jeder Knoten den Vorgang fortsetzt. Während der Synchronisierung werden Nachrichten, die auf Spiegelungen repliziert werden müssen, vom entsprechenden Amazon Elastic Block Store (Amazon EBS) -Volume in den Speicher geladen, um in Batches verarbeitet zu werden. Durch die Verarbeitung von Nachrichten in Batches können Warteschlangen schneller synchronisiert werden.
Wenn Warteschlangen kurz gehalten werden und Nachrichten klein sind, werden die Warteschlangen erfolgreich synchronisiert und wie erwartet fortgesetzt. Wenn sich die Datenmenge in einem Batch jedoch dem Speicherlimit des Knotens nähert, löst der Knoten einen Alarm mit hohem Speicher aus, der die Warteschlangen-Synchronisierung pausiert. Sie können die Speichernutzung überprüfen, indem Sie die Node-Metriken `RabbitMemUsed` und die `RabbitMqMemLimit` [Broker-Node-Metriken unter](amazon-mq-accessing-metrics.md) vergleichen CloudWatch. Die Synchronisierung kann erst abgeschlossen werden, wenn Nachrichten verbraucht oder gelöscht oder die Anzahl der Nachrichten im Stapel reduziert wird.
**Anmerkung**
Die Reduzierung der Stapelgröße der Warteschlangensynchronisierung kann zu einer höheren Anzahl von Replikationstransaktionen führen.
Um eine angehaltene Warteschlangensynchronisierung aufzulösen, führen Sie die Schritte in diesem Lernprogramm aus, in dem veranschaulicht wird, wie eine `ha-sync-batch-size`-Richtlinie angewendet wird, und starten Sie die Warteschlangen-Synchronisierung neu.
**Topics**
+ [Voraussetzungen](#rabbitmq-queue-sync-prerequisites)
+ [Schritt 1: Wenden Sie eine `ha-sync-batch-size` Richtlinie an](#rabbitmq-queue-sync-step-1)
+ [Schritt 2: Starten Sie die Warteschlangen-Synchronisierung](#rabbitmq-queue-sync-step-2)
+ [Nächste Schritte](#rabbitmq-queue-sync-next-steps)
+ [Zugehörige Ressourcen](#rabbitmq-queue-sync-related-resources)
## Voraussetzungen
Für dieses Tutorial benötigen Sie einen Amazon MQ for RabbitMQ Broker Benutzer mit Administratorberechtigungen. Sie können den Administratorbenutzer verwenden, der beim ersten Erstellen des Brokers erstellt wurde, oder einen anderen Benutzer, den Sie später erstellt haben. Die folgende Tabelle enthält die erforderlichen Administratorbenutzer-Tag und Berechtigungen als reguläre Ausdrücke (regexp) Muster.
| Tags (Markierungen) | Lesen Sie regexp | Konfigurieren von regexp | REGEXP-Schreiben |
| --- | --- | --- | --- |
| administrator | .\$1 | .\$1 | .\$1 |
Weitere Informationen zum Erstellen von RabbitMQ-Benutzern und zum Verwalten von Benutzer-Tags und -Berechtigungen finden Sie unter[Amazon MQ für RabbitMQ-Broker-Benutzer](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Schritt 1: Wenden Sie eine `ha-sync-batch-size` Richtlinie an
Die folgenden Verfahren veranschaulichen das Hinzufügen einer Richtlinie, die für alle Warteschlangen gilt, die auf dem Broker erstellt wurden. Sie können die RabbitMQ-Webkonsole oder die RabbitMQ-Management-API verwenden. Weitere Informationen finden Sie unter [Management-Plugin](https://www.rabbitmq.com/management.html) auf der RabbitMQ-Website.
**So wenden Sie eine `ha-sync-batch-size`-Richtlinie mit der RabbitMQ-Webkonsole an**
1. Melden Sie sich bei der [Amazon MQ-Konsole](https://console.aws.amazon.com/amazon-mq/) an.
1. Wählen Sie im linken Navigationsbereich die Option **Broker** aus.
1. Wählen Sie in der Broker-Liste den Namen des Brokers aus, auf den Sie die neue Richtlinie anwenden möchten.
1. Auf der Seite des Brokers im**-Verbindungen**, wählen Sie im Bereich die Option**RabbitMQ Webkonsole**URL. Die RabbitMQ-Webkonsole wird in einer neuen Browserregisterkarte oder -fenster geöffnet.
1. Melden Sie sich mit Ihren Broker-Administratoranmeldeinformationen bei der RabbitMQ-Webkonsole an.
1. Wählen Sie in der RabbitMQ-Webkonsole oben auf der Seite die Option**Admin**.
1. Klicken Sie auf der**Admin**Wählen Sie im rechten Navigationsbereich die Option**Richtlinien**.
1. Klicken Sie auf der**Richtlinien**können Sie eine Liste der aktuellen Broker-**Benutzerrichtlinien** sehen. Unter**Benutzerrichtlinien**Erweitern Sie mit**So fügen/aktualisieren Sie eine Richtlinie**.
**Anmerkung**
Standardmäßig werden Amazon MQ für RabbitMQ-Cluster mit einer anfänglichen Broker-Richtlinie namens`ha-all-AWS-OWNED-DO-NOT-DELETE`. Amazon MQ verwaltet diese Richtlinie, um sicherzustellen, dass jede Warteschlange im Broker auf alle drei Knoten repliziert wird und dass Warteschlangen automatisch synchronisiert werden.
1. Um eine neue Broker-Richtlinie zu erstellen, gehen Sie unter **Eine Richtlinie hinzufügen/aktualisieren** wie folgt vor:
1. Geben Sie unter **Name** einen Namen für Ihre Richtlinie ein, z. B. **batch-size-policy**.
1. Für **Pattern** geben Sie das regexp-Muster ein**.\$1**, damit die Richtlinie mit allen Warteschlangen auf dem Broker übereinstimmt.
1. Für**Übernehmen von**, wählen Sie **Tauschen von Warteschlangen** aus der Dropdown-Liste.
1. Für**Priorität**, geben Sie eine Ganzzahl ein, die größer ist als alle anderen Richtlinien, die auf den vhost angewendet werden. Sie können jederzeit genau einen Satz von Richtliniendefinitionen auf RabbitMQ-Warteschlangen und -Austauschvorgänge anwenden. RabbitMQ wählt die Matching-Policy mit dem höchsten Prioritätswert . Weitere Informationen zu Richtlinienprioritäten und zum Kombinieren von Richtlinien finden Sie unter [Richtlinien](https://www.rabbitmq.com/parameters.html#policies) in der Dokumentation zu RabbitMQ Server.
1. Für**Definition**, fügen Sie die folgenden Schlüssel/Wert-Paare hinzu:
+ **ha-sync-batch-size**=*100*. Wählen Sie **Zahl** aus der Drop-down-Liste aus.
**Anmerkung**
Möglicherweise müssen Sie den Wert von `ha-sync-batch-size` basierend auf der Anzahl und Größe der nicht synchronisierten Nachrichten in Ihren Warteschlangen anpassen.
+ **ha-mode**=**all**. Klicken Sie auf**Zeichenfolge**aus der Dropdown-Liste.
**Wichtig**
Die `ha-mode`-Definition ist für alle HA-bezogenen Richtlinien erforderlich. Das Auslassen führt zu einem Validierungsfehler.
+ **ha-sync-mode**=**automatic**. Klicken Sie auf**Zeichenfolge**aus der Dropdown-Liste.
**Anmerkung**
Die `ha-sync-mode`-Definition ist für alle benutzerdefinierten Richtlinien erforderlich. Wenn sie nicht angegeben wird, hängt Amazon MQ die Definition automatisch an.
1. Wählen Sie **Richtlinie aktualisieren**.
1. Vergewissern Sie sich, dass die neue Richtlinie in der Liste der**Benutzerrichtlinien** erscheint.
**So verwenden Sie eine`ha-sync-batch-size`-Richtlinie mit der RabbitMQ-Verwaltungs-API**
1. Melden Sie sich bei der [Amazon MQ-Konsole](https://console.aws.amazon.com/amazon-mq/) an.
1. Wählen Sie im linken Navigationsbereich die Option **Broker** aus.
1. Wählen Sie in der Broker-Liste den Namen des Brokers aus, auf den Sie die neue Richtlinie anwenden möchten.
1. Auf der Seite des Brokers im **-Verbindungen**-Abschnitt, notieren Sie sich die**RabbitMQ Webkonsole**URL. Dies ist der Broker-Endpunkt, den Sie in einer HTTP-Anforderung verwenden.
1. Öffnen Sie ein neues Terminal- oder Befehlszeilenfenster Ihrer Wahl.
1. Um eine neue Broker-Richtlinie zu erstellen, geben Sie Folgendes ein`curl`-Befehl. Dieser Befehl nimmt an, dass eine Warteschlange auf der`/`vhost, der als`%2F` encodiert ist.
**Anmerkung**
Ersetzen Sie *username* und *password* durch die Anmeldeinformationen Ihres Broker-Administrators. Möglicherweise müssen Sie den Wert von `ha-sync-batch-size` (*100*) anhand der Anzahl und Größe der nicht synchronisierten Nachrichten in Ihren Warteschlangen anpassen und kalibrieren. Ersetzen Sie den Broker-Endpunkt durch die URL, die Sie zuvor notiert haben.
```
curl -i -u username:password -H "content-type:application/json" -XPUT \
-d '{"pattern":".*", "priority":1, "definition":{"ha-sync-batch-size":100, "ha-mode":"all", "ha-sync-mode":"automatic"}}' \
https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies/%2F/batch-size-policy
```
1. Um zu bestätigen, dass die neue Richtlinie den Benutzerrichtlinien Ihres Brokers hinzugefügt wird, geben Sie folgen `curl`-Befehl, um alle Broker-Richtlinien aufzulisten.
```
curl -i -u username:password https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies
```
## Schritt 2: Starten Sie die Warteschlangen-Synchronisierung
Nach dem Anwenden einer neuen`ha-sync-batch-size`-Richtlinie an Ihren Broker, starten Sie die Warteschlangen-Synchronisierung neu.
**So starten Sie die Warteschlangensynchronisierung mithilfe der RabbitMQ-Webkonsole neu**
**Anmerkung**
Informationen zum Öffnen der RabbitMQ-Webkonsole finden Sie in den vorherigen Anweisungen in Schritt 1 dieses Lernprogramms.
1. Wählen Sie in der RabbitMQ-Webkonsole oben auf der Seite die Option**Queues (Warteschlangen)**.
1. Klicken Sie auf die Seite **Queues (Warteschlangen)**, und suchen Sie Ihre angehaltene Warteschlange unter**Alle Warteschlangen**. In der Zeile **Richtlinie** sollte in Ihrer Warteschlange der Name der neuen Richtlinie aufgeführt sein, die Sie erstellt haben (z. B.). `batch-size-policy`
1. Um den Synchronisierungsvorgang mit einer reduzierten Batchgröße neu zu starten, brechen Sie zunächst die Warteschlangensynchronisierung ab. Starten Sie dann die Warteschlangensynchronisierung neu.
**Anmerkung**
Wenn die Synchronisation angehalten wird und nicht erfolgreich abgeschlossen wird, versuchen Sie, den `ha-sync-batch-size`-Wert zu reduzieren und starten Sie die Warteschlangen-Synchronisierung erneut.
## Nächste Schritte
+ Sobald Ihre Warteschlange erfolgreich synchronisiert wurde, können Sie anhand der Amazon-Metrik überwachen, wie viel Speicher Ihre RabbitMQ-Knoten verwenden. CloudWatch `RabbitMQMemUsed` Sie können auch die `RabbitMQMemLimit`-Metrik, um das Speicherlimit eines Knotens zu überwachen. Weitere Informationen erhalten Sie unter [Zugreifen auf CloudWatch Metriken für Amazon MQ](amazon-mq-accessing-metrics.md) und [Verfügbare CloudWatch Metriken für Amazon MQ für RabbitMQ-Broker](rabbitmq-logging-monitoring.md).
+ Um eine angehaltene Warteschlangensynchronisierung zu verhindern, empfehlen wir, Warteschlangen kurz zu halten und Nachrichten zu verarbeiten. Für Workloads mit größeren Nachrichtengrößen empfehlen wir außerdem, Ihren Broker-Instance-Typ auf eine größere Instance-Größe mit mehr Speicher zu aktualisieren. Weitere Informationen zu Broker-Instance-Typen und zur Bearbeitung von Broker-Einstellungen finden Sie unter. [Bearbeiten von Broker-Einstellungen](amazon-mq-rabbitmq-editing-broker-preferences.md)
+ Wenn Sie einen neuen Amazon MQ für RabbitMQ Broker erstellen, wendet Amazon MQ eine Reihe von Standardrichtlinien und virtuellen Host-Limits an, um die Broker-Performance zu optimieren. Wenn Ihr Broker nicht über die empfohlenen Standardrichtlinien und -beschränkungen verfügt, empfehlen wir, diese selbst zu erstellen. Weitere Informationen zum Erstellen von Standardrichtlinien und Vhost-Grenzwerten finden Sie unter[https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html](https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html).
## Zugehörige Ressourcen
+ [UpdateBrokerInput](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-model-updatebrokerinput)— Verwenden Sie diese Broker-Eigenschaft, um einen Broker-Instance-Typ mithilfe der Amazon MQ MQ-API zu aktualisieren.
+ [Parameter und Richtlinien](https://www.rabbitmq.com/parameters.html)(RabbitMQ Server Documentation) — Erfahren Sie mehr über RabbitMQ-Parameter und -Richtlinien auf der RabbitMQ-Website.
+ [RabbitMQ-Management HTTP-API](https://pulse.mozilla.org/api/)— Erfahren Sie mehr über die RabbitMQ-Management-API.
# Reduzierung der Anzahl der Verbindungen und Kanäle
Verbindungen zu Ihrem RabbitMQ on Amazon MQ Broker können entweder durch Ihre Client-Anwendungen oder durch manuelles Schließen über die RabbitMQ-Webkonsole geschlossen werden. Gehen Sie wie folgt vor, um eine Verbindung über die RabbitMQ-Webkonsole zu schließen:
1. Melden Sie sich bei der AWS-Managementkonsole RabbitMQ-Webkonsole Ihres Brokers an und öffnen Sie sie.
1. Wählen Sie auf der RabbitMQ-Konsole die Registerkarte **Verbindungen**.
1. Wählen Sie auf der Seite **Verbindungen** unter **Alle Verbindungen** den Namen der Verbindung aus, die Sie aus der Liste schließen möchten.
1. Wählen Sie auf der Seite der Verbindungsdetails die Option **Diese Verbindung schließen** aus, um den Abschnitt zu erweitern, wählen Sie dann **Schließen erzwingen** aus. Optional können Sie den Standardtext für den **Grund** durch eine eigene Beschreibung ersetzen. RabbitMQ auf Amazon MQ gibt den von Ihnen angegebenen Grund an den Client zurück, wenn Sie die Verbindung schließen.
1. Klicken Sie im Dialogfeld auf **OK**, um die Verbindung zu bestätigen und zu schließen.
Wenn Sie eine Verbindung schließen, werden alle Kanäle, die mit einer geschlossenen Verbindung verbunden sind, ebenfalls geschlossen.
**Anmerkung**
Ihre Clientanwendungen sind möglicherweise so konfiguriert, dass sie Verbindungen zum Broker automatisch wiederherstellen, nachdem sie geschlossen wurden. In diesem Fall reicht das Schließen von Verbindungen von der Broker-Webkonsole nicht aus, um die Verbindungs- oder Kanalanzahl zu reduzieren.
Für Broker ohne öffentlichen Zugriff können Sie Verbindungen vorübergehend blockieren, indem Sie eingehenden Datenverkehr auf dem entsprechenden Nachrichtenprotokoll-Port verweigern, z. B. Port `5671` für AMQP-Verbindungen. Sie können den Port in der Sicherheitsgruppe blockieren, die Sie Amazon MQ beim Erstellen des Brokers zur Verfügung gestellt haben. Weitere Informationen zum Ändern Ihrer Sicherheitsgruppe finden Sie unter [Hinzufügen von Regeln zu einer Sicherheitsgruppe](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#adding-security-group-rules) im *Amazon-VPC-Benutzerhandbuch*.
## Schritt 2: Connect eine JVM-basierte Anwendung mit Ihrem Broker
Nachdem Sie einen RabbitMQ-Broker erstellt haben, können Sie Ihre Anwendung mit ihm verbinden. Die folgenden Beispiele zeigen, wie Sie die [RabbitMQ-Client-Bibliothek](https://www.rabbitmq.com/java-client.html), um eine Verbindung zu Ihrem Broker zu erstellen, eine Warteschlange zu erstellen und eine Nachricht zu senden. Sie können sich mit RabbitMQ-Brokern verbinden, indem Sie unterstützte RabbitMQ-Client-Bibliotheken für eine Vielzahl von Sprachen verwenden. [Weitere Informationen zu unterstützten RabbitMQ-Clientbibliotheken finden Sie unter RabbitMQ-Clientbibliotheken und Entwicklertools.](https://www.rabbitmq.com/devtools.html)
### Voraussetzungen
**Anmerkung**
Die folgenden Schritte gelten nur für RabbitMQ-Broker, die ohne öffentliche Zugänglichkeit erstellt wurden. Wenn Sie einen Broker mit öffentlicher Barrierefreiheit erstellen, können Sie ihn überspringen.
#### Aktivieren der VPC-Attribute
Um sicherzustellen, dass Ihr Broker innerhalb Ihrer VPC zugänglich ist, müssen Sie die`enableDnsHostnames`und`enableDnsSupport`VPC Attribute Weitere Informationen finden Sie unter [DNS-Support in Ihrer VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) im *Amazon-VPC-Benutzerhandbuch*.
#### Eingehende Verbindungen aktivieren
1. Melden Sie sich bei der [Amazon MQ-Konsole](https://console.aws.amazon.com/amazon-mq/) an.
1. Wählen Sie aus der Brokerliste den Namen Ihres Brokers aus (z. B.). **MyBroker**
1. Notieren Sie sich auf der ***MyBroker***Seite im Abschnitt **Verbindungen** die Adressen und Ports der Webkonsolen-URL und der Wire-Level-Protokolle des Brokers.
1. Wählen Sie im Abschnitt **Details** unter **Sicherheit und Netzwerk** den Namen Ihrer Sicherheitsgruppe oder ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/de_de/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).
Die Seite **Security Groups** (Sicherheitsgruppen) des EC2-Dashboards wird angezeigt.
1. Wählen Sie in der Liste der Sicherheitsgruppen Ihre Sicherheitsgruppe.
1. Klicken Sie unten auf der Seite auf **Inbound** (Eingehend) und anschließend auf **Edit** (Bearbeiten).
1. In dem Dialogfeld **Edit inbound rules** (Bearbeiten von Regeln für eingehenden Datenverkehr), fügen Sie eine Regel für jede URL oder jeden Endpunkt hinzu, auf den Sie öffentlich zugreifen möchten (im folgenden Beispiel wird gezeigt, wie Sie dies für eine Broker-Webkonsole tun).
1. Klicken Sie auf **Add Rule** (Regel hinzufügen).
1. Wählen Sie für **Type** (Typ) **Custom TCP** (Benutzerdefiniertes TCP).
1. Für**Source**verlassen**Benutzerdefiniert**und geben Sie dann die IP-Adresse des Systems ein, auf das auf die Webkonsole zugegriffen werden soll (z. B.`192.0.2.1`).
1. Wählen Sie **Save**.
Ihr Broker kann nun eingehende Verbindungen akzeptieren.
#### Java-Abhängigkeiten hinzufügen
Wenn Sie Apache Maven zum Automatisieren von Builds verwenden, fügen Sie die folgende Abhängigkeit zu Ihrer`pom.xml`Datei. Weitere Informationen zu Project Object Model-Dateien in Apache Maven finden Sie unter [Einführung](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html) in das POM.
```
com.rabbitmq
amqp-client
5.9.0
```
Wenn Sie [Gradle](https://docs.gradle.org/current/userguide/userguide.html) zum Automatisieren von Builds verwenden, deklarieren Sie die folgende Abhängigkeit.
```
dependencies {
compile 'com.rabbitmq:amqp-client:5.9.0'
}
```
#### Import `Connection` und `Channel` Klassen
Der RabbitMQ-Java-Client verwendet `com.rabbitmq.client` als Top-Level-Paket mit `Connection` und `Channel` API-Klassen, die eine AMQP-0-9-1-Verbindung bzw. einen Kanal darstellen. Importieren Sie die `Connection` und `Channel` Klassen vor der Verwendung, wie im folgenden Beispiel gezeigt.
```
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
```
#### Erstellen Sie ein `ConnectionFactory` und verbinden Sie es mit Ihrem Broker
Mithilfe des folgenden Beispiels können Sie eine Instance der `ConnectionFactory`-Klasse mit den gegebenen Parametern. Verwenden Sie die `setHost` Methode um den Broker-Endpunkt zu konfigurieren, den Sie zuvor notiert haben. Für`AMQPS`Wire-Level-Verbindungen, Port verwenden`5671`.
```
ConnectionFactory factory = new ConnectionFactory();
factory.setUsername(username);
factory.setPassword(password);
//Replace the URL with your information
factory.setHost("b-c8352341-ec91-4a78-ad9c-a43f23d325bb.mq.us-west-2.amazonaws.com");
factory.setPort(5671);
// Allows client to establish a connection over TLS
factory.useSslProtocol();
// Create a connection
Connection conn = factory.newConnection();
// Create a channel
Channel channel = conn.createChannel();
```
#### Veröffentlichen einer Nachricht in einem Börse
Sie können `Channel.basicPublish` verwenden, um Nachrichten in einem Austausch veröffentlichen. Im folgenden Beispiel wird verwendet, um das AMQP`Builder`-Klasse zum Erstellen eines Nachrichteneigenschaftenobjekts mit dem Inhaltstyp`plain/text`.
```
byte[] messageBodyBytes = "Hello, world!".getBytes();
channel.basicPublish(exchangeName, routingKey,
new AMQP.BasicProperties.Builder()
.contentType("text/plain")
.userId("userId")
.build(),
messageBodyBytes);
```
**Anmerkung**
Beachten Sie, dass`BasicProperties`ist eine innere Klasse der automatisch generierten Holder-Klasse,`AMQP`.
#### Abonnieren Sie eine Warteschlange und erhalten Sie eine Nachricht
Sie können eine Nachricht erhalten, indem Sie eine Warteschlange mit der `Consumer`-Schnittstelle implementieren. Sobald sie abonniert sind, werden Nachrichten automatisch zugestellt, sobald sie eintreffen.
Der einfachste Weg, um ein`Consumer`besteht darin, die Unterklasse`DefaultConsumer`. Ein `DefaultConsumer`-Objekt kann als Teil eines `basicConsume`-Aufrufs, um das Abonnement einzurichten, wie im folgenden Beispiel gezeigt.
```
boolean autoAck = false;
channel.basicConsume(queueName, autoAck, "myConsumerTag",
new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException
{
String routingKey = envelope.getRoutingKey();
String contentType = properties.getContentType();
long deliveryTag = envelope.getDeliveryTag();
// (process the message components here ...)
channel.basicAck(deliveryTag, false);
}
});
```
**Anmerkung**
Weil wir `autoAck = false` spezifizieren, ist es notwendig, Nachrichten zu bestätigen, die an die `Consumer` geliefert werden, am bequemsten in der `handleDelivery`-Methode wie im Beispiel gezeigt.
#### Schließen Sie Ihre Verbindung und trennen Sie vom Broker
Um die Verbindung zu Ihrem RabbitMQ-Broker zu trennen, schließen Sie sowohl den Kanal als auch die Verbindung, wie im Folgenden dargestellt.
```
channel.close();
conn.close();
```
**Anmerkung**
Weitere Informationen zur Arbeit mit der RabbitMQ Java-Clientbibliothek finden Sie im [RabbitMQ](https://www.rabbitmq.com/api-guide.html) Java Client API Guide.
## Schritt 3: (Optional) Connect zu einer AWS Lambda Funktion herstellen
AWS Lambda kann eine Verbindung zu Ihrem Amazon MQ-Broker herstellen und Nachrichten von diesem empfangen. Wenn Sie einen Broker mit Lambda verbinden, erstellen Sie eine [Ereignisquellen-Zuweisung](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html), der Nachrichten aus einer Warteschlange liest und die Funktion[synchron](https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html). Die Ereignisquellen-Zuweisung, die Sie erstellen, liest Nachrichten von Ihrem Broker in Batches und wandelt sie in eine Lambda -Payload in Form eines JSON-Objekts um.
**So verbinden Sie Ihren Broker mit einer Lambda Funktion**
1. Fügen Sie die folgenden IAM-Rollenberechtigungen zu der [Ausführungsrolle](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) Ihrer Lambda-Funktion hinzu.
+ [mq: DescribeBroker](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-http-methods)
+ [ec2: CreateNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html)
+ [ec2: DeleteNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteNetworkInterface.html)
+ [ec2: DescribeNetworkInterfaces](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeNetworkInterfaces.html)
+ [ec2: DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)
+ [ec2: DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html)
+ [ec2: DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html)
+ [Logs: CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html)
+ [Protokolle: CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html)
+ [Protokolle: PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)
+ [Verwalter von Geheimnissen: GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
**Anmerkung**
Ohne die erforderlichen IAM-Berechtigungen ist Ihre Funktion nicht in der Lage, Datensätze aus Amazon MQ Ressourcen erfolgreich zu lesen.
1. (Optional) Wenn Sie einen Broker ohne öffentliche Zugänglichkeit erstellt haben, müssen Sie einen der folgenden Schritte ausführen, damit Lambda eine Verbindung zu Ihrem Broker herstellen kann:
+ Konfigurieren Sie ein NAT-Gateway pro öffentlichem Subnetz. Weitere Informationen finden Sie unter[Internet- und Servicezugriff für VPC-verbundene Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-internet)im*AWS Lambda Entwicklerhandbuch*.
+ Erstellen Sie mithilfe eines VPC-Endpunkts eine Verbindung zwischen Ihrer Amazon Virtual Private Cloud (Amazon VPC) und Lambda. Ihre Amazon VPC muss auch eine Verbindung zu AWS -Security-Token-Service (AWS STS) und Secrets Manager Manager-Endpunkten herstellen. Weitere Informationen finden Sie unter[Konfigurieren von Schnittstellen-VPC-Endpunkten für Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html)im*AWS Lambda Entwicklerhandbuch*.
1. [Konfigurieren Sie Ihren Broker als Ereignisquelle](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping)Verwendung für eine Lambda -Funktion unter Verwendung der AWS-Managementkonsole. Sie können den Befehl auch verwenden. [https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html) AWS Command Line Interface
1. Schreiben Sie Code für Ihre Lambda Funktion, um die von Ihrem Broker verbrauchten Nachrichten zu verarbeiten. Die Lambda-Payload, die von der Ereignisquellen-Zuweisung abgerufen wird, hängt vom Modultyp des Brokers ab. Im Folgenden finden Sie ein Beispiel für eine Lambda -Payload für eine Amazon MQ for RabbitMQ-Warteschlange.
**Anmerkung**
Im Beispiel ist `test` der Name der Warteschlange und `/` der Name des vorgegebenen virtuellen Hosts. Beim Empfang von Nachrichten listet die Ereignisquelle Nachrichten unter `test::/` auf.
```
{
"eventSource": "aws:rmq",
"eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8",
"rmqMessagesByQueue": {
"test::/": [
{
"basicProperties": {
"contentType": "text/plain",
"contentEncoding": null,
"headers": {
"header1": {
"bytes": [
118,
97,
108,
117,
101,
49
]
},
"header2": {
"bytes": [
118,
97,
108,
117,
101,
50
]
},
"numberInHeader": 10
}
"deliveryMode": 1,
"priority": 34,
"correlationId": null,
"replyTo": null,
"expiration": "60000",
"messageId": null,
"timestamp": "Jan 1, 1970, 12:33:41 AM",
"type": null,
"userId": "AIDACKCEVSQ6C2EXAMPLE",
"appId": null,
"clusterId": null,
"bodySize": 80
},
"redelivered": false,
"data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ=="
}
]
}
}
```
*Weitere Informationen zur Verbindung von Amazon MQ mit Lambda, zu den Optionen, die Lambda für eine Amazon MQ-Ereignisquelle unterstützt, und zu Fehlern bei der Zuordnung von Ereignisquellen finden Sie unter [Using Lambda with Amazon MQ](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html) im Developer Guide.AWS Lambda *
# Verwenden der OAuth 2.0-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ
In diesem Tutorial wird beschrieben, wie Sie die [OAuth 2.0-Authentifizierung](oauth-for-amq-for-rabbitmq.md) für Ihre Amazon MQ for RabbitMQ-Broker mit Amazon Cognito als 2.0-Anbieter konfigurieren. OAuth
**Anmerkung**
Amazon Cognito ist in China (Peking) und China (Ningxia) nicht verfügbar.
**Wichtig**
Dieses Tutorial ist spezifisch für Amazon Cognito, Sie können jedoch auch andere Identitätsanbieter (IdPs) verwenden. Weitere Informationen finden Sie unter [OAuth 2.0-Authentifizierungsbeispiele](https://www.rabbitmq.com/docs/oauth2-examples).
**Topics**
+ [Voraussetzungen für die Konfiguration der OAuth 2.0-Authentifizierung](#oauth-tutorial-prerequisites)
+ [Konfiguration der OAuth 2.0-Authentifizierung mit Amazon Cognito mithilfe AWS CLI](#oauth-tutorial-config-cognito-using-cli)
+ [Konfiguration OAuth 2.0 und einfache Authentifizierung mit Amazon Cognito](#oauth-tutorial-config-both-auth-methods-using-cli)
## Voraussetzungen für die Konfiguration der OAuth 2.0-Authentifizierung
Sie können die in diesem Tutorial benötigten Amazon Cognito-Ressourcen festlegen, indem Sie das AWS CDK Stack-Plug-In [Amazon Cognito Stack für OAuth RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample) 2 bereitstellen. Wenn Sie Amazon Cognito manuell einrichten, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen, bevor Sie OAuth 2.0 auf Ihrem Amazon MQ für RabbitMQ-Broker konfigurieren:
**Voraussetzungen für die Einrichtung von Amazon Cognito**
+ Richten Sie einen Amazon Cognito Cognito-Endpunkt ein, indem Sie einen Benutzerpool erstellen. Lesen Sie dazu den Blog mit dem Titel [How to use OAuth 2.0 in Amazon Cognito: Learn about the different OAuth 2.0-Stipendien](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/).
+ Erstellen Sie einen Ressourcenserver, der `rabbitmq` im Benutzerpool aufgerufen wird und für den die folgenden Bereiche definiert sind:`read:all`, `write:all``configure:all`, und. `tag:administrator` Diese Bereiche werden mit RabbitMQ-Berechtigungen verknüpft.
Informationen zum Erstellen eines Ressourcenservers finden Sie unter [Definieren eines Ressourcenservers für Ihren Benutzerpool (AWS-Managementkonsole)](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-define-resource-servers.html#cognito-user-pools-define-resource-servers-console) im *Amazon Cognito Developer Guide*.
+ Erstellen Sie die folgenden Anwendungsclients:
+ Anwendungsclient für den Benutzerpool des Typs`Machine-to-Machine application`. Dies ist ein vertraulicher Client mit einem geheimen Client-Schlüssel, der für RabbitMQ AMQP-Clients verwendet wird. [Weitere Informationen zu Anwendungsclients und deren Erstellung finden Sie unter [App-Clienttypen und Einen App-Client](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#user-pool-settings-client-app-client-types) erstellen.](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#cognito-user-pools-app-idp-settings-console-create)
+ Anwendungsclient für den Benutzerpool des Typs`Single-page application`. Dies ist ein öffentlicher Client, der verwendet wird, um Benutzer an der RabbitMQ-Managementkonsole anzumelden. Sie müssen diesen Anwendungsclient so aktualisieren, dass er den Endpunkt des Amazon MQ for RabbitMQ-Brokers enthält, den Sie im folgenden Verfahren als zulässige Callback-URL erstellen. Weitere Informationen finden Sie unter [Verwaltete Anmeldung mit der Amazon Cognito Cognito-Konsole einrichten](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-managed-login.html#set-up-managed-login).
**Voraussetzung für die Einrichtung von Amazon MQ**
+ Eine funktionierende [Docker-Installation](https://docs.docker.com/engine/install/) zur Ausführung eines Bash-Skripts, das überprüft, ob das OAuth 2.0-Setup erfolgreich ist oder nicht.
+ AWS CLI Version >=`2.28.23`, um das Hinzufügen eines Benutzernamens und eines Passworts bei der Broker-Erstellung optional zu machen.
## Konfiguration der OAuth 2.0-Authentifizierung mit Amazon Cognito mithilfe AWS CLI
Das folgende Verfahren zeigt, wie Sie die OAuth 2.0-Authentifizierung für Ihre Amazon MQ for RabbitMQ-Broker einrichten, die Amazon Cognito als IdP verwenden. Dieses Verfahren dient dazu, die erforderlichen Ressourcen AWS CLI zu erstellen und zu konfigurieren.
Stellen Sie im folgenden Verfahren sicher, dass Sie die Platzhalterwerte, wie ConfigurationID und Revision, durch ihre ** tatsächlichen *<2>* Werte ersetzen.
1. Erstellen Sie mit dem AWS CLI Befehl [create-configuration eine neue Konfiguration](https://docs.aws.amazon.com/cli/latest/reference/mq/create-configuration.html), wie im folgenden Beispiel gezeigt.
```
aws mq create-configuration \
--name "rabbitmq-oauth2-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-oauth2-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-oauth2-config"
}
```
1. Erstellen Sie eine Konfigurationsdatei, die aufgerufen wird**rabbitmq.conf**, um OAuth 2.0 als Authentifizierungs- und Autorisierungsmethode zu verwenden, wie im folgenden Beispiel gezeigt.
```
auth_backends.1 = oauth2
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool.
# If you used the AWS CDK stack to deploy Amazon Cognito, this is one of the stack outputs.
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
# Amazon Cognito does not include an audience field in access tokens
auth_oauth2.verify_aud = false
# Amazon Cognito does not allow * in its custom scopes. Use aliases to translate between Amazon Cognito and RabbitMQ.
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
# Allow OAuth 2.0 login for RabbitMQ management console
management.oauth_enabled = true
# FIXME: Update this value with the client ID of your public application client
management.oauth_client_id = ${RabbitMqOAuth2TestStack.ManagementConsoleAppClientId}
# FIXME: Update this value with the base JWKS URI (without /.well-known/jwks.json)
auth_oauth2.issuer = ${RabbitMqOAuth2TestStack.Issuer}
management.oauth_scopes = rabbitmq/tag:administrator
```
Diese Konfiguration verwendet [Bereichsaliase](https://www.rabbitmq.com/docs/oauth2#scope-translation), um die in Amazon Cognito definierten Bereiche RabbitMQ-kompatiblen Bereichen zuzuordnen.
1. Aktualisieren Sie die Konfiguration mithilfe des Befehls [update-configuration, wie im folgenden Beispiel gezeigt](https://docs.aws.amazon.com/cli/latest/reference/mq/update-configuration.html) AWS CLI . Fügen Sie in diesem Befehl die Konfigurations-ID hinzu, die Sie als Antwort auf Schritt 1 dieses Verfahrens erhalten haben. Beispiel, **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca**.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-oauth2-config",
"Warnings": []
}
```
1. Erstellen Sie einen Broker mit der OAuth 2.0-Konfiguration, die Sie in Schritt 2 dieses Verfahrens erstellt haben. Verwenden Sie dazu den AWS CLI Befehl [create-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/create-broker.html), wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Konfigurations-ID und die Revisionsnummer an, die Sie in den Antworten von Schritt 1 bzw. 2 erhalten haben. Beispiel: **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca** und **2**.
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-oauth2-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Vergewissern Sie sich, dass der Status des Brokers von `CREATION_IN_PROGRESS` zu wechselt`RUNNING`, indem Sie den AWS CLI Befehl [describe-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/describe-broker.html) verwenden, wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Broker-ID ein, die Sie im Ergebnis des vorherigen Schritts erhalten haben, z. B. **b-2a1b5133-a10c-49d2-879b-8c176c34cf73**
```
aws mq describe-broker \
--broker-id ""
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt. Die folgende Antwort ist eine abgekürzte Version der vollständigen Ausgabe, die der `describe-broker` Befehl zurückgibt. Diese Antwort zeigt den Brokerstatus und die Authentifizierungsstrategie, die zur Sicherung des Brokers verwendet wurden. In diesem Fall weist die `config_managed` Authentifizierungsstrategie darauf hin, dass der Broker OAuth zwei Authentifizierungsmethoden verwendet.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
Um sich mit der RabbitMQ Management Console anzumelden OAuth2, muss der Broker-Endpunkt als gültige Callback-URL im entsprechenden Amazon Cognito-App-Client hinzugefügt werden. Weitere Informationen finden Sie in Schritt 5 bei der Einrichtung unseres [Amazon Cognito CDK-Beispielstapels](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample#step-5-update-callback-urls-if-using-placeholder-urls).
1. Überprüfen Sie die OAuth 2.0-Authentifizierung und Autorisierung mit dem folgenden `perf-test.sh` Skript.
Verwenden Sie dieses Bash-Skript, um die Konnektivität zu Ihrem Amazon MQ for RabbitMQ Broker zu testen. Dieses Skript ruft ein Token von Amazon Cognito ab und überprüft, ob die Verbindung ordnungsgemäß konfiguriert wurde. Wenn es erfolgreich konfiguriert wurde, werden Sie sehen, wie Ihr Broker Nachrichten veröffentlicht und verarbeitet.
Wenn Sie eine `ACCESS_REFUSED` Fehlermeldung erhalten, können Sie mithilfe der CloudWatch Protokolle Ihres Brokers Fehler in Ihren Konfigurationseinstellungen beheben. Sie finden den Link für die CloudWatch Protokollgruppe für Ihren Broker in der Amazon MQ MQ-Konsole.
In diesem Skript müssen Sie die folgenden Werte angeben:
+ `CLIENT_ID`und`CLIENT_SECRET`: Sie finden diese Werte auf der **App-Client-Seite** der Amazon Cognito Cognito-Konsole.
+ Cognito-Domain: Sie finden diese Domain auf der Amazon Cognito Cognito-Konsole. **Wählen Sie unter **Branding** die Option Domain aus.** Auf der **Domain-Seite** finden Sie diesen Wert im Abschnitt **Resource Servers**.
+ Amazon MQ-Broker-Endpunkt: Sie finden diesen Wert unter **Verbindungen** auf der Broker-Detailseite der Amazon MQ MQ-Konsole.
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
CLIENT_ID=${RabbitMqOAuth2TestStack.AmqpAppClientId}
CLIENT_SECRET=${RabbitMqOAuth2TestStack.AmqpAppClientSecret}
# FIXME: Update this value with the domain of your Amazon Cognito user pool
RESPONSE=$(curl -X POST ${RabbitMqOAuth2TestStack.TokenEndpoint} \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=client_credentials&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}&scope=rabbitmq/configure:all rabbitmq/read:all rabbitmq/tag:administrator rabbitmq/write:all")
# Extract the access_token from the response.
# This token will be passed in the password field when connecting to the broker.
# Note that the username is left blank, the field is ignored by the plugin.
BROKER_PASSWORD=$(echo ${RESPONSE} | jq -r '.access_token')
# FIXME: Update this value with the endpoint of your broker. For example, b-89424106-7e0e-4abe-8e98-8de0dada7630.mq.us-east-1.on.aws.
BROKER_DNS=
CONNECTION_STRING=amqps://:${BROKER_PASSWORD}@${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
docker run -it --rm --ulimit nofile=40960:40960 pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--flag persistent --rate $PRODUCER_RATE
```
## Konfiguration OAuth 2.0 und einfache Authentifizierung mit Amazon Cognito
Wenn Sie einen Broker mit OAuth 2.0-Authentifizierung erstellen, können Sie eine der folgenden Authentifizierungsmethoden angeben:
+ **OAuth Nur 2.0**: Um diese Methode zu verwenden, geben Sie bei der Erstellung des Brokers keinen Benutzernamen und kein Passwort an. Das [vorherige Verfahren](#oauth-tutorial-config-cognito-using-cli) zeigt, wie nur die OAuth 2.0-Authentifizierungsmethode verwendet wird.
+ **Sowohl OAuth 2.0 als auch einfache Authentifizierung**: Um diese Methode zu verwenden, geben Sie bei der Erstellung des Brokers einen Benutzernamen und ein Passwort ein. Fügen Sie `auth_backends.2 = internal` außerdem Ihre Broker-Konfiguration hinzu, wie im folgenden Verfahren gezeigt.
Stellen Sie im folgenden Verfahren sicher, dass Sie die Platzhalterwerte, wie z. B. ** und**, durch ihre tatsächlichen Werte ersetzen.
1. Um beide Authentifizierungsmethoden zu verwenden, erstellen Sie Ihre Broker-Konfiguration, wie im folgenden Beispiel gezeigt.
```
auth_backends.1 = oauth2
auth_backends.2 = internal
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
auth_oauth2.verify_aud = false
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
```
Diese Konfiguration verwendet [Bereichsaliase](https://www.rabbitmq.com/docs/oauth2#scope-translation), um die in Amazon Cognito definierten Bereiche RabbitMQ-kompatiblen Bereichen zuzuordnen.
1. Erstellen Sie einen Broker, der beide Authentifizierungsmethoden verwendet, wie im folgenden Beispiel gezeigt.
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker-with-internal-user" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": }' \
--users '[{"Username":"","Password":""}]'
```
1. Stellen Sie sicher, dass der Brokerstatus und die Konfiguration für die Einrichtung der Authentifizierungsmethode erfolgreich waren, wie in den Schritten 5 und 6 des [Konfiguration der OAuth 2.0-Authentifizierung mit Amazon Cognito](#oauth-tutorial-config-cognito-using-cli) Verfahrens beschrieben.
# Verwenden der IAM-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ
Das folgende Verfahren zeigt, wie Sie die AWS IAM-Authentifizierung und -Autorisierung für einen Amazon MQ for RabbitMQ-Broker aktivieren. Nach der Aktivierung von IAM können sich Benutzer mithilfe von AWS IAM-Anmeldeinformationen authentifizieren, um auf die RabbitMQ Management API zuzugreifen und sich über AMQP zu verbinden. Einzelheiten zur Funktionsweise der IAM-Authentifizierung mit Amazon MQ für RabbitMQ finden Sie unter. [IAM-Authentifizierung und Autorisierung für Amazon MQ for RabbitMQ](iam-for-amq-for-rabbitmq.md)
## Voraussetzungen
+ AWS Administratoranmeldedaten für das AWS Konto, dem der Amazon MQ for RabbitMQ-Broker gehört
+ Eine mit diesen Administratoranmeldedaten konfigurierte Shell-Umgebung (mithilfe von AWS CLI-Profilen oder Umgebungsvariablen)
+ AWS CLI installiert und konfiguriert
+ `jq`Befehlszeilen-JSON-Prozessor installiert
+ `curl`Befehlszeilentool installiert
## Konfiguration der IAM-Authentifizierung und -Autorisierung mit AWS CLI
1. **Legen Sie Umgebungsvariablen fest**
Stellen Sie die erforderlichen Umgebungsvariablen für Ihren Broker ein:
```
export AWS_DEFAULT_REGION=
export BROKER_ID=
```
1. **Aktivieren Sie ausgehende JWT-Token**
Aktivieren Sie den ausgehenden Web-Identitätsverbund für Ihr Konto: AWS
```
ISSUER_IDENTIFIER=$(aws iam enable-outbound-web-identity-federation --query 'IssuerIdentifier' --output text)
echo $ISSUER_IDENTIFIER
```
In der Ausgabe wird eine eindeutige URL zur Aussteller-ID für Ihr Konto im folgenden Format angezeigt. `https://.tokens.sts.global.api.aws`
1. **Erstellen Sie das IAM-Richtliniendokument**
Erstellen Sie ein Richtliniendokument, das Berechtigungen zum Abrufen von Web-Identitätstoken gewährt:
```
cat > policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sts:GetWebIdentityToken",
"sts:TagGetWebIdentityToken"
],
"Resource": "*"
}
]
}
EOF
```
1. **Erstellen Sie die Vertrauensrichtlinie**
Rufen Sie Ihre Anruferidentität ab und erstellen Sie ein Dokument zur Vertrauensrichtlinie:
```
CALLER_ARN=$(aws sts get-caller-identity --query Arn --output text)
cat > trust-policy.json << EOF
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "$CALLER_ARN"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
```
1. **Erstellen Sie die IAM-Rolle**
Erstellen Sie die IAM-Rolle und fügen Sie die Richtlinie hinzu:
```
aws iam create-role --role-name RabbitMqAdminRole --assume-role-policy-document file://trust-policy.json
aws iam put-role-policy --role-name RabbitMqAdminRole --policy-name RabbitMqAdminRolePolicy --policy-document file://policy.json
```
1. **Konfigurieren Sie die OAuth2 RabbitMQ-Einstellungen**
Erstellen Sie eine RabbitMQ-Konfigurationsdatei mit Authentifizierungs- und Autorisierungseinstellungen: OAuth2
```
cat > rabbitmq.conf << EOF
auth_backends.1 = oauth2
auth_backends.2 = internal
auth_oauth2.jwks_url = ${ISSUER_IDENTIFIER}/.well-known/jwks.json
auth_oauth2.resource_server_id = rabbitmq
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.additional_scopes_key = sub
auth_oauth2.scope_aliases.1.alias = arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/RabbitMqAdminRole
auth_oauth2.scope_aliases.1.scope = rabbitmq/tag:administrator rabbitmq/read:*/* rabbitmq/write:*/* rabbitmq/configure:*/*
auth_oauth2.https.hostname_verification = wildcard
management.oauth_enabled = true
EOF
```
1. **Aktualisieren Sie die Broker-Konfiguration**
Wenden Sie die neue Konfiguration auf Ihren Broker an:
```
# Retrieve the configuration ID
CONFIG_ID=$(aws mq describe-broker --broker-id $BROKER_ID --query 'Configurations[0].Id' --output text)
# Create a new configuration revision
REVISION=$(aws mq update-configuration --configuration-id $CONFIG_ID --data "$(cat rabbitmq.conf | base64 --wrap=0)" --query 'LatestRevision.Revision' --output text)
# Apply the configuration to the broker
aws mq update-broker --broker-id $BROKER_ID --configuration Id=$CONFIG_ID,Revision=$REVISION
# Reboot the broker to apply changes
aws mq reboot-broker --broker-id $BROKER_ID
```
Warten Sie, bis der Broker-Status wieder erreicht ist, `RUNNING` bevor Sie mit dem nächsten Schritt fortfahren.
1. **Besorgen Sie sich ein JWT-Token**
Nehmen Sie die IAM-Rolle an und holen Sie sich ein Web-Identitätstoken:
```
# Assume the RabbitMqAdminRole
ROLE_CREDS=$(aws sts assume-role --role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/RabbitMqAdminRole --role-session-name rabbitmq-session)
# Configure the session with temporary credentials
export AWS_ACCESS_KEY_ID=$(echo "$ROLE_CREDS" | jq -r '.Credentials.AccessKeyId')
export AWS_SECRET_ACCESS_KEY=$(echo "$ROLE_CREDS" | jq -r '.Credentials.SecretAccessKey')
export AWS_SESSION_TOKEN=$(echo "$ROLE_CREDS" | jq -r '.Credentials.SessionToken')
# Obtain the web identity token
TOKEN_RESPONSE=$(aws sts get-web-identity-token \
--audience "rabbitmq" \
--signing-algorithm ES384 \
--duration-seconds 300 \
--tags Key=scope,Value="rabbitmq/tag:administrator")
# Extract the token
TOKEN=$(echo "$TOKEN_RESPONSE" | jq -r '.WebIdentityToken')
```
1. **Greifen Sie auf die RabbitMQ Management API zu**
Verwenden Sie das JWT-Token, um auf die RabbitMQ Management API zuzugreifen:
```
BROKER_URL=.mq..on.aws
curl -u ":$TOKEN" \
-X GET https://${BROKER_URL}/api/overview \
-H "Content-Type: application/json"
```
Eine erfolgreiche Antwort bestätigt, dass die IAM-Authentifizierung korrekt funktioniert. Die Antwort enthält Informationen zur Brokerübersicht im JSON-Format.
1. **Stellen Sie mithilfe des JWT-Tokens eine Connect über AMQP her**
Testen Sie die AMQP-Konnektivität mithilfe des JWT-Tokens mit dem Perf-Test-Tool:
```
BROKER_DNS=
CONNECTION_STRING=amqps://:${TOKEN}@${BROKER_DNS}:5671
docker run -it --rm --ulimit nofile=40960:40960 pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-%d' --queue-pattern-from 1 --queue-pattern-to 1 \
--producers 1 --consumers 1 \
--uri ${CONNECTION_STRING} \
--flag persistent --rate 1
```
Wenn Sie eine `ACCESS_REFUSED` Fehlermeldung erhalten, können Sie mithilfe der Protokolle für Ihren Broker Fehler in Ihren Konfigurationseinstellungen beheben. CloudWatch Sie finden den Link für die Protokollgruppe CloudWatch Logs für Ihren Broker in der Amazon MQ MQ-Konsole.
# Verwenden der LDAP-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ
In diesem Tutorial wird beschrieben, wie Sie die LDAP-Authentifizierung und -Autorisierung für Ihre Amazon MQ for RabbitMQ-Broker mithilfe von konfigurieren. AWS Managed Microsoft AD
**Topics**
+ [Voraussetzungen für die Konfiguration der LDAP-Authentifizierung und -Autorisierung](#rabbitmq-ldap-tutorial-prerequisites)
+ [Konfiguration von LDAP in RabbitMQ mit CLI AWS](#rabbitmq-ldap-tutorial-configure-cli)
## Voraussetzungen für die Konfiguration der LDAP-Authentifizierung und -Autorisierung
Sie können die in diesem Tutorial erforderlichen AWS Ressourcen einrichten, indem Sie den [AWS CDK-Stack für Amazon MQ für die RabbitMQ LDAP-Integration](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-ldap-activedirectory-sample/) mit bereitstellen. AWS Managed Microsoft AD
Dieser CDK-Stack erstellt automatisch alle erforderlichen AWS Ressourcen AWS Managed Microsoft AD, einschließlich LDAP-Benutzer und -Gruppen, Network Load Balancer, Zertifikate und IAM-Rollen. Eine vollständige Liste der vom Stack erstellten Ressourcen finden Sie in der README-Datei des Pakets.
Wenn Sie die Ressourcen manuell einrichten, anstatt den CDK-Stack zu verwenden, stellen Sie sicher, dass Sie über die entsprechende Infrastruktur verfügen, bevor Sie LDAP auf Ihrem Amazon MQ für RabbitMQ-Broker konfigurieren.
### Voraussetzung für die Einrichtung von Amazon MQ
AWS CLI-Version >= 2.28.23, um das Hinzufügen eines Benutzernamens und Kennworts bei der Brokererstellung optional zu machen.
## Konfiguration von LDAP in RabbitMQ mit CLI AWS
Dieses Verfahren verwendet AWS CLI, um die erforderlichen Ressourcen zu erstellen und zu konfigurieren. Stellen Sie im folgenden Verfahren sicher, dass Sie die Platzhalterwerte, wie ConfigurationID und Revision, durch ihre `` tatsächlichen `<2>` Werte ersetzen.
1. Erstellen Sie mit dem `create-configuration` AWS CLI-Befehl eine neue Konfiguration, wie im folgenden Beispiel gezeigt.
```
aws mq create-configuration \
--name "rabbitmq-ldap-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-ldap-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-ldap-config"
}
```
1. Erstellen Sie eine Konfigurationsdatei`rabbitmq.conf`, die aufgerufen wird, um LDAP als Authentifizierungs- und Autorisierungsmethode zu verwenden, wie im folgenden Beispiel gezeigt. Ersetzen Sie alle Platzhalterwerte in der Vorlage (gekennzeichnet mit`${RabbitMqLdapTestStack.*}`) durch tatsächliche Werte aus Ihren bereitgestellten Stack-Ausgaben oder AWS CDK einer gleichwertigen Infrastruktur.
```
auth_backends.1 = ldap
# LDAP authentication settings - For more information,
# see https://www.rabbitmq.com/docs/ldap#basic
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_ldap.servers.1 = ${RabbitMqLdapTestStack.NlbDnsName}
auth_ldap.dn_lookup_bind.user_dn = ${RabbitMqLdapTestStack.DnLookupUserDn}
auth_ldap.dn_lookup_base = ${RabbitMqLdapTestStack.DnLookupBase}
auth_ldap.dn_lookup_attribute = ${RabbitMqLdapTestStack.DnLookupAttribute}
auth_ldap.port = 636
auth_ldap.use_ssl = true
auth_ldap.ssl_options.verify = verify_peer
auth_ldap.log = network
# AWS integration for secure credential retrieval
# - see: https://github.com/amazon-mq/rabbitmq-aws
# The aws plugin allows RabbitMQ to securely retrieve credentials and certificates
# from AWS services.
# Replace the ${RabbitMqLdapTestStack.*} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.auth_ldap.ssl_options.cacertfile = ${RabbitMqLdapTestStack.CaCertArn}
aws.arns.auth_ldap.dn_lookup_bind.password = ${RabbitMqLdapTestStack.DnLookupUserPasswordArn}
aws.arns.assume_role_arn = ${RabbitMqLdapTestStack.AmazonMqAssumeRoleArn}
# LDAP authorization queries - For more information,
# see: https://www.rabbitmq.com/docs/ldap#authorisation
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual group DN
# values from your deployed prerequisite CDK stack outputs
# Uses Active Directory groups created by the prerequisite CDK stack
auth_ldap.queries.tags = '''
[{administrator, {in_group, "${RabbitMqLdapTestStack.RabbitMqAdministratorsGroupDn}"}},
{management, {in_group, "${RabbitMqLdapTestStack.RabbitMqMonitoringUsersGroupDn}"}}]
'''
# FIXME: This provides all authenticated users access to all vhosts
# - update to restrict access as required
auth_ldap.queries.vhost_access = '''
{constant, true}
'''
# FIXME: This provides all authenticated users full access to all
# queues and exchanges - update to restrict access as required
auth_ldap.queries.resource_access = '''
{for, [ {permission, configure, {constant, true}},
{permission, write,
{for, [{resource, queue, {constant, true}},
{resource, exchange, {constant, true}}]}},
{permission, read,
{for, [{resource, exchange, {constant, true}},
{resource, queue, {constant, true}}]}}
]
}
'''
# FIXME: This provides all authenticated users access to all topics
# - update to restrict access as required
auth_ldap.queries.topic_access = '''
{for, [{permission, write, {constant, true}},
{permission, read, {constant, true}}
]
}
'''
```
1. Aktualisieren Sie die Konfiguration mit dem `update-configuration` AWS CLI-Befehl, wie im folgenden Beispiel gezeigt. Fügen Sie in diesem Befehl die Konfigurations-ID hinzu, die Sie als Antwort auf Schritt 1 dieses Verfahrens erhalten haben. Beispiel, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-ldap-config",
"Warnings": []
}
```
1. Erstellen Sie einen Broker mit der LDAP-Konfiguration, die Sie in Schritt 2 dieses Verfahrens erstellt haben. Verwenden Sie dazu den `create-broker` AWS CLI-Befehl, wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Konfigurations-ID und die Revisionsnummer an, die Sie in den Antworten von Schritt 1 bzw. 2 erhalten haben. Beispiel: `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` und `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-ldap-test-1" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}'
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ldap-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
**Beschränkung der Benennung von Brokern**
Die IAM-Rolle, die durch den vorausgesetzten CDK-Stack erstellt wurde, schränkt Broker-Namen zunächst ein. `rabbitmq-ldap-test` Stellen Sie sicher, dass Ihr Brokername diesem Muster folgt, da die IAM-Rolle sonst nicht berechtigt ist, die Rolle für die ARN-Auflösung zu übernehmen.
1. Stellen Sie mithilfe des `describe-broker` AWS CLI-Befehls sicher`RUNNING`, dass der Status des Brokers von `CREATION_IN_PROGRESS` zu wechselt, wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Broker-ID ein, die Sie im Ergebnis des vorherigen Schritts erhalten haben, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73` z. B.
```
aws mq describe-broker \
--broker-id ""
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt. Die folgende Antwort ist eine abgekürzte Version der vollständigen Ausgabe, die der `describe-broker` Befehl zurückgibt. Diese Antwort zeigt den Brokerstatus und die Authentifizierungsstrategie, mit der der Broker gesichert wurde. In diesem Fall weist die `config_managed` Authentifizierungsstrategie darauf hin, dass der Broker die LDAP-Authentifizierungsmethode verwendet.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Überprüfen Sie den RabbitMQ-Zugriff mit einem der Testbenutzer, die mit dem CDK-Stack als Voraussetzung erstellt wurden
```
# FIXME: Replace ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a user (should fail - console user only has monitoring permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/users/testuser \
-H "Content-Type: application/json" \
-d '{"password":"testpass","tags":"management"}'
```
# Verwendung der HTTP-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ
In diesem Tutorial wird beschrieben, wie Sie die HTTP-Authentifizierung und -Autorisierung für Ihre Amazon MQ for RabbitMQ-Broker mithilfe eines externen HTTP-Servers konfigurieren.
**Anmerkung**
Das HTTP-Authentifizierungs-Plugin ist nur für Amazon MQ für RabbitMQ Version 4 und höher verfügbar.
**Topics**
+ [Voraussetzungen für die Konfiguration der HTTP-Authentifizierung und -Autorisierung](#rabbitmq-http-tutorial-prerequisites)
+ [Konfiguration der HTTP-Authentifizierung in RabbitMQ mit CLI AWS](#rabbitmq-http-tutorial-configure-cli)
## Voraussetzungen für die Konfiguration der HTTP-Authentifizierung und -Autorisierung
Sie können die in diesem Tutorial erforderlichen AWS Ressourcen einrichten, indem Sie den [AWS CDK-Stack für Amazon MQ für die HTTP-Authentifizierungsintegration von RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-http-sample/) bereitstellen.
Dieser CDK-Stack erstellt automatisch alle erforderlichen AWS Ressourcen, einschließlich des HTTP-Authentifizierungsservers, der Zertifikate und der IAM-Rollen. Eine vollständige Liste der vom Stack erstellten Ressourcen finden Sie in der README-Datei des Pakets.
Wenn Sie die Ressourcen manuell einrichten, anstatt den CDK-Stack zu verwenden, stellen Sie sicher, dass Sie über die entsprechende Infrastruktur verfügen, bevor Sie die HTTP-Authentifizierung auf Ihrem Amazon MQ für RabbitMQ-Broker konfigurieren.
### Voraussetzung für die Einrichtung von Amazon MQ
AWS CLI-Version >= 2.28.23, um das Hinzufügen eines Benutzernamens und Kennworts bei der Brokererstellung optional zu machen.
## Konfiguration der HTTP-Authentifizierung in RabbitMQ mit CLI AWS
Dieses Verfahren verwendet AWS CLI, um die erforderlichen Ressourcen zu erstellen und zu konfigurieren. Stellen Sie im folgenden Verfahren sicher, dass Sie die Platzhalterwerte durch ihre tatsächlichen Werte ersetzen.
1. Erstellen Sie mit dem `create-configuration` AWS CLI-Befehl eine neue Konfiguration, wie im folgenden Beispiel gezeigt.
```
aws mq create-configuration \
--name "rabbitmq-http-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-http-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-http-config"
}
```
1. Erstellen Sie eine Konfigurationsdatei, die aufgerufen wird`rabbitmq.conf`, um HTTP als Authentifizierungs- und Autorisierungsmethode zu verwenden, wie im folgenden Beispiel gezeigt. Ersetzen Sie alle Platzhalterwerte in der Vorlage (gekennzeichnet mit`${...}`) durch tatsächliche Werte aus Ihren bereitgestellten AWS CDK Stack-Ausgaben oder einer gleichwertigen Infrastruktur.
```
auth_backends.1 = cache
auth_backends.2 = http
auth_cache.cached_backend = http
# HTTP authentication settings
# For more information, see https://github.com/rabbitmq/rabbitmq-auth-backend-http
# FIXME: Replace the ${...} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_http.http_method = post
auth_http.user_path = ${HttpServerUserPath}
auth_http.vhost_path = ${HttpServerVhostPath}
auth_http.resource_path = ${HttpServerResourcePath}
auth_http.topic_path = ${HttpServerTopicPath}
# TLS/HTTPS configuration
auth_http.ssl_options.verify = verify_peer
auth_http.ssl_options.sni = test.amazonaws.com
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.auth_http.ssl_options.cacertfile = ${CaCertArn}
```
1. Aktualisieren Sie die Konfiguration mit dem `update-configuration` AWS CLI-Befehl. Verwenden Sie die Konfigurations-ID aus Schritt 3.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-http-config",
"Warnings": []
}
```
1. Erstellen Sie einen Broker mit der HTTP-Konfiguration. Verwenden Sie die Konfigurations-ID und die Revisionsnummer aus den vorherigen Schritten.
```
aws mq create-broker \
--broker-name "rabbitmq-http-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}'
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-http-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Stellen Sie mithilfe des `describe-broker` AWS CLI-Befehls sicher`RUNNING`, dass der Status des Brokers von `CREATION_IN_PROGRESS` zu wechselt.
```
aws mq describe-broker \
--broker-id ""
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt. Die `config_managed` Authentifizierungsstrategie gibt an, dass der Broker die HTTP-Authentifizierungsmethode verwendet.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Überprüfen Sie den RabbitMQ-Zugriff mit einem der Testbenutzer, die mit dem erforderlichen CDK-Stack erstellt wurden
```
# FIXME: Replace ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a vhost (should fail - console user only has management permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/vhosts/test-vhost \
-H "Content-Type: application/json" \
-d '{}'
```
# Verwendung der SSL-Zertifikatsauthentifizierung für Amazon MQ für RabbitMQ
In diesem Tutorial wird beschrieben, wie Sie die SSL-Zertifikatsauthentifizierung für Ihre Amazon MQ for RabbitMQ-Broker mithilfe einer privaten Zertifizierungsstelle konfigurieren.
**Anmerkung**
Das SSL-Zertifikat-Authentifizierungs-Plugin ist nur für Amazon MQ für RabbitMQ Version 4 und höher verfügbar.
**Topics**
+ [Voraussetzungen für die Konfiguration der SSL-Zertifikatsauthentifizierung](#rabbitmq-ssl-tutorial-prerequisites)
+ [Konfiguration der SSL-Zertifikatsauthentifizierung in RabbitMQ mit CLI AWS](#rabbitmq-ssl-tutorial-configure-cli)
## Voraussetzungen für die Konfiguration der SSL-Zertifikatsauthentifizierung
Die SSL-Zertifikatsauthentifizierung verwendet Mutual TLS (mTLS), um Clients mit X.509-Zertifikaten zu authentifizieren. Sie können die in diesem Tutorial erforderlichen AWS Ressourcen einrichten, indem Sie den [AWS CDK-Stack für Amazon MQ für die MTLS-Integration von RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/) bereitstellen.
Dieser CDK-Stack erstellt automatisch alle erforderlichen AWS Ressourcen, einschließlich Zertifizierungsstelle, Client-Zertifikate und IAM-Rollen. Eine vollständige Liste der vom Stack erstellten Ressourcen finden Sie in der README-Datei des Pakets.
**Anmerkung**
Bevor Sie den CDK-Stack bereitstellen, legen Sie die `RABBITMQ_TEST_USER_NAME` Umgebungsvariable fest. Dieser Wert wird als Common Name (CN) im Client-Zertifikat verwendet und muss mit dem Benutzernamen übereinstimmen, den Sie in den Schritten der Anleitung verwenden. Beispiel: `export RABBITMQ_TEST_USER_NAME="myuser"`
Wenn Sie die Ressourcen manuell einrichten, anstatt den CDK-Stack zu verwenden, stellen Sie sicher, dass Sie über die entsprechende Infrastruktur verfügen, bevor Sie die SSL-Zertifikatsauthentifizierung auf Ihrem Amazon MQ für RabbitMQ-Broker konfigurieren.
### Voraussetzung für die Einrichtung von Amazon MQ
AWS CLI-Version >= 2.28.23, um das Hinzufügen eines Benutzernamens und Kennworts bei der Brokererstellung optional zu machen.
## Konfiguration der SSL-Zertifikatsauthentifizierung in RabbitMQ mit CLI AWS
Dieses Verfahren verwendet AWS CLI, um die erforderlichen Ressourcen zu erstellen und zu konfigurieren. Stellen Sie im folgenden Verfahren sicher, dass Sie die Platzhalterwerte, wie ConfigurationID und Revision, durch ihre `` tatsächlichen `<2>` Werte ersetzen.
1. Erstellen Sie mit dem `create-configuration` AWS CLI-Befehl eine neue Konfiguration, wie im folgenden Beispiel gezeigt.
```
aws mq create-configuration \
--name "rabbitmq-ssl-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-ssl-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-ssl-config"
}
```
1. Erstellen Sie eine Konfigurationsdatei`rabbitmq.conf`, die aufgerufen wird, um die SSL-Zertifikatsauthentifizierung zu verwenden, wie im folgenden Beispiel gezeigt. Ersetzen Sie alle Platzhalterwerte in der Vorlage (gekennzeichnet mit`${...}`) durch tatsächliche Werte aus Ihren bereitgestellten Stack-Ausgaben für die AWS CDK erforderlichen Komponenten oder einer gleichwertigen Infrastruktur.
```
auth_mechanisms.1 = EXTERNAL
ssl_cert_login_from = common_name
auth_backends.1 = internal
# Reject if no client cert
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# FIXME: Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.ssl_options.cacertfile = ${CaCertArn}
```
1. Aktualisieren Sie die Konfiguration mit dem `update-configuration` AWS CLI-Befehl, wie im folgenden Beispiel gezeigt. Fügen Sie in diesem Befehl die Konfigurations-ID hinzu, die Sie als Antwort auf Schritt 1 dieses Verfahrens erhalten haben. Beispiel, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-ssl-config",
"Warnings": []
}
```
1. Erstellen Sie einen Broker mit der Konfiguration für die SSL-Zertifikatauthentifizierung, die Sie in Schritt 2 dieses Verfahrens erstellt haben. Verwenden Sie dazu den `create-broker` AWS CLI-Befehl, wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Konfigurations-ID und die Revisionsnummer an, die Sie in den Antworten von Schritt 1 bzw. 2 erhalten haben. Beispiel: `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` und `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-ssl-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ssl-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Stellen Sie sicher, dass der Status des Brokers von `CREATION_IN_PROGRESS` zu wechselt`RUNNING`, indem Sie den `describe-broker` AWS CLI-Befehl verwenden, wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Broker-ID ein, die Sie im Ergebnis des vorherigen Schritts erhalten haben. Beispiel, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt. Die folgende Antwort ist eine abgekürzte Version der vollständigen Ausgabe, die der `describe-broker` Befehl zurückgibt. Diese Antwort zeigt den Brokerstatus und die Authentifizierungsstrategie, die zur Sicherung des Brokers verwendet wurden. In diesem Fall weist die `config_managed` Authentifizierungsstrategie darauf hin, dass der Broker die SSL-Zertifikatsauthentifizierungsmethode verwendet.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Überprüfen Sie die SSL-Zertifikatsauthentifizierung mit dem folgenden `ssl.sh` Skript.
Verwenden Sie dieses Bash-Skript, um die Konnektivität zu Ihrem Amazon MQ for RabbitMQ Broker zu testen. Dieses Skript verwendet Ihr Client-Zertifikat zur Authentifizierung und überprüft, ob die Verbindung ordnungsgemäß konfiguriert wurde. Wenn es erfolgreich konfiguriert wurde, werden Sie sehen, wie Ihr Broker Nachrichten veröffentlicht und verarbeitet.
Wenn Sie eine `ACCESS_REFUSED` Fehlermeldung erhalten, können Sie mithilfe der CloudWatch Protokolle Ihres Brokers Fehler in Ihren Konfigurationseinstellungen beheben. Sie finden den Link für die CloudWatch Protokollgruppe für Ihren Broker in der Amazon MQ MQ-Konsole.
In diesem Skript müssen Sie die folgenden Werte angeben:
+ `USERNAME`: Der allgemeine Name (CN) aus Ihrem Client-Zertifikat.
+ `CLIENT_KEYSTORE`: Pfad zu Ihrer Client-Keystore-Datei (PKCS12 Format). Wenn Sie den erforderlichen CDK-Stack verwendet haben, lautet der Standardpfad. `$(pwd)/certs/client-keystore.p12`
+ `KEYSTORE_PASSWORD`: Passwort für Ihren Client-Keystore. Wenn Sie den vorausgesetzten CDK-Stack verwendet haben, lautet das Standardkennwort. `changeit`
+ `BROKER_DNS`: Sie finden diesen Wert unter **Verbindungen** auf der Seite mit den Broker-Details der Amazon MQ MQ-Konsole.
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
USERNAME=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
BROKER_DNS=
CONNECTION_STRING=amqps://${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
finch run --rm --ulimit nofile=40960:40960 \
-v ${CLIENT_KEYSTORE}:/certs/client-keystore.p12:ro \
-e JAVA_TOOL_OPTIONS="-Djavax.net.ssl.keyStore=/certs/client-keystore.p12 -Djavax.net.ssl.keyStorePassword=${KEYSTORE_PASSWORD} -Djavax.net.ssl.keyStoreType=PKCS12" \
pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-cert-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "cert-test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--sasl-external \
--use-default-ssl-context \
--flag persistent --rate $PRODUCER_RATE
```
# Verwendung von mTLS für AMQP- und Management-Endpunkte
In diesem Tutorial wird beschrieben, wie Mutual TLS (mTLS) für AMQP-Client-Verbindungen und die RabbitMQ-Verwaltungsschnittstelle mithilfe einer privaten Zertifizierungsstelle konfiguriert wird.
**Anmerkung**
Die Verwendung privater Zertifizierungsstellen für mTLS ist nur für Amazon MQ for RabbitMQ Version 4 und höher verfügbar.
**Topics**
+ [Voraussetzungen für die Konfiguration von mTLS](#rabbitmq-mtls-tutorial-prerequisites)
+ [Konfiguration von mTLS in RabbitMQ mit CLI AWS](#rabbitmq-mtls-tutorial-configure-cli)
## Voraussetzungen für die Konfiguration von mTLS
Sie können die in diesem Tutorial erforderlichen AWS Ressourcen einrichten, indem Sie den [AWS CDK-Stack für Amazon MQ für die MTLS-Integration mit RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/) bereitstellen.
Dieser CDK-Stack erstellt automatisch alle erforderlichen AWS Ressourcen, einschließlich Zertifizierungsstelle, Client-Zertifikate und IAM-Rollen. Eine vollständige Liste der vom Stack erstellten Ressourcen finden Sie in der README-Datei des Pakets.
Wenn Sie die Ressourcen manuell einrichten, anstatt den CDK-Stack zu verwenden, stellen Sie sicher, dass Sie über die entsprechende Infrastruktur verfügen, bevor Sie mTLS auf Ihrem Amazon MQ für RabbitMQ-Broker konfigurieren.
### Voraussetzung für die Einrichtung von Amazon MQ
AWS CLI-Version >= 2.28.23, um das Hinzufügen eines Benutzernamens und Kennworts bei der Brokererstellung optional zu machen.
## Konfiguration von mTLS in RabbitMQ mit CLI AWS
Dieses Verfahren verwendet AWS CLI, um die erforderlichen Ressourcen zu erstellen und zu konfigurieren. Stellen Sie im folgenden Verfahren sicher, dass Sie die Platzhalterwerte, wie ConfigurationID und Revision, durch ihre `` tatsächlichen `<2>` Werte ersetzen.
1. Erstellen Sie mit dem `create-configuration` AWS CLI-Befehl eine neue Konfiguration, wie im folgenden Beispiel gezeigt.
```
aws mq create-configuration \
--name "rabbitmq-mtls-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-mtls-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-mtls-config"
}
```
1. Erstellen Sie eine Konfigurationsdatei`rabbitmq.conf`, die aufgerufen wird, um mTLS für AMQP und Verwaltungsendpunkte zu konfigurieren, wie im folgenden Beispiel gezeigt. Ersetzen Sie alle Platzhalterwerte in der Vorlage (gekennzeichnet mit`${...}`) durch tatsächliche Werte aus Ihren bereitgestellten Stack-Ausgaben oder einer AWS CDK gleichwertigen Infrastruktur.
```
auth_backends.1 = internal
# TLS configuration
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
management.ssl.verify = verify_peer
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# FIXME: Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.ssl_options.cacertfile = ${CaCertArn}
aws.arns.management.ssl.cacertfile = ${CaCertArn}
```
1. Aktualisieren Sie die Konfiguration mit dem `update-configuration` AWS CLI-Befehl, wie im folgenden Beispiel gezeigt. Fügen Sie in diesem Befehl die Konfigurations-ID hinzu, die Sie als Antwort auf Schritt 1 dieses Verfahrens erhalten haben. Beispiel, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-mtls-config",
"Warnings": []
}
```
1. Erstellen Sie einen Broker mit der mTLS-Konfiguration, die Sie in Schritt 2 dieses Verfahrens erstellt haben. Verwenden Sie dazu den `create-broker` AWS CLI-Befehl, wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Konfigurations-ID und die Revisionsnummer an, die Sie in den Antworten von Schritt 1 bzw. 2 erhalten haben. Beispiel: `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` und `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-mtls-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-mtls-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Stellen Sie mithilfe des `describe-broker` AWS CLI-Befehls sicher`RUNNING`, dass der Status des Brokers von `CREATION_IN_PROGRESS` zu wechselt, wie im folgenden Beispiel gezeigt. Geben Sie in diesem Befehl die Broker-ID ein, die Sie im Ergebnis des vorherigen Schritts erhalten haben. Beispiel, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Dieser Befehl gibt eine Antwort zurück, die dem folgenden Beispiel ähnelt. Die folgende Antwort ist eine abgekürzte Version der vollständigen Ausgabe, die der `describe-broker` Befehl zurückgibt.
```
{
"AuthenticationStrategy": "simple",
...,
"BrokerState": "RUNNING",
...
}
```
1. Überprüfen Sie die mTLS-Authentifizierung mit dem folgenden `mtls.sh` Skript.
Verwenden Sie dieses Bash-Skript, um die Konnektivität zu Ihrem Amazon MQ for RabbitMQ Broker zu testen. Dieses Skript verwendet Ihr Client-Zertifikat zur Authentifizierung und überprüft, ob die Verbindung ordnungsgemäß konfiguriert wurde. Wenn es erfolgreich konfiguriert wurde, werden Sie sehen, wie Ihr Broker Nachrichten veröffentlicht und verarbeitet.
Wenn Sie eine `ACCESS_REFUSED` Fehlermeldung erhalten, können Sie mithilfe der CloudWatch Protokolle Ihres Brokers Fehler in Ihren Konfigurationseinstellungen beheben. Sie finden den Link für die CloudWatch Protokollgruppe für Ihren Broker in der Amazon MQ MQ-Konsole.
In diesem Skript müssen Sie die folgenden Werte angeben:
+ `USERNAME`und`PASSWORD`: Die RabbitMQ-Benutzeranmeldeinformationen, die Sie mit dem Broker erstellt haben.
+ `CLIENT_KEYSTORE`: Pfad zu Ihrer Client-Keystore-Datei (Format). PKCS12 Wenn Sie den erforderlichen CDK-Stack verwendet haben, lautet der Standardpfad. `$(pwd)/certs/client-keystore.p12`
+ `KEYSTORE_PASSWORD`: Passwort für Ihren Client-Keystore. Wenn Sie den erforderlichen CDK-Stack verwendet haben, lautet das Standardkennwort. `changeit`
+ `BROKER_DNS`: Sie finden diesen Wert unter **Verbindungen** auf der Seite mit den Broker-Details der Amazon MQ MQ-Konsole.
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
USERNAME=
PASSWORD=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
BROKER_DNS=
CONNECTION_STRING=amqps://${USERNAME}:${PASSWORD}@${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
finch run --rm --ulimit nofile=40960:40960 \
-v ${CLIENT_KEYSTORE}:/certs/client-keystore.p12:ro \
-e JAVA_TOOL_OPTIONS="-Djavax.net.ssl.keyStore=/certs/client-keystore.p12 -Djavax.net.ssl.keyStorePassword=${KEYSTORE_PASSWORD} -Djavax.net.ssl.keyStoreType=PKCS12" \
pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-cert-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "cert-test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--use-default-ssl-context \
--flag persistent --rate $PRODUCER_RATE
```
# Ihre JMS-Anwendung verbinden
Dieses Tutorial zeigt Ihnen, wie Sie Ihre JMS-Anwendung mithilfe des RabbitMQ JMS-Clients mit Amazon MQ for RabbitMQ Broker verbinden. Sie erfahren, wie Sie einen Producer zum Senden von Nachrichten und einen Consumer zum Empfangen von Nachrichten aus RabbitMQ-Warteschlangen einrichten.
Bevor Sie beginnen, fügen Sie Ihrem Maven-Projekt die entsprechende RabbitMQ-JMS-Abhängigkeit hinzu:
Für JMS 1.1 und 2.0:
```
com.rabbitmq.jms
rabbitmq-jms
2.12.0
```
Für JMS 3.1:
```
com.rabbitmq.jms
rabbitmq-jms
3.5.0
```
## Erstellen Sie einen Produzenten
Das folgende Codebeispiel zeigt, wie man mit JMS in eine RabbitMQ-Warteschlange schreibt:
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
connection = factory.createConnection();
connection.start();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination(queueName, true, false);
// Send the message to the queue
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
String msg_content = "Hello World!!";
TextMessage textMessage = session.createTextMessage(msg_content);
producer.send(textMessage);
System.out.printf("Published to AMQP queue '%s': %s", queueName, msg_content);
```
## Erstellen Sie einen Verbraucher
Das folgende Codebeispiel zeigt, wie mit JMS aus einer RabbitMQ-Warteschlange gelesen wird:
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
// Establish the connection and session
jakarta.jms.Connection connection = factory.createConnection();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination();
destination.setDestinationName(queueName);
destination.setAmqp(true);
destination.setAmqpQueueName(queueName);
// Initialize consumer
MessageConsumer consumer = session.createConsumer(destination);
consumer.setMessageListener(message -> {
try {
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
System.out.printf("Message: %s%n", textMessage.getText());
} else if (message instanceof BytesMessage) {
BytesMessage bytesMessage = (BytesMessage) message;
byte[] bytes = new byte[(int) bytesMessage.getBodyLength()];
bytesMessage.readBytes(bytes);
String content = new String(bytes);
System.out.printf("Message: %s%n", content);
} else {
System.out.printf("Message: [%s]%n", message.getClass().getSimpleName());
}
} catch (JMSException e) {
System.err.printf("Error processing message: %s%n", e.getMessage());
}
});
connection.start();
```