Remplacer les appels directs par des messages découple les services dans le temps — au prix de nouvelles règles : doublons, ordre, reprise, et un état qu'on reconstruit à partir de l'histoire.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : avancé · 🏅 Badge : Facteur du système
🎬 L'histoire
Quand un formateur de HashBox publie un cours, six choses doivent arriver : indexer la recherche, prévenir les abonnés, mettre à jour les statistiques, générer le PDF, alerter la modération, mettre à jour le cache. L'API les appelle l'une après l'autre. Quand le service des PDF ralentit, la publication entière prend 12 secondes. Quand il tombe, la publication échoue, alors que le cours est enregistré en base. Et si l'API plante entre deux appels, certains services ne sont jamais prévenus.
« On peut inverser la logique, propose Maya : l'API enregistre le cours et publie un événement "CoursPublié". Chaque service s'abonne et fait son travail à son rythme, y compris après une panne. Mais ce découplage ouvre trois questions : que se passe-t-il si le message est livré deux fois ? Si l'API plante entre l'enregistrement et la publication ? Et dans quel ordre les messages sont-ils traités ? »
Tu apprends à construire un journal d'événements partitionné avec groupes de consommateurs et offsets, à garantir la livraison au moins une fois, à utiliser le patron « boîte d'envoi » (outbox), à traiter les messages en échec (file morte), et à reconstruire l'état par rejeu d'événements.
🎯 Ta mission
À la fin, je serai capable de :
- distinguer file de messages, publication/abonnement et journal d'événements
- implémenter partitions, offsets et groupes de consommateurs avec livraison au moins une fois
- utiliser une file morte (dead-letter) pour les messages en échec répété
- appliquer le patron outbox pour publier un événement de façon atomique avec l'écriture en base
- reconstruire un état par rejeu d'événements (event sourcing) et projeter des vues de lecture
🧩 Défi d'échauffement (5 XP)
Dans un restaurant, les serveurs écrivent des bons sur un passe-plat et la cuisine les prend dans l'ordre. Si la cuisine est débordée, les bons s'accumulent sans bloquer les serveurs. Si un cuisinier tombe malade, un autre reprend la pile. Si un bon est collé deux fois, le plat est préparé deux fois. Si un serveur écrit le bon… puis oublie de le mettre sur le passe-plat ? Liste les avantages et les risques de ce fonctionnement.
💡 Le concept
Trois outils de messagerie
| Outil | Principe | Usage |
|---|---|---|
| File de messages (queue) | chaque message est traité par un seul consommateur parmi plusieurs ; il disparaît une fois traité | répartir du travail |
| Publication/abonnement (pub/sub) | chaque abonné reçoit sa copie de chaque message | notifier plusieurs services |
| Journal d'événements (log, Kafka) | suite ordonnée et persistante de messages ; chaque consommateur lit à son rythme avec un offset ; rejouable | flux d'événements, reconstruction d'état |
Le journal partitionné
Un sujet (topic) est divisé en partitions (mission 6). Dans une partition :
- les messages sont ordonnés (offsets 0, 1, 2…) ;
- l'ordre n'est garanti qu'au sein d'une partition, pas entre partitions.
La clé du message (par exemple l'identifiant du cours) détermine la partition : tous les événements d'un même cours vont dans la même partition, donc dans l'ordre.
Groupes de consommateurs
Un groupe de consommateurs se partage les partitions : chaque partition est lue par un seul consommateur du groupe (parallélisme, ordre préservé). Plusieurs groupes distincts lisent indépendamment (chacun reçoit tous les messages). Quand un consommateur tombe ou arrive, les partitions sont réaffectées (rebalance).
Offsets et livraison
Le consommateur enregistre (valide, commit) son offset : « j'ai traité jusqu'ici ». Selon le moment de la validation :
| Choix | Comportement en cas de panne | Sémantique |
|---|---|---|
| Valider avant de traiter | message perdu si panne pendant le traitement | au plus une fois |
| Valider après traitement | message rejoué si panne avant validation | au moins une fois (le standard) |
D'où : consommateurs idempotents (mission 4).
Messages en échec : file morte
Un message qui échoue toujours (« message empoisonné ») bloquerait la partition. Après N tentatives (avec recul), on le déplace dans une file morte (dead-letter queue) pour examen humain, et on continue.
Le problème de l'écriture double
1. enregistrer le cours en base ← réussi
2. publier l'événement CoursPublié ← l'API plante ici : l'événement n'est jamais publié !
Deux systèmes (base + courtier) ne se mettent pas à jour de façon atomique. Patron « boîte d'envoi » (outbox) :
- dans la même transaction que la modification, insérer l'événement dans une table
outbox; - un relais lit la table
outbox, publie dans le courtier, puis marque l'événement comme publié ; - si le relais plante entre la publication et le marquage, l'événement est republié → doublon → consommateurs idempotents.
Résultat : au moins une fois, sans événement perdu.
Événements et ordre
- Un événement décrit un fait passé (« CoursPublié », « InscriptionAnnulée »), immuable, avec identifiant, horodatage, version.
- Ne pas supposer l'ordre entre partitions ; utiliser une version par entité pour ignorer un événement plus ancien que l'état.
- Évolution des schémas d'événements : compatibilité ascendante (mission 2).
Sourçage d'événements (event sourcing)
Au lieu de stocker l'état courant, on stocke la suite des événements qui y ont mené. L'état est déduit par rejeu (plier les événements).
| Avantage | Coût |
|---|---|
| historique complet, audit | complexité |
| « voyager dans le temps » : état à n'importe quelle date | rejeu long : on prend des instantanés (snapshots) |
| nouvelles vues sans migration : on rejoue | évolution des événements |
CQRS et projections
CQRS sépare le modèle d'écriture (commandes, événements) des modèles de lecture (vues optimisées pour les requêtes), appelés projections, alimentés par les événements. Les vues sont finalement cohérentes : un léger retard est normal.
Contre-pression et dimensionnement
Une file qui grandit signale que les consommateurs sont trop lents : surveiller le retard (lag = offset du dernier message − offset validé). Remèdes : plus de consommateurs (jusqu'au nombre de partitions), traitement par lots, optimisation.
🧠 Astuce : décris chaque flux par trois phrases : qui produit, qui consomme, que se passe-t-il si le message arrive deux fois ou dans le désordre ?
🔍 Exemple pas à pas
Problème : construire un courtier en mémoire avec partitions, offsets et groupes de consommateurs, montrer la livraison au moins une fois après panne, la file morte, le patron outbox avec un relais qui plante, puis reconstruire un état par rejeu d'événements.
import hashlib, json, sqlite3
from collections import defaultdict
# ---------------- 1. un courtier : journal partitionné, offsets par groupe ----------------
class Courtier:
def __init__(self, partitions=3):
self.n = partitions
self.journal = [[] for _ in range(partitions)] # chaque partition : liste ordonnée de messages
self.offsets = defaultdict(lambda: [0] * partitions) # offset VALIDÉ par groupe et par partition
def publier(self, cle, valeur):
p = int(hashlib.md5(str(cle).encode()).hexdigest(), 16) % self.n # même clé → même partition → ordre préservé
self.journal[p].append({"cle": cle, "valeur": valeur}); return p, len(self.journal[p]) - 1
def lire(self, groupe, partition, max_messages=100):
debut = self.offsets[groupe][partition]
return [(debut + i, m) for i, m in (.journal[partition][debut:debut + max_messages])]
():
.offsets[groupe][partition] = (.offsets[groupe][partition], offset + )
(): ((.journal[p]) - .offsets[groupe][p] p (.n))
courtier = Courtier()
i ():
courtier.publier(, {: , : i, : })
cle (, ):
p = (hashlib.md5(cle.encode()).hexdigest(), ) %
ns = [m[][] m courtier.journal[p] m[] == cle]
ns == (ns)
(, courtier.retard())
courtier.retard() ==
():
traites =
p (courtier.n):
offset, m courtier.lire(groupe, p, lot):
traiter(m[]); traites +=
planter_a traites == planter_a: RuntimeError()
courtier.journal[p]: courtier.valider(groupe, p, courtier.offsets[groupe][p] + (lot, (courtier.journal[p]) - courtier.offsets[groupe][p]) - )
traites
vus = []
: consommer(, courtier, vus.append, planter_a=)
RuntimeError e: (, e)
avant = (vus)
courtier.retard() > : consommer(, courtier, vus.append)
doublons = (vus) - ({m[] m vus})
()
{m[] m vus} == (()) doublons > courtier.retard() ==
effets, deja = defaultdict(), ()
():
valeur[] deja:
deja.add(valeur[]); effets[valeur[]] +=
c2 = Courtier()
i (): c2.publier(, {: i, : })
: consommer(, c2, traiter_idempotent, planter_a=)
RuntimeError:
c2.retard() > : consommer(, c2, traiter_idempotent)
(effets.values()) == (v == v effets.values())
()
():
morte, essais = [], defaultdict()
courtier.retard(groupe) > :
offset, m courtier.lire(groupe, partition, ):
:
: traiter(m[]);
ValueError:
essais[offset] +=
essais[offset] >= max_essais: morte.append(m);
courtier.valider(groupe, partition, offset)
(courtier.offsets[groupe][p] >= (courtier.journal[p]) p [partition]):
morte
c3 = Courtier()
i (): c3.publier(, {: i, : i == })
ok = []
():
v[]: ValueError()
ok.append(v[])
morte = traiter_avec_morte(c3, , , fragile)
(, ok, , [m[][] m morte])
ok == [, , , , ] [m[][] m morte] == []
:
():
.bd = sqlite3.connect(, isolation_level=)
.bd.executescript()
():
.bd.execute()
:
cur = .bd.execute(, (titre,))
.bd.execute(, (json.dumps({: , : cur.lastrowid, : titre}),))
planter: RuntimeError()
.bd.execute()
RuntimeError:
.bd.execute();
():
id_, ev .bd.execute().fetchall():
courtier.publier(, json.loads(ev))
planter_apres_publication: RuntimeError()
.bd.execute(, (id_,))
s, cb = Service(), Courtier()
: s.publier_cours(, planter=)
RuntimeError:
s.bd.execute().fetchone()[] == s.bd.execute().fetchone()[] ==
s.publier_cours()
: s.relais(cb, planter_apres_publication=)
RuntimeError e: (, e)
s.relais(cb)
evts = cb.journal[]
(, (evts), )
(evts) == evts[] == evts[]
EVENEMENTS = [(, {: , : }), (, {: , : }), (, {: , : }),
(, {: , : }), (, {: , : }), (, {: , : })]
():
type_, d = evenement
etat = {k: ((v) (v, ) v) k, v etat.items()}
type_ == : etat.update(places=d[], inscrits=())
type_ == : etat[].add(d[])
type_ == : etat[].discard(d[])
type_ == : etat[] = d[]
etat
():
etat = {}
e evenements[:jusqua]: etat = appliquer(etat, e)
etat
final = rejouer(EVENEMENTS)
(, final, , rejouer(EVENEMENTS, ))
final == {: , : {, }} rejouer(EVENEMENTS, )[] == {, }
Lecture :
- L'ordre est préservé par clé (dans une partition) ; entre partitions, aucun ordre n'est garanti.
- En validant l'offset après traitement, une panne provoque un rejeu : tous les messages sont traités, certains deux fois (au moins une fois).
- Avec un consommateur idempotent, les doublons restent sans effet : 30 messages, 30 effets.
- La file morte isole un message empoisonné après 3 essais ; la partition continue.
- Le patron outbox rend l'enregistrement et la publication de l'événement atomiques ; le relais peut republier après une panne (doublon, absorbé par l'idempotence).
- L'état d'un cours se reconstruit par rejeu des événements ; on peut aussi « voyager dans le temps » (état après 3 événements).
✍️ À toi, avec aide (10 XP)
Écris affecter(partitions, consommateurs) qui répartit P partitions entre C consommateurs d'un même groupe (affectation par plages contiguës, aussi équilibrée que possible), puis simule le rééquilibrage quand un consommateur disparaît. Vérifie que :
- chaque partition est affectée à exactement un consommateur ;
- l'écart de charge entre consommateurs est au plus 1 ;
- avec 6 partitions et 3 consommateurs → 2 chacun ; après la perte d'un consommateur → 3 et 3 ;
- avec plus de consommateurs que de partitions, certains restent inactifs.
💡 Indice 1
Chaque consommateur reçoit P // C partitions, les P % C premiers en reçoivent une de plus.
💡 Indice 2
Retire le consommateur et recalcule.
💡 Indice 3
Compte les partitions par consommateur avec un Counter.
✅ Réponse
from collections import Counter
def affecter(nb_partitions, consommateurs):
consommateurs = sorted(consommateurs)
base, reste = divmod(nb_partitions, len(consommateurs))
attribution, debut = {}, 0
for i, c in enumerate(consommateurs):
taille = base + (1 if i < reste else 0)
attribution[c] = list(range(debut, debut + taille)); debut += taille
return attribution
a = affecter(6, ["c1", "c2", "c3"])
print(a)
assert all(len(v) == 2 for v in a.values())
b = affecter(6, ["c1", "c3"]) # c2 a disparu
print("après la perte de c2 :", b)
assert all(len(v) == 3 for v in b.values())
for nb, cs in ((7, [, , ]), (, ()), (, ())):
r = affecter(nb, cs)
toutes = (p v r.values() p v)
toutes == ((nb))
tailles = [(v) v r.values()]; (tailles) - (tailles) <=
((v) v affecter(, ()).values()) == [, , , , ]
🚀 À toi, en solo (20 XP)
Sourçage d'événements avec instantanés et projection. Pour un agrégat « cours » (créer, inscrire, désinscrire, augmenter les places, fermer) :
- un magasin d'événements
append(agregat, evenement, version_attendue)qui refuse l'écriture si la version attendue ne correspond pas (concurrence optimiste) ; etat(agregat)rejoue les événements, avec un instantané tous les 5 événements (rejoue à partir du dernier instantané) ;- une commande
inscrire(cours, membre)qui valide la règle métier (places disponibles, cours ouvert, pas de doublon) en rejouant l'état, et refuse sinon ; - une projection « liste des cours complets » alimentée par les événements (mise à jour incrémentale) ;
- teste : (a) l'état par rejeu complet égale l'état avec instantanés pour 200 événements aléatoires ; (b) deux commandes concurrentes sur la même version : l'une est refusée ; (c) la projection égale un calcul complet par rejeu.
✅ Pistes de correction
import random, copy
class ConflitVersion(Exception): pass
def appliquer(etat, evt):
etat = copy.deepcopy(etat); t, d = evt
if t == "Cree": etat = {"places": d["places"], "inscrits": [], "ferme": False}
elif t == "Inscrit": etat["inscrits"].append(d["membre"])
elif t == "Desinscrit": etat["inscrits"].remove(d["membre"])
elif t == "Places": etat["places"] = d["places"]
elif t == "Ferme": etat["ferme"] = True
return etat
class Magasin:
def __init__(self, intervalle=5):
self.evenements, self.instantanes, self.intervalle = {}, {}, intervalle
self.abonnes = []
def version(): (.evenements.get(agregat, []))
():
.version(agregat) != version_attendue: ConflitVersion()
.evenements.setdefault(agregat, []).append(evt)
n = .version(agregat)
n % .intervalle == : .instantanes[agregat] = (n, .etat(agregat, utiliser_instantane=))
f .abonnes: f(agregat, evt)
():
debut, etat = , {}
utiliser_instantane agregat .instantanes: debut, etat = .instantanes[agregat]
evt .evenements.get(agregat, [])[debut:]: etat = appliquer(etat, evt)
etat
():
v, e = m.version(cours), m.etat(cours)
e e[]: ValueError()
membre e[]: ValueError()
(e[]) >= e[]: ValueError()
m.append(cours, (, {: membre}), v)
complets = ()
():
():
e = m.etat(agregat)
(complets.add e (e[]) >= e[] complets.discard)(agregat)
f
m = Magasin(); m.abonnes.append(projeter(m))
rng = random.Random()
c (, , ): m.append(c, (, {: }), )
_ ():
c, membre = rng.choice([, , ]),
action = rng.random()
:
action < : inscrire(m, c, membre)
action < membre m.etat(c).get(, []): m.append(c, (, {: membre}), m.version(c))
action < : m.append(c, (, {: rng.randint(, )}), m.version(c))
ValueError:
c (, , ):
m.etat(c) == m.etat(c, utiliser_instantane=)
(c complets) == ((m.etat(c)[]) >= m.etat(c)[])
v = m.version()
m.append(, (, {: }), v)
: m.append(, (, {: }), v); AssertionError
ConflitVersion e: (, e)
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Écrire en base puis publier, sans outbox | Événement perdu si panne entre les deux | Outbox transactionnelle + relais |
| Valider l'offset avant de traiter | Messages perdus en cas de panne | Valider après traitement + consommateur idempotent |
| Supposer l'ordre global | Événements traités dans le désordre | Ordre par clé/partition, versions par entité |
| Message empoisonné qui bloque la partition | Retard infini | Nombre d'essais borné, file morte, alerte |
🐉 Mini-boss (40 XP)
Pipeline de commandes de HashBox. Concois et simule : un service Inscriptions (base SQLite + outbox), un courtier à 3 partitions, trois consommateurs (Paiement, Notifications, Statistiques) dans des groupes distincts.
- outbox atomique, relais avec injection de panne à chaque point ;
- consommateurs avec boîte de réception (messages traités) atomique avec leurs effets ;
- file morte avec recul, rejouable après correction du bug ;
- injection de pannes (relais, consommateur avant/après validation, perte de connexion), duplication et réordonnancement entre partitions ;
- invariants vérifiés sur 200 graines : aucune inscription sans événement, aucun événement sans inscription, chaque événement a un effet dans chaque consommateur, jamais deux paiements pour la même inscription ;
- mesure du retard (lag) et du temps de convergence après panne ;
- documente le schéma d'événements et sa stratégie d'évolution.
✅ Pistes de correction
Un bon travail : tables inscriptions, outbox, boite_reception(consommateur, evenement_id) par consommateur; transactions locales atomiques; file morte avec compteur d'essais; test d'injection exhaustive des points de panne; invariants vérifiés après convergence; schéma d'événement {id, type, version_schema, entite, version, donnees} avec règles d'évolution (champs optionnels ajoutés, jamais retirés).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Valider l'offset après le traitement d'un message donne la sémantique :
- A. au plus une fois
- B. exactement une fois garantie par le réseau
- C. au moins une fois
2. Le patron outbox sert à :
- A. publier un événement de façon atomique avec la modification en base
- B. chiffrer les messages
- C. accélérer le courtier
3. Dans un journal partitionné, l'ordre est garanti :
- A. entre toutes les partitions
- B. au sein d'une partition
- C. nulle part
4. 🔁 Révision mission 07 : Pendant une partition réseau, un système CP :
- A. répond partout avec des copies divergentes
- B. ignore la partition
- C. refuse de répondre côté minoritaire pour préserver la cohérence
5. 🔁 Révision mission 07 : Dans Raft, une entrée est validée (committed) quand elle est stockée sur :
- A. une majorité de nœuds
- B. tous les nœuds
- C. un seul nœud
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quel appel synchrone de ton système gagnerait à devenir un événement, et que perdrais-tu ?
- Que se passe-t-il chez toi si un consommateur reçoit le même message deux fois ?
🎒 À retenir
- File, publication/abonnement, journal d'événements : trois outils.
- Partitions + clé = ordre par entité ; groupes de consommateurs = parallélisme.
- Valider après traitement = au moins une fois ; consommateurs idempotents.
- Outbox : événement et donnée dans la même transaction ; file morte pour l'empoisonné.
- Event sourcing : état = rejeu ; instantanés, projections, concurrence optimiste.
flowchart LR
T(["Files et événements"])
T --> R1["1. File, publication/abonnement, journal d'événements : trois outils."]
T --> R2["2. Partitions + clé = ordre par entité ; groupes de consommateurs =…"]
T --> R3["3. Valider après traitement = au moins une fois ; consommateurs…"]
T --> R4["4. Outbox : événement et donnée dans la même transaction ; file morte…"]
T --> R5["5. Event sourcing : état = rejeu ; instantanés, projections, concurrence…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Facteur du système
← Mission 07 — Cohérence et consensus : panorama · Mission 09 — Tolérance aux pannes →
HEF-140 — Systèmes distribués

