As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usando autenticação e autorização do IAM para Amazon MQ para RabbitMQ
<a name="rabbitmq-iam-tutorial"></a>

O procedimento a seguir demonstra como habilitar a autenticação e autorização AWS do IAM para um agente Amazon MQ for RabbitMQ. Depois de habilitar o IAM, os usuários podem se autenticar usando as credenciais AWS do IAM para acessar a API de gerenciamento do RabbitMQ e se conectar via AMQP. Para obter detalhes sobre como a autenticação do IAM funciona com o Amazon MQ para RabbitMQ, consulte. [Autenticação e autorização do IAM para Amazon MQ para RabbitMQ](iam-for-amq-for-rabbitmq.md)

## Pré-requisitos
<a name="iam-tutorial-prerequisites"></a>
+ AWS credenciais de administrador para a AWS conta proprietária do agente Amazon MQ for RabbitMQ
+ Um ambiente de shell configurado com essas credenciais de administrador (usando perfis AWS CLI ou variáveis de ambiente)
+ AWS CLI instalada e configurada
+ `jq`processador JSON de linha de comando instalado
+ `curl`ferramenta de linha de comando instalada

## Configurando a autenticação e autorização do IAM usando AWS CLI
<a name="iam-tutorial-procedure"></a>

1. **Definir variáveis de ambiente**

   Defina as variáveis de ambiente necessárias para seu corretor:

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

1. **Ativar tokens JWT de saída**

   Ative a federação externa de identidade da web para sua AWS conta:

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

   A saída exibe um URL de identificador de emissor exclusivo para sua conta no formato`https://<id>.tokens.sts.global.api.aws`.

1. **Crie o documento de política do IAM**

   Crie um documento de política que conceda permissões para obter tokens de identidade da web:

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

1. **Crie a política de confiança**

   Recupere sua identidade de chamador e crie um documento de política de confiança:

   ```
   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. **Crie a função do IAM**

   Crie a função do IAM e anexe a 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. **Definir as configurações do OAuth2 RabbitMQ**

   Crie um arquivo de configuração do RabbitMQ com configurações de OAuth2 autenticação e autorização:

   ```
   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. **Atualizar a configuração do broker**

   Aplique a nova configuração ao seu corretor:

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

   Aguarde até que o status do corretor retorne `RUNNING` antes de prosseguir para a próxima etapa.

1. **Obtenha um token JWT**

   Assuma a função do IAM e obtenha um token de identidade da 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. **Acesse a API de gerenciamento do RabbitMQ**

   Use o token JWT para acessar a API de gerenciamento do RabbitMQ:

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

   Uma resposta bem-sucedida confirma que a autenticação do IAM está funcionando corretamente. A resposta contém informações de visão geral do corretor no formato JSON.

1. **Conecte-se via AMQP usando o token JWT**

   Teste a conectividade AMQP usando o token JWT com a ferramenta 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
   ```

   Se você receber um `ACCESS_REFUSED` erro, poderá solucionar seus problemas de configuração usando os CloudWatch registros do seu corretor. Você pode encontrar o link para o grupo de CloudWatch registros de registros do seu agente no console do Amazon MQ.