Les compromis nécessaires avec les healthchecks

Une sonde de santé décide, elle ne mesure pas. Voici les trois compromis que personne ne veut assumer.

Les compromis nécessaires avec les healthchecks

Un healthcheck qui répond 200 n'a jamais sauvé une production. Ce qui l'a sauvée, c'est quelqu'un qui a accepté de trancher ce que « en bonne santé » voulait dire pour son service — et d'en payer le prix en latence, en faux positifs ou en capacité perdue.

J'ai longtemps traité la sonde de santé comme un détail de configuration. Puis j'ai vu un déploiement Kubernetes redémarrer en boucle douze pods parce que la sonde de liveness interrogeait Redis, et Redis était en train de redémarrer. Le healthcheck a transformé une panne de cache de quarante secondes en incident de vingt minutes.

Un healthcheck est une décision, pas une sonde

Une sonde mesure. Un healthcheck décide. La différence tient dans ce que le système fait de la réponse : retirer un nœud du trafic, redémarrer un conteneur, alerter un humain à 3 h du matin.

Chaque fois que tu écris return 200, tu signes un contrat qui dit : « cette instance peut prendre du trafic maintenant ». Si c'est faux, tu perds des requêtes.

Si c'est trop prudent, tu perds de la capacité. Il n'existe aucun réglage qui te donne les deux en même temps.

Compromis n°1 : la profondeur tue la disponibilité

Plus ta sonde vérifie de choses, plus elle est honnête — et plus elle est fragile. Un /healthz qui teste la base, le cache, le broker et un partenaire externe va échouer à cause du partenaire externe. Tu redémarres alors une application parfaitement saine.

La règle que j'applique maintenant : une sonde de liveness ne teste que ce qui justifie un redémarrage. Un processus bloqué, un pool de threads saturé, un deadlock interne. Le reste relève de la readiness ou de l'alerte.

livenessProbe:
  httpGet:
    path: /livez
    port: 8080
  periodSeconds: 10
  failureThreshold: 3
startupProbe:
  httpGet:
    path: /livez
    port: 8080
  failureThreshold: 30
  periodSeconds: 2
readinessProbe:
  httpGet:
    path: /readyz
    port: 8080
  periodSeconds: 5
  failureThreshold: 2

Le startupProbe est la pièce que tout le monde oublie. Sans lui, une application Java qui met quarante secondes à démarrer se fait tuer par sa liveness avant d'avoir chargé son contexte. Le failureThreshold: 30 à deux secondes donne soixante secondes de sursis au démarrage, sans allonger la détection en régime normal.

Compromis n°2 : la fréquence se paie deux fois

Une sonde toutes les deux secondes sur cinquante instances, c'est 1500 requêtes par minute vers un endpoint qui, s'il est profond, interroge une base. La charge de surveillance devient une charge applicative.

Et ce n'est pas le pire. Une sonde trop fréquente avec un seuil trop bas transforme le moindre hoquet en oscillation : le nœud sort du trafic, le trafic se redistribue sur les autres qui saturent, leurs sondes échouent, tout le monde sort. C'est la panne en cascade déclenchée par la surveillance elle-même.

Deux garde-fous suffisent dans la majorité des cas. Un seuil d'échec à 3 minimum, jamais 1.

Et un amortissement côté load balancer. Sur un target group AWS, deux checks consécutifs en échec avec un intervalle de 10 secondes donnent vingt secondes de détection — largement acceptable pour une API qui répond en 80 ms. La documentation AWS sur les health checks de target groups détaille ces paramètres (HealthyThresholdCount, UnhealthyThresholdCount) et vaut la lecture avant de copier une config par défaut.

Compromis n°3 : ton check partage le sort de sa dépendance

C'est le piège que j'ai vu le plus souvent, et celui qui coûte le plus cher. La sonde interroge la base de données pour vérifier que tout va bien.

La base tombe. Toutes les instances déclarent forfait en même temps, alors qu'elles fonctionnent et pourraient servir du cache ou des réponses dégradées.

Autrement dit : tu as construit un détecteur de panne qui amplifie la panne. La sortie est simple à énoncer, plus dure à accepter.

Une sonde de disponibilité répond à « est-ce que je peux servir ce que je suis censé servir », avec une tolérance explicite. Si ton service dégrade proprement quand la base est absente, la sonde doit rester verte.

Côté Kubernetes, cette distinction est documentée noir sur blanc dans le guide officiel des liveness, readiness et startup probes. Elle est aussi la raison pour laquelle le format de réponse des health checks HTTP a été normalisé dans un draft IETF : un champ status, des composants détaillés, et la possibilité de dire « pass » avec un composant en warn.

L'objection « un check superficiel ne sert à rien »

On me l'oppose à chaque audit, et elle est partiellement juste. Un return 200 codé en dur vérifie une seule chose : que le serveur web répond encore. Ça n'attrape ni un pool de connexions mort, ni une file de messages saturée, ni une fuite mémoire en cours.

Ma réponse : c'est exactement pour ça que la sonde ne doit pas porter seule la responsabilité de la vérité. Un healthcheck répond à une question binaire et immédiate — « je prends du trafic, oui ou non ». Le reste appartient aux métriques et aux SLO, qui savent exprimer un dégradé.

Le contre-argument tient quand même sur un point : un check trop pauvre laisse passer des instances qui répondent 200 en renvoyant des erreurs 500 à chaque requête. La parade n'est pas d'alourdir la sonde, c'est d'ajouter un signal côté trafic. Un taux d'erreur 5xx supérieur à 5 % sur deux minutes doit retirer le nœud, et ça se règle dans le load balancer, pas dans le code applicatif.

Ce que je fige dans mes déploiements

Trois endpoints, trois rôles, et aucun ne fait le travail de l'autre. /livez vérifie uniquement l'état interne du processus, sans I/O réseau. /readyz vérifie que les dépendances nécessaires au trafic courant sont joignables, avec un timeout de 500 ms.

Le troisième n'est pas un endpoint : c'est l'alerte sur le taux d'erreur réel. Un healthcheck ne remplace pas une alerte, il la précède.

Le timeout court n'est pas un détail. J'ai déjà diagnostiqué une readiness qui mettait huit secondes à répondre parce que le driver Postgres attendait son propre timeout de connexion.

Résultat : le kubelet considérait la sonde en échec par dépassement de délai, alors que l'application allait bien. Un SELECT 1 avec un timeout explicite de 500 ms règle le problème et rend la sonde prévisible.

Reste la question que personne ne veut poser : combien d'instances es-tu prêt à perdre simultanément ? Si la réponse est « aucune », ton healthcheck est un interrupteur de panne total, pas un mécanisme de résilience. Le dimensionnement du maxUnavailable et de la capacité de réserve fait partie du compromis, au même titre que la profondeur de la sonde.

Le vrai juge, c'est le SLO

Un healthcheck ne dit pas si ton service va bien. Il dit si une instance doit recevoir du trafic à cet instant. Confondre les deux, c'est se retrouver avec des tableaux de bord tout verts et des utilisateurs en colère.

La seule mesure qui tranche reste le SLO : quel pourcentage de requêtes répond en moins de 300 ms sur trente jours. Si ton budget d'erreur tient, tes sondes peuvent clignoter, personne ne s'en aperçoit. S'il se consume, aucune sonde verte ne te sauvera.

Pour creuser la partie « ce qu'on mesure vraiment quand on surveille », j'ai détaillé le coût réel des outils dans le vrai coût de l'observabilité. Et ce qui se cache derrière la supervision pose le cadre humain qui manque à toute sonde. Les compromis décrits ici sont les mêmes que ceux d'un load balancer, analysés dans ce débat sur les load balancers.

Sources : Kubernetes — Configure Liveness, Readiness and Startup Probes, Google SRE Workbook — Alerting on SLOs, IETF — Health Check Response Format for HTTP APIs.