Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo di MTL per AMQP e endpoint di gestione
<a name="rabbitmq-mtls-tutorial"></a>

Questo tutorial descrive come configurare il TLS reciproco (mTLS) per le connessioni client AMQP e l'interfaccia di gestione RabbitMQ utilizzando un'autorità di certificazione privata.

**Nota**  
L'uso di autorità di certificazione private per MTL è disponibile solo per Amazon MQ for RabbitMQ versione 4 e successive.

**Topics**
+ [Prerequisiti per configurare gli MTL](#rabbitmq-mtls-tutorial-prerequisites)
+ [Configurazione degli MTL in RabbitMQ tramite CLI AWS](#rabbitmq-mtls-tutorial-configure-cli)

## Prerequisiti per configurare gli MTL
<a name="rabbitmq-mtls-tutorial-prerequisites"></a>

Puoi configurare le AWS risorse richieste in questo tutorial distribuendo lo [stack AWS CDK per l'integrazione di Amazon MQ for RabbitMQ MTL](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/) con.

Questo stack CDK crea automaticamente tutte le AWS risorse necessarie, tra cui l'autorità di certificazione, i certificati client e i ruoli IAM. Consulta il pacchetto README per un elenco completo delle risorse create dallo stack.

Se stai configurando le risorse manualmente anziché utilizzare lo stack CDK, assicurati di disporre dell'infrastruttura equivalente prima di configurare MTL sui tuoi broker Amazon MQ for RabbitMQ.

### Prerequisito per configurare Amazon MQ
<a name="rabbitmq-mtls-tutorial-prerequisite-cli"></a>

AWS Versione CLI >= 2.28.23 per rendere opzionale l'aggiunta di un nome utente e una password durante la creazione del broker.

## Configurazione degli MTL in RabbitMQ tramite CLI AWS
<a name="rabbitmq-mtls-tutorial-configure-cli"></a>

Questa procedura utilizza la AWS CLI per creare e configurare le risorse necessarie. Nella procedura seguente, assicuratevi di sostituire i valori segnaposto, come ConfigurationID e Revision, con i relativi valori `<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>` effettivi`<2>`.

1. Creare una nuova configurazione utilizzando il comando `create-configuration` AWS CLI, come illustrato nell'esempio seguente.

   ```
   aws mq create-configuration \
     --name "rabbitmq-mtls-config" \
     --engine-type "RABBITMQ" \
     --engine-version "4.2"
   ```

   Questo comando restituisce una risposta simile all'esempio seguente.

   ```
   {
       "Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
       "AuthenticationStrategy": "simple",
       "Created": "2025-07-17T16:03:01.759943+00:00",
       "Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
       "LatestRevision": {
           "Created": "2025-07-17T16:03:01.759000+00:00",
           "Description": "Auto-generated default for rabbitmq-mtls-config on RabbitMQ 4.2",
           "Revision": 1
       },
       "Name": "rabbitmq-mtls-config"
   }
   ```

1. Create un file di configurazione chiamato `rabbitmq.conf` a configurare MTL per AMQP e gli endpoint di gestione, come illustrato nell'esempio seguente. Sostituisci tutti i valori segnaposto nel modello (contrassegnati con`${...}`) con i valori effettivi degli output dello stack dei prerequisiti implementati AWS CDK o dell'infrastruttura equivalente.

   ```
   auth_backends.1 = internal
   
   # TLS configuration
   ssl_options.verify = verify_peer
   ssl_options.fail_if_no_peer_cert = true
   management.ssl.verify = verify_peer
   
   # AWS integration for secure credential retrieval
   # For more information, see https://github.com/amazon-mq/rabbitmq-aws
   
   # FIXME: Replace the ${...} placeholders with actual ARN values
   # from your deployed prerequisite CDK stack outputs.
   aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
   aws.arns.ssl_options.cacertfile = ${CaCertArn}
   aws.arns.management.ssl.cacertfile = ${CaCertArn}
   ```

1. Aggiornate la configurazione utilizzando il comando `update-configuration` AWS CLI come illustrato nell'esempio seguente. In questo comando, aggiungi l'ID di configurazione ricevuto nella risposta del passaggio 1 di questa procedura. Ad esempio, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.

   ```
   aws mq update-configuration \
     --configuration-id "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>" \
     --data "$(cat rabbitmq.conf | base64 --wrap=0)"
   ```

   Questo comando restituisce una risposta simile all'esempio seguente.

   ```
   {
       "Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
       "Created": "2025-07-17T16:57:04.520931+00:00",
       "Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
       "LatestRevision": {
           "Created": "2025-07-17T16:57:39.172000+00:00",
           "Revision": 2
       },
       "Name": "rabbitmq-mtls-config",
       "Warnings": []
   }
   ```

1. Crea un broker con la configurazione mTLS creata nel passaggio 2 di questa procedura. A tale scopo, utilizzate il comando `create-broker` AWS CLI come illustrato nell'esempio seguente. In questo comando, fornite l'ID di configurazione e il numero di revisione ottenuti rispettivamente nelle risposte dei passaggi 1 e 2. Ad esempio `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` e `2`.

   ```
   aws mq create-broker \
     --broker-name "rabbitmq-mtls-test-1" \
     --engine-type "RABBITMQ" \
     --engine-version "4.2" \
     --host-instance-type "mq.m7g.large" \
     --deployment-mode "SINGLE_INSTANCE" \
     --logs '{"General": true}' \
     --publicly-accessible \
     --configuration '{"Id": "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>","Revision": <2>}' \
     --users '[{"Username":"testuser","Password":"testpassword"}]'
   ```

   Questo comando restituisce una risposta simile all'esempio seguente.

   ```
   {
       "BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-mtls-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
       "BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
   }
   ```

1. Verifica che lo stato del broker passi da `CREATION_IN_PROGRESS` a`RUNNING`, utilizzando il comando `describe-broker` AWS CLI come mostrato nell'esempio seguente. In questo comando, fornisci l'ID del broker che hai ottenuto nel risultato del passaggio precedente. Ad esempio, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.

   ```
   aws mq describe-broker \
     --broker-id "<b-2a1b5133-a10c-49d2-879b-8c176c34cf73>"
   ```

   Questo comando restituisce una risposta simile all'esempio seguente. La risposta seguente è una versione abbreviata dell'output completo restituito dal `describe-broker` comando.

   ```
   {
       "AuthenticationStrategy": "simple",
       ...,
       "BrokerState": "RUNNING",
       ...
   }
   ```

1. Verifica l'autenticazione mTLS con lo script seguente`mtls.sh`.

   Usa questo script bash per testare la connettività al tuo broker Amazon MQ for RabbitMQ. Questo script utilizza il certificato client per l'autenticazione e verifica se la connessione è stata configurata correttamente. Se è configurato correttamente, vedrai il tuo broker pubblicare e consumare messaggi.

   Se ricevi un `ACCESS_REFUSED` errore, puoi risolvere i problemi delle impostazioni di configurazione utilizzando CloudWatch i log del tuo broker. Puoi trovare il link per il gruppo di CloudWatch log del tuo broker nella console Amazon MQ.

   In questo script, dovrai fornire i seguenti valori:
   + `USERNAME`e`PASSWORD`: le credenziali utente di RabbitMQ che hai creato con il broker.
   + `CLIENT_KEYSTORE`: Percorso del file keystore del client (formato). PKCS12 Se hai utilizzato lo stack CDK prerequisito, il percorso predefinito è. `$(pwd)/certs/client-keystore.p12`
   + `KEYSTORE_PASSWORD`: Password per il keystore del cliente. Se hai utilizzato lo stack CDK prerequisito, la password predefinita è. `changeit`
   + `BROKER_DNS`: Puoi trovare questo valore in **Connessioni** nella pagina dei dettagli del broker della console Amazon MQ.

   ```
   #! /bin/bash
   set -e
   
   # Client information
   ## FIXME: Update this value with the client ID and secret of your confidential application client
   USERNAME={{<testuser>}}
   PASSWORD={{<testpassword>}}
   CLIENT_KEYSTORE={{$(pwd)/certs/client-keystore.p12}}
   KEYSTORE_PASSWORD={{changeit}}
   
   BROKER_DNS={{<broker_dns>}}
   CONNECTION_STRING=amqps://${USERNAME}:${PASSWORD}@${BROKER_DNS}:5671 
   
   # Produce/consume messages using the above connection string
   QUEUES_COUNT=1
   PRODUCERS_COUNT=1
   CONSUMERS_COUNT=1
   PRODUCER_RATE=1
   
   finch run --rm --ulimit nofile=40960:40960 \
       -v ${CLIENT_KEYSTORE}:/certs/client-keystore.p12:ro \
       -e JAVA_TOOL_OPTIONS="-Djavax.net.ssl.keyStore=/certs/client-keystore.p12 -Djavax.net.ssl.keyStorePassword=${KEYSTORE_PASSWORD} -Djavax.net.ssl.keyStoreType=PKCS12" \
       pivotalrabbitmq/perf-test:latest \
       --queue-pattern 'test-queue-cert-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
       --producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
       --id "cert-test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
       --uri ${CONNECTION_STRING} \
       --use-default-ssl-context \
       --flag persistent --rate $PRODUCER_RATE
   ```