Aller au contenu
Cabinet d'expertise en transformation technologique · ARDIANE Group Innover, sécuriser, réussir

Cloud et plateformes

Supervision Kubernetes : les indicateurs à suivre, du cluster à l'application

L'essentiel

La supervision Kubernetes est le suivi continu de l'état et de la consommation d'un cluster à quatre niveaux : plan de contrôle, nœuds, charges de travail et applications. Management Square détaille ici les indicateurs à suivre à chaque niveau, la manière de les lire et ce qu'aucun d'eux ne dit des autres niveaux.

Sommaire de la page

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.

Insights

À lire sur le sujet

Tous les insights
Quelle migration informatique engager, et quand vaut-il mieux différer ?

Une migration informatique transfère une infrastructure, une application ou des données d'un environnement d'origine vers un environnement cible, jusqu'à l'arrêt de l'origine. Management Square donne ici les critères pour choisir le type de migration et la stratégie de bascule, préparer la reprise des données et le retour arrière, et reconnaître les cas où il vaut mieux s'abstenir ou différer.

Lire l'analyse
Docker vs Kubernetes : construire des conteneurs, les orchestrer, ou les deux

Docker sert à construire des images de conteneurs et à les exécuter sur une machine, Kubernetes à orchestrer des conteneurs sur un ensemble de machines : la comparaison Docker vs Kubernetes porte sur deux niveaux qui se complètent. Management Square compare ici leurs rôles et décrit les situations où l'un suffit sans l'autre.

Lire l'analyse
L'observabilité des systèmes distribués commence par un parcours tracé de bout en bout

L'observabilité des systèmes distribués repose sur le traçage distribué : un identifiant propagé de service en service relie les opérations d'une même demande, puis les journaux et les métriques qui s'y rapportent. Management Square décrit ici la méthode pour instrumenter un parcours de bout en bout, de la propagation du contexte à l'échantillonnage, avec ce que chaque étape produit et qui en répond.

Lire l'analyse

FAQ

Questions fréquentes

Une autre question ? Posez-la-nous

Quels indicateurs suivre en priorité dans un cluster Kubernetes ?

Commencez par un indicateur par niveau. Pour le plan de contrôle, la latence et le taux d'erreur du serveur d'API. Pour les nœuds, la part de la capacité allouable déjà réservée par les demandes de ressources. Pour les charges de travail, l'écart entre réplicas demandés et réplicas disponibles, et le rythme des redémarrages. Pour l'application, le taux d'erreur et le temps de réponse vus par l'utilisateur.

Quelle différence entre metrics-server et kube-state-metrics ?

Le serveur de métriques (metrics-server) alimente l'API de métriques de Kubernetes, qui fournit le minimum de mesures de processeur et de mémoire nécessaire à la mise à l'échelle automatique et à la commande kubectl top. kube-state-metrics est un composant additionnel qui interroge le serveur d'API et expose, sous forme de métriques, l'état des objets du cluster : réplicas, phases des pods, redémarrages. Le premier sert l'orchestrateur, le second sert la supervision.

Quels outils utilise-t-on pour le monitoring Kubernetes ?

Les composants de Kubernetes exposent leurs métriques au format de Prometheus, ce qui fait de cet outil de collecte une base fréquente, associé à un outil de tableaux de bord tel que Grafana. OpenTelemetry sert à instrumenter les applications de manière homogène. Les fournisseurs de cloud et les éditeurs proposent des services équivalents. L'outil pèse moins sur le résultat que le choix des indicateurs et des seuils d'alerte.

Un service Kubernetes managé dispense-t-il de superviser le cluster ?

Non. Le fournisseur exploite le plan de contrôle, mais les nœuds que vous configurez, les charges de travail et les applications restent à votre charge, de même que les demandes et les limites de ressources de chaque conteneur. Les métriques du plan de contrôle ne sont en outre exposées qu'en partie : la latence et les erreurs constatées depuis vos propres outils de déploiement restent à suivre.

Faut-il alerter sur l'utilisation du processeur et de la mémoire des pods ?

Rarement en urgence. Une consommation élevée n'est pas une panne tant que le service répond, et Kubernetes absorbe une partie des écarts par la mise à l'échelle. Les alertes immédiates gagnent à porter sur le service rendu : erreurs, temps de réponse, indisponibilité. La consommation se suit comme une tendance, rapportée aux demandes et aux limites, pour ajuster le dimensionnement en journée.

Un projet à faire aboutir ?

Un premier échange suffit pour situer votre enjeu, identifier les bons interlocuteurs et vous dire franchement ce que nous pouvons apporter.