Event-Driven & Message Queue, ou le fait déposé dans un tamponEvent-Driven & Message Queue, or the fact dropped into a buffer

Un fait, cinq consommateurs, aucun tampon. Et si l'un est débordé, ou absent ?One fact, five consumers, no buffer. And if one is overwhelmed, or absent?

Au #1, on a coupé le fil : « commande payée » n'attend plus le mail. Mais l'émetteur appelle encore chaque consommateur en direct, un à un. Deux choses varient désormais ensemble : la liste de ceux qui réagissent — Logistique, Growth, Data, Fidélité, demain d'autres — et la charge dans le temps, qui explose un jour de soldes. Sans rien entre l'émetteur et eux, un pic les écrase et une panne perd l'événement. Le réflexe : ne livre pas le fait à des destinataires ; dépose-le dans une file, et laisse chacun le consommer à son rythme.In #1 we cut the thread: 'order paid' no longer waits for the email. But the emitter still calls each consumer directly, one by one. Two things now vary together: the list of reactors — Logistics, Growth, Data, Loyalty, more tomorrow — and the load over time, which explodes on a sale day. With nothing between the emitter and them, a spike crushes them and an outage loses the event. The reflex: don't deliver the fact to recipients; drop it in a queue, and let each consume it at its own pace.

def on_order_paid(order):
    # async, oui — mais l'émetteur appelle chaque consommateur, en direct
    warehouse_api.post("/reserve", order)    # l'équipe Logistique
    email_api.post("/receipt", order)        # l'équipe Growth
    analytics_api.post("/track", order)      # l'équipe Data
    loyalty_api.post("/points", order)       # … et demain Fidélité, Compta, Anti-fraude
    # un pic de commandes ? chaque service le prend de plein fouet.
    # Analytics en plein déploiement ? son événement est perdu, sans trace.

Le pic n'a nulle part où attendre, et l'absent perd son fait.The spike has nowhere to wait, and the absent loses its fact.

Livrer chaque fait en direct, même en asynchrone, laisse trois douleurs sans réponse. Sans tampon, un pic se transmet tel quel : l'émetteur produit 10× plus vite que la Logistique ne digère, et le service fond. Sans persistance, un consommateur en panne ne rattrape rien : son événement est passé, perdu. Et la liste des destinataires reste dans l'émetteur : ajouter Compta, c'est rouvrir le code qui publie.Delivering each fact directly, even asynchronously, leaves three pains unanswered. Without a buffer, a spike passes through as-is: the emitter produces 10× faster than Logistics digests, and the service melts. Without persistence, a downed consumer catches up on nothing: its event went by, lost. And the recipient list stays in the emitter: adding Accounting means reopening the publishing code.

# soldes : 1000 commandes/s
for order in flood:
    warehouse_api.post("/reserve", order)   # capacité : 100/s → 💥 sature
    analytics_api.post("/track", order)     # en déploiement → 💥 perdu
# l'émetteur n'a pas de frein, les consommateurs pas de file d'attente.

On intercale une file : elle retient, elle amortit, elle diffuse.Insert a queue: it retains, it absorbs, it broadcasts.

La file n'est pas un tuyau de plus : c'est un tampon durable posé entre l'émetteur et ses consommateurs. L'émetteur y dépose un fait et rend la main ; la file le garde jusqu'à ce qu'on vienne le prendre. L'animation insère ce tampon, puis montre ses trois métiers : retenir le message pour qu'une panne ne le perde pas, amortir un pic en se remplissant, diffuser à N consommateurs qui lisent chacun à leur curseur.The queue isn't one more pipe: it's a durable buffer placed between the emitter and its consumers. The emitter drops a fact and returns; the queue holds it until someone takes it. The animation inserts that buffer, then shows its three jobs: retain the message so an outage doesn't lose it, absorb a spike by filling up, broadcast to N consumers each reading at its own cursor.

# l'émetteur — dépose un fait, ne connaît aucun consommateur▸ à toiyour turn — déposer un fait, sans connaître de destinataire — quelle méthode du broker ?drop a fact, knowing no recipient — which broker method? · cliquer pour révélerclick to reveal
# chaque équipe — un groupe de consommateurs indépendant, son propre curseur▸ à toiyour turn — un consommateur indépendant, avec son propre curseur — comment s'abonne-t-il au fait ?an independent consumer, with its own cursor — how does it subscribe to the fact? · cliquer pour révélerclick to revealdef reserve(evt): warehouse.reserve(evt.order_id)   # amorti, rejoué si panne
▸ à toiyour turn — ajouter l'équipe Data sans toucher l'émetteur — que suffit-il d'écrire ?add the Data team without touching the emitter — what alone must you write? · cliquer pour révélerclick to revealdef track(evt): analytics.track(evt.order_id)

Brancher une file ne suffit pas. Le consommateur qui parie exactement-une-fois.Wiring a queue isn't enough. The consumer that bets on exactly-once.

Le piège n'est pas d'oublier la file — c'est de la traiter comme un appel de fonction fiable. Une file de messages donne deux garanties faibles et contre-intuitives : au moins une fois (un message peut être relivré) et aucun ordre global (OrderShipped peut précéder OrderPaid). Un consommateur écrit comme si chaque événement arrivait une seule fois, dans l'ordre, devient une machine à doublons et à courses. Bascule le toggle : cherche l'effet qui ne supporte ni rejeu ni désordre.The trap isn't forgetting the queue — it's treating it like a reliable function call. A message queue gives two weak, counter-intuitive guarantees: at-least-once (a message may be redelivered) and no global ordering (OrderShipped can precede OrderPaid). A consumer written as if each event arrives once, in order, becomes a duplicate-and-race machine. Flip the toggle: hunt the effect that tolerates neither replay nor reordering.

# la file garantit AU MOINS une fois, sans ordre global → on s'y prépare
@subscribe("OrderPaid", group="logistique")
def reserve(evt):
    if seen(evt.id): return                 # idempotent : rejouer ne re-réserve pas
    mark_seen(evt.id)
    warehouse.reserve(evt.order_id)

@subscribe("OrderShipped", group="logistique")
def ship(evt):
    order = load(evt.order_id)
    if order.state != "paid": defer(evt)    # tolère le désordre : pas encore payé ? on attend
    else: warehouse.dispatch(order)

Livrer à chaque consommateur, ou déposer un fait dans un tampon durable.Deliver to each consumer, or drop a fact into a durable buffer.

Quand ne pas sortir la file de messagesWhen not to reach for the message queue

Une file est de l'infrastructure : un broker à exploiter, une cohérence à terme à assumer, un flux à tracer sur plusieurs services. On garde l'appel direct — et c'est correct — quand :A queue is infrastructure: a broker to operate, eventual consistency to accept, a flow to trace across several services. Keep the direct call — and that's fine — when:

• tu as besoin de la cohérence maintenant : si le résultat doit être vrai au moment où tu réponds (le solde après un virement), la file et son « un jour » sont la mauvaise sémantique. C'est le tri du #1 : la réponse gate-t-elle la décision ?you need consistency now: if the result must be true the moment you answer (the balance after a transfer), the queue and its 'someday' are the wrong semantics. It's #1's sorting: does the answer gate the decision?
• il y a un seul consommateur connu et stable : pas de fan-out, pas de pic, un service toujours disponible. La file n'amortit rien et ne diffuse à personne ; elle n'ajoute qu'un broker à exploiter — de la cérémonie (YAGNI, Vol 0 #3).there's a single, known, stable consumer: no fan-out, no spike, an always-available service. The queue absorbs nothing and broadcasts to no one; it only adds a broker to run — ceremony (YAGNI, Vol 0 #3).
• la traçabilité prime sur le découplage : un flux critique qu'il faut pouvoir suivre d'un bout à l'autre se lit mieux en appels explicites qu'en événements anonymes. Ne disperse pas dans une file ce que tu auras besoin de raconter en ligne droite.traceability matters more than decoupling: a critical flow you must follow end to end reads better as explicit calls than as anonymous events. Don't scatter into a queue what you'll need to narrate in a straight line.

Le réflexe n'est donc pas « mets une file partout, c'est découplé ». C'est : « la charge est-elle irrégulière, les consommateurs multiples ou faillibles, et personne n'attend de réponse ? Si oui, dépose un fait dans un tampon durable — mais conçois chaque consommateur pour au moins une fois, sans ordre. Sinon, appelle, et garde le flux traçable. »So the reflex isn't 'put a queue everywhere, it's decoupled'. It's: 'is the load uneven, the consumers many or fallible, and no one awaits a response? If yes, drop a fact into a durable buffer — but design every consumer for at-least-once, no order. If not, call, and keep the flow traceable.'

Mot de l'éditeurFrom the editor

L'event-driven est la rencontre de deux numéros qu'on a déjà écrits. Observer (Vol 3 #2) a coupé le savoir : l'émetteur ignore qui réagit. Synchrone vs asynchrone (Vol 4 #1) a coupé le temps : personne n'attend la réponse. La file de messages ne fait que durcir et réseauter cette double coupure — elle pose un tampon qui survit aux pannes là où Observer n'avait qu'une liste en mémoire. Ce qu'on achète est réel : absorber les pics, survivre aux absences, diffuser sans se connaître. Ce qu'on paie l'est tout autant : la cohérence à terme, l'absence d'ordre, la relivraison, et un broker de plus à garder en vie.Event-driven is where two issues we've already written meet. Observer (Vol 3 #2) cut knowledge: the emitter ignores who reacts. Synchronous vs asynchronous (Vol 4 #1) cut time: no one awaits the response. The message queue merely hardens and networks that double cut — it lays a buffer that survives outages where Observer had only an in-memory list. What you buy is real: absorb spikes, survive absences, broadcast without knowing each other. What you pay is just as real: eventual consistency, no ordering, redelivery, and one more broker to keep alive.

Le danger n'est pas la file : c'est l'enthousiasme. Transformer chaque appel en événement « parce que c'est découplé » fabrique un système que plus personne ne sait suivre — un monolithe distribué, mais par messages. L'architecte ne demande pas « est-ce event-driven ? » mais « ce fait mérite-t-il un tampon durable, et puis-je encore raconter ce qui se passe ? ». Le prochain numéro pose la question qui reste : quand plus personne n'attend en ligne droite, qui tient le fil d'une transaction métier en plusieurs étapes ?The danger isn't the queue: it's the enthusiasm. Turning every call into an event 'because it's decoupled' builds a system no one can follow anymore — a distributed monolith, but by messages. The architect doesn't ask 'is it event-driven?' but 'does this fact deserve a durable buffer, and can I still narrate what happens?'. The next issue poses the question that remains: when no one waits in a straight line, who holds the thread of a multi-step business transaction?

Les voisins que ce numéro débloqueThe neighbors this issue unlocks

• Pub/Sub — le modèle de diffusion de la file : un fait publié, N abonnés indépendants. C'est Observer (Vol 3 #2) à l'échelle du réseau, avec un tampon durable entre l'émetteur et ses publics.the queue's broadcast model: one published fact, N independent subscribers. It's Observer (Vol 3 #2) at network scale, with a durable buffer between the emitter and its audiences.
• Event Bus — la file vue comme une colonne vertébrale interne : tous les modules y publient et s'y abonnent. Pratique pour un monolithe modulaire (Vol 6 #1) ; dangereux dès qu'on l'utilise pour masquer un couplage qu'il faudrait nommer.the queue seen as an internal backbone: every module publishes to it and subscribes. Handy for a modular monolith (Vol 6 #1); dangerous the moment it hides a coupling you should name.
• Outbox pattern — la pièce qui ferme le piège de la double écriture : enregistrer le message dans la même transaction que la donnée métier, puis le relayer vers le broker. La garantie « publié si et seulement si commité », reprise du #1.the piece that closes the dual-write trap: record the message in the same transaction as the business data, then relay it to the broker. The 'published if and only if committed' guarantee, carried over from #1.

Le kata — écris-le, ne le relis pasThe kata — write it, don't reread it

# test_consumer.py — la file promet « au moins une fois, sans ordre ».
# Écris le consommateur qui rend ces deux faiblesses inoffensives.

def test_traite_une_fois():
    c = Consumer()
    c.handle(Event("evt-1", "OrderPaid", order=42))
    assert reserved(42) == 1                  # un événement → un effet

def test_rejeu_ne_double_pas():
    c = Consumer()
    e = Event("evt-1", "OrderPaid", order=42)
    c.handle(e); c.handle(e)                   # même message relivré…
    assert reserved(42) == 1                   # …un seul effet : idempotent

def test_desordre_differe():
    c = Consumer()
    c.handle(Event("evt-9", "OrderShipped", order=42))  # arrive AVANT le paiement
    assert shipped(42) == 0                     # préalable absent → on diffère, rien n'est expédié

def test_le_differe_repart_apres_son_prealable():
    c = Consumer()
    c.handle(Event("evt-9", "OrderShipped", order=42))  # différé…
    c.handle(Event("evt-1", "OrderPaid", order=42))     # …le préalable arrive
    assert shipped(42) == 1                     # …et le différé repart tout seul

def test_dedup_par_id_pas_par_effet():
    c = Consumer()
    c.handle(Event("evt-1", "OrderPaid", order=42))
    c.handle(Event("evt-2", "OrderPaid", order=42))     # DEUX événements distincts, même commande
    assert reserved(42) == 2                    # deux ids = deux effets : on dédoublonne l'ID,
    #                                             PAS l'effet — sinon on avale un vrai 2e paiement.