🐇 RabbitMQ – Architecture, Opérations & Bonnes Pratiques

Bindings & clés

• Plusieurs bindings d'une queue = duplication contrôlée (mêmes msg dans plusieurs queues).
• Headers passent par les propriétés du message (table AMQP), utiles pour routage hors clé.
• Alternate‑exchange pour capter les messages non routés (dead‑letter fonctionnelle).

arguments = { 'alternate-exchange': 'ae.unrouted' }
        

Topologies fréquentes

[Work queues]
producer -> exchange(direct) -> queueA, queueB (round‑robin par channel, via acks/prefetch)

[Pub/Sub]
producer -> exchange(fanout) -> queue_mail, queue_sms, queue_push

[Topic routing]
producer -> exchange(topic 'events.*') -> queue_app1(events.#), queue_ops(#.error)
        

docker‑compose.yml

version: '3.8'
services:
  rabbit:
    image: rabbitmq:3.13-management
    ports: ["5672:5672", "15672:15672"]
    environment:
      RABBITMQ_DEFAULT_USER: ideolab
      RABBITMQ_DEFAULT_PASS: change_me
    volumes:
      - rabbit-data:/var/lib/rabbitmq
volumes:
  rabbit-data:
        

Cluster 3 nœuds (hostname r1,r2,r3)

# Sur chaque nœud
sudo rabbitmqctl stop_app
sudo rabbitmqctl reset
# Sur r2 et r3 joindre r1
sudo rabbitmqctl join_cluster rabbit@r1
sudo rabbitmqctl start_app

# Politique HA pour Quorum par défaut
rabbitmqctl set_policy ha-q "^q\." '{"queue-type":"quorum"}' --apply-to queues
        

• rabbitmq_management : UI + API HTTP.
• rabbitmq_prometheus : export des métriques.
• rabbitmq_federation / _management : liaisons inter‑sites.
• rabbitmq_shovel : copie/relai de messages entre brokers.
• rabbitmq_stream : modèle streaming (3.13+).

• Durable queue : survit au redémarrage du broker.
• Persistent message : delivery_mode=2 (sauvé sur disque).
• La persistance n'est pas un flush instantané : nécessite publisher‑confirm côté producteur.

# Python (pika)
props = pika.BasicProperties(delivery_mode=2)  # persistent
channel.basic_publish(exchange='events', routing_key='user.created', body=payload, properties=props)
        

Politique de rétention

# TTL par message et DLX
args = {
  'x-message-ttl': 300000,         # 5 min
  'x-dead-letter-exchange': 'dlx',
  'x-dead-letter-routing-key': 'retry'
}
channel.queue_declare('orders.q', durable=True, arguments=args)
        

# Limite de longueur
{'x-max-length': 100000, 'x-overflow': 'reject-publish' }
        

• prefetch=1 : distribution équitable (évite qu'un consumer lent sature).
• prefetch global vs par‑channel : par‑consumer recommandé.

channel.basic_qos(prefetch_count=8)  # batch 8 messages/conso
        

Côté producteur, garantit la persistance côté broker.

channel.confirm_delivery()
channel.basic_publish(...)
# lève une exception si le broker n'a pas ack le publish
        

exchange fanout 'broadcast' -> queue_mail, queue_sms, queue_push

RPC = reply_to + correlation_id
client publishes (reply_to=temp-queue)
server replies to reply_to with same correlation_id
        

# Retry avec délais exponentiels (x-dead-letter-exchange)
try_queue -> DLX-> retry_5s -> DLX-> retry_30s -> DLX-> parking

# Exemple (non recommandé large prod)
rabbitmqctl set_policy mirror-all ".*" '{"ha-mode":"all"}' --apply-to queues
        

• Activer peer discovery (K8s/Consul) pour l'auto‑cluster.
• Surveiller latence inter‑nœuds (< 10ms conseillé).
• En cas de partition, configurer la politique de résolution (pause_minority, autoheal).

rabbitmqctl list_queues name messages consumers state
rabbitmq-diagnostics observer  # vue Erlang
rabbitmq-diagnostics check_port_connectivity
        

# Appliquer un TTL par défaut sur *.retry
rabbitmqctl set_policy retry-ttl "^.*\.retry$" '{"message-ttl":30000}' --apply-to queues
        

rabbitmqctl add_vhost prod
rabbitmqctl add_user api secret
rabbitmqctl set_permissions -p prod api "^events.*" ".*" ".*"
        

• LDAP, OAuth2/OIDC via plugin, authN externe.
• Rotation des credentials applicatifs, interdiction de guest à distance.

const amqp = require('amqplib');
const conn = await amqp.connect('amqp://ideolab:pass@host');
const ch = await conn.createChannel();
await ch.assertExchange('events','topic',{durable:true});
await ch.publish('events','order.paid',Buffer.from(JSON.stringify(obj)),{persistent:true});
        

// Spring Boot application.yml
spring:
  rabbitmq:
    host: host
    username: ideolab
    password: pass
        

Se produit quand producteurs saturent les queues ou I/O disque — ralentissement volontaire.

rabbitmqctl list_connections name state send_pend
        

# Politique de résolution
distribution.application:set_env(rabbit, net_ticktime, 60).