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](https://www.rabbitmq.com/download.html).

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:
   ```sh
   pip install pika
   ```

### Micro-service 1: Producteur (Producer)

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

```python
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:

```python
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:
   ```sh
   python consumer_service.py
   ```

3. **Exécuter le producteur**: Ouvrez un autre terminal et exécutez le producteur:
   ```sh
   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.