Observabilité

Point de départ

// ── 1. Budget d'erreur ────────────────────────────────────────────────────
const MOIS_MINUTES = 30 * 24 * 60;   // 43 200

const INCIDENTS = [
  { jour: 3,  minutes: 4,  cause: "déploiement défaillant, retour arrière" },
  { jour: 11, minutes: 2,  cause: "sonde mal réglée, redémarrages" },
  { jour: 18, minutes: 22, cause: "panne du fournisseur de base" },
  { jour: 26, minutes: 6,  cause: "migration bloquante" },
];

function budget(slo, incidents) {
  const autorise = 0;    // ← à écrire : (1 − slo) × minutes du mois
  const consomme = 0;    // ← à écrire
  return { autorise, consomme, restant: autorise - consomme,
           realise: 0 }; // ← disponibilité réellement atteinte
}

// ── 2. Qualité des alertes ────────────────────────────────────────────────
// Chaque alerte : la valeur mesurée, et s'il y avait VRAIMENT un problème.
const ALERTES = [
  { valeur: 2.4, vraiProbleme: true },  { valeur: 0.9, vraiProbleme: false },
  { valeur: 5.1, vraiProbleme: true },  { valeur: 1.2, vraiProbleme: false },
  { valeur: 3.8, vraiProbleme: true },  { valeur: 0.6, vraiProbleme: false },
  { valeur: 1.8, vraiProbleme: false }, { valeur: 4.2, vraiProbleme: true },
  { valeur: 1.1, vraiProbleme: true },  { valeur: 0.8, vraiProbleme: false },
  { valeur: 2.9, vraiProbleme: false }, { valeur: 6.0, vraiProbleme: true },
];

function qualite(seuil, alertes) {
  // ← à écrire : précision = part des alertes qui méritaient une action ;
  //   rappel = part des vrais problèmes détectés.
  return { declenchees: 0, precision: 0, rappel: 0 };
}

// ── 3. Chronologie d'un incident ──────────────────────────────────────────
const CHRONOLOGIE = {
  panne: "10:04",        // le déploiement défaillant part
  alerte: "10:31",       // quelqu'un est prévenu
  diagnostic: "10:44",   // la cause est comprise
  retabli: "10:46",      // le retour arrière est terminé
};

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez budget(). Que reste-t-il à 99,9 % ? Et à 99,99 % ?
// 2. Écrivez qualite() et faites varier le seuil de 0,5 à 5. Peut-on
//    améliorer précision ET rappel en même temps ?
// 3. Découpez la chronologie en trois segments. Lequel domine, et sur quoi
//    faut-il donc travailler en priorité ?

console.log(JSON.stringify(budget(0.999, INCIDENTS)));

Solution

const MOIS_MINUTES = 30 * 24 * 60;

const INCIDENTS = [
  { jour: 3,  minutes: 4,  cause: "déploiement défaillant, retour arrière" },
  { jour: 11, minutes: 2,  cause: "sonde mal réglée, redémarrages" },
  { jour: 18, minutes: 22, cause: "panne du fournisseur de base" },
  { jour: 26, minutes: 6,  cause: "migration bloquante" },
];

function budget(slo, incidents) {
  const autorise = (1 - slo) * MOIS_MINUTES;
  const consomme = incidents.reduce((s, i) => s + i.minutes, 0);
  return { autorise, consomme, restant: autorise - consomme,
           realise: 1 - consomme / MOIS_MINUTES };
}

console.log("— 1. budget d'erreur —");
for (const slo of [0.99, 0.999, 0.9999]) {
  const b = budget(slo, INCIDENTS);
  console.log("   SLO " + (slo * 100).toFixed(2).padStart(6) + " % : " +
    "budget " + b.autorise.toFixed(0).padStart(4) + " min | consommé " +
    b.consomme + " min | restant " + b.restant.toFixed(0).padStart(5) + " min" +
    (b.restant < 0 ? "   BUDGET ÉPUISÉ : gel des changements risqués" : "   on peut déployer"));
}
console.log("   disponibilité réellement atteinte : " +
  (budget(0.999, INCIDENTS).realise * 100).toFixed(3) + " %");
console.log("   À 99,9 % il reste " + budget(0.999, INCIDENTS).restant.toFixed(0) +
            " minutes : l'équipe est autorisée à prendre des risques.");
console.log("   À 99,99 % le budget est dépassé dès le premier incident : ce SLO");
console.log("   interdirait presque tout changement, pour un bénéfice qu'aucun");
console.log("   utilisateur ne perçoit. Un SLO trop élevé coûte plus qu'il ne rapporte.");

console.log("");
console.log("— 2. précision et rappel des alertes —");
const ALERTES = [
  { valeur: 2.4, vraiProbleme: true },  { valeur: 0.9, vraiProbleme: false },
  { valeur: 5.1, vraiProbleme: true },  { valeur: 1.2, vraiProbleme: false },
  { valeur: 3.8, vraiProbleme: true },  { valeur: 0.6, vraiProbleme: false },
  { valeur: 1.8, vraiProbleme: false }, { valeur: 4.2, vraiProbleme: true },
  { valeur: 1.1, vraiProbleme: true },  { valeur: 0.8, vraiProbleme: false },
  { valeur: 2.9, vraiProbleme: false }, { valeur: 6.0, vraiProbleme: true },
];

function qualite(seuil, alertes) {
  const declenchees = alertes.filter((a) => a.valeur >= seuil);
  const vraisPositifs = declenchees.filter((a) => a.vraiProbleme).length;
  const totalVrais = alertes.filter((a) => a.vraiProbleme).length;
  return {
    declenchees: declenchees.length,
    // Précision : parmi ce qui a sonné, quelle part méritait une action ?
    precision: declenchees.length ? vraisPositifs / declenchees.length : 1,
    // Rappel : parmi les vrais problèmes, quelle part a sonné ?
    rappel: vraisPositifs / totalVrais,
  };
}

console.log("   seuil | alertes | précision | rappel | lecture");
for (const seuil of [0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 5.0]) {
  const q = qualite(seuil, ALERTES);
  const lecture = q.precision < 0.6 ? "bruyant : on apprend à ignorer"
                : q.rappel < 0.6 ? "silencieux : des incidents passent"
                : "acceptable";
  console.log("   " + seuil.toFixed(1).padStart(5) + " | " + String(q.declenchees).padStart(7) +
    " | " + (q.precision * 100).toFixed(0).padStart(8) + " %" +
    " | " + (q.rappel * 100).toFixed(0).padStart(5) + " %" + " | " + lecture);
}
console.log("   Les deux ne s'améliorent pas ensemble : abaisser le seuil détecte");
console.log("   plus d'incidents ET plus de faux positifs. Un seuil trop bas produit");
console.log("   le bruit qui détruit le signal ; trop haut, il laisse passer. Le");
console.log("   réglage est une décision, pas un réglage par défaut.");

console.log("");
console.log("— 3. anatomie d'un incident —");
const minutes = (h) => { const [a, b] = h.split(":").map(Number); return a * 60 + b; };
const C = { panne: "10:04", alerte: "10:31", diagnostic: "10:44", retabli: "10:46" };
const segments = [
  { nom: "panne → alerte (détection)", d: minutes(C.alerte) - minutes(C.panne) },
  { nom: "alerte → diagnostic", d: minutes(C.diagnostic) - minutes(C.alerte) },
  { nom: "diagnostic → rétabli (action)", d: minutes(C.retabli) - minutes(C.diagnostic) },
];
const total = segments.reduce((s, x) => s + x.d, 0);
for (const s of segments) {
  console.log("   " + s.nom.padEnd(32) + String(s.d).padStart(3) + " min  " +
    "█".repeat(s.d) + "  " + Math.round((s.d / total) * 100) + " %");
}
console.log("   temps de rétablissement : " + total + " min");
const pire = segments.reduce((a, b) => (b.d > a.d ? b : a));
console.log("   Le segment dominant est « " + pire.nom + " » : c'est là qu'il faut");
console.log("   travailler. Améliorer le retour arrière — déjà à 2 minutes — ne");
console.log("   gagnerait presque rien ; abaisser le délai de DÉTECTION diviserait");
console.log("   le temps de rétablissement par deux. C'est exactement ce que le");
console.log("   canari du chapitre 6 attendait de ce chapitre.");

Avant de commencer

• Le déploiement du TP 9, qui tourne
• Prometheus et Grafana dans le cluster, ou en Compose à côté
• Une charge continue sur l'application (une boucle curl suffit)

Énoncé

1. Exposer les métriques — Faites exposer par l'application un compteur de requêtes étiqueté par code de réponse, et un histogramme de latence. Vérifiez que Prometheus les récupère. Indice : Un compteur par code permet de calculer un TAUX d'erreur ; un compteur global ne le permet pas.
2. Construire le tableau de bord minimal — Affichez les quatre signaux dorés : latence au 95e centile, trafic, taux d'erreur, saturation. Rien d'autre. Indice : Une moyenne de latence cache exactement ce qu'on cherche : surveillez des centiles.
3. Fixer un SLO et calculer le budget — Choisissez un objectif de disponibilité sur trente jours, calculez le budget d'erreur correspondant en minutes, et affichez la part déjà consommée.
4. Écrire une seule alerte — Une alerte, sur un symptôme, avec un seuil et une durée. Écrivez à côté, en une phrase, ce que fait la personne réveillée — si vous ne savez pas l'écrire, l'alerte n'est pas la bonne.
5. Casser la production — Sans prévenir vos camarades, déployez une version qui échoue sur une part des requêtes. Notez l'heure exacte.
6. Diagnostiquer — L'équipe d'astreinte — vos camarades — travaille SANS regarder le code déployé. Ils partent de l'alerte, passent au tableau de bord, puis aux journaux. Notez l'heure de l'alerte et celle du diagnostic.
7. Revenir en arrière — Exécutez le retour arrière et notez l'heure de rétablissement. Vérifiez sur le tableau de bord que le taux d'erreur redescend.
8. Écrire le post-mortem — Cinq parties, comme au TP 1. Calculez les trois segments — détection, diagnostic, action — et dites lequel domine votre temps de rétablissement. C'est celui-là qu'il faudra travailler.

C'est réussi quand

• ✓ L'alerte est partie sans intervention humaine
• ✓ Le diagnostic a été fait sans lire le code fautif
• ✓ Vous avez trois durées chiffrées, et vous savez laquelle réduire en priorité
• ✓ Le post-mortem ne nomme personne et ses actions ont une échéance

Correction

const requetes = new client.Counter({
name: "http_requetes_total",
help: "requêtes servies",
labelNames: ["route", "code"],       // l'étiquette rend le taux calculable
});

const duree = new client.Histogram({
name: "http_duree_secondes",
help: "latence",
buckets: [0.05, 0.1, 0.3, 1, 3],
});

SLO 99,9 % sur 30 jours
budget = 0,1 % × 43 200 min = 43,2 min

incident de ce TP : 42 min d'erreurs à 30 %
consommation ≈ 42 × 0,30 = 12,6 min  →  29 % du budget mensuel

- alert: TauxErreurEleve
expr: |
  sum(rate(http_requetes_total{code=~"5.."}[5m]))
    / sum(rate(http_requetes_total[5m])) > 0.02
for: 2m
annotations:
  resume: "taux d'erreur au-dessus de 2 % depuis 2 minutes"
  action: |
    1. tableau de bord : la hausse suit-elle un déploiement ?
    2. si oui : kubectl rollout undo deployment/tickets
    3. sinon : journaux du service, filtrer sur code 5xx

10:04  déploiement de la version fautive
10:31  alerte reçue          → détection   27 min
10:44  cause identifiée      → diagnostic  13 min
10:46  retour arrière fini   → action       2 min
                             total        42 min