Kamorion

Blog · SRE et observabilité · · 5 min de lecture

Une sonde de liveness qui dépend de la base : un CrashLoopBackOff à chaque maintenance

Quand la sonde de liveness interroge la base de données, une simple maintenance fait redémarrer les pods en boucle, et le service reste coupé après le retour de la base. La correction tient en quelques lignes : séparer ce qui dit « je suis vivant » de ce qui dit « je peux servir ».

Une base PostgreSQL managée devait passer en haute disponibilité. L’opération était planifiée, la base indisponible quelques minutes, et l’application devait simplement attendre. En pratique, chaque pod applicatif a redémarré sept fois, a fini en CrashLoopBackOff, et le service est resté coupé après le retour de la base.

La base n’était pas en cause. La sonde de liveness, si.

Ce qui s’est passé

L’application était un moteur GraphQL, Hasura, déployé par son chart Helm. Sa sonde de liveness interrogeait l’endpoint /healthz. Cet endpoint vérifie la connexion à PostgreSQL et répond 500 quand la base est injoignable.

La suite est mécanique :

Maintenance de la basePostgreSQL injoignable quelques minutes
Liveness en échec/healthz répond 500, le kubelet tue le conteneur
Redémarragel’application n’arrive pas à se connecter et s’arrête
CrashLoopBackOffchaque nouvel essai attend plus longtemps, jusqu’à 5 minutes
Retour de la basele pod attend encore la fin de son délai avant de repartir
Une maintenance de quelques minutes devient une coupure plus longue.

Le dernier point est le plus coûteux. Après chaque échec, Kubernetes double le délai avant le redémarrage suivant : 10 secondes, 20, 40, et ainsi de suite jusqu’à un plafond de 5 minutes. Quand la base revient, les pods sont au milieu de cette attente. Ils ne retentent pas tout de suite. Le service reste donc indisponible plusieurs minutes de plus que la base elle-même.

Pire : la sonde n’a rien protégé. Redémarrer un processus sain ne répare pas une base absente. La liveness a transformé une dépendance indisponible en une panne de l’application.

Trois sondes, trois questions

Kubernetes propose trois sondes. Elles n’ont pas le même effet, et c’est là que se joue la correction.

SondeQuestion poséeEffet d’un échec
LivenessLe processus est-il vivant ?Le conteneur est tué et redémarré
ReadinessLe pod peut-il servir maintenant ?Le pod est retiré des endpoints du Service, sans redémarrage
StartupL’application a-t-elle fini de démarrer ?Tant qu’elle n’a pas réussi, liveness et readiness ne s’exécutent pas

La liveness sert à détecter un processus bloqué, qu’un redémarrage peut débloquer : un interblocage, une boucle infinie, un serveur qui n’accepte plus de connexions. Elle ne doit dépendre de rien d’extérieur au conteneur. Sinon, une panne de dépendance déclenche des redémarrages qui n’ont aucune chance de la résoudre.

La readiness, elle, peut vérifier la base. Un échec retire le pod du load balancer, le temps que la dépendance revienne. Le pod reste vivant, garde son état, et redevient disponible dès que la sonde repasse au vert.

Liveness qui dépend de la base

La base tombe : les pods sont tués

Au redémarrage, l’application s’arrête faute de base

Backoff jusqu’à 5 minutes entre deux essais

Le service revient bien après la base

Liveness sans dépendance, readiness sur la base

La base tombe : les pods sortent du load balancer

Les pods restent démarrés et attendent

Aucun redémarrage, aucun backoff

Le service revient dès que la readiness repasse

Même panne de base, deux comportements très différents.

La configuration corrigée

Pour la liveness, nous utilisons une sonde tcpSocket : le processus écoute-t-il sur son port ? La readiness garde l’endpoint qui vérifie la base.

livenessProbe:
  tcpSocket:
    port: 8080
  periodSeconds: 10
  failureThreshold: 3
readinessProbe:
  httpGet:
    path: /healthz
    port: 8080
  periodSeconds: 5
  failureThreshold: 2

Si l’application expose un endpoint de santé qui ne consulte aucune dépendance, il convient aussi à la liveness. L’essentiel est qu’il réponde tant que le processus fonctionne, quel que soit l’état de la base.

Pour une application lente à démarrer, une sonde de startup évite d’allonger artificiellement les délais de la liveness. Elle laisse à l’application le temps de démarrer, puis passe la main :

startupProbe:
  tcpSocket:
    port: 8080
  periodSeconds: 5
  failureThreshold: 30   # jusqu’à 150 secondes pour démarrer

Le piège de la fusion Helm

Avec le chart, déclarer tcpSocket dans nos valeurs n’a pas suffi. Le chart définissait déjà un httpGet par défaut pour la liveness. Helm fusionne les maps de valeurs : notre tcpSocket s’ajoutait au httpGet existant au lieu de le remplacer. Or une sonde ne peut porter qu’un seul mécanisme, et l’API Kubernetes refuse le manifeste.

La solution est d’annuler explicitement la clé par défaut. Dans les valeurs Helm, null supprime une clé héritée :

livenessProbe:
  httpGet: null
  tcpSocket:
    port: 8080

Le réflexe vaut pour tous les charts : avant de changer le type d’une sonde, lisez les valeurs par défaut, et vérifiez le rendu avec helm template avant de déployer.

Le résultat

Après la correction, la base a de nouveau basculé : aucun pod n’a redémarré. Pendant l’indisponibilité, la readiness retire les pods du load balancer ; ils y reviennent seuls dès que la base répond.

Le service est bien indisponible pendant que la base l’est : la readiness ne crée pas de capacité qui n’existe pas. Mais la coupure s’arrête avec la panne, au lieu de lui survivre plusieurs minutes.

Vérifier vos déploiements

Quelques questions suffisent pour repérer le problème :

  • Que vérifie l’endpoint appelé par la liveness ? S’il touche une base, un cache ou une API externe, c’est un risque.
  • Le chart Helm définit-il des sondes par défaut ? Elles ont souvent été écrites pour le cas général, pas pour votre usage.
  • Le compteur de redémarrages des pods augmente-t-il pendant les maintenances des dépendances ? C’est le symptôme le plus visible.
kubectl get pods -n <namespace> \
  -o custom-columns='NOM:.metadata.name,REDEMARRAGES:.status.containerStatuses[*].restartCount'

Une nuance : une readiness qui vérifie une dépendance partagée sort tous les pods en même temps quand cette dépendance tombe. C’est le comportement voulu quand l’application ne peut rien servir sans elle. Si une partie du service peut fonctionner sans la base, mieux vaut que la readiness le reflète.

À retenir

  • La liveness ne vérifie que le processus. Tout ce qui est extérieur au conteneur relève de la readiness.
  • Un redémarrage ne répare jamais une dépendance absente. Il ajoute un backoff qui prolonge la coupure.
  • Testez vos sondes en simulant la panne d’une dépendance, pas seulement au déploiement.

Nous revoyons ces réglages dans nos missions de fiabilité et d’observabilité et d’exploitation Kubernetes. Vos pods redémarrent à chaque maintenance ? Parlons-en.

Contact

Commençons par un audit

Nous lisons votre plateforme : ce qui est en code et ce qui ne l’est pas, ce qui vous expose, ce qui vous coûte, et ce que nous ferions en premier.

  • Premier échange sans engagement
  • Un diagnostic écrit, qui reste à vous
  • Accès en lecture seule pendant l’audit

Ou écrivez-nous : [email protected]