Un retry mal placé transforme une panne locale en catastrophe globale. Bien utilisé, il masque les pannes brèves. La différence tient à quelques chiffres.
⏱️ Durée : environ 105 minutes · 🎓 Niveau : avancé · 🏅 Badge : Maître des délais
🎬 L'histoire
Un mardi, la base de données de HashBox ralentit pendant 30 secondes. Aucun problème grave en soi. Mais la passerelle réessaie 3 fois, le service d'inscription réessaie 3 fois, et la couche d'accès à la base réessaie 3 fois. Chaque requête utilisateur devient 4 × 4 × 4 = 64 requêtes vers une base déjà en difficulté. La base ne se remet pas. La panne dure 40 minutes.
« Chaque maillon a fait quelque chose de raisonnable, dit Sam. Réessayer. Ensemble, ils ont fabriqué une avalanche. En distribué, la sûreté est globale : il faut un budget de retry, des échéances partagées, et parfois une deuxième requête... exprès, pour réduire la queue de latence. »
Tu apprends à calculer l'amplification des retries, à propager des échéances, à utiliser le hedging contre la latence de queue, et à plafonner les retries avec un budget.
🎯 Ta mission
À la fin, je serai capable de :
- calculer l'amplification de charge due aux retries en couches
- propager une échéance (deadline) à travers une chaîne d'appels
- expliquer et simuler les requêtes doublées (hedged requests) contre la latence de queue
- implémenter un budget de retries pour éviter les tempêtes
- choisir des délais d'attente à partir de percentiles mesurés
🧩 Défi d'échauffement (5 XP)
Une file au cinéma : si chaque client lance trois personnes de plus dans la file « au cas où » quand elle avance lentement, que devient la file ? Cite un cas de ta vie où essayer à nouveau, plusieurs à la fois, a aggravé la situation (réseau saturé, appels en pic, serveur de réservation).
💡 Le concept
La latence en distribué
Une requête utilisateur traverse souvent N services. Si chacun a une latence p99 de 100 ms et qu'une requête en appelle 10 en séquence, la probabilité qu'au moins un soit lent est 1 − 0,99¹⁰ ≈ 9,6 %. En parallèle sur 100 services (fan-out), 1 − 0,99¹⁰⁰ ≈ 63 %. La latence de queue (tail latency) se propage et s'amplifie.
Choisir un délai d'attente
| Trop court | Trop long |
|---|---|
| fausses alertes, relances inutiles, charge accrue | ressources bloquées, utilisateurs qui attendent, cascades |
Méthode : regarder la distribution réelle. Un délai vers p99,9 de la latence normale (ou 2 à 3 × p99) évite la plupart des faux positifs ; la requête qui l'atteint est considérée comme échouée.
Retry : quand et comment
On réessaie uniquement :
- les erreurs transitoires (délai, 503, connexion refusée), pas les erreurs métier ;
- les opérations idempotentes (mission 4) ;
- avec recul exponentiel et gigue (HEF-120, mission 9) ;
- avec un nombre limité de tentatives ;
- à un seul niveau de la chaîne (de préférence le plus proche de l'utilisateur ou de la dépendance).
L'amplification
Si chaque couche fait r tentatives (1 normale + r − 1 relances) et que la dépendance échoue, le nombre d'appels à la dépendance est r^L pour L couches. Avec 3 tentatives sur 3 couches : 27 ×. Avec 4 tentatives : 64 ×.
Pire : les retries arrivent quand le système est déjà fragile. Une panne brève peut devenir une panne métastable : même après la disparition de la cause initiale, la surcharge due aux retries empêche le retour à la normale.
Le budget de retries
Plafonner les relances à une fraction du trafic (par exemple 10 % des requêtes). Principe du seau à jetons :
- chaque requête réussie ajoute 0,1 jeton ;
- une relance consomme 1 jeton ;
- sans jeton, on n'essaie pas : on échoue vite.
En panne totale, les relances s'arrêtent d'elles-mêmes après quelques-unes ; en panne partielle (1 % d'échec), elles passent. La charge supplémentaire est bornée à ~10 %.
Propager l'échéance (deadline propagation)
L'appelant initial dispose d'un budget de temps (par exemple 1 s). Chaque appel en aval reçoit l'échéance restante, pas un nouveau délai. Une couche qui reçoit une requête dont l'échéance est dépassée ne commence pas le travail : personne n'attend plus la réponse. Sans cela, on continue à travailler pour des clients déjà partis.
Les requêtes doublées (hedging)
La latence de queue est causée par des ralentissements ponctuels (ramasse-miettes, voisin bruyant). Un remède : si la réponse n'est pas arrivée après p95, envoyer la même requête à un autre réplicat et prendre la première réponse. Coût : environ 5 % de requêtes supplémentaires ; gain : un p99 divisé par 2 ou plus. Prérequis : opérations idempotentes (lectures) et capacité en réserve.
Autres protections
| Mécanisme | Effet |
|---|---|
| Disjoncteur (HEF-120) | cesser d'appeler une dépendance malade |
| Délestage | refuser tôt le travail en excès |
| Limitation de débit | plafonner un client |
| Isolation (bulkhead) | une dépendance lente ne monopolise pas tous les threads |
| Priorités | traiter l'important d'abord |
| Repli | réponse dégradée plutôt qu'une erreur |
🧠 Astuce : place le retry à un seul endroit, protège-le par un budget, et fais circuler l'échéance. Ces trois règles évitent la plupart des avalanches.
🔍 Exemple pas à pas
Problème : calculer et simuler l'amplification des retries, propager une échéance, mesurer l'effet du hedging sur la latence de queue, et construire un budget de retries qui empêche la tempête.
import math, random
# ---------------- 1. amplification des retries en couches ----------------
def amplification(couches, tentatives):
return tentatives ** couches
def simuler_chaine(couches, tentatives, p_echec_base, graine=1, n=20000):
# chaque requête utilisateur traverse `couches` niveaux ; chaque niveau réessaie jusqu'à `tentatives` fois si l'aval échoue
rng, appels_base = random.Random(graine), [0]
def appeler(niveau):
if niveau == couches:
appels_base[0] += 1
return rng.random() >= p_echec_base # True = succès
for _ in range(tentatives):
if appeler(niveau + 1): return True
return False
succes = sum(appeler(0) for _ in range(n))
return appels_base[0] / n, succes / n
print("couches × tentatives | échec base | appels à la base par requête | succès utilisateur")
for tentatives in (1, 3):
for p (, , ):
charge, ok = simuler_chaine(, tentatives, p)
()
amplification(, ) == amplification(, ) ==
(simuler_chaine(, , )[] - ) <
simuler_chaine(, , )[] > > simuler_chaine(, , )[]
:
(): .echeance = echeance
():
horloge[] >= ctx.echeance:
horloge[] += duree
aval: aval(ctx)
():
base = appeler_service(, ctx, , horloge)
base
():
c = ctx propager Contexte(horloge[] + )
appeler_service(, c, , horloge, aval= cc: chaine(cc, horloge, propager))
():
ctx = Contexte(horloge[] + budget)
appeler_service(, ctx, , horloge, aval= cc: service(cc, horloge, propager))
h1, h2 = {: }, {: }
r1, r2 = passerelle(h1, ), passerelle(h2, )
()
()
r1 h1[] < h2[] r2 ==
():
base = rng.lognormvariate(math.log(), )
base + (rng.uniform(, ) rng.random() < )
():
v = (v); v[((v) - , math.ceil(p / * (v)) - )]
():
rng, lat, requetes = random.Random(graine), [],
_ (n):
a = latence(rng); requetes +=
hedging a > seuil:
requetes +=
b = seuil + latence(rng)
a = (a, b)
lat.append(a)
percentile(lat, ), percentile(lat, ), percentile(lat, ), requetes / n
seuil = percentile([latence(random.Random()) _ ()] + [latence(random.Random(i)) i ()], )
sans, avec = simuler(, seuil), simuler(, seuil)
()
()
()
avec[] < sans[] / avec[] < sans[] >
:
():
.ratio, .plafond, .jetons = ratio, plafond, plafond
(): .jetons = (.plafond, .jetons + .ratio)
():
.jetons >= : .jetons -= ;
():
rng, appels, budget = random.Random(graine), , BudgetRetries()
succes =
_ (n):
tentative ():
appels +=
rng.random() >= p_echec:
succes += ; budget.succes();
strategie == budget.peut_reessayer():
strategie == :
appels / n, succes / n
()
p (, , ):
a, b, c = (charge_avec(s, p) s (, , ))
()
charge_avec(, )[] > charge_avec(, )[] <
charge_avec(, )[] > charge_avec(, )[]
Lecture :
- Amplification : 3 couches × 3 tentatives = 27 × la charge en cas de panne totale. Les retries masquent bien une panne partielle (30 % d'échec devient ~0 % côté utilisateur) mais multiplient la charge d'une dépendance déjà en difficulté.
- Propagation d'échéance : avec une échéance partagée, la couche
serviceconstate que l'utilisateur est déjà parti et ne démarre pas son travail. Sans propagation, chaque couche reprend un délai neuf et travaille pour rien. - Hedging : en doublant seulement ~5 % des requêtes, le p99 chute fortement (il n'est plus déterminé par les ralentissements ponctuels), au prix de moins de 10 % de charge en plus.
- Budget de retries : en panne légère, les relances passent et masquent les échecs ; en panne totale, le budget s'épuise et la charge reste proche de 1 × (au lieu de 4 ×) : on échoue vite sans marteler la dépendance.
✍️ À toi, avec aide (10 XP)
Un appel utilisateur traverse : navigateur → passerelle → service A → service B → base. Chaque appel a une latence normale et un délai (timeout) :
| Appel | Latence p99 | Délai choisi |
|---|---|---|
| passerelle → A | 150 ms | 2 s |
| A → B | 100 ms | 1 s |
| B → base | 50 ms | 500 ms |
- Quel est le temps maximal d'attente de l'utilisateur si chaque maillon réessaie 2 fois (3 tentatives) et que la base ne répond jamais ?
- Quelle serait la bonne règle pour les délais (relation entre un délai amont et les délais aval) ? Propose des valeurs cohérentes si l'utilisateur ne doit pas attendre plus de 2 s.
- Combien de requêtes la base reçoit-elle pour une seule requête utilisateur dans le cas 1 ?
💡 Indice 1
Dans le pire cas, chaque niveau attend tentatives × délai du niveau aval.
💡 Indice 2
Le délai amont doit être supérieur à la somme (tentatives × délais aval), ou on propage une échéance globale.
💡 Indice 3
La charge sur la base = produit des tentatives des couches.
✅ Réponse
# 1. pire cas du point de vue de chaque niveau (la base ne répond jamais)
t_B = 3 * 0.5 # B attend la base 3 fois 500 ms
t_A = 3 * 1.0 # A attend B 3 fois 1 s (borné par son propre délai)
t_pass = 3 * 2.0 # la passerelle attend A 3 fois 2 s
print("attente de l'utilisateur dans le pire cas :", t_pass, "s")
# 3. appels à la base : passerelle(3) × A(3) × B(3)
appels_base = 3 * 3 * 3
print("appels reçus par la base :", appels_base)
assert t_pass == 6.0 and appels_base == 27
- 6 secondes pour un utilisateur qui ne devrait pas attendre plus de 2 s : les délais amont sont mal liés.
- Règle : un délai amont doit être plus grand que le total de ce que l'aval peut consommer — ou mieux, on propage une échéance globale (2 s) et chaque maillon l'honore. Valeurs cohérentes : échéance 2 s ; passerelle → A : 1,8 s ; A → B : 1,2 s ; B → base : 0,4 s, avec un seul niveau de retry (par exemple à la passerelle, avec budget).
- 27 requêtes vers la base pour 1 requête utilisateur (3 × 3 × 3) : c'est l'amplification que la mission décrit.
🚀 À toi, en solo (20 XP)
Client résilient complet. Écris ClientResilient qui combine :
- échéance globale transmise (temps simulé) ;
- retries avec recul exponentiel et gigue, limités par un budget (seau à jetons à 10 %) ;
- doublage (hedging) après un seuil pour les opérations marquées idempotentes ;
- disjoncteur (5 échecs consécutifs → ouvert pendant 2 s) ;
- compte-rendu : nombre d'appels réels envoyés, latence perçue, issue (succès, échec, refusé par le disjoncteur).
Teste trois scénarios simulés (horloge virtuelle, graine fixée) : (a) dépendance saine, (b) 5 % d'erreurs transitoires, (c) panne totale pendant 30 s puis rétablissement. Pour chaque scénario, compare un client naïf (3 retries immédiats) et ton client : charge sur la dépendance, taux de succès, latence p99.
✅ Pistes de correction
import math, random
class Dependance:
def __init__(self, horloge, rng, p_echec=lambda t: 0.0):
self.h, self.rng, self.p_echec, self.appels = horloge, rng, p_echec, 0
def appeler(self):
self.appels += 1
base = self.rng.lognormvariate(math.log(0.02), 0.3)
if self.rng.random() < self.p_echec(self.h["t"]):
return False, 0.05 # échec rapide
return True, base
class ClientNaif:
def __init__(self, dep): self.dep = dep
def executer(self, h):
debut = h["t"]
for _ in ():
ok, d = .dep.appeler(); h[] += d
ok: , h[] - debut
, h[] - debut
:
():
.dep, .rng, .jetons, .ratio = dep, rng, , budget_ratio
.echecs_consecutifs, .ouvert_jusqua = , -
():
debut, limite = h[], h[] + echeance
h[] < .ouvert_jusqua: ,
tentative ():
h[] >= limite:
ok, d = .dep.appeler(); h[] += d
ok:
.jetons = (, .jetons + .ratio); .echecs_consecutifs =
, h[] - debut
.echecs_consecutifs +=
.echecs_consecutifs >= : .ouvert_jusqua = h[] + ; .echecs_consecutifs = ;
.jetons < :
.jetons -=
h[] += .rng.uniform(, * ** tentative)
, h[] - debut
():
v = (v); v[((v) - , math.ceil( * (v)) - )]
():
rng = random.Random(graine); h = {: }
dep = Dependance(h, rng, p_echec)
client = ClientNaif(dep) client_type == ClientResilient(dep, rng)
resultats, latences = [], []
i (n):
h[] = i *
r, l = client.executer(h); resultats.append(r); latences.append(l)
dep.appels / n, resultats.count() / n, p99(latences)
SCENARIOS = {: t: , : t: , : t: <= t < }
()
res = {}
nom, f SCENARIOS.items():
ct (, ):
res[(nom, ct)] = scenario(nom, f, ct)
a, s, l = res[(nom, ct)]
()
res[(, )][] < res[(, )][] *
res[(, )][] > res[(, )][] <
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Retries à tous les niveaux | Amplification multiplicative (27 ×, 64 ×) | Un seul niveau de retry, avec budget |
| Délais amont plus courts que la somme des délais aval | Travail abandonné, résultats incohérents | Échéance globale propagée |
| Relancer immédiatement sans recul ni gigue | Tempête de retries synchronisés | Recul exponentiel + gigue |
| Hedging sur des opérations non idempotentes | Doublons d'effets | Seulement pour les lectures / opérations idempotentes |
🐉 Mini-boss (40 XP)
Banc de test de résilience. Construis une simulation de la chaîne passerelle → A → B → base (horloge virtuelle, graine fixée) où tu peux configurer à chaque niveau délais, retries, disjoncteurs, hedging, et injecter : panne totale de 30 s de la base, ralentissement ponctuel (3 % de requêtes à 10×), pertes de réponses.
- mesure pour 5 configurations (aucune protection, retries partout, retry unique avec budget, + échéance propagée, + disjoncteur et hedging) : charge sur la base, succès perçu, p50/p99, temps de rétablissement après la panne ;
- mets en évidence au moins un cas de panne métastable (la charge reste élevée après la fin de la panne) ;
- calcule l'amplification théorique et compare à la simulation ;
- recommande une configuration, justifie chaque choix par un chiffre ;
- écris 8 tests (propriétés : charge ≤ k × trafic, aucune requête exécutée après son échéance, pas de retry sur erreur métier).
✅ Pistes de correction
Un bon travail : une classe par mécanisme combinable, un tableau des 5 configurations (la dernière doit avoir la charge la plus faible sur la base pendant la panne et le meilleur p99), démonstration que les retries illimités maintiennent la surcharge après la fin de la panne (la file ne se vide pas) alors que le budget permet un retour à la normale en quelques secondes. L'amplification mesurée correspond à 3³ = 27 pour la configuration « retries partout » en panne totale.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Avec 3 couches qui réessaient chacune 3 fois, une dépendance en panne totale reçoit :
- A. 3 fois la charge
- B. 27 fois la charge normale
- C. aucune charge
2. Un budget de retries sert à :
- A. augmenter le nombre de relances
- B. supprimer les délais d'attente
- C. plafonner les relances à une fraction du trafic pour éviter l'avalanche
3. La propagation d'échéance évite que :
- A. des couches travaillent pour un client qui a déjà abandonné
- B. le réseau soit lent
- C. les messages soient chiffrés
4. 🔁 Révision mission 02 : Un délai dépassé sur un appel distant laisse le résultat :
- A. forcément échoué
- B. inconnu : l'action a pu avoir lieu ou non
- C. forcément réussi
5. 🔁 Révision mission 02 : « Exactement une fois » s'obtient en pratique par :
- A. une garantie du réseau
- B. un délai plus long
- C. au moins une fois (relances) + idempotence
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Dans ton système, combien de couches réessaient un même appel ? Le sais-tu ?
- Quels délais d'attente de ta chaîne d'appels sont plus longs que le délai de l'utilisateur qui attend ?
🎒 À retenir
- La latence de queue se propage ; fan-out = plus de probabilité de lenteur.
- Retries : transitoires, idempotents, recul + gigue, un seul niveau.
- Amplification = produit des tentatives par couche.
- Budget de retries (10 %) et disjoncteur évitent les tempêtes.
- Échéance propagée ; hedging contre la queue de latence.
flowchart LR
T(["Latence, timeout et retry"])
T --> R1["1. La latence de queue se propage ; fan-out = plus de probabilité de…"]
T --> R2["2. Retries : transitoires, idempotents, recul + gigue, un seul niveau."]
T --> R3["3. Amplification = produit des tentatives par couche."]
T --> R4["4. Budget de retries 10 % et disjoncteur évitent les tempêtes."]
T --> R5["5. Échéance propagée ; hedging contre la queue de latence."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Maître des délais
← Mission 02 — RPC et communication · Mission 04 — Idempotence →
HEF-140 — Systèmes distribués

