Les leçons apprises avec les healthchecks
Un 200 sur /health ne prouve rien. Les erreurs de healthcheck qui m'ont coûté des incidents, et les règles que j'applique désormais.
Le premier healthcheck que j'ai écrit tenait en trois lignes. Il renvoyait 200 dès que le process répondait, parce que c'était ça, la définition du mot « vivant ». Trois mois plus tard, une saturation du pool Postgres a mis l'API à genoux pendant quarante minutes, et aucune sonde n'a bronché. Le process respirait très bien. Il ne servait juste plus rien.
Depuis, j'ai relu chaque healthcheck de mes stacks avec un œil beaucoup moins indulgent. Voilà ce que j'en retire.
Un 200 sur /health ne prouve presque rien
Mon handler répondait 200 en deux millisecondes, parce qu'il ne touchait à rien. Pas de requête SQL, pas d'appel réseau : juste un return "ok" et un statut 200.
Pendant l'incident, le pool de connexions était plein à 100/100, les requêtes métier patientaient trente secondes avant de partir en timeout, et le healthcheck continuait d'affirmer que tout allait bien. Le load balancer envoyait donc du trafic à un service qui ne pouvait plus en absorber.
La leçon n'est pas « ajoute un ping SQL dans /health ». La leçon, c'est que liveness et readiness ne répondent pas à la même question. La liveness demande « faut-il tuer ce process ? ». La readiness demande « faut-il lui envoyer des requêtes ? ». Confondre les deux, c'est piloter un avion avec un seul instrument. La doc Kubernetes sur les probes le dit en deux paragraphes, mais il faut un incident pour le lire vraiment.
Le healthcheck qui teste ses dépendances fabrique les pannes en cascade
Pendant deux ans, j'ai mis Redis et Postgres dans mon /health. Je trouvais ça sérieux. C'était surtout le meilleur moyen de propager une panne locale à tout le cluster.
Un failover Redis de vingt secondes a suffi : les readiness probes sont passées au rouge sur 42 pods d'un coup, les endpoints se sont vidés, et un incident limité à un service de cache est devenu un 503 global. Quarante-deux redémarrages inutiles pour une dépendance qui était déjà revenue.
Ma règle est devenue bête. La liveness ne regarde que la boucle interne du process : un mutex, un event loop qui tourne, un thread qui répond. La readiness peut interroger les dépendances, mais son seul droit est de retirer du trafic, jamais de tuer. J'ai détaillé ce partage dans les compromis nécessaires avec les healthchecks, et l'incident m'a confirmé que ce n'était pas de la théorie.
Les timeouts par défaut transforment un ralentissement en CrashLoop
Un /health qui interroge la base met 1,4 seconde au p99 quand la charge monte. Avec timeoutSeconds: 1 et failureThreshold: 3, trois échecs consécutifs suffisent : le kubelet tue un pod parfaitement fonctionnel, en pleine montée en charge, exactement au moment où tu as le moins besoin de perdre de la capacité.
livenessProbe:
httpGet:
path: /livez
port: 8080
initialDelaySeconds: 20
periodSeconds: 10
timeoutSeconds: 5
failureThreshold: 5
readinessProbe:
httpGet:
path: /readyz
port: 8080
periodSeconds: 5
timeoutSeconds: 2
failureThreshold: 2Le calcul à retenir : timeoutSeconds × failureThreshold donne la fenêtre avant le kill, pas periodSeconds. Avec les valeurs ci-dessus, la liveness laisse vingt-cinq secondes de mou, la readiness sort du trafic en dix. Le symétrique existe aussi : une stack sans readiness probe garde un pod mort dans la rotation, et un tiers du trafic part en 502 jusqu'à ce que quelqu'un regarde le dashboard.
Les jobs silencieux : ce qu'un healthcheck entrant ne verra jamais
Un healthcheck classique surveille quelque chose qui reçoit des requêtes. Un pg_dump nocturne ne reçoit rien. Il tourne, il échoue, et personne ne le sait.
Le mien a échoué onze jours de suite. Disque plein sur la cible, code retour 1, aucune alerte, et un cron qui réessayait sagement chaque nuit. On l'a découvert en cherchant tout autre chose.
Depuis, tout job sans requête entrante a un heartbeat sortant. Une URL de ping en fin de script, un period de 24 h et une grâce d'une heure côté service : si le ping n'arrive pas, l'alerte part. La documentation healthchecks.io couvre le cas en entier, y compris le suivi de la durée d'exécution pour repérer un backup qui prend trois fois plus de temps qu'avant.
#!/usr/bin/env bash
set -euo pipefail
pg_dump -Fc app > /backup/app.dump
curl -fsS -m 10 --retry 3 https://hc-ping.com/00000000-0000-0000-0000-000000000000Le set -euo pipefail n'est pas décoratif : sans lui, un pg_dump en échec laisse le script continuer et envoyer le ping de succès. J'ai vu cette variante en production, et elle produit exactement le pire des deux mondes : un faux positif vert et un backup absent.
Ce que je mesure maintenant : le taux de succès, pas le pouls
Un healthcheck est binaire. Un service qui échoue sur 4 % de ses requêtes répond 200 à toutes les sondes. Tu peux avoir un healthcheck vert et un budget d'erreur déjà brûlé depuis deux heures.
Sur les services qui comptent, j'ai remplacé l'alerte « sonde DOWN » par une alerte sur le taux de consommation du budget d'erreur. Le SRE Workbook décrit le burn rate, et l'implémentation est simple : une règle qui compare les erreurs 5xx des soixante dernières minutes au budget mensuel, avec un seuil à 2 %.
Résultat concret sur une API à 99,9 % de SLO : une dégradation à 97 % de succès déclenche une alerte en quatre minutes, alors que l'ancienne sonde binaire n'aurait rien vu du tout. La sonde est devenue un filet de sécurité, plus le détecteur principal.
« Un /health, ça coûte rien » — si
C'est l'argument qu'on m'oppose à chaque revue d'architecture, et il est faux deux fois.
D'abord, un healthcheck mal calibré a un coût direct. Sur un service Java, une pause GC de huit secondes a suffi à déclencher trois redémarrages en rafale : cache froid, pool de connexions reconstruit, latence multipliée par dix pendant quatre-vingt-dix secondes. Le pod n'avait rien, la sonde l'a tué.
Ensuite, le coût différé est pire. Un healthcheck vert te fait croire que tu es couvert, donc tu investis ailleurs, et le jour où la panne arrive tu découvres que ta seule sonde ne mesurait que l'existence d'un process. La correction réflexe dans ce cas, c'est de monter failureThreshold à 10 : tu gagnes le silence, tu perds la détection des vrais OOM.
Mon avis est tranché : un healthcheck mal calibré est plus dangereux que pas de healthcheck du tout. L'absence d'instrument ne trompe personne.
Trois règles que j'applique maintenant
La liveness ne touche à rien d'externe et prend un timeout généreux : cinq secondes, cinq échecs, vingt-cinq secondes de fenêtre avant le kill. Si le process est réellement bloqué, ça suffit largement.
La readiness peut tester les dépendances, mais elle ne tue jamais : son rôle est de sortir le pod de la rotation, et elle doit réagir plus vite que la liveness, pas l'inverse. C'est la leçon que j'ai le plus mal apprise, et elle recoupe ce que j'avais écrit sur les enseignements des readiness probes.
Tout ce qui ne reçoit pas de requêtes a un heartbeat sortant, avec une grâce calculée sur la durée normale du job plus une marge. Un backup de quarante minutes avec une grâce d'une heure, c'est raisonnable. Une grâce de cinq minutes sur un job qui prend douze minutes, c'est une alerte quotidienne à ignorer.
Un healthcheck n'est pas une case à cocher dans un manifeste. C'est une affirmation sur ce que tu sais mesurer, et cette affirmation se vérifie en incident, jamais en revue de code.