

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
<a name="rabbitmq-on-amazon-mq"></a>

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)

## Schritt 2: Connect eine JVM-basierte Anwendung mit Ihrem Broker
<a name="rabbitmq-connect-jvm-application"></a>

 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
<a name="rabbitmq-connect-application-prerequisites-getting-started"></a>

**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
<a name="rabbitmq-connect-application-enable-vpc-attributes-getting-started"></a>

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
<a name="rabbitmq-connect-application-allow-inbound-connections-getting-started"></a>

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 ![](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
<a name="rabbitmq-connect-application-java-dependencies-getting-started"></a>

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.

```
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.9.0</version>
</dependency>
```

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
<a name="rabbitmq-import-connections-and-channels"></a>

 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
<a name="rabbitmq-create-connection-factory-and-connect"></a>

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
<a name="rabbitmq-publish-message"></a>

 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
<a name="rabbitmq-subscribe-receive-message"></a>

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
<a name="rabbitmq-disconnect"></a>

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
<a name="rabbitmq-connect-to-lambda"></a>

 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 *