Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation de l'authentification et de l'autorisation IAM pour Amazon MQ pour RabbitMQ
<a name="rabbitmq-iam-tutorial"></a>

La procédure suivante explique comment activer l'authentification et l'autorisation AWS IAM pour un courtier Amazon MQ pour RabbitMQ. Après avoir activé IAM, les utilisateurs peuvent s'authentifier à l'aide des informations d'identification AWS IAM pour accéder à l'API de gestion RabbitMQ et se connecter via AMQP. Pour en savoir plus sur le fonctionnement de l'authentification IAM avec Amazon MQ pour RabbitMQ, consultez. [Authentification et autorisation IAM pour Amazon MQ pour RabbitMQ](iam-for-amq-for-rabbitmq.md)

## Conditions préalables
<a name="iam-tutorial-prerequisites"></a>
+ AWS informations d'identification d'administrateur pour le AWS compte propriétaire du courtier Amazon MQ pour RabbitMQ
+ Un environnement shell configuré avec ces informations d'identification d'administrateur (à l'aide de profils AWS CLI ou de variables d'environnement)
+ AWS CLI installée et configurée
+ `jq`processeur JSON en ligne de commande installé
+ `curl`outil de ligne de commande installé

## Configuration de l'authentification et de l'autorisation IAM à l'aide de AWS CLI
<a name="iam-tutorial-procedure"></a>

1. **Définir les variables d'environnement**

   Définissez les variables d'environnement requises pour votre courtier :

   ```
   export AWS_DEFAULT_REGION=<region>
   export BROKER_ID=<broker-id>
   ```

1. **Activer les jetons JWT sortants**

   Activez la fédération d'identité Web sortante pour votre AWS compte :

   ```
   ISSUER_IDENTIFIER=$(aws iam enable-outbound-web-identity-federation --query 'IssuerIdentifier' --output text)
   echo $ISSUER_IDENTIFIER
   ```

   La sortie affiche une URL d'identifiant d'émetteur unique pour votre compte au format`https://<id>.tokens.sts.global.api.aws`.

1. **Création du document de politique IAM**

   Créez un document de politique qui accorde des autorisations pour obtenir des jetons d'identité Web :

   ```
   cat > policy.json << 'EOF'
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor0",
               "Effect": "Allow",
               "Action": [
                   "sts:GetWebIdentityToken",
                   "sts:TagGetWebIdentityToken"
               ],
               "Resource": "*"
           }
       ]
   }
   EOF
   ```

1. **Créez la politique de confiance**

   Récupérez l'identité de votre appelant et créez un document de politique de confiance :

   ```
   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. **Création du rôle IAM**

   Créez le rôle IAM et associez la politique :

   ```
   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. **Configurer les paramètres de RabbitMQ OAuth2 **

   Créez un fichier de configuration RabbitMQ avec les paramètres OAuth2 d'authentification et d'autorisation :

   ```
   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. **Mettre à jour la configuration du broker**

   Appliquez la nouvelle configuration à votre courtier :

   ```
   # 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
   ```

   Attendez que le statut du courtier revienne à nouveau `RUNNING` avant de passer à l'étape suivante.

1. **Obtenir un jeton JWT**

   Assumez le rôle IAM et obtenez un jeton d'identité Web :

   ```
   # 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. **Accédez à l'API de gestion RabbitMQ**

   Utilisez le jeton JWT pour accéder à l'API de gestion RabbitMQ :

   ```
   BROKER_URL=<broker-id>.mq.<region>.on.aws
   
   curl -u ":$TOKEN" \
       -X GET https://${BROKER_URL}/api/overview \
       -H "Content-Type: application/json"
   ```

   Une réponse réussie confirme que l'authentification IAM fonctionne correctement. La réponse contient des informations générales sur les courtiers au format JSON.

1. **Connectez-vous via AMQP à l'aide du jeton JWT**

   Testez la connectivité AMQP à l'aide du jeton JWT avec l'outil Perf-Test :

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

   Si vous recevez un `ACCESS_REFUSED` message d'erreur, vous pouvez résoudre les problèmes liés à vos paramètres de configuration en utilisant les CloudWatch journaux de votre courtier. Vous trouverez le lien vers le groupe de CloudWatch journaux Logs de votre courtier dans la console Amazon MQ.