La supervision Kubernetes est le suivi continu de l’état et de la consommation d’un cluster à quatre niveaux : le plan de contrôle, les nœuds, les charges de travail et les applications qu’elles exécutent. Elle répond à trois questions. Le cluster peut-il encore accueillir et déplacer des charges ? Celles-ci tournent-elles dans l’état demandé ? Les utilisateurs sont-ils servis ?
La difficulté tient à la nature de l’orchestrateur. Kubernetes corrige de lui-même une partie des défaillances : il redémarre un conteneur, replace un pod, ajoute un réplica. Une panne peut donc se répéter longtemps sans se voir. Aucun niveau ne renseigne non plus sur les autres. Un cluster sain peut héberger une application en erreur, et une application peut répondre alors que le cluster ne sait plus rien déployer.
La supervision Kubernetes, niveau par niveau
| Niveau | Ce que l’on mesure | D’où vient la mesure | Ce que le chiffre ne dit pas |
|---|---|---|---|
| Cluster (plan de contrôle) | Latence et erreurs du serveur d’API, santé d’etcd, pods en attente de placement | Métriques exposées par les composants du plan de contrôle | Si les applications répondent |
| Nœuds | État déclaré, pressions mémoire et disque, capacité réservée et consommée | Kubelet, exportateur de métriques système | Si les pods hébergés fonctionnent |
| Charges de travail | Réplicas disponibles, redémarrages, sondes, consommation rapportée aux demandes et aux limites | kube-state-metrics, cAdvisor intégré au kubelet | Si le service rendu est correct |
| Application | Débit, taux d’erreur, temps de réponse, saturation | Point d’entrée du trafic, instrumentation du code | Où se trouve la cause |
Les composants de Kubernetes exposent leurs métriques au format de Prometheus. Cet outil de collecte, associé à un outil de tableaux de bord tel que Grafana, se rencontre donc dans beaucoup de dispositifs. Le choix de l’outillage compte moins que celui des indicateurs.
Ce découpage ne rouvre pas le débat entre les deux approches, traité dans notre article observabilité vs supervision. Il s’en tient à ce qu’il faut surveiller dans un cluster, niveau par niveau.
Le cluster : un plan de contrôle qui répond et qui décide
Le plan de contrôle reçoit toutes les demandes (serveur d’API), conserve l’état du cluster (etcd) et décide du placement des pods (ordonnanceur). Cinq mesures le décrivent : la latence et le taux d’erreur des requêtes adressées au serveur d’API, la latence d’écriture et la taille de la base etcd, la fréquence des changements de leader, le nombre de pods que l’ordonnanceur ne parvient pas à placer, l’échéance des certificats.
Un plan de contrôle lent ne coupe pas le service : les applications déjà en place continuent en général de répondre. En revanche, plus rien ne se répare, ne se déploie ni ne s’adapte à la charge au rythme attendu. L’effet apparaît ailleurs et plus tard, ce qui rend la cause difficile à remonter sans ces mesures.
Sur un service managé, le fournisseur exploite le plan de contrôle et n’en expose qu’une partie des métriques. La latence et les erreurs constatées depuis vos propres outils de déploiement restent alors la mesure la plus fidèle de ce que vous subissez.
Les nœuds : état déclaré, pression et capacité réservée
Chaque nœud publie des conditions : prêt ou non, sous pression mémoire, sous pression disque, à court d’identifiants de processus. S’y ajoutent les mesures habituelles d’un serveur (processeur, mémoire, disque, réseau) et une mesure propre à Kubernetes : la part de la capacité allouable déjà réservée par les demandes de ressources (requests) des pods.
Cette dernière se lit avant les autres. L’ordonnanceur place un pod d’après les ressources qu’il demande, sans regarder la consommation réelle du nœud. Un nœud dont le processeur est peu sollicité peut donc rester fermé à tout nouveau pod qui déclare une demande, parce que sa capacité est entièrement réservée. À l’inverse, des demandes sous-estimées laissent s’entasser des pods sur un nœud qui sature.
Une moyenne calculée sur le cluster masque le nœud en difficulté. La lecture se fait par groupe de nœuds, avec la valeur la plus défavorable. Les nœuds, par ailleurs, se remplacent : une alerte utile porte sur la proportion de nœuds indisponibles dans un groupe, ou sur l’impossibilité d’en ajouter, rarement sur une machine nommée.
Les charges de travail : l’écart entre l’état demandé et l’état constaté
Kubernetes fonctionne par déclaration : vous décrivez un état, il s’efforce de l’atteindre. Superviser les charges de travail revient donc à mesurer un écart. Un composant additionnel, kube-state-metrics, traduit en métriques l’état des objets du cluster. cAdvisor, intégré au kubelet, fournit la consommation des conteneurs.
Les indicateurs qui comptent :
- le nombre de réplicas disponibles rapporté au nombre demandé, pour chaque déploiement ;
- la durée passée par un pod en attente, signe d’un manque de capacité ou d’une contrainte de placement impossible à satisfaire ;
- le rythme des redémarrages de conteneurs et leur motif, en particulier l’arrêt pour dépassement de mémoire (OOMKilled) et le redémarrage en boucle (CrashLoopBackOff) ;
- les échecs de la sonde de disponibilité (readiness probe), qui retirent un pod de la répartition du trafic ;
- la consommation rapportée aux demandes et aux limites, et le temps pendant lequel le processeur d’un conteneur est bridé par sa limite ;
- une mise à l’échelle automatique arrivée à son nombre maximal de réplicas ;
- les traitements planifiés en échec ou non déclenchés, et le remplissage des volumes persistants.
Le compteur de redémarrages est cumulatif : c’est sa pente qui alerte. Un pod à l’état Running n’est pas forcément prêt à recevoir du trafic.
Les chiffres de consommation trompent de deux façons. Une utilisation moyenne modeste du processeur n’exclut pas un bridage pendant les pics, que seule la mesure de bridage révèle. La mémoire affichée inclut du cache que le système peut libérer : la valeur à suivre est la mémoire de travail (working set), celle que le kubelet retient pour décider d’évincer des pods. Enfin, les événements du cluster, qui expliquent un échec de placement ou de sonde, ne sont conservés qu’une heure par défaut par le serveur d’API. Ils sont à exporter si vous voulez les relire après un incident.
L’application : ce que vit l’utilisateur du service
Les trois premiers niveaux décrivent la plateforme. Le quatrième est le seul à dire si le service est rendu. Il se mesure au point d’entrée du trafic et dans le code : débit des requêtes, taux d’erreur, temps de réponse, saturation des ressources dont dépend le service (files d’attente, connexions à la base). L’ouvrage Site Reliability Engineering, rédigé par des ingénieurs de Google, les nomme les quatre signaux dorés : latence, trafic, erreurs, saturation. Un standard ouvert tel qu’OpenTelemetry sert à produire ces mesures de façon homogène d’un service à l’autre.
Les temps de réponse se lisent en centiles, pour les raisons exposées dans notre article sur le test de charge. Les alertes qui réveillent une astreinte gagnent à partir de ce niveau : un pod qui redémarre sans effet sur les utilisateurs mérite un ticket le lendemain. Cette hiérarchie est celle des objectifs de niveau de service, présentés dans notre page SRE et observabilité.
Ce niveau ne donne pas la cause. Un taux d’erreur qui monte désigne un symptôme. L’explication se cherche en redescendant vers les charges de travail, les nœuds, puis le plan de contrôle. Les indicateurs des quatre niveaux doivent donc porter les mêmes étiquettes (espace de noms, application, version), faute de quoi le rapprochement se fait à la main, en plein incident.
Fournir ces étiquettes, la collecte et les règles d’alerte avec le modèle de déploiement, plutôt que de les laisser reconstruire par chaque équipe, est une affaire de plateforme. C’est le rôle des chemins balisés décrits dans notre offre DevOps et platform engineering.
Les questions à poser avant d’ajouter un tableau de bord
- Chaque niveau dispose-t-il d’au moins un indicateur suivi, et d’un responsable qui le regarde ?
- Les alertes urgentes portent-elles sur le service rendu, et les autres sur des tendances traitées en journée ?
- Chaque conteneur déclare-t-il des demandes de ressources, sans lesquelles la capacité réservée ne signifie rien ?
- Les sondes de disponibilité vérifient-elles que l’application sait répondre, au-delà de la seule existence du processus ?
- Les événements et les métriques sont-ils conservés hors du cluster, pour rester lisibles quand il est lui-même en panne ?
- Le dispositif de supervision est-il surveillé depuis l’extérieur du cluster ?
- Un nouveau service est-il supervisé dès son premier déploiement, sans travail propre à l’équipe qui le livre ?
Une réponse négative désigne le premier chantier, avant tout nouvel outil.