Un système en production est une boîte noire. Journaux, métriques et traces sont les fenêtres qui permettent de voir ce qui se passe à l'intérieur.
⏱️ Durée : environ 105 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Sentinelle des signaux
🎬 L'histoire
Mardi, les utilisateurs de HashBox se plaignent de lenteurs. L'équipe regarde les serveurs : le processeur est calme, la mémoire aussi. Quelques journaux contiennent « erreur » mais sans heure précise ni contexte. Après deux heures, un développeur remarque qu'un appel à un service tiers prend 8 secondes — depuis le déploiement de lundi soir.
« On a perdu deux heures parce qu'on ne voyait pas, dit Sam. Observer un système, c'est pouvoir poser des questions nouvelles à partir de ce qu'il émet, sans avoir à le modifier. »
Tu apprends les trois piliers de l'observabilité (journaux, métriques, traces), les indicateurs d'objectif de service (SLI/SLO), le budget d'erreurs, et comment alerter sans noyer les gens.
🎯 Ta mission
À la fin, je serai capable de :
- distinguer journaux, métriques et traces et leur usage
- écrire des journaux structurés avec identifiant de corrélation
- mesurer des latences par percentiles et des taux d'erreur
- définir des SLI, SLO et un budget d'erreurs
- concevoir des alertes qui signalent de vrais problèmes (taux de consommation du budget)
🧩 Défi d'échauffement (5 XP)
Tu conduis une voiture. Le tableau de bord affiche la vitesse, le niveau de carburant et les voyants. Si la voiture n'avait aucun affichage et qu'elle se mettait à vibrer, que ferais-tu ? Cite trois informations que tu voudrais voir. Lesquelles sont des mesures continues, lesquelles des événements isolés ?
💡 Le concept
Surveillance et observabilité
- Surveillance (monitoring) : vérifier des choses connues (« le service répond-il ? »).
- Observabilité : pouvoir comprendre l'état interne d'un système à partir de ses sorties, y compris pour des problèmes inattendus.
Les trois piliers
| Pilier | Quoi | Question typique | Coût |
|---|---|---|---|
| Journaux (logs) | événements discrets horodatés | que s'est-il passé pour cette requête ? | volumineux |
| Métriques | valeurs numériques agrégées dans le temps | quelle est la tendance ? quel taux d'erreurs ? | compactes |
| Traces | parcours d'une requête à travers les services (suite de spans) | où le temps est-il passé ? | échantillonnées |
Des journaux utiles
- Structurés (JSON) : analysables par machine ;
- niveaux cohérents (DEBUG, INFO, WARNING, ERROR) ;
- horodatage UTC précis, service, version ;
- identifiant de corrélation (
request_id) transmis entre services ; - pas de secrets ni de données personnelles inutiles (HEF-100) ;
- un événement = un message clair avec ses champs.
Les métriques : types
| Type | Exemple |
|---|---|
| Compteur (counter) | nombre de requêtes, d'erreurs : ne fait que croître |
| Jauge (gauge) | mémoire utilisée, taille de la file : monte et descend |
| Histogramme | distribution des durées par tranches : permet les percentiles |
Percentiles, pas moyennes : la moyenne cache la « queue » des requêtes lentes. p50 (médiane), p95, p99 disent ce que vivent la majorité et les moins chanceux.
Quelles métriques regarder ?
- RED (services) : Rate (débit), Errors (erreurs), Duration (durée).
- USE (ressources) : Utilization (utilisation), Saturation (file d'attente), Errors.
- Les « quatre signaux d'or » : latence, trafic, erreurs, saturation.
Traces
Une trace suit une requête : une suite de spans (opération, début, durée, span parent). Elle révèle quel service ou quelle requête de base de données consomme le temps.
GET /cours (320 ms)
├─ authentification (12 ms)
├─ lecture base (45 ms)
└─ appel service tiers (260 ms) ← le coupable
SLI, SLO, budget d'erreurs
| Sigle | Sens | Exemple |
|---|---|---|
| SLI | indicateur mesuré du niveau de service | proportion de requêtes réussies en moins de 500 ms |
| SLO | objectif visé sur une période | 99,9 % sur 30 jours |
| SLA | engagement contractuel (avec pénalités) | 99,5 % |
| Budget d'erreurs | part d'échec acceptable : 100 % − SLO | 0,1 % ≈ 43,2 min d'indisponibilité par mois |
Le budget d'erreurs arbitre entre vitesse et fiabilité : tant qu'il reste du budget, on peut livrer des changements risqués ; quand il est épuisé, on se concentre sur la fiabilité.
Alerter : le taux de consommation (burn rate)
Alerter sur chaque erreur épuise les gens. On alerte quand le budget est consommé trop vite :
burn rate = taux d'erreurs observé / taux d'erreurs toléré (1 − SLO)
Un burn rate de 1 épuise le budget exactement à la fin de la période ; 14,4 sur 1 heure consomme 2 % du budget mensuel en 1 heure : alerte urgente. On utilise deux fenêtres (longue et courte) pour réagir vite et éviter les fausses alertes.
Principes d'une bonne alerte
- Actionnable : quelqu'un sait quoi faire ;
- liée à l'impact utilisateur, pas à un détail interne (processeur à 85 %) ;
- avec un lien vers un guide d'intervention (runbook) ;
- peu nombreuse ; chaque fausse alerte est un défaut à corriger.
🧠 Astuce : avant de livrer une fonctionnalité, demande-toi « comment saurai-je en production qu'elle fonctionne ? ». Si la réponse est vague, ajoute la mesure.
🔍 Exemple pas à pas
Problème : instrumenter un service simulé (journaux structurés avec corrélation, compteur, histogramme, trace), détecter un déploiement fautif par les percentiles, et calculer SLI, SLO et budget d'erreurs.
import contextvars, io, json, logging, math, random, time
from contextlib import contextmanager
# ---------------- journaux structurés avec identifiant de corrélation ----------------
id_requete = contextvars.ContextVar("id_requete", default="-")
class FormatJSON(logging.Formatter):
def format(self, enreg):
return json.dumps({"niveau": enreg.levelname, "message": enreg.getMessage(), "id_requete": id_requete.get(),
**getattr(enreg, "champs", {})}, ensure_ascii=False, sort_keys=True)
flux = io.StringIO()
journal = logging.getLogger("hashbox"); journal.handlers.clear(); journal.setLevel(logging.INFO)
gestionnaire = logging.StreamHandler(flux); gestionnaire.setFormatter(FormatJSON()); journal.addHandler(gestionnaire); journal.propagate = False
id_requete.set("req-42")
journal.info("inscription créée", extra={"champs": {"cours": "HEF-010", "duree_ms": 37}})
ligne = json.loads(flux.getvalue().splitlines()[0])
print(ligne)
assert ligne["id_requete"] == "req-42" and ligne["cours"] == "HEF-010"
# ---------------- métriques : compteur et histogramme ----------------
class Histogramme:
(): .valeurs = []
(): .valeurs.append(v)
():
v = (.valeurs)
v[((v) - , math.ceil(p / * (v)) - )]
:
(): .spans, ._pile, ._horloge = [], [],
():
parent = ._pile[-] ._pile
._pile.append(nom)
debut = ._horloge
:
:
._horloge = (._horloge, debut + duree_ms)
._pile.pop()
.spans.append({: nom, : parent, : duree_ms})
():
rng = random.Random(graine)
requetes = []
i (n):
apres = i >= deploiement_a
latence = rng.lognormvariate(math.log(), )
apres rng.random() < :
latence +=
erreur = rng.random() < ( apres )
requetes.append({: i, : latence, : erreur})
requetes
reqs = simuler()
avant, apres = [r r reqs r[] < ], [r r reqs r[] >= ]
nom, groupe ((, avant), (, apres)):
h = Histogramme()
r groupe: h.observer(r[])
moyenne = (h.valeurs) / (h.valeurs)
taux = (r[] r groupe) / (groupe)
()
h_av, h_ap = Histogramme(), Histogramme()
r avant: h_av.observer(r[])
r apres: h_ap.observer(r[])
h_ap.percentile() > * h_av.percentile()
h_ap.percentile() < * h_av.percentile()
t = Trace()
t.span(, ):
t.span(, ):
t.span(, ):
t.span(, ):
coupable = ((s s t.spans s[]), key= s: s[])
(, coupable[], coupable[], )
coupable[] ==
SLO =
():
( r groupe r[] r[] < ) / (groupe)
total = sli(reqs)
budget_total = ( - SLO) * (reqs)
echecs = ( r reqs r[] r[] >= )
()
total < SLO echecs > budget_total
minutes_mois = * *
()
(minutes_mois * ( - SLO), ) ==
():
echecs = ( r groupe r[] r[] >= )
(echecs / (groupe)) / ( - SLO)
()
burn_rate(apres) > > burn_rate(avant)
Lecture :
- Le journal structuré porte l'
id_requete: toutes les lignes d'une même requête se retrouvent d'un coup d'œil, même entre services. - Après le déploiement, la médiane (p50) ne bouge presque pas, mais le p99 est multiplié par plus de cinq : une moyenne ou une médiane aurait caché le problème.
- La trace pointe immédiatement
appel service tierscomme le span le plus long. - Le SLI (réussite en moins de 500 ms sans erreur) tombe sous le SLO de 99,9 % ; le budget est largement dépassé. Le burn rate après déploiement dépasse 14,4 : une alerte urgente aurait sonné en quelques minutes.
✍️ À toi, avec aide (10 XP)
Un service a un SLO de 99,95 % de disponibilité sur 30 jours.
- Calcule le budget d'indisponibilité en minutes.
- Un incident de 18 minutes a eu lieu cette semaine, un autre de 9 minutes il y a 10 jours : quelle part du budget est consommée ? Combien reste-t-il ?
- À ce rythme, sur 30 jours, le SLO sera-t-il tenu ? (Suppose que d'autres incidents suivent le même rythme : 27 minutes en 10 jours.)
- Que recommandes-tu à l'équipe concernant les déploiements risqués ?
💡 Indice 1
Budget = 30 × 24 × 60 × (1 − 0,9995).
💡 Indice 2
Part consommée = minutes d'incident / budget.
💡 Indice 3
Projection : 27 minutes pour 10 jours → 81 minutes pour 30 jours.
✅ Réponse
minutes = 30 * 24 * 60
budget = minutes * (1 - 0.9995)
consomme = 18 + 9
print(f"budget {budget:.1f} min, consommé {consomme} min ({consomme / budget:.0%}), reste {budget - consomme:.1f} min")
projection = consomme * 3
print(f"projection à 30 jours : {projection} min ({projection / budget:.0%} du budget)")
assert round(budget, 1) == 21.6 and consomme > budget
Le budget est de 21,6 minutes. Avec 27 minutes d'incident, il est déjà dépassé (125 %), et la projection à 30 jours (81 minutes) serait de 375 %. Le SLO ne sera pas tenu. Recommandation : geler les déploiements risqués, concentrer l'équipe sur la fiabilité (cause des incidents, tests, retour arrière automatique), et ne reprendre les nouvelles fonctionnalités qu'une fois la tendance rétablie. C'est le rôle du budget d'erreurs : transformer la fiabilité en décision objective.
🚀 À toi, en solo (20 XP)
Alerte à double fenêtre sur le taux de consommation. Implémente une alerte de type « burn rate » :
- SLO 99,9 % ; flux de requêtes simulé minute par minute (échecs par minute et total par minute) ;
- règle d'alerte urgente : burn rate > 14,4 sur 1 heure ET > 14,4 sur 5 minutes ;
- règle d'alerte lente : burn rate > 1 sur 3 jours (ticket, pas d'appel) ;
- teste trois scénarios : (a) panne franche (taux d'erreur de 5 % pendant 20 min) → alerte urgente rapide ; (b) micro-pic d'une minute (30 % d'erreurs) → aucune alerte ; (c) dégradation lente (0,3 % d'erreurs en continu) → alerte lente seulement ;
- mesure le délai de détection de (a).
✅ Pistes de correction
SLO = 0.999
BUDGET = 1 - SLO
def burn(minutes, fin, fenetre):
debut = max(0, fin - fenetre + 1)
echecs = sum(m[0] for m in minutes[debut:fin + 1]); total = sum(m[1] for m in minutes[debut:fin + 1])
return (echecs / total) / BUDGET if total else 0.0
def evaluer(minutes):
alertes = []
for t in range(len(minutes)):
if burn(minutes, t, 60) > 14.4 and burn(minutes, t, 5) > 14.4 and not any(a[0] == "urgente" for a in alertes):
alertes.append(("urgente", t))
if t >= 3 * 24 * 60 - 1 burn(minutes, t, * * ) > (a[] == a alertes):
alertes.append((, t))
alertes
TRAFIC =
():
minutes = []
t (duree):
p = taux_panne (debut_panne debut_panne <= t < fin_panne) taux
t pics: p =
minutes.append(((TRAFIC * p), TRAFIC))
minutes
a = evaluer(flux( * , , debut_panne=, fin_panne=, taux_panne=))
b = evaluer(flux( * , , pics=(,)))
c = evaluer(flux( * * , ))
(, a, , b, , c)
[x[] x a] == [] <= a[][] <=
b == []
[x[] x c] == []
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Se fier aux moyennes | Elles cachent la queue de latence | Percentiles p95 / p99, histogrammes |
| Journaux non structurés, sans corrélation | Enquête interminable | JSON + identifiant de requête |
| Alerter sur tout | Fatigue d'alerte, vraies alertes ignorées | Alertes liées à l'impact utilisateur et au burn rate |
| Journaliser des secrets ou des données personnelles | Fuite via les journaux (HEF-100) | Masquer, minimiser |
🐉 Mini-boss (40 XP)
Observer un incident de bout en bout. Simule un service HashBox à trois composants (api, base, service de paiement) sur 24 heures, avec un déploiement fautif à 14 h (le service de paiement ralentit pour 10 % des requêtes). Construis :
- les journaux structurés, les compteurs, les histogrammes et les traces de chaque requête ;
- les SLI (disponibilité et latence), le SLO, le budget d'erreurs consommé ;
- les deux alertes à double fenêtre et leur délai de détection ;
- une analyse automatique : compare les percentiles avant/après chaque déploiement, identifie par les traces le composant responsable ;
- un rapport d'incident d'une page : chronologie, impact (requêtes affectées), cause, détection, correction, actions ;
- 10 tests, dont l'absence de fausse alerte sans incident.
✅ Pistes de correction
Un bon travail : générateur reproductible avec composants et durées par span; histogrammes par minute; SLI/SLO/budget; alerte double fenêtre; comparaison des p99 avant/après le déploiement; agrégation des spans par composant pour désigner paiement; rapport de type post-mortem sans blâme (chronologie avec heures, impact chiffré, cause racine, ce qui a bien marché — l'alerte, ce qui a manqué — un test de latence en pré-production, actions avec responsables).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Pour mesurer la latence ressentie par les moins chanceux, on regarde :
- A. la moyenne uniquement
- B. le nombre de serveurs
- C. les percentiles élevés (p95, p99)
2. Un budget d'erreurs de 99,9 % sur 30 jours correspond à environ :
- A. 43 minutes d'indisponibilité
- B. 4 heures
- C. 4 secondes
3. Un identifiant de corrélation sert à :
- A. chiffrer les journaux
- B. relier toutes les lignes d'une même requête entre services
- C. accélérer la base
4. 🔁 Révision mission 07 : Un déploiement canary consiste à :
- A. remplacer tout d'un coup
- B. déployer seulement la nuit
- C. envoyer une petite part du trafic vers la nouvelle version, mesurer, puis étendre
5. 🔁 Révision mission 07 : Un artefact promu de staging à la production doit être :
- A. le même, construit une seule fois
- B. reconstruit pour la production
- C. modifié à la main
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Si ton service ralentissait cette nuit, quelle première mesure regarderais-tu, et existe-t-elle ?
- Quelle alerte de ton équipe a sonné ces derniers mois sans qu'on ait rien à faire ?
🎒 À retenir
- Trois piliers : journaux, métriques, traces.
- Journaux structurés avec identifiant de corrélation, sans secrets.
- Percentiles plutôt que moyennes ; RED et USE.
- SLI, SLO, budget d'erreurs : la fiabilité devient une décision chiffrée.
- Alerter sur le burn rate, avec double fenêtre, sur l'impact utilisateur.
flowchart LR
T(["Observabilité"])
T --> R1["1. Trois piliers : journaux, métriques, traces."]
T --> R2["2. Journaux structurés avec identifiant de corrélation, sans secrets."]
T --> R3["3. Percentiles plutôt que moyennes ; RED et USE."]
T --> R4["4. SLI, SLO, budget d'erreurs : la fiabilité devient une décision…"]
T --> R5["5. Alerter sur le burn rate, avec double fenêtre, sur l'impact…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Sentinelle des signaux
← Mission 07 — CD et environnements · Mission 09 — Rollback et résilience opérationnelle →
HEF-120 — DevOps et livraison

