Exploitation informatique — fiabilité des sites (SRE) Modèle en direct

Vous êtes d’astreinte pour un service web : un répartiteur de charge devant un parc d’instances, un cache devant une base de données, et un objectif de disponibilité de 99,9 %. Chaque minute, le modèle calcule le délai de file d’attente, les expirations, les succès de cache et la charge de la base de données à partir de formules de manuel — et ce que coûtent vos décisions.

Ce que vous allez apprendre

Simulateur

Temps 0 min
Requêtes 1125 · Taux d’erreur 0,00% · Latence p99 342 ms · Instances en service 10 (+0) · Taux de succès du cache 77% · Utilisation de la base de données 19% · Budget d’erreur restant (30 jours) 50,0%⇉1125 req/s▶▶▶▶▶▶▶▶▶▶······························▶ 10 · ⚙ 0 · 52% · p99 342 msUtilisation du parc 52%Taux de succès du cache 77%Utilisation de la base de données 19%⚠ 0,00% · 🔥 0,0×50%$ 4,00/h · Σ $0,00
  • Instance en service
  • Instance en démarrage
  • Instance sur le mauvais build
  • Emplacement libre
  • Requêtes entrantes

Commandes

Plancher du parc. L’augmenter lance des instances immédiatement — elles ont encore besoin du délai de démarrage avant de servir.

Suivi de cible sur l’utilisation ; pas de nouvelle montée en charge tant que des instances démarrent. Désactivé = exactement le minimum.

Plus bas = plus de marge et plus de coût. L’utilisation mesurée ne peut pas dépasser 100 %, donc un parc saturé ne grandit que pas à pas.

TTL plus long = plus de succès, mais des réponses plus anciennes (âge moyen ≈ TTL/2).

Charge les clés chaudes pendant 6 minutes (+12 % du cache par minute) au prix de 600 requêtes de base de données/s supplémentaires.

Part des 30 % de faible priorité (préchargement, batch, robots d’indexation) rejetée au répartiteur de charge avec « réessayez plus tard ».

La fonctionnalité lourde ajoute 20 ms de CPU et une requête de base de données par requête. Désactivé = dégradation gracieuse.

Redéploie la dernière bonne version sur un parc neuf (5 min, facturé deux fois), puis bascule le trafic. Appuyer à nouveau relance la préparation ; sans mauvaise version en production, cela ne coûte que de l’argent.

Indicateurs

Taux d’erreur
0,00%
normal
Latence p99
342ms
normal
Budget d’erreur restant (30 jours)
50,0%
normal
Utilisation du parc
52%
normal
Taux de consommation (1 h)0,0 ×
Requêtes1125 req/s
Instances en service10
Instances en démarrage0
Taux de succès du cache77 %
Utilisation de la base de données19 %
Trafic délesté0 %
Coût du parc4,00 $/h
Coût à ce jour0,00 $
Âge moyen des réponses en cache30 s
Trafic sur le mauvais build0 %
Recommandations disponibles100 %

Tendance

Taux d’erreur: — %20,000,00

Scénarios de crise

Niveau 1 · Mauvaise version

Un nouveau build est déployé à 09:10. Le mois a déjà été difficile : il ne reste que 20 % du budget d’erreur. Quelques minutes après le déploiement, l’alerte de burn rate se déclenche. Protégez le budget.

  • Budget d’erreur restant à la fin ≥ 18,5 %
  • Taux d’erreur moyen ≤ 0,65 % après le déploiement
  • Coût du parc ≤ 9,50 $

Niveau 2 · Afflux soudain de trafic

Un lien vers le service se propage vite et un pic de trafic est attendu à un moment de cette matinée — personne ne sait quand ni de quelle ampleur. Le démarrage de nouvelles instances prend 8 minutes aujourd’hui. Quand il arrivera, gardez les erreurs et la latence faibles sans brûler d’argent dans une capacité inutilisée.

  • Taux d’erreur moyen ≤ 0,2 %
  • Latence p99 moyenne ≤ 400 ms
  • Trafic délesté moyen ≤ 5 %
  • Coût total ≤ 21 $
  • Recommandations disponibles ≥ 85 % du temps

Niveau 3 · Cache froid

Au pic de midi, un script de maintenance vide tout le cache. Chaque requête va maintenant à la base de données, dimensionnée pour le taux de succès habituel de 85 %. Rétablissez le service sans surcharger la base de données.

  • Taux d’erreur moyen ≤ 1,5 %
  • Utilisation de la base de données jamais au-dessus de 90 % après la première minute
  • Âge moyen des réponses en cache ≤ 90 s en moyenne
  • Coût total ≤ 9 $
  • Recommandations disponibles ≥ 80 % du temps
  • Trafic délesté moyen ≤ 5 %

Base — le modèle derrière les chiffres

Chaque relation utilisée par le simulateur, avec sa source. Les constantes marquées comme hypothèses sont des calibrations illustratives.

Les requêtes suivent une courbe journalière plus des perturbations ; le nombre par minute est aléatoire (Poisson, approximation normale) avec un peu de rafales.
λ(t) = base × (1 + 0.25·sin(2π(t + clock − 6 h)/24 h)) × surge(t), clock = time of day at the start (peak at 12:00); count/min ≈ N(60λ, √(60λ)) × (1 + N(0, 0.02))[6]Hypothèse : le nombre de workers, les temps de service, la capacité de la base de données, la taille du cache, la vitesse de remplissage, les prix et le taux d’erreur du mauvais build sont des valeurs illustratives pour un service web de taille moyenne.
Erlang C : probabilité qu’une requête doive attendre un worker libre dans un système M/M/N.
N = instances × 16 workers, a = λ·S; C(a, N) = B / (1 − (a/N)(1 − B)), B = Erlang B[3][6]
Queue du temps d’attente : la probabilité d’attendre plus de t décroît de façon exponentielle ; les requêtes encore en attente au délai d’expiration de 2 s échouent. Au-delà de la capacité, l’excédent échoue.
P(W > t) = C·e^(−(N/S − λ)·t); timeouts = P(W > 2 s); a ≥ N ⇒ failed share = 1 − N/a[3]
Latence p99 à partir des quantiles du temps de service et du temps d’attente.
p99 ≈ S·ln 100 + ln(C/0.01)/(N/S − λ) (service + waiting quantile, an approximation)[3][6]Approximation : additionner les quantiles de service et d’attente ne donne pas le p99 exact de leur somme (il peut être un peu trop haut ou trop bas) ; la file est traitée comme stationnaire à l’intérieur de chaque minute, car les requêtes durent des millisecondes.
Loi de Little : workers occupés = taux d’arrivée × temps de service.
busy workers L = λ·S ⇒ utilization = λ·S / N[4]
Cache à TTL : avec des requêtes aléatoires, chaque échec ouvre une période de TTL pendant laquelle les requêtes sont servies par le cache.
hit = warm × rT/(1 + rT), r = λ / 20,000 objects; mean age of a cached answer ≈ T/2[5]
Les échecs de cache chargent la base de données ; son délai de file d’attente ralentit chaque requête qui la touche, ce qui remplit aussi les workers de l’application.
DB load = λ·q·(1 − hit); query time = 5 ms/(1 − ρ_db) (≤ 250 ms); S = S_app + (1 − hit)·q·query time[6]Hypothèse : le nombre de workers, les temps de service, la capacité de la base de données, la taille du cache, la vitesse de remplissage, les prix et le taux d’erreur du mauvais build sont des valeurs illustratives pour un service web de taille moyenne.
SLO et budget d’erreur : le taux de consommation (burn rate) dit combien de fois plus vite que prévu le budget est dépensé.
budget = 1 − SLO = 0.1 %; burn = error rate / 0.1 %; Δbudget per min = burn / 43,200; burn (1 h) = mean error rate over the last 60 min / 0.1 % (window pre-filled with the opening minute)[1][2]
Autoscaler à suivi de cible avec délai de démarrage et temps de repos.
desired = ⌈serving × utilization / target⌉ (utilization saturates at 100 %); new instances serve after the boot delay[6]Hypothèse : le nombre de workers, les temps de service, la capacité de la base de données, la taille du cache, la vitesse de remplissage, les prix et le taux d’erreur du mauvais build sont des valeurs illustratives pour un service web de taille moyenne.
Autres constantes d’exploitation utilisées par le modèle.
16 workers/instance · app time 50 ms (+20 ms and +1 query with the feature on) · 2 queries/request · DB 4,000 queries/s · 20,000 hot objects · cache refill τ = 30 min (slower while the DB is saturated) · warm-up job +12 %/min for 6 min, +600 queries/s · timeout 2 s · 30 % low-priority traffic · bad build +5 % errors, ×1.25 CPU · rollback 5 min · $0.40 per instance-hour · scale-in by ≤ 20 % of the fleet after 10 quiet minutes · up to 40 instancesHypothèse : le nombre de workers, les temps de service, la capacité de la base de données, la taille du cache, la vitesse de remplissage, les prix et le taux d’erreur du mauvais build sont des valeurs illustratives pour un service web de taille moyenne.

Aléa : un générateur mulberry32 à graine ; lois utilisées — uniforme, exponentielle (fonction de répartition inverse), normale (Box–Muller), Poisson (Knuth). La graine est affichée et partageable.

Sources

  1. Site Reliability Engineering — Ch. 3 Embracing Risk (error budgets), Ch. 4 Service Level Objectives — Beyer, Jones, Petoff, Murphy (eds.), O'Reilly, 2016
  2. The Site Reliability Workbook — Ch. 5 Alerting on SLOs (burn rate; 14.4× over 1 h = 2 % of a 30-day budget) — Beyer, Murphy, Rensin, Kawahara, Thorne (eds.), O'Reilly, 2018
  3. Teletraffic Engineering Handbook — Erlang C formula; waiting-time distribution for M/M/n, FCFS — ITU-D Study Group 2 Question 16/2 (V. B. Iversen), 2005
  4. J. D. C. Little — A Proof for the Queuing Formula: L = λW — Operations Research 9(3):383–387, 1961
  5. J. Jung, A. W. Berger, H. Balakrishnan — Modeling TTL-based Internet Caches — IEEE INFOCOM 2003, 2003
  6. M. Harchol-Balter — Performance Modeling and Design of Computer Systems: Queueing Theory in Action (M/M/k, server farms, capacity provisioning) — Cambridge University Press, 2013

Qui fait cela comme métier

Modèle pédagogique — pas pour des décisions opérationnelles. Les sites réels calibrent chaque constante sur leurs propres équipements et données.