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.
# Didacticiels RabbitMQ
Les didacticiels suivants vous montrent comment configurer et utiliser RabbitMQ sur Amazon MQ. Pour en savoir plus sur l'utilisation des bibliothèques client prises en charge dans une variété de langages de programmation tels que Node.js, Python, .NET, etc., consultez [Didacticiels RabbitMQ](https://www.rabbitmq.com/getstarted.html) du *Guide de démarrage RabbitMQ*.
**Topics**
+ [Modification des préférences d'agent](amazon-mq-rabbitmq-editing-broker-preferences.md)
+ [Utilisation de Python Pika avec Amazon MQ pour RabbitMQ](amazon-mq-rabbitmq-pika.md)
+ [Résolution de la synchronisation de la file d'attente mise en pause RabbitMQ](rabbitmq-queue-sync.md)
+ [Réduction du nombre de connexions et de canaux](reducing-connections-and-channels.md)
+ [Étape 2 : Connectez une application basée sur JVM à votre courtier](#rabbitmq-connect-jvm-application)
+ [Connect your Amazon MQ for RabbitMQ broker to Lambda](#rabbitmq-connect-to-lambda)
+ [Utilisation de l'authentification et de l'autorisation OAuth 2.0 pour Amazon MQ pour RabbitMQ](oauth-tutorial.md)
+ [Utilisation de l'authentification et de l'autorisation IAM pour Amazon MQ pour RabbitMQ](rabbitmq-iam-tutorial.md)
+ [Utilisation de l'authentification et de l'autorisation LDAP pour Amazon MQ pour RabbitMQ](rabbitmq-ldap-tutorial.md)
+ [Utilisation de l'authentification et de l'autorisation HTTP pour Amazon MQ pour RabbitMQ](rabbitmq-http-tutorial.md)
+ [Utilisation de l'authentification par certificat SSL pour Amazon MQ pour RabbitMQ](rabbitmq-ssl-tutorial.md)
+ [Utilisation de MTL pour l'AMQP et les points de terminaison de gestion](rabbitmq-mtls-tutorial.md)
+ [Connexion de votre application JMS](rabbitmq-tutorial-jms.md)
# Modification des préférences d'agent
Vous pouvez modifier les préférences de votre courtier, par exemple en activant ou en désactivant CloudWatch les journaux à l'aide du AWS Management Console.
## Modifier les options de l'agent RabbitMQ
1. Connectez-vous à la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. Dans la liste des courtiers, sélectionnez votre courtier (par exemple **MyBroker**), puis choisissez **Modifier**.
1. Sur la *MyBroker* page **Modifier**, dans la section **Spécifications**, sélectionnez une **version du moteur Broker** ou un **type d'instance Broker**.
1. Dans la section **CloudWatch Journaux**, cliquez sur le bouton bascule pour activer ou désactiver les journaux généraux. Les autres étapes sont requises.
**Note**
Pour les courtiers RabbitMQ, Amazon MQ utilise automatiquement un rôle lié au service (SLR) pour publier des journaux généraux sur. CloudWatch Pour de plus amples informations, consultez [Utilisation des rôles liés à un service pour Amazon MQ](using-service-linked-roles.md).
Amazon MQ ne prend pas en charge la journalisation d'audit pour les agents RabbitMQ.
1. Dans la section **Maintenance**, configurez le programme de maintenance de votre agent :
Pour mettre à niveau le broker vers de nouvelles versions au fur et à mesure de sa AWS publication, choisissez **Activer les mises à niveau automatiques des versions mineures**. Les mises à niveau automatiques se produisent pendant la *fenêtre de maintenance* définie par le jour de la semaine, l'heure de la journée (au format 24 heures) et le fuseau horaire (UTC par défaut).
1. Choisissez **Schedule Modifications (Planifier les modifications)**.
**Note**
Si vous choisissez uniquement **Enable automatic minor version upgrades (Activer les mises à niveau automatiques des versions mineures)**, le bouton est remplacé par **Save (Enregistrer)**, car aucun redémarrage d'agent n'est nécessaire.
Vos préférences sont appliquées à votre agent à l'heure spécifiée.
# Utilisation de Python Pika avec Amazon MQ pour RabbitMQ
Le didacticiel suivant montre comment vous pouvez configurer un client [Pika Python](https://github.com/pika/pika) avec TLS configuré pour se connecter à un agent Amazon MQ pour RabbitMQ. Pika est une implémentation Python du protocole AMQP 0-9-1 pour RabbitMQ. Ce didacticiel vous explique comment installer Pika, déclarer une file d'attente, configurer un éditeur pour envoyer des messages à la plateforme d'échange par défaut du courtier et configurer un consommateur pour recevoir les messages de la file d'attente.
**Topics**
+ [Conditions préalables](#amazon-mq-rabbitmq-pika-prerequisites)
+ [Permissions](#amazon-mq-rabbitmq-pika-permissions)
+ [Première étape : création d'un client Python Pika de base](#amazon-mq-rabbitmq-pika-basic-client)
+ [Deuxième étape : création d'un éditeur et envoi d'un message](#amazon-mq-rabbitmq-pika-publisher-basic-publish)
+ [Troisième étape : créer un consommateur et recevoir un message](#amazon-mq-rabbitmq-pika-consumer-basic-get)
+ [Étape quatre : (facultatif) configuration d'une boucle d'événements et consommation des messages](#amazon-mq-rabbitmq-pika-consumer-basic-consume)
+ [Quelle est la prochaine étape ?](#amazon-mq-rabbitmq-pika-whats-next)
## Conditions préalables
Pour compléter les cinq premières étapes de ce didacticiel, vous devez disposer des éléments suivants :
+ Un agent Amazon MQ pour RabbitMQ. Pour de plus amples informations, consultez l'article sur la [création d'un agent Amazon MQ pour RabbitMQ](getting-started-rabbitmq.md#create-rabbitmq-broker).
+ L'outil [Python 3](https://www.python.org/downloads/) correspondant à votre système d'exploitation.
+ L'outil [Pika](https://pika.readthedocs.io/en/stable/) installé à l'aide de Python `pip`. Pour installer Pika, ouvrez une nouvelle fenêtre dans le terminal et exécutez la procédure suivante.
```
$ python3 -m pip install pika
```
## Permissions
Pour pouvoir suivre ce didacticiel, vous aurez besoin d'au moins un utilisateur d'agent Amazon MQ pour RabbitMQ autorisé à écrire et à lire depuis un vhost. Le tableau suivant décrit les autorisations minimales nécessaires sous forme de modèles d'expressions régulières (regexp).
| Étiquettes | Configurer regexp | Regexp en écriture | Lire regexp |
| --- | --- | --- | --- |
| none | | .\$1 | .\$1 |
Les autorisations utilisateur répertoriées accordent uniquement des autorisations en lecture et en écriture et ne donnent aucun accès au plugin de gestion permettant d'effectuer des opérations administratives sur l'agent. Vous pouvez encore restreindre davantage les autorisations en fournissant des modèles de regexp qui limitent l'accès de l'utilisateur à des files d'attente spécifiées. Par exemple, si vous remplacez le modèle de regexp en lecture par `^[hello world].*`, l'utilisateur sera uniquement autorisé à lire des files d'attente commençant par `hello world`.
Pour plus d'informations sur la création d'utilisateurs RabbitMQ et la gestion de balises et autorisations utilisateur, consultez [Amazon MQ pour les utilisateurs du broker RabbitMQ](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Première étape : création d'un client Python Pika de base
Pour créer une classe de client de base Python Pika capable de définir un constructeur et de fournit le contexte SSL nécessaire à la configuration TLS lors de l'interaction avec un agent Amazon MQ pour RabbitMQ, procédez comme suit.
1. Ouvrez une nouvelle fenêtre dans le terminal, créez un nouveau répertoire pour votre projet et accédez-y.
```
$ mkdir pika-tutorial
$ cd pika-tutorial
```
1. Créez un fichier nommé `basicClient.py` contenant le code suivant.
```
import ssl
import pika
class BasicPikaClient:
def __init__(self, rabbitmq_broker_id, rabbitmq_user, rabbitmq_password, region):
# SSL Context for TLS configuration of Amazon MQ for RabbitMQ
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
ssl_context.set_ciphers('ECDHE+AESGCM:!ECDSA')
url = f"amqps://{rabbitmq_user}:{rabbitmq_password}@{rabbitmq_broker_id}.mq.{region}.amazonaws.com:5671"
parameters = pika.URLParameters(url)
parameters.ssl_options = pika.SSLOptions(context=ssl_context)
self.connection = pika.BlockingConnection(parameters)
self.channel = self.connection.channel()
```
Vous pouvez désormais définir des classes supplémentaires pour votre éditeur et votre consommateur qui héritent de `BasicPikaClient`.
## Deuxième étape : création d'un éditeur et envoi d'un message
Pour créer un éditeur capable de déclarer une file d'attente et d'envoyer un message unique, procédez comme suit.
1. Copiez le contenu de l'exemple de code suivant et enregistrez-le localement sous `publisher.py` dans le même répertoire que celui que vous avez créé à l'étape précédente.
```
from basicClient import BasicPikaClient
class BasicMessageSender(BasicPikaClient):
def declare_queue(self, queue_name):
print(f"Trying to declare queue({queue_name})...")
self.channel.queue_declare(queue=queue_name)
def send_message(self, exchange, routing_key, body):
channel = self.connection.channel()
channel.basic_publish(exchange=exchange,
routing_key=routing_key,
body=body)
print(f"Sent message. Exchange: {exchange}, Routing Key: {routing_key}, Body: {body}")
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Initialize Basic Message Sender which creates a connection
# and channel for sending messages.
basic_message_sender = BasicMessageSender(
"",
"",
"",
""
)
# Declare a queue
basic_message_sender.declare_queue("hello world queue")
# Send a message to the queue.
basic_message_sender.send_message(exchange="", routing_key="hello world queue", body=b'Hello World!')
# Close connections.
basic_message_sender.close()
```
La classe `BasicMessageSender` hérite de `BasicPikaClient` et implémente des méthodes supplémentaires pour déclarer une file d'attente, envoyer un message sur celle-ci et fermer les connexions. L'exemple de code achemine un message vers l'échange par défaut, avec une clé de routage identique au nom de la file d'attente.
1. Sous `if __name__ == "__main__":`, remplacez les paramètres transmis à la déclaration de constructeur `BasicMessageSender` par les informations suivantes.
+ **``** – ID unique généré par Amazon MQ pour l’agent. Vous pouvez analyser l’ID de votre ARN d’agent. Par exemple, avec l’ARN suivant, `arn:aws:mq:us-east-2:123456789012:broker:MyBroker:b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`, l’ID de l’agent serait `b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`.
+ **``** : nom d'utilisateur d'agent disposant des autorisations suffisantes pour écrire des messages à l'agent.
+ **``** : mot de passe d'un utilisateur d'agent disposant des autorisations suffisantes pour écrire des messages à l'agent.
+ **``**— La AWS région dans laquelle vous avez créé votre courtier Amazon MQ pour RabbitMQ. Par exemple, `us-west-2`.
1. Exécutez la commande suivante dans le répertoire où vous avez créé `publisher.py`.
```
$ python3 publisher.py
```
Si le code s'exécute correctement, vous verrez la sortie suivante dans la fenêtre de votre terminal.
```
Trying to declare queue(hello world queue)...
Sent message. Exchange: , Routing Key: hello world queue, Body: b'Hello World!'
```
## Troisième étape : créer un consommateur et recevoir un message
Pour créer un consommateur qui reçoit un seul message de la file d'attente, procédez comme suit.
1. Copiez le contenu de l'exemple de code suivant et enregistrez-le sous `consumer.py` dans le même répertoire.
```
from basicClient import BasicPikaClient
class BasicMessageReceiver(BasicPikaClient):
def get_message(self, queue):
method_frame, header_frame, body = self.channel.basic_get(queue)
if method_frame:
print(method_frame, header_frame, body)
self.channel.basic_ack(method_frame.delivery_tag)
return method_frame, header_frame, body
else:
print('No message returned')
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection
# and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
basic_message_receiver.get_message("hello world queue")
# Close connections.
basic_message_receiver.close()
```
Semblable à l'éditeur que vous avez créé à l'étape précédente, `BasicMessageReceiver` hérite de méthodes supplémentaires `BasicPikaClient` et implémente des méthodes supplémentaires pour recevoir un seul message et fermer les connexions.
1. Sous la déclaration `if __name__ == "__main__":`, remplacez les paramètres transmis au constructeur `BasicMessageReceiver` par vos données.
1. Exécutez la commande suivante dans le répertoire de votre projet.
```
$ python3 consumer.py
```
Si le code s'exécute correctement, le corps du message et les en-têtes, y compris la clé de routage, s'affichent dans la fenêtre de votre terminal.
```
b'Hello World!'
```
## Étape quatre : (facultatif) configuration d'une boucle d'événements et consommation des messages
Pour consommer plusieurs messages d'une file d'attente, utilisez la méthode [https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume](https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume) de Pika ainsi qu'une fonction de rappel, comme illustré ci-dessous.
1. Dans `consumer.py`, ajoutez la définition de méthode suivante à la classe `BasicMessageReceiver`.
```
def consume_messages(self, queue):
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
self.channel.basic_consume(queue=queue, on_message_callback=callback, auto_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
self.channel.start_consuming()
```
1. Dans `consumer.py`, sous `if __name__ == "__main__":`, invoquez la méthode `consume_messages` que vous avez définie à l'étape précédente.
```
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
# basic_message_receiver.get_message("hello world queue")
# Consume multiple messages in an event loop.
basic_message_receiver.consume_messages("hello world queue")
# Close connections.
basic_message_receiver.close()
```
1. Exécutez `consumer.py` à nouveau. Si tout se passe normalement, les messages mis en file d'attente s'afficheront dans la fenêtre de votre terminal.
```
[*] Waiting for messages. To exit press CTRL+C
[x] Received b'Hello World!'
[x] Received b'Hello World!'
...
```
## Quelle est la prochaine étape ?
+ Pour en savoir plus sur les autres bibliothèques de clients RabbitMQ prises en charge, consultez la [documentation sur les clients RabbitMQ](https://www.rabbitmq.com/clients.html) disponible sur le site web de RabbitMQ.
# Résolution de la synchronisation de la file d'attente mise en pause RabbitMQ
Dans un [déploiement en cluster](rabbitmq-broker-architecture.md#rabbitmq-broker-architecture-cluster) Amazon MQ for RabbitMQ, les messages publiés dans chaque file d'attente sont répliqués sur trois nœuds d'agent. Cette réplication, appelée *mise en miroir*, fournit une haute disponibilité (HA) pour les agents RabbitMQ. Les files d'attente d'un déploiement en cluster se composent d'un réplica *principal* sur un nœud et un ou plusieurs *miroirs*. Chaque opération appliquée à une file d'attente mise en miroir, y compris les messages de mise en file d'attente, est d'abord appliquée à la file d'attente principale, puis répliquée sur ses miroirs.
Par exemple, considérez une file d'attente en miroir répliquée sur trois nœuds : le nœud principal (`main`) et deux miroirs (`mirror-1` et `mirror-2`). Si tous les messages de cette file d'attente en miroir sont propagés avec succès à tous les miroirs, la file d'attente est synchronisée. Si un nœud (`mirror-1`) devient indisponible pendant un intervalle de temps, la file d'attente est toujours opérationnelle et peut continuer à mettre en file d'attente des messages. Toutefois, pour que la file d'attente se synchronise, les messages publiés dans `main` tandis que `mirror-1` n'est pas disponible doivent être répliqués dans `mirror-1`.
Pour plus d'informations sur la mise en miroir, consultez [Files d'attente mises en miroir classiques](https://www.rabbitmq.com/ha.html) sur le site web RabbitMQ.
**Maintenance et synchronisation des files d'attente**
Lors de [fenêtres de maintenance](amazon-mq-rabbitmq-editing-broker-preferences.md#rabbitmq-edit-current-configuration-console), Amazon MQ effectue tous les travaux de maintenance un nœud à la fois pour s'assurer que l'agent reste opérationnel. Par conséquent, les files d'attente peuvent devoir se synchroniser à mesure que chaque nœud reprend l'opération. Pendant la synchronisation, les messages qui doivent être répliqués en miroirs sont chargés en mémoire à partir du volume Amazon Elastic Block Store (Amazon EBS) correspondant à traiter par lots. Le traitement des messages par lots permet aux files d'attente de se synchroniser plus rapidement.
Si les files d'attente sont courtes et que les messages sont petits, les files d'attente se synchronisent et reprennent le fonctionnement comme prévu. Toutefois, si la quantité de données dans un lot approche de la limite de mémoire du nœud, le nœud déclenche une alarme de mémoire élevée, mettant en pause la synchronisation de la file d'attente. Vous pouvez confirmer l'utilisation de la mémoire en comparant les [métriques du nœud `RabbitMemUsed` et du nœud `RabbitMqMemLimit` broker dans CloudWatch](amazon-mq-accessing-metrics.md). La synchronisation ne peut pas se terminer tant que les messages ne sont pas consommés ou supprimés, ou que le nombre de messages dans le lot est réduit.
**Note**
La réduction de la taille du lot de synchronisation des files d'attente peut entraîner un plus grand nombre de transactions de réplication.
Pour résoudre une synchronisation de file d'attente mise en pause, suivez les étapes de ce didacticiel, qui illustre l'application d'une politique `ha-sync-batch-size` et le redémarrage de la synchronisation de la file d'attente.
**Topics**
+ [Conditions préalables](#rabbitmq-queue-sync-prerequisites)
+ [Étape 1 : Appliquer une politique `ha-sync-batch-size`](#rabbitmq-queue-sync-step-1)
+ [Étape 2 : Redémarrer la synchronisation de la file d'attente](#rabbitmq-queue-sync-step-2)
+ [Étapes suivantes](#rabbitmq-queue-sync-next-steps)
+ [Ressources connexes](#rabbitmq-queue-sync-related-resources)
## Conditions préalables
Pour ce didacticiel, vous devez disposer d'un utilisateur d'agent Amazon MQ for RabbitMQ avec les autorisations d'administrateur. Vous pouvez utiliser l'utilisateur administrateur créé lors de la création de l'agent pour la première fois, ou un autre utilisateur que vous avez créé par la suite. Le tableau suivant fournit la balise utilisateur administrateur et les autorisations nécessaires en tant que modèles d'expression régulière (regexp).
| Étiquettes | Lire regexp | Configurer regexp | Regexp en écriture |
| --- | --- | --- | --- |
| administrator | .\$1 | .\$1 | .\$1 |
Pour plus d'informations sur la création d'utilisateurs RabbitMQ et la gestion de balises et autorisations utilisateur, consultez [Amazon MQ pour les utilisateurs du broker RabbitMQ](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Étape 1 : Appliquer une politique `ha-sync-batch-size`
Les procédures suivantes illustrent l'ajout d'une politique qui s'applique à toutes les files d'attente créées sur l'agent. Vous pouvez utiliser la console web RabbitMQ ou l'API de gestion RabbitMQ. Pour plus d'informations, consultez [Plugin de gestion](https://www.rabbitmq.com/management.html) sur le site web RabbitMQ.
**Pour appliquer une politique `ha-sync-batch-size` à l'aide de la console web RabbitMQ**
1. Connectez-vous à la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. Dans le panneau de navigation de gauche, choisissez **Brokers (Agents)**.
1. Dans la liste des agents, choisissez le nom de l'agent auquel vous souhaitez appliquer la nouvelle politique.
1. Sur la page de l'agent, dans la section **Connection (Connexions)**, choisissez l'URL **RabbitMQ web console (Console web RabbitMQ)**. La console web RabbitMQ s'ouvre dans un nouvel onglet ou une nouvelle fenêtre du navigateur.
1. Connectez-vous à la console Web RabbitMQ à l'aide de vos informations d’identification de connexion d'administrateur d'agent.
1. Dans la console web RabbitMQ, en haut de la page, choisissez **Admin (Administrateur)**.
1. Dans la page **Admin (Administrateur)**, dans le volet de navigation droit, choisissez **Policies (Politiques)**.
1. Dans la page **Policies (Politiques)**, vous pouvez consulter la liste actuelle **User policies (Politiques utilisateur)** de l'agent. Sous **User policies (Politiques utilisateur)**, développez **Add/update a policy (Ajouter ou mettre à jour une politique)**.
**Note**
Par défaut, les clusters Amazon MQ for RabbitMQ sont créés avec une politique d'agent initiale nommée `ha-all-AWS-OWNED-DO-NOT-DELETE`. Amazon MQ gère cette politique pour s'assurer que chaque file d'attente de l'agent est répliquée sur les trois nœuds et que les files d'attente sont synchronisées automatiquement.
1. Pour créer une politique d'agent, sous **Add/update a policy (Ajouter ou mettre à jour une politique)**, procédez comme suit :
1. Dans **Name (Name)**, attribuez un nom à votre politique IAM, par exemple **batch-size-policy**.
1. Pour **Pattern (Modèle)**, entrez le modèle regexp **.\$1** afin que la politique corresponde à toutes les files d'attente sur l'agent.
1. Pour **Apply to (Appliquer à)**, choisissez **Exchanges and queues (Échanges et files d'attente)** dans la liste déroulante.
1. Pour **Priority (Priorité)**, entrez un entier supérieur à toutes les autres politiques appliquées au vhost. Vous pouvez appliquer exactement un ensemble de définitions de politiques aux files d'attente et aux échanges RabbitMQ à tout moment. RabbitMQ choisit la politique correspondante avec la valeur de priorité la plus élevée. Pour plus d'informations sur les priorités de politique et sur la façon de combiner des politiques, veuillez consulter [Policies (Politiques)](https://www.rabbitmq.com/parameters.html#policies) dans la documentation du serveur RabbitMQ.
1. Pour **Definition (Définition)**, ajoutez les paires clé-valeur suivantes :
+ **ha-sync-batch-size**=*100*. Choisissez **Numéro** dans la liste déroulante.
**Note**
Vous devrez peut-être ajuster et calibrer la valeur de `ha-sync-batch-size` en fonction du nombre et de la taille des messages non synchronisés dans vos files d'attente.
+ **ha-mode**=**all**. Choisissez **String (Chaîne)** dans la liste déroulante.
**Important**
La définition `ha-mode` est requise pour toutes les politiques relatives à la haute disponibilité. Son omission entraîne un échec de validation.
+ **ha-sync-mode**=**automatic**. Choisissez **String (Chaîne)** dans la liste déroulante.
**Note**
La définition `ha-sync-mode` est requise pour toutes les politiques relatives à la haute disponibilité. Si elle est omise, Amazon MQ ajoute automatiquement la définition.
1. Choisissez **Add / update policy (Ajouter/mettre à jour une politique)**.
1. Confirmez que la nouvelle politique apparaît dans la liste **User policies (Politiques utilisateur)**.
**Pour appliquer une politique `ha-sync-batch-size` à l'aide de l'API de gestion RabbitMQ**
1. Connectez-vous à la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. Dans le panneau de navigation de gauche, choisissez **Brokers (Agents)**.
1. Dans la liste des agents, choisissez le nom de l'agent auquel vous souhaitez appliquer la nouvelle politique.
1. Sur la page de l'agent, dans la section **Connection (Connexion)**, notez l'URL de la **console web RabbitMQ**. Il s'agit du point de terminaison de l'agent que vous utilisez dans une requête HTTP.
1. Ouvrez une nouvelle fenêtre de terminal ou de ligne de commande.
1. Pour créer une politique d'agent, entrez la commande `curl` suivante. Cette commande suppose la présence d'une file d'attente sur le vhost `/` par défaut, qui est encodé en tant que `%2F`.
**Note**
Remplacez *username* et par *password* les informations de connexion de l'administrateur de votre courtier. Vous devrez peut-être ajuster et calibrer la valeur de `ha-sync-batch-size` (*100*) en fonction du nombre et de la taille des messages non synchronisés dans vos files d'attente. Remplacez le point de terminaison de l'agent par l'URL que vous avez notée précédemment.
```
curl -i -u username:password -H "content-type:application/json" -XPUT \
-d '{"pattern":".*", "priority":1, "definition":{"ha-sync-batch-size":100, "ha-mode":"all", "ha-sync-mode":"automatic"}}' \
https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies/%2F/batch-size-policy
```
1. Pour confirmer que la nouvelle politique est ajoutée aux politiques utilisateur de votre agent, entrez la commande `curl` suivante pour répertorier toutes les politiques de l'agent.
```
curl -i -u username:password https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies
```
## Étape 2 : Redémarrer la synchronisation de la file d'attente
Après avoir appliqué une nouvelle politique `ha-sync-batch-size` à votre agent, redémarrez la synchronisation de la file d'attente.
**Pour redémarrer la synchronisation de la file d'attente à l'aide de la console web RabbitMQ**
**Note**
Pour ouvrir la console web RabbitMQ, reportez-vous aux instructions précédentes à l'étape 1 de ce didacticiel.
1. Dans la console web RabbitMQ, en haut de la page, choisissez **Queues (Fils d'attent)**.
1. Dans la page **Files d'attente (Queues)**, sous **All queues (Toutes les files d'attente)**, localisez votre file d'attente mise en pause. Dans la ligne **Politique**, votre file d'attente doit indiquer le nom de la nouvelle politique que vous avez créée (par exemple,`batch-size-policy`).
1. Pour redémarrer le processus de synchronisation avec une taille de lot réduite, annulez d'abord la synchronisation de la file d'attente. Redémarrez ensuite la synchronisation des files d'attente.
**Note**
Si la synchronisation s'interrompt et ne se termine pas correctement, essayez de réduire la valeur `ha-sync-batch-size` et de redémarrer la synchronisation de la file d'attente.
## Étapes suivantes
+ Une fois que votre file d'attente est correctement synchronisée, vous pouvez surveiller la quantité de mémoire utilisée par vos nœuds RabbitMQ en consultant la métrique Amazon. CloudWatch `RabbitMQMemUsed` Vous pouvez également afficher la métrique `RabbitMQMemLimit` pour surveiller la limite de mémoire d'un nœud. Pour plus d’informations, consultez [Accès aux CloudWatch métriques pour Amazon MQ](amazon-mq-accessing-metrics.md) et [CloudWatch Mesures disponibles pour Amazon MQ pour les courtiers RabbitMQ](rabbitmq-logging-monitoring.md).
+ Pour empêcher la synchronisation des files d'attente interrompues, nous vous recommandons de conserver les files d'attente courtes et de traiter les messages. Pour les applications ayant une taille de message plus grande, nous vous recommandons également de mettre à niveau votre type d'instance d'agent vers une taille d'instance plus grande avec plus de mémoire. Pour plus d'informations sur les types d'instances de courtier et sur la modification des préférences du courtier, consultez[Modification des préférences d'agent](amazon-mq-rabbitmq-editing-broker-preferences.md).
+ Lorsque vous créez un nouvel agent Amazon MQ for RabbitMQ, Amazon MQ applique un ensemble de politiques par défaut et de limites d'hôte virtuel pour optimiser les performances de l'agent. Si votre agent ne dispose pas des politiques et limites par défaut recommandées, nous vous recommandons de les créer vous-même. Pour plus d'informations sur la création de politiques par défaut et de limites de vhost, consultez [https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html](https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html).
## Ressources connexes
+ [UpdateBrokerInput](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-model-updatebrokerinput)— Utilisez cette propriété de courtier pour mettre à jour un type d'instance de courtier à l'aide de l'API Amazon MQ.
+ [Paramètres et politiques](https://www.rabbitmq.com/parameters.html) (Documentation du serveur RabbitMQ) – Pour en savoir plus sur les paramètres et les politiques RabbitMQ, consultez le site web RabbitMQ.
+ [API HTTP de gestion RabbitMQ](https://pulse.mozilla.org/api/) – En savoir plus sur l'API de gestion RabbitMQ.
# Réduction du nombre de connexions et de canaux
Les connexions à votre courtier RabbitMQ sur Amazon MQ peuvent être fermées soit par vos applications clientes, soit en les fermant manuellement à l'aide de la console Web RabbitMQ. Pour fermer une connexion à l'aide de la console Web RabbitMQ, procédez comme suit :
1. Connectez-vous à la console AWS Management Console Web RabbitMQ de votre courtier et ouvrez-la.
1. Sur la console RabbitMQ, choisissez l’onglet **Connexions**.
1. Dans la page de **Connexions**, sous **Toutes les connexions**, choisissez le nom de la connexion à fermer dans la liste.
1. Sur la page des informations de la connexion, choisissez **Fermez cette connexion** pour développer la section, choisissez **Forcer la fermeture**. Le cas échéant, vous pouvez remplacer le texte par défaut de **Raison** avec votre propre description. RabbitMQ sur Amazon MQ renverra la raison que vous avez spécifiée au client lorsque vous fermez la connexion.
1. Choisissez **OK** dans la boîte de dialogue pour confirmer et fermer la connexion.
Lorsque vous fermez une connexion, tous les canaux associés à une connexion fermée seront également fermés.
**Note**
Vos applications clientes peuvent être configurées pour rétablir automatiquement les connexions avec l’agent après leur fermeture. Dans ce cas, la fermeture des connexions à partir de la console Web Broker ne suffira pas à réduire le nombre de connexions ou de canaux.
Pour les agents sans accès public, vous pouvez bloquer temporairement les connexions en refusant le trafic entrant sur le port de protocole de message approprié, par exemple le port `5671` pour les connexions AMQP. Vous pouvez bloquer le port du groupe de sécurité que vous avez fourni à Amazon MQ lors de la création de l’agent. Pour de plus amples informations sur la modification d’un groupe de sécurité de VPC, veuillez consulter [Security Groups for Your VPC (Groupes de sécurité pour votre VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#adding-security-group-rules) dans le *Guide de l’utilisateur *.
## Étape 2 : Connectez une application basée sur JVM à votre courtier
Après avoir créé un agent RabbitMQ, vous pouvez y connecter votre application. Les exemples suivants montrent comment utiliser la [bibliothèque client Java RabbitMQ](https://www.rabbitmq.com/java-client.html) pour créer une connexion à votre agent, créer une file d'attente et envoyer un message. Vous pouvez vous connecter à des agents RabbitMQ à l'aide des bibliothèques client RabbitMQ prises en charge pour une variété de langages. Pour plus d'informations sur les bibliothèques clientes RabbitMQ prises en charge, voir Bibliothèques clientes [RabbitMQ](https://www.rabbitmq.com/devtools.html) et outils de développement.
### Conditions préalables
**Note**
Les étapes préalables suivantes ne s'appliquent qu'aux agents RabbitMQ créés sans accès public. Si vous créez un agent avec accès public, vous pouvez les ignorer.
#### Activer les attributs du VPC
Pour vous assurer que votre agent est accessible dans votre VPC, vous devez activer les attributs `enableDnsHostnames` et `enableDnsSupport` du VPC. Pour plus d'informations, consultez [Prise en charge du DNS dans votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) dans le *Guide de l'utilisateur Amazon VPC*.
#### Activer les connexions entrantes
1. Connectez-vous à la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. Dans la liste des courtiers, choisissez le nom de votre courtier (par exemple, **MyBroker**).
1. Sur la ***MyBroker***page, dans la section **Connexions**, notez les adresses et les ports de l'URL de la console Web du courtier et des protocoles au niveau du fil.
1. Dans la section **Details (Détails)**, sous **Security and network (Sécurité et réseau)**, choisissez le nom de votre groupe de sécurité ou ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).
La page **Groupes de sécurité** du tableau de bord EC2 est affichée.
1. Dans la liste des groupes de sécurité, choisissez votre groupe de sécurité.
1. Au bas de la page, choisissez **Entrant**, puis **Modifier**.
1. Dans la boîte de dialogue **Edit inbound rules (Modifier les règles entrantes)**, ajoutez une règle pour chaque URL ou point de terminaison pour qu'ils soient accessibles publiquement (l'exemple suivant montre comment procéder pour une console web d'agent).
1. Choisissez **Add Rule** (Ajouter une règle).
1. Pour **Type**, sélectionnez **Custom TCP (TCP personnalisé)**.
1. Pour **Source**, laissez l'option **Custom (Personnalisée)** sélectionnée, puis tapez l'adresse IP du système qui doit pouvoir accéder à la console web (par exemple, `192.0.2.1`).
1. Choisissez **Enregistrer**.
Votre agent peut désormais accepter les connexions entrantes.
#### Ajout de dépendances Java
Si vous utilisez Apache Maven pour automatiser les builds, ajoutez la dépendance suivante à votre fichier `pom.xml`. Pour plus d'informations sur les fichiers de modèle d'objet de projet dans Apache Maven, [voir Présentation du POM](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html).
```
com.rabbitmq
amqp-client
5.9.0
```
Si vous utilisez [Gradle](https://docs.gradle.org/current/userguide/userguide.html) pour automatiser les builds, déclarez la dépendance suivante.
```
dependencies {
compile 'com.rabbitmq:amqp-client:5.9.0'
}
```
#### Importer les classe `Connection` et `Channel`
Le client Java RabbitMQ utilise `com.rabbitmq.client` comme paquet de premier niveau, avec les classes d'API `Connection` et `Channel` représentant une connexion et un canal AMQP 0-9-1, respectivement. Importez les classe `Connection` et `Channel` avant de les utiliser, comme illustré dans l'exemple suivant.
```
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
```
#### Créer un `ConnectionFactory` et se connecter à votre agent
Utilisez l'exemple suivant pour créer une instance de la classe `ConnectionFactory` avec les paramètres donnés. Utilisation de la méthode `setHost` pour configurer le point de terminaison de l'agent noté précédemment. Pour les connexions au niveau filaire `AMQPS`, utilisez le port `5671`.
```
ConnectionFactory factory = new ConnectionFactory();
factory.setUsername(username);
factory.setPassword(password);
//Replace the URL with your information
factory.setHost("b-c8352341-ec91-4a78-ad9c-a43f23d325bb.mq.us-west-2.amazonaws.com");
factory.setPort(5671);
// Allows client to establish a connection over TLS
factory.useSslProtocol();
// Create a connection
Connection conn = factory.newConnection();
// Create a channel
Channel channel = conn.createChannel();
```
#### Publier un message dans un échange
Vous pouvez utiliser `Channel.basicPublish` pour publier des messages dans un échange. L'exemple suivant utilise la classe `Builder` AMQP pour créer un objet de propriétés de message avec le type de contenu `plain/text`.
```
byte[] messageBodyBytes = "Hello, world!".getBytes();
channel.basicPublish(exchangeName, routingKey,
new AMQP.BasicProperties.Builder()
.contentType("text/plain")
.userId("userId")
.build(),
messageBodyBytes);
```
**Note**
Notez que `BasicProperties` est une classe interne de la classe de support générée automatiquement, `AMQP`.
#### S'abonner à une file d'attente et recevoir un message
Vous pouvez recevoir un message en vous abonnant à une file d'attente à l'aide de l'interface `Consumer`. Une fois abonné, les messages seront alors remis automatiquement dès leur arrivée.
La façon la plus simple d'implémenter un objet `Consumer` est d'utiliser la sous-classe `DefaultConsumer`. Un objet `DefaultConsumer` peut être transmis comme faisant partie d'un appel `basicConsume` pour configurer l'abonnement comme illustré dans l'exemple suivant.
```
boolean autoAck = false;
channel.basicConsume(queueName, autoAck, "myConsumerTag",
new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException
{
String routingKey = envelope.getRoutingKey();
String contentType = properties.getContentType();
long deliveryTag = envelope.getDeliveryTag();
// (process the message components here ...)
channel.basicAck(deliveryTag, false);
}
});
```
**Note**
Parce que nous avons spécifié `autoAck = false`, il est nécessaire d'accuser réception des messages remis à `Consumer`, le plus commodément fait dans la méthode `handleDelivery`, comme illustré dans l'exemple.
#### Fermer votre connexion et se déconnecter de l'agent
Afin de vous déconnecter de votre agent RabbitMQ, fermez à la fois le canal et la connexion comme indiqué ci-dessous.
```
channel.close();
conn.close();
```
**Note**
Pour plus d'informations sur l'utilisation de la bibliothèque cliente Java RabbitMQ, consultez le Guide de l'API client Java [RabbitMQ](https://www.rabbitmq.com/api-guide.html).
## Étape 3 : (Facultatif) Se connecter à une AWS Lambda fonction
AWS Lambda peut se connecter à votre courtier Amazon MQ et en consommer les messages. Lorsque vous connectez un agent à Lambda, vous créez un [mappage de la source d'événement](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html) qui lit les messages d'une file d'attente et appelle la fonction [de manière synchrone](https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html). Le mappage de la source d'événements que vous créez lit les messages de votre agent par lots et les convertit en une charge utile Lambda sous la forme d'un objet JSON.
**Pour connecter votre agent à une fonction Lambda**
1. Ajoutez les autorisations de rôle IAM suivantes au [rôle d'exécution](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) de votre fonction Lambda.
+ [mq : DescribeBroker](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-http-methods)
+ [EC2 : CreateNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html)
+ [EC2 : DeleteNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteNetworkInterface.html)
+ [EC2 : DescribeNetworkInterfaces](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeNetworkInterfaces.html)
+ [EC2 : DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)
+ [EC2 : DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html)
+ [EC2 : DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html)
+ [journaux : CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html)
+ [journaux : CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html)
+ [journaux : PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)
+ [responsable des secrets : GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
**Note**
Sans les autorisations IAM nécessaires, votre fonction ne sera pas en mesure de lire correctement les enregistrements des ressources Amazon MQ.
1. (Facultatif) Si vous avez créé un agent sans accès public, vous devez effectuer l'une des opérations suivantes pour permettre à Lambda de se connecter à votre agent :
+ Configurez une passerelle NAT par sous-réseau public. Pour plus d'informations, consultez [Accès à Internet et aux services pour les fonctions connectées à un VPC](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-internet) dans le *Guide du développeur AWS Lambda *.
+ Créez une connexion entre votre Amazon Virtual Private Cloud (Amazon VPC) et Lambda à l'aide d'un point de terminaison VPC. Votre Amazon VPC doit également se connecter à AWS Security Token Service (AWS STS) et aux points de terminaison Secrets Manager. Pour plus d’informations, consultez [Configuration de points de terminaison de VPC d’interface pour Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) dans le *Guide du développeur AWS Lambda *.
1. [Configurez votre agent en tant que source d'événement](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping) pour une fonction Lambda à l'aide de la AWS Management Console. Vous pouvez également utiliser la [https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html) AWS Command Line Interface commande.
1. Écrivez du code pour votre fonction Lambda pour traiter les messages de votre consommateur à partir de votre agent. La charge utile Lambda récupérée par votre mappage de source d'événement dépend du type de moteur de l'agent. Voici un exemple de charge utile Lambda pour une file d'attente Amazon MQ for RabbitMQ.
**Note**
Dans l'exemple, `test` est le nom de la file d'attente et `/` est le nom de l'hôte virtuel par défaut. Lors de la réception de messages, la source d’événement répertorie les messages sous `test::/`.
```
{
"eventSource": "aws:rmq",
"eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8",
"rmqMessagesByQueue": {
"test::/": [
{
"basicProperties": {
"contentType": "text/plain",
"contentEncoding": null,
"headers": {
"header1": {
"bytes": [
118,
97,
108,
117,
101,
49
]
},
"header2": {
"bytes": [
118,
97,
108,
117,
101,
50
]
},
"numberInHeader": 10
}
"deliveryMode": 1,
"priority": 34,
"correlationId": null,
"replyTo": null,
"expiration": "60000",
"messageId": null,
"timestamp": "Jan 1, 1970, 12:33:41 AM",
"type": null,
"userId": "AIDACKCEVSQ6C2EXAMPLE",
"appId": null,
"clusterId": null,
"bodySize": 80
},
"redelivered": false,
"data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ=="
}
]
}
}
```
[https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html)
# Utilisation de l'authentification et de l'autorisation OAuth 2.0 pour Amazon MQ pour RabbitMQ
Ce didacticiel explique comment configurer l'[authentification OAuth 2.0](oauth-for-amq-for-rabbitmq.md) pour votre Amazon MQ pour les courtiers RabbitMQ utilisant Amazon Cognito comme fournisseur 2.0. OAuth
**Note**
Amazon Cognito n'est pas disponible en Chine (Pékin) et en Chine (Ningxia).
**Important**
Ce didacticiel est spécifique à Amazon Cognito, mais vous pouvez utiliser d'autres fournisseurs d'identité ()IdPs. Pour plus d'informations, consultez la section [Exemples d'authentification OAuth 2.0](https://www.rabbitmq.com/docs/oauth2-examples).
**Topics**
+ [Conditions préalables à la configuration de l'authentification OAuth 2.0](#oauth-tutorial-prerequisites)
+ [Configuration de l'authentification OAuth 2.0 avec Amazon Cognito à l'aide de AWS CLI](#oauth-tutorial-config-cognito-using-cli)
+ [Configuration de la OAuth version 2.0 et authentification simple avec Amazon Cognito](#oauth-tutorial-config-both-auth-methods-using-cli)
## Conditions préalables à la configuration de l'authentification OAuth 2.0
Vous pouvez définir les ressources Amazon Cognito requises dans ce didacticiel en déployant le plugin AWS CDK stack [Amazon Cognito pour OAuth RabbitMQ 2](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample). Si vous configurez Amazon Cognito manuellement, assurez-vous de remplir les conditions préalables suivantes avant de configurer la OAuth version 2.0 sur votre Amazon MQ pour les courtiers RabbitMQ :
**Conditions préalables à la configuration d'Amazon Cognito**
+ Configurez un point de terminaison Amazon Cognito en créant un groupe d'utilisateurs. Pour ce faire, consultez le blog intitulé [Comment utiliser la OAuth version 2.0 dans Amazon Cognito : découvrez les différentes subventions OAuth 2.0](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/).
+ Créez un serveur de ressources appelé `rabbitmq` dans le groupe d'utilisateurs avec les étendues suivantes définies :`read:all`, `write:all``configure:all`, et`tag:administrator`. Ces étendues seront associées aux autorisations RabbitMQ.
Pour plus d'informations sur la création d'un serveur de ressources, consultez la section [Définition d'un serveur de ressources pour votre groupe d'utilisateurs (AWS Management Console)](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-define-resource-servers.html#cognito-user-pools-define-resource-servers-console) dans le manuel *Amazon Cognito Developer Guide*.
+ Créez les clients d'application suivants :
+ Client d'application pour le groupe d'utilisateurs de ce type`Machine-to-Machine application`. Il s'agit d'un client confidentiel avec un secret client qui sera utilisé pour les clients RabbitMQ AMQP. Pour plus d'informations sur les clients d'applications et sur la création d'un [client d'application, consultez les sections Types de clients](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#user-pool-settings-client-app-client-types) d'applications et [Création d'un client d'application](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#cognito-user-pools-app-idp-settings-console-create).
+ Client d'application pour le groupe d'utilisateurs de ce type`Single-page application`. Il s'agit d'un client public qui sera utilisé pour connecter les utilisateurs à la console de gestion RabbitMQ. Vous devez mettre à jour ce client d'application pour inclure le point de terminaison du broker Amazon MQ pour RabbitMQ que vous allez créer dans la procédure suivante en tant qu'URL de rappel autorisée. Pour plus d'informations, consultez [Configuration de la connexion gérée avec la console Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-managed-login.html#set-up-managed-login).
**Prérequis pour configurer Amazon MQ**
+ Une installation [Docker](https://docs.docker.com/engine/install/) fonctionnelle pour exécuter un script bash qui vérifie si la configuration OAuth 2.0 est réussie ou non.
+ AWS CLI version >= `2.28.23` pour rendre facultatif l'ajout d'un nom d'utilisateur et d'un mot de passe lors de la création du broker.
## Configuration de l'authentification OAuth 2.0 avec Amazon Cognito à l'aide de AWS CLI
La procédure suivante explique comment configurer l'authentification OAuth 2.0 pour votre Amazon MQ pour les courtiers RabbitMQ utilisant Amazon Cognito comme IdP. Cette procédure permet AWS CLI de créer et de configurer les ressources nécessaires.
Dans la procédure suivante, assurez-vous de remplacer les valeurs d'espace réservé, telles que ConfigurationID et Revision*<2>*, ** par leurs valeurs réelles.
1. Créez une nouvelle configuration à l'aide de la AWS CLI commande [create-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/create-configuration.html) comme indiqué dans l'exemple suivant.
```
aws mq create-configuration \
--name "rabbitmq-oauth2-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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-oauth2-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-oauth2-config"
}
```
1. Créez un fichier de configuration appelé **rabbitmq.conf** pour utiliser la OAuth version 2.0 comme méthode d'authentification et d'autorisation, comme indiqué dans l'exemple suivant.
```
auth_backends.1 = oauth2
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool.
# If you used the AWS CDK stack to deploy Amazon Cognito, this is one of the stack outputs.
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
# Amazon Cognito does not include an audience field in access tokens
auth_oauth2.verify_aud = false
# Amazon Cognito does not allow * in its custom scopes. Use aliases to translate between Amazon Cognito and RabbitMQ.
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
# Allow OAuth 2.0 login for RabbitMQ management console
management.oauth_enabled = true
# FIXME: Update this value with the client ID of your public application client
management.oauth_client_id = ${RabbitMqOAuth2TestStack.ManagementConsoleAppClientId}
# FIXME: Update this value with the base JWKS URI (without /.well-known/jwks.json)
auth_oauth2.issuer = ${RabbitMqOAuth2TestStack.Issuer}
management.oauth_scopes = rabbitmq/tag:administrator
```
Cette configuration utilise des [alias d'étendue pour mapper les](https://www.rabbitmq.com/docs/oauth2#scope-translation) étendues définies dans Amazon Cognito à des étendues compatibles avec RabbitMQ.
1. Mettez à jour la configuration à l'aide de la AWS CLI commande [update-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/update-configuration.html), comme indiqué dans l'exemple suivant. Dans cette commande, ajoutez l'ID de configuration que vous avez reçu en réponse à l'étape 1 de cette procédure. Par exemple, **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca**.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-oauth2-config",
"Warnings": []
}
```
1. Créez un broker avec la configuration OAuth 2.0 que vous avez créée à l'étape 2 de cette procédure. Pour ce faire, utilisez la AWS CLI commande [create-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/create-broker.html) comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID de configuration et le numéro de révision que vous avez obtenus dans les réponses des étapes 1 et 2 respectivement. Par exemple : **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca** et **2**.
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-oauth2-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Vérifiez que le statut du courtier passe de à`RUNNING`, `CREATION_IN_PROGRESS` à l'aide de la AWS CLI commande [describe-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/describe-broker.html), comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID du courtier que vous avez obtenu dans le résultat de l'étape précédente. Par exemple,**b-2a1b5133-a10c-49d2-879b-8c176c34cf73**.
```
aws mq describe-broker \
--broker-id ""
```
Cette commande renvoie une réponse similaire à l'exemple suivant. La réponse suivante est une version abrégée de la sortie complète renvoyée par la `describe-broker` commande. Cette réponse indique le statut du courtier et la stratégie d'authentification utilisée pour sécuriser le courtier. Dans ce cas, la stratégie `config_managed` d'authentification indique que le courtier utilise OAuth 2 méthodes d'authentification.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
Pour vous connecter à la console de gestion RabbitMQ en utilisant OAuth2, le point de terminaison du courtier doit être ajouté en tant qu'URL de rappel valide dans le client d'application Amazon Cognito correspondant. Pour plus d'informations, reportez-vous à l'étape 5 de la configuration de notre exemple de stack [Amazon Cognito CDK](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample#step-5-update-callback-urls-if-using-placeholder-urls).
1. Vérifiez l'authentification et l'autorisation OAuth 2.0 à l'aide du `perf-test.sh` script suivant.
Utilisez ce script bash pour tester la connectivité à votre courtier Amazon MQ for RabbitMQ. Ce script obtient un jeton auprès d'Amazon Cognito et vérifie si la connexion a été correctement configurée. S'il est correctement configuré, vous verrez votre courtier publier et consommer des messages.
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 de votre courtier dans la console Amazon MQ.
Dans ce script, vous devez fournir les valeurs suivantes :
+ `CLIENT_ID`et `CLIENT_SECRET` : vous pouvez trouver ces valeurs sur la page des **clients de l'application** de la console Amazon Cognito.
+ Domaine Cognito : vous pouvez le trouver sur la console Amazon Cognito. Sous **Branding**, sélectionnez **Domain**. Sur la page **Domaine**, vous pouvez trouver cette valeur dans la section **Serveurs de ressources**.
+ Point de terminaison du courtier Amazon MQ : vous pouvez trouver cette valeur sous **Connexions** sur la page de détails du courtier de la console Amazon MQ.
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
CLIENT_ID=${RabbitMqOAuth2TestStack.AmqpAppClientId}
CLIENT_SECRET=${RabbitMqOAuth2TestStack.AmqpAppClientSecret}
# FIXME: Update this value with the domain of your Amazon Cognito user pool
RESPONSE=$(curl -X POST ${RabbitMqOAuth2TestStack.TokenEndpoint} \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=client_credentials&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}&scope=rabbitmq/configure:all rabbitmq/read:all rabbitmq/tag:administrator rabbitmq/write:all")
# Extract the access_token from the response.
# This token will be passed in the password field when connecting to the broker.
# Note that the username is left blank, the field is ignored by the plugin.
BROKER_PASSWORD=$(echo ${RESPONSE} | jq -r '.access_token')
# FIXME: Update this value with the endpoint of your broker. For example, b-89424106-7e0e-4abe-8e98-8de0dada7630.mq.us-east-1.on.aws.
BROKER_DNS=
CONNECTION_STRING=amqps://:${BROKER_PASSWORD}@${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
docker run -it --rm --ulimit nofile=40960:40960 pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--flag persistent --rate $PRODUCER_RATE
```
## Configuration de la OAuth version 2.0 et authentification simple avec Amazon Cognito
Lorsque vous créez un courtier avec une authentification OAuth 2.0, vous pouvez spécifier l'une des méthodes d'authentification suivantes :
+ **OAuth 2.0 uniquement** : pour utiliser cette méthode, ne fournissez pas de nom d'utilisateur ni de mot de passe lors de la création du courtier. La [procédure précédente](#oauth-tutorial-config-cognito-using-cli) montre comment utiliser uniquement la méthode d'authentification OAuth 2.0.
+ Authentification ** OAuth 2.0 et authentification simple** : pour utiliser cette méthode, fournissez un nom d'utilisateur et un mot de passe lors de la création du courtier. Ajoutez également `auth_backends.2 = internal` à la configuration de votre courtier, comme indiqué dans la procédure suivante.
Dans la procédure suivante, veillez à remplacer les valeurs d'espace réservé, telles que ** et**, par leurs valeurs réelles.
1. Pour utiliser les deux méthodes d'authentification, créez la configuration de votre courtier, comme indiqué dans l'exemple suivant.
```
auth_backends.1 = oauth2
auth_backends.2 = internal
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
auth_oauth2.verify_aud = false
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
```
Cette configuration utilise des [alias d'étendue pour mapper les](https://www.rabbitmq.com/docs/oauth2#scope-translation) étendues définies dans Amazon Cognito à des étendues compatibles avec RabbitMQ.
1. Créez un courtier qui utilise les deux méthodes d'authentification, comme illustré dans l'exemple suivant.
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker-with-internal-user" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": }' \
--users '[{"Username":"","Password":""}]'
```
1. Vérifiez que l'état du courtier et que la configuration de la méthode d'authentification a été correctement configurée, comme décrit aux étapes 5 et 6 de la [Configuration de l'authentification OAuth 2.0 avec Amazon Cognito](#oauth-tutorial-config-cognito-using-cli) procédure.
# Utilisation de l'authentification et de l'autorisation IAM pour Amazon MQ pour RabbitMQ
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
+ 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
1. **Définir les variables d'environnement**
Définissez les variables d'environnement requises pour votre courtier :
```
export AWS_DEFAULT_REGION=
export 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://.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=.mq..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=
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.
# Utilisation de l'authentification et de l'autorisation LDAP pour Amazon MQ pour RabbitMQ
Ce didacticiel explique comment configurer l'authentification et l'autorisation LDAP pour votre Amazon MQ pour les courtiers RabbitMQ à l'aide de. AWS Managed Microsoft AD
**Topics**
+ [Conditions préalables pour configurer l'authentification et l'autorisation LDAP](#rabbitmq-ldap-tutorial-prerequisites)
+ [Configuration de LDAP dans RabbitMQ à l'aide de la CLI AWS](#rabbitmq-ldap-tutorial-configure-cli)
## Conditions préalables pour configurer l'authentification et l'autorisation LDAP
Vous pouvez configurer les AWS ressources requises dans ce didacticiel en déployant la [pile AWS CDK pour Amazon MQ pour l'intégration LDAP de RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-ldap-activedirectory-sample/) avec. AWS Managed Microsoft AD
Cette pile CDK crée automatiquement toutes les AWS ressources nécessaires AWS Managed Microsoft AD, notamment les utilisateurs et groupes LDAP, Network Load Balancer, les certificats et les rôles IAM. Consultez le package README pour une liste complète des ressources créées par la pile.
Si vous configurez les ressources manuellement au lieu d'utiliser la pile CDK, assurez-vous de disposer de l'infrastructure équivalente avant de configurer LDAP sur votre Amazon MQ pour les courtiers RabbitMQ.
### Prérequis pour configurer Amazon MQ
AWS Version CLI >= 2.28.23 pour rendre l'ajout d'un nom d'utilisateur et d'un mot de passe facultatif lors de la création du broker.
## Configuration de LDAP dans RabbitMQ à l'aide de la CLI AWS
Cette procédure utilise la AWS CLI pour créer et configurer les ressources nécessaires. Dans la procédure suivante, assurez-vous de remplacer les valeurs d'espace réservé, telles que ConfigurationID et Revision`<2>`, `` par leurs valeurs réelles.
1. Créez une nouvelle configuration à l'aide de la commande `create-configuration` AWS CLI comme indiqué dans l'exemple suivant.
```
aws mq create-configuration \
--name "rabbitmq-ldap-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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-ldap-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-ldap-config"
}
```
1. Créez un fichier de configuration appelé `rabbitmq.conf` pour utiliser LDAP comme méthode d'authentification et d'autorisation, comme indiqué dans l'exemple suivant. Remplacez toutes les valeurs d'espace réservé du modèle (marquées d'un`${RabbitMqLdapTestStack.*}`) par des valeurs réelles provenant de vos sorties de pile AWS CDK prérequises déployées ou d'une infrastructure équivalente.
```
auth_backends.1 = ldap
# LDAP authentication settings - For more information,
# see https://www.rabbitmq.com/docs/ldap#basic
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_ldap.servers.1 = ${RabbitMqLdapTestStack.NlbDnsName}
auth_ldap.dn_lookup_bind.user_dn = ${RabbitMqLdapTestStack.DnLookupUserDn}
auth_ldap.dn_lookup_base = ${RabbitMqLdapTestStack.DnLookupBase}
auth_ldap.dn_lookup_attribute = ${RabbitMqLdapTestStack.DnLookupAttribute}
auth_ldap.port = 636
auth_ldap.use_ssl = true
auth_ldap.ssl_options.verify = verify_peer
auth_ldap.log = network
# AWS integration for secure credential retrieval
# - see: https://github.com/amazon-mq/rabbitmq-aws
# The aws plugin allows RabbitMQ to securely retrieve credentials and certificates
# from AWS services.
# Replace the ${RabbitMqLdapTestStack.*} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.auth_ldap.ssl_options.cacertfile = ${RabbitMqLdapTestStack.CaCertArn}
aws.arns.auth_ldap.dn_lookup_bind.password = ${RabbitMqLdapTestStack.DnLookupUserPasswordArn}
aws.arns.assume_role_arn = ${RabbitMqLdapTestStack.AmazonMqAssumeRoleArn}
# LDAP authorization queries - For more information,
# see: https://www.rabbitmq.com/docs/ldap#authorisation
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual group DN
# values from your deployed prerequisite CDK stack outputs
# Uses Active Directory groups created by the prerequisite CDK stack
auth_ldap.queries.tags = '''
[{administrator, {in_group, "${RabbitMqLdapTestStack.RabbitMqAdministratorsGroupDn}"}},
{management, {in_group, "${RabbitMqLdapTestStack.RabbitMqMonitoringUsersGroupDn}"}}]
'''
# FIXME: This provides all authenticated users access to all vhosts
# - update to restrict access as required
auth_ldap.queries.vhost_access = '''
{constant, true}
'''
# FIXME: This provides all authenticated users full access to all
# queues and exchanges - update to restrict access as required
auth_ldap.queries.resource_access = '''
{for, [ {permission, configure, {constant, true}},
{permission, write,
{for, [{resource, queue, {constant, true}},
{resource, exchange, {constant, true}}]}},
{permission, read,
{for, [{resource, exchange, {constant, true}},
{resource, queue, {constant, true}}]}}
]
}
'''
# FIXME: This provides all authenticated users access to all topics
# - update to restrict access as required
auth_ldap.queries.topic_access = '''
{for, [{permission, write, {constant, true}},
{permission, read, {constant, true}}
]
}
'''
```
1. Mettez à jour la configuration à l'aide de la commande `update-configuration` AWS CLI comme indiqué dans l'exemple suivant. Dans cette commande, ajoutez l'ID de configuration que vous avez reçu en réponse à l'étape 1 de cette procédure. Par exemple, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-ldap-config",
"Warnings": []
}
```
1. Créez un courtier avec la configuration LDAP que vous avez créée à l'étape 2 de cette procédure. Pour ce faire, utilisez la commande `create-broker` AWS CLI comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID de configuration et le numéro de révision que vous avez obtenus dans les réponses des étapes 1 et 2 respectivement. Par exemple : `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` et `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-ldap-test-1" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}'
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ldap-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
**Restriction de dénomination des courtiers**
Le rôle IAM créé par la pile CDK requise limite d'emblée les noms des courtiers. `rabbitmq-ldap-test` Assurez-vous que le nom de votre courtier suit ce modèle, sinon le rôle IAM ne sera pas autorisé à assumer le rôle de résolution des ARN.
1. Vérifiez que le statut du broker passe de à`RUNNING`, `CREATION_IN_PROGRESS` à l'aide de la commande `describe-broker` AWS CLI, comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID du courtier que vous avez obtenu dans le résultat de l'étape précédente. Par exemple,`b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Cette commande renvoie une réponse similaire à l'exemple suivant. La réponse suivante est une version abrégée de la sortie complète renvoyée par la `describe-broker` commande. Cette réponse indique le statut du courtier et la stratégie d'authentification utilisée pour sécuriser le courtier. Dans ce cas, la stratégie `config_managed` d'authentification indique que le courtier utilise la méthode d'authentification LDAP.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Validez l'accès à RabbitMQ en utilisant l'un des utilisateurs de test créés par la pile CDK requise
```
# FIXME: Replace ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a user (should fail - console user only has monitoring permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/users/testuser \
-H "Content-Type: application/json" \
-d '{"password":"testpass","tags":"management"}'
```
# Utilisation de l'authentification et de l'autorisation HTTP pour Amazon MQ pour RabbitMQ
Ce didacticiel explique comment configurer l'authentification et l'autorisation HTTP pour votre Amazon MQ pour les courtiers RabbitMQ à l'aide d'un serveur HTTP externe.
**Note**
Le plug-in d'authentification HTTP est uniquement disponible pour Amazon MQ pour RabbitMQ version 4 et supérieure.
**Topics**
+ [Conditions préalables à la configuration de l'authentification et de l'autorisation HTTP](#rabbitmq-http-tutorial-prerequisites)
+ [Configuration de l'authentification HTTP dans RabbitMQ à l'aide de la CLI AWS](#rabbitmq-http-tutorial-configure-cli)
## Conditions préalables à la configuration de l'authentification et de l'autorisation HTTP
Vous pouvez configurer les AWS ressources requises dans ce didacticiel en déployant la [pile AWS CDK pour Amazon MQ pour l'intégration de l'authentification HTTP RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-http-sample/).
Cette pile CDK crée automatiquement toutes les AWS ressources nécessaires, y compris le serveur d'authentification HTTP, les certificats et les rôles IAM. Consultez le package README pour une liste complète des ressources créées par la pile.
Si vous configurez les ressources manuellement au lieu d'utiliser la pile CDK, assurez-vous de disposer de l'infrastructure équivalente avant de configurer l'authentification HTTP sur votre Amazon MQ pour les courtiers RabbitMQ.
### Prérequis pour configurer Amazon MQ
AWS Version CLI >= 2.28.23 pour rendre l'ajout d'un nom d'utilisateur et d'un mot de passe facultatif lors de la création du broker.
## Configuration de l'authentification HTTP dans RabbitMQ à l'aide de la CLI AWS
Cette procédure utilise la AWS CLI pour créer et configurer les ressources nécessaires. Dans la procédure suivante, assurez-vous de remplacer les valeurs de l'espace réservé par leurs valeurs réelles.
1. Créez une nouvelle configuration à l'aide de la commande `create-configuration` AWS CLI, comme indiqué dans l'exemple suivant.
```
aws mq create-configuration \
--name "rabbitmq-http-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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-http-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-http-config"
}
```
1. Créez un fichier de configuration appelé `rabbitmq.conf` pour utiliser le protocole HTTP comme méthode d'authentification et d'autorisation, comme indiqué dans l'exemple suivant. Remplacez toutes les valeurs d'espace réservé du modèle (marquées d'un`${...}`) par des valeurs réelles provenant de vos sorties de pile AWS CDK prérequises déployées ou d'une infrastructure équivalente.
```
auth_backends.1 = cache
auth_backends.2 = http
auth_cache.cached_backend = http
# HTTP authentication settings
# For more information, see https://github.com/rabbitmq/rabbitmq-auth-backend-http
# FIXME: Replace the ${...} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_http.http_method = post
auth_http.user_path = ${HttpServerUserPath}
auth_http.vhost_path = ${HttpServerVhostPath}
auth_http.resource_path = ${HttpServerResourcePath}
auth_http.topic_path = ${HttpServerTopicPath}
# TLS/HTTPS configuration
auth_http.ssl_options.verify = verify_peer
auth_http.ssl_options.sni = test.amazonaws.com
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.auth_http.ssl_options.cacertfile = ${CaCertArn}
```
1. Mettez à jour la configuration à l'aide de la commande `update-configuration` AWS CLI. Utilisez l'ID de configuration indiqué à l'étape 3.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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-http-config",
"Warnings": []
}
```
1. Créez un broker avec la configuration HTTP. Utilisez l'ID de configuration et le numéro de révision indiqués lors des étapes précédentes.
```
aws mq create-broker \
--broker-name "rabbitmq-http-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": "","Revision": <2>}'
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-http-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Vérifiez que le statut du broker passe de à`RUNNING`, `CREATION_IN_PROGRESS` à l'aide de la commande `describe-broker` AWS CLI.
```
aws mq describe-broker \
--broker-id ""
```
Cette commande renvoie une réponse similaire à l'exemple suivant. La stratégie `config_managed` d'authentification indique que le courtier utilise la méthode d'authentification HTTP.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Validez l'accès à RabbitMQ en utilisant l'un des utilisateurs de test créés par la pile CDK requise
```
# FIXME: Replace ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a vhost (should fail - console user only has management permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/vhosts/test-vhost \
-H "Content-Type: application/json" \
-d '{}'
```
# Utilisation de l'authentification par certificat SSL pour Amazon MQ pour RabbitMQ
Ce didacticiel explique comment configurer l'authentification par certificat SSL pour votre Amazon MQ pour les courtiers RabbitMQ à l'aide d'une autorité de certification privée.
**Note**
Le plug-in d'authentification par certificat SSL est uniquement disponible pour Amazon MQ pour RabbitMQ version 4 et supérieure.
**Topics**
+ [Conditions préalables à la configuration de l'authentification par certificat SSL](#rabbitmq-ssl-tutorial-prerequisites)
+ [Configuration de l'authentification par certificat SSL dans RabbitMQ à l'aide de la CLI AWS](#rabbitmq-ssl-tutorial-configure-cli)
## Conditions préalables à la configuration de l'authentification par certificat SSL
L'authentification par certificat SSL utilise le protocole TLS mutuel (mTLS) pour authentifier les clients à l'aide de certificats X.509. Vous pouvez configurer les AWS ressources requises dans ce didacticiel en déployant la [pile AWS CDK pour Amazon MQ pour l'intégration mTLS de RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/).
Cette pile CDK crée automatiquement toutes les AWS ressources nécessaires, y compris l'autorité de certification, les certificats clients et les rôles IAM. Consultez le package README pour une liste complète des ressources créées par la pile.
**Note**
Avant de déployer la pile CDK, définissez la variable d'`RABBITMQ_TEST_USER_NAME`environnement. Cette valeur sera utilisée comme nom commun (CN) dans le certificat client et doit correspondre au nom d'utilisateur que vous utilisez dans les étapes du didacticiel. Par exemple : `export RABBITMQ_TEST_USER_NAME="myuser"`
Si vous configurez les ressources manuellement au lieu d'utiliser la pile CDK, assurez-vous de disposer de l'infrastructure équivalente avant de configurer l'authentification par certificat SSL sur votre Amazon MQ pour les courtiers RabbitMQ.
### Prérequis pour configurer Amazon MQ
AWS Version CLI >= 2.28.23 pour rendre l'ajout d'un nom d'utilisateur et d'un mot de passe facultatif lors de la création du broker.
## Configuration de l'authentification par certificat SSL dans RabbitMQ à l'aide de la CLI AWS
Cette procédure utilise la AWS CLI pour créer et configurer les ressources nécessaires. Dans la procédure suivante, assurez-vous de remplacer les valeurs d'espace réservé, telles que ConfigurationID et Revision`<2>`, `` par leurs valeurs réelles.
1. Créez une nouvelle configuration à l'aide de la commande `create-configuration` AWS CLI, comme indiqué dans l'exemple suivant.
```
aws mq create-configuration \
--name "rabbitmq-ssl-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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-ssl-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-ssl-config"
}
```
1. Créez un fichier de configuration appelé `rabbitmq.conf` pour utiliser l'authentification par certificat SSL, comme indiqué dans l'exemple suivant. Remplacez toutes les valeurs d'espace réservé du modèle (marquées d'un`${...}`) par des valeurs réelles provenant de vos sorties de pile AWS CDK prérequises déployées ou d'une infrastructure équivalente.
```
auth_mechanisms.1 = EXTERNAL
ssl_cert_login_from = common_name
auth_backends.1 = internal
# Reject if no client cert
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
# 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}
```
1. Mettez à jour la configuration à l'aide de la commande `update-configuration` AWS CLI comme indiqué dans l'exemple suivant. Dans cette commande, ajoutez l'ID de configuration que vous avez reçu en réponse à l'étape 1 de cette procédure. Par exemple, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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-ssl-config",
"Warnings": []
}
```
1. Créez un courtier avec la configuration d'authentification par certificat SSL que vous avez créée à l'étape 2 de cette procédure. Pour ce faire, utilisez la commande `create-broker` AWS CLI comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID de configuration et le numéro de révision que vous avez obtenus dans les réponses des étapes 1 et 2 respectivement. Par exemple : `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` et `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-ssl-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": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ssl-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Vérifiez que le statut du broker passe de à`RUNNING`, `CREATION_IN_PROGRESS` à l'aide de la commande `describe-broker` AWS CLI, comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID du courtier que vous avez obtenu dans le résultat de l'étape précédente. Par exemple, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Cette commande renvoie une réponse similaire à l'exemple suivant. La réponse suivante est une version abrégée de la sortie complète renvoyée par la `describe-broker` commande. Cette réponse indique le statut du courtier et la stratégie d'authentification utilisée pour sécuriser le courtier. Dans ce cas, la stratégie `config_managed` d'authentification indique que le courtier utilise la méthode d'authentification par certificat SSL.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Vérifiez l'authentification du certificat SSL à l'aide du `ssl.sh` script suivant.
Utilisez ce script bash pour tester la connectivité à votre courtier Amazon MQ for RabbitMQ. Ce script utilise votre certificat client pour l'authentification et vérifie si la connexion a été correctement configurée. S'il est correctement configuré, vous verrez votre courtier publier et consommer des messages.
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 de votre courtier dans la console Amazon MQ.
Dans ce script, vous devez fournir les valeurs suivantes :
+ `USERNAME`: le nom commun (CN) de votre certificat client.
+ `CLIENT_KEYSTORE`: chemin d'accès au fichier keystore de votre client (PKCS12 format). Si vous avez utilisé la pile CDK requise, le chemin par défaut est`$(pwd)/certs/client-keystore.p12`.
+ `KEYSTORE_PASSWORD`: mot de passe pour le keystore de votre client. Si vous avez utilisé la pile CDK requise, le mot de passe par défaut est`changeit`.
+ `BROKER_DNS`: vous pouvez trouver cette valeur sous **Connexions** sur la page des informations du courtier de la 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=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
BROKER_DNS=
CONNECTION_STRING=amqps://${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} \
--sasl-external \
--use-default-ssl-context \
--flag persistent --rate $PRODUCER_RATE
```
# Utilisation de MTL pour l'AMQP et les points de terminaison de gestion
Ce didacticiel explique comment configurer le protocole TLS mutuel (MTL) pour les connexions client AMQP et l'interface de gestion RabbitMQ à l'aide d'une autorité de certification privée.
**Note**
L'utilisation d'autorités de certification privées pour les MTL n'est disponible que pour Amazon MQ pour RabbitMQ version 4 et supérieure.
**Topics**
+ [Conditions préalables à la configuration des mTLs](#rabbitmq-mtls-tutorial-prerequisites)
+ [Configuration de MTL dans RabbitMQ à l'aide de la CLI AWS](#rabbitmq-mtls-tutorial-configure-cli)
## Conditions préalables à la configuration des mTLs
Vous pouvez configurer les AWS ressources requises dans ce didacticiel en déployant la [pile AWS CDK pour Amazon MQ pour l'intégration de mTLS avec RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/).
Cette pile CDK crée automatiquement toutes les AWS ressources nécessaires, y compris l'autorité de certification, les certificats clients et les rôles IAM. Consultez le package README pour une liste complète des ressources créées par la pile.
Si vous configurez les ressources manuellement au lieu d'utiliser la pile CDK, assurez-vous de disposer de l'infrastructure équivalente avant de configurer les MTL sur votre Amazon MQ pour les courtiers RabbitMQ.
### Prérequis pour configurer Amazon MQ
AWS Version CLI >= 2.28.23 pour rendre l'ajout d'un nom d'utilisateur et d'un mot de passe facultatif lors de la création du broker.
## Configuration de MTL dans RabbitMQ à l'aide de la CLI AWS
Cette procédure utilise la AWS CLI pour créer et configurer les ressources nécessaires. Dans la procédure suivante, assurez-vous de remplacer les valeurs d'espace réservé, telles que ConfigurationID et Revision`<2>`, `` par leurs valeurs réelles.
1. Créez une nouvelle configuration à l'aide de la commande `create-configuration` AWS CLI comme indiqué dans l'exemple suivant.
```
aws mq create-configuration \
--name "rabbitmq-mtls-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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. Créez un fichier de configuration appelé `rabbitmq.conf` pour configurer les MTL pour l'AMQP et les points de terminaison de gestion, comme indiqué dans l'exemple suivant. Remplacez toutes les valeurs d'espace réservé du modèle (marquées d'un`${...}`) par des valeurs réelles provenant de vos sorties de pile AWS CDK prérequises déployées ou d'une infrastructure équivalente.
```
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. Mettez à jour la configuration à l'aide de la commande `update-configuration` AWS CLI comme indiqué dans l'exemple suivant. Dans cette commande, ajoutez l'ID de configuration que vous avez reçu en réponse à l'étape 1 de cette procédure. Par exemple, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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. Créez un broker avec la configuration mTLS que vous avez créée à l'étape 2 de cette procédure. Pour ce faire, utilisez la commande `create-broker` AWS CLI comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID de configuration et le numéro de révision que vous avez obtenus dans les réponses des étapes 1 et 2 respectivement. Par exemple : `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` et `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": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
Cette commande renvoie une réponse similaire à l'exemple suivant.
```
{
"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. Vérifiez que le statut du broker passe de à`RUNNING`, `CREATION_IN_PROGRESS` à l'aide de la commande `describe-broker` AWS CLI, comme indiqué dans l'exemple suivant. Dans cette commande, indiquez l'ID du courtier que vous avez obtenu dans le résultat de l'étape précédente. Par exemple, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Cette commande renvoie une réponse similaire à l'exemple suivant. La réponse suivante est une version abrégée de la sortie complète renvoyée par la `describe-broker` commande.
```
{
"AuthenticationStrategy": "simple",
...,
"BrokerState": "RUNNING",
...
}
```
1. Vérifiez l'authentification mTLS à l'aide du `mtls.sh` script suivant.
Utilisez ce script bash pour tester la connectivité à votre courtier Amazon MQ for RabbitMQ. Ce script utilise votre certificat client pour authentifier et vérifier si la connexion a été correctement configurée. S'il est correctement configuré, vous verrez votre courtier publier et consommer des messages.
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 de votre courtier dans la console Amazon MQ.
Dans ce script, vous devez fournir les valeurs suivantes :
+ `USERNAME`et `PASSWORD` : les informations d'identification utilisateur RabbitMQ que vous avez créées avec le courtier.
+ `CLIENT_KEYSTORE`: chemin d'accès au fichier keystore de votre client (PKCS12 format). Si vous avez utilisé la pile CDK requise, le chemin par défaut est`$(pwd)/certs/client-keystore.p12`.
+ `KEYSTORE_PASSWORD`: mot de passe pour le keystore de votre client. Si vous avez utilisé la pile CDK requise, le mot de passe par défaut est`changeit`.
+ `BROKER_DNS`: vous pouvez trouver cette valeur sous **Connexions** sur la page des informations du courtier de la 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=
PASSWORD=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
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
```
# Connexion de votre application JMS
Ce didacticiel explique comment connecter votre application JMS au courtier Amazon MQ pour RabbitMQ à l'aide du client JMS RabbitMQ. Vous apprendrez à créer un producteur pour envoyer des messages et un consommateur pour recevoir des messages depuis les files d'attente de RabbitMQ.
Avant de commencer, ajoutez la dépendance RabbitMQ JMS appropriée à votre projet Maven :
Pour JMS 1.1 et 2.0 :
```
com.rabbitmq.jms
rabbitmq-jms
2.12.0
```
Pour JMS 3.1 :
```
com.rabbitmq.jms
rabbitmq-jms
3.5.0
```
## Création d'un producteur
L'exemple de code suivant montre comment écrire dans une file d'attente RabbitMQ à l'aide de JMS :
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
connection = factory.createConnection();
connection.start();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination(queueName, true, false);
// Send the message to the queue
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
String msg_content = "Hello World!!";
TextMessage textMessage = session.createTextMessage(msg_content);
producer.send(textMessage);
System.out.printf("Published to AMQP queue '%s': %s", queueName, msg_content);
```
## Créez un consommateur
L'exemple de code suivant montre comment lire à partir d'une file d'attente RabbitMQ à l'aide de JMS :
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
// Establish the connection and session
jakarta.jms.Connection connection = factory.createConnection();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination();
destination.setDestinationName(queueName);
destination.setAmqp(true);
destination.setAmqpQueueName(queueName);
// Initialize consumer
MessageConsumer consumer = session.createConsumer(destination);
consumer.setMessageListener(message -> {
try {
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
System.out.printf("Message: %s%n", textMessage.getText());
} else if (message instanceof BytesMessage) {
BytesMessage bytesMessage = (BytesMessage) message;
byte[] bytes = new byte[(int) bytesMessage.getBodyLength()];
bytesMessage.readBytes(bytes);
String content = new String(bytes);
System.out.printf("Message: %s%n", content);
} else {
System.out.printf("Message: [%s]%n", message.getClass().getSimpleName());
}
} catch (JMSException e) {
System.err.printf("Error processing message: %s%n", e.getMessage());
}
});
connection.start();
```