You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
107 lines
3.8 KiB
Markdown
107 lines
3.8 KiB
Markdown
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.
|