Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso de la autenticación y autorización de IAM para Amazon MQ for RabbitMQ
<a name="rabbitmq-iam-tutorial"></a>

El siguiente procedimiento muestra cómo habilitar la autenticación y la autorización de AWS IAM para un bróker de Amazon MQ for RabbitMQ. Tras habilitar la IAM, los usuarios pueden autenticarse con las credenciales de IAM para acceder a la API de administración de AWS RabbitMQ y conectarse a través de AMQP. Para obtener más información sobre cómo funciona la autenticación de IAM con Amazon MQ para RabbitMQ, consulte. [Autenticación y autorización de IAM para Amazon MQ para RabbitMQ](iam-for-amq-for-rabbitmq.md)

## Requisitos previos
<a name="iam-tutorial-prerequisites"></a>
+ AWS credenciales de administrador de la AWS cuenta propietaria del bróker Amazon MQ for RabbitMQ
+ Un entorno de shell configurado con estas credenciales de administrador (mediante perfiles AWS CLI o variables de entorno)
+ AWS CLI instalada y configurada
+ `jq`Procesador JSON de línea de comandos instalado
+ `curl`herramienta de línea de comandos instalada

## Configurar la autenticación y la autorización de IAM mediante AWS CLI
<a name="iam-tutorial-procedure"></a>

1. **Defina las variables de entorno**

   Establezca las variables de entorno necesarias para su corredor:

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

1. **Habilite los tokens JWT salientes**

   Habilite la federación de identidades web salientes para su cuenta: AWS 

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

   El resultado muestra una URL de identificador de emisor única para su cuenta en este formato. `https://<id>.tokens.sts.global.api.aws`

1. **Cree el documento de política de IAM**

   Cree un documento de política que conceda permisos para obtener tokens de identidad web:

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

1. **Cree la política de confianza**

   Recupera la identidad de la persona que llama y crea un documento de política de confianza:

   ```
   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. **Cree el rol de IAM**

   Cree el rol de IAM y adjunte la política:

   ```
   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. **Configure los ajustes de RabbitMQ OAuth2 **

   Cree un archivo de configuración de RabbitMQ con los ajustes de autenticación y autorización: 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. **Actualice la configuración del corredor**

   Aplique la nueva configuración a su corredor:

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

   Espere a que vuelva al estado de corredor `RUNNING` antes de continuar con el siguiente paso.

1. **Obtenga un token JWT**

   Asuma el rol de IAM y obtenga un token de identidad 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. **Acceda a la API de administración de RabbitMQ**

   Utilice el token JWT para acceder a la API de administración de RabbitMQ:

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

   Una respuesta correcta confirma que la autenticación de IAM funciona correctamente. La respuesta contiene información general sobre el corredor en formato JSON.

1. **Conéctese a través de AMQP utilizando el token JWT**

   Pruebe la conectividad AMQP con el token JWT con la herramienta de prueba de rendimiento:

   ```
   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 recibe un `ACCESS_REFUSED` error, puede solucionar los problemas de configuración utilizando los registros de su agente. CloudWatch Puede encontrar el enlace al grupo de CloudWatch registros de registros de su agente en la consola de Amazon MQ.