LeMansMaalsi2025/rabbit/message_queue.md

Pour créer deux micro-services Python qui communiquent via un bus de messages (message broker) comme RabbitMQ, nous allons structurer les services de manière à ce qu'ils ne communiquent pas directement entre eux, mais plutôt via des files d'attente RabbitMQ.

Prérequis

1. Installer RabbitMQ: Assurez-vous que RabbitMQ est installé et en cours d'exécution sur votre machine. Vous pouvez télécharger RabbitMQ depuis le site officiel.

2. Installer les bibliothèques Python nécessaires: Vous aurez besoin de la bibliothèque pika pour interagir avec RabbitMQ. Vous pouvez l'installer via pip:

   pip install pika
   

Micro-service 1: Producteur (Producer)

Créez un fichier nommé producer_service.py avec le contenu suivant:

import pika
import json

def send_message(message):
    # Connexion à RabbitMQ
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()

    # Déclaration de la file d'attente
    channel.queue_declare(queue='task_queue', durable=True)

    # Envoi du message
    channel.basic_publish(
        exchange='',
        routing_key='task_queue',
        body=json.dumps(message),
        properties=pika.BasicProperties(
            delivery_mode=2,  # make message persistent
        ))
    print(f" [x] Sent {message}")

    # Fermeture de la connexion
    connection.close()

if __name__ == '__main__':
    for i in range(10):
        message = {"task_id": i, "data": f"Task data {i}"}
        send_message(message)

Micro-service 2: Consommateur (Consumer)

Créez un fichier nommé consumer_service.py avec le contenu suivant:

import pika
import json

def callback(ch, method, properties, body):
    message = json.loads(body)
    print(f" [x] Received {message}")
    # Traitement du message
    process_message(message)
    print(f" [x] Done processing {message}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

def process_message(message):
    # Simuler le traitement du message
    print(f"Processing message: {message}")

def main():
    # Connexion à RabbitMQ
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()

    # Déclaration de la file d'attente
    channel.queue_declare(queue='task_queue', durable=True)

    # Configuration du consommateur
    channel.basic_qos(prefetch_count=1)
    channel.basic_consume(queue='task_queue', on_message_callback=callback)

    print(' [*] Waiting for messages. To exit press CTRL+C')
    channel.start_consuming()

if __name__ == '__main__':
    main()

Exécution

1. Démarrer RabbitMQ: Assurez-vous que le serveur RabbitMQ est en cours d'exécution.

2. Exécuter le consommateur: Ouvrez un terminal et exécutez le consommateur:

   python consumer_service.py
   

3. Exécuter le producteur: Ouvrez un autre terminal et exécutez le producteur:

   python producer_service.py
   

Explication

• Producer Service: Le producteur se connecte à RabbitMQ, déclare une file d'attente nommée task_queue, et envoie 10 messages à cette file d'attente. Chaque message est un dictionnaire JSON contenant un identifiant de tâche et des données de tâche.

• Consumer Service: Le consommateur se connecte à RabbitMQ, déclare la même file d'attente task_queue, et commence à consommer les messages de cette file d'attente. Chaque message reçu est traité par la fonction process_message, et un accusé de réception est envoyé à RabbitMQ pour confirmer que le message a été traité.

Ces deux micro-services communiquent via RabbitMQ, ce qui permet une communication asynchrone et fiable entre eux sans qu'ils aient besoin de se connaître directement.