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.

# Verwenden der IAM-Authentifizierung und -Autorisierung für Amazon MQ für RabbitMQ
<a name="rabbitmq-iam-tutorial"></a>

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
<a name="iam-tutorial-prerequisites"></a>
+ 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
<a name="iam-tutorial-procedure"></a>

1. **Legen Sie Umgebungsvariablen fest**

   Stellen Sie die erforderlichen Umgebungsvariablen für Ihren Broker ein:

   ```
   export AWS_DEFAULT_REGION=<region>
   export BROKER_ID=<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://<id>.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=<broker-id>.mq.<region>.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=<broker-endpoint>
   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.