Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Utilisation de 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.