Pods en CrashLoopBackOff OOMKilled : diagnostiquer avec Dynatrace

Pods en CrashLoopBackOff OOMKilled ? Confirmez la cause avec kubectl, trouvez les workloads touchés en DQL, comparez mémoire et limites, puis alertez.
Pods en CrashLoopBackOff OOMKilled : diagnostiquer avec Dynatrace

Un déploiement part en production, et quelques minutes plus tard kubectl get pods affiche le même statut sur plusieurs réplicas : CrashLoopBackOff. Juste au-dessus, un champ de dernier état indique OOMKilled. Le couple CrashLoopBackOff OOMKilled est l’un des incidents Kubernetes les plus fréquents, et l’un des plus mal diagnostiqués : on augmente la limite mémoire, le problème revient la semaine suivante.

Chaque redémarrage coupe des requêtes en cours, vide les caches et consomme le budget d’erreur du service. Le délai de back-off grandit à chaque échec : plus on tarde, plus la capacité disponible fond. Un diagnostic méthodique réduit le MTTR et évite de transformer une fuite mémoire en simple ajustement de YAML.

Objectif de ce tutoriel : distinguer les causes d’un CrashLoopBackOff, confirmer un OOMKilled, puis utiliser Dynatrace pour trouver les workloads touchés, comparer consommation et limites, et alerter avant la panne. Les requêtes DQL valent pour Dynatrace SaaS (Grail, application Kubernetes). Sur Dynatrace Managed, la même démarche passe par les pages Kubernetes classiques et l’explorateur de données.

CrashLoopBackOff et OOMKilled : deux signaux différents

CrashLoopBackOff n’est pas une cause : c’est l’état d’attente d’un conteneur que le kubelet redémarre après des échecs successifs, avec un délai croissant. La cause est ailleurs. OOMKilled est l’une d’elles : le noyau a tué le processus parce que le conteneur a dépassé sa limite mémoire (code de sortie 137).

Raison du dernier arrêt Code de sortie Piste
OOMKilled 137 Limite mémoire trop basse, fuite mémoire, pic de charge
Error 1 ou autre Exception au démarrage, configuration ou secret manquant
Completed 0 Processus qui se termine alors qu’il devrait tourner
Sonde de liveness en échec 137 ou 143 Sonde trop agressive, démarrage lent

Le code 137 seul ne suffit pas : un conteneur tué par une sonde de liveness reçoit aussi un signal. Seule la raison OOMKilled confirme le dépassement mémoire.

Prérequis

  • kubectl avec un accès en lecture au namespace concerné.
  • Le cluster surveillé par Dynatrace Operator (voir Connecter Dynatrace Operator à un cluster), avec la surveillance Kubernetes activée.
  • En SaaS : l’accès aux Notebooks et à l’application Kubernetes. En Managed : l’accès aux écrans Kubernetes et à l’explorateur de données.

Diagnostiquer un pod CrashLoopBackOff OOMKilled pas à pas

Étape 1 : lire l’état du conteneur

kubectl get pods -n boutique
kubectl describe pod paiement-7d9c6b5f8-x2kq4 -n boutique

Dans la sortie de describe, cherchez le bloc Last State du conteneur : Reason: OOMKilled et Exit Code: 137 confirment l’hypothèse mémoire. Notez aussi Restart Count et la section Limits. Pour aller droit au but :

kubectl get pod paiement-7d9c6b5f8-x2kq4 -n boutique \
  -o jsonpath='{.status.containerStatuses[*].lastState.terminated.reason}'

Étape 2 : lire les logs de l’exécution précédente

Le conteneur actuel vient de redémarrer : ses logs sont presque vides. Ceux qui comptent sont ceux de l’instance tuée.

kubectl logs paiement-7d9c6b5f8-x2kq4 -n boutique --previous

Un OOMKilled laisse rarement un message d’erreur clair : le noyau tue le processus sans préavis. En revanche, une exception de démarrage (variable manquante, connexion refusée) apparaît ici et oriente vers une autre cause.

Étape 3 : trouver tous les workloads touchés avec DQL

kubectl montre un pod. Dynatrace montre tout le parc. Dans un Notebook SaaS, la métrique dt.kubernetes.container.oom_kills compte les arrêts pour dépassement mémoire :

timeseries oom = sum(dt.kubernetes.container.oom_kills, rollup:sum),
  by:{k8s.namespace.name, k8s.workload.name},
  from:-7d
| fieldsAdd total = arraySum(oom)
| filter total > 0
| sort total desc

Le rollup:sum additionne les événements de chaque intervalle ; arraySum ramène la série à un total par workload. Un workload isolé en tête de liste pointe vers un problème applicatif ; plusieurs workloads d’un même nœud évoquent plutôt une pression sur le nœud.

Étape 4 : comparer consommation et limite

Superposez la mémoire réellement utilisée (working set) et la limite configurée :

timeseries {
    utilise = sum(dt.kubernetes.container.memory_working_set),
    limite = sum(dt.kubernetes.container.limits_memory)
  },
  by:{k8s.workload.name},
  filter: k8s.namespace.name == "boutique",
  from:-24h
| fieldsAdd ratio = utilise[] / limite[] * 100

Lisez la forme de la courbe, pas seulement son maximum :

  • montée régulière jusqu’à la limite, puis chute : fuite mémoire. Augmenter la limite ne fait que retarder le prochain OOMKilled ;
  • plateau stable proche de la limite : limite sous-dimensionnée pour la charge normale ;
  • pics brefs corrélés au trafic : dimensionnement à revoir avec la charge de pointe, ou cache non borné.

Pour l’équivalent côté CPU, l’article Requêtes CPU effectives des pods Kubernetes détaille la logique des ressources effectives.

Étape 5 : lire les événements Kubernetes

Les événements Kubernetes ingérés dans Grail donnent la chronologie (back-off, échecs de sonde, évictions) :

fetch events, from:-24h
| filter event.provider == "KUBERNETES_EVENT"
| summarize n = count(), by:{event.name}
| sort n desc

Ajoutez ensuite un filtre sur le namespace ou le pod pour reconstituer la séquence de l’incident. Les noms exacts des champs d’événements peuvent varier : affichez d’abord une ligne brute pour les repérer.

Étape 6 : corriger, puis protéger

Selon le diagnostic :

resources:
  requests:
    memory: "512Mi"
  limits:
    memory: "768Mi"
  • Limite sous-dimensionnée : ajustez requests et limits sur la base du working set observé en charge de pointe, avec une marge.
  • Runtime géré (JVM, Node.js) : alignez la taille du tas sur la limite du conteneur, sinon le runtime croit disposer de toute la mémoire du nœud.
  • Fuite mémoire : ouvrez un ticket applicatif avec la courbe Dynatrace en pièce jointe. Le profilage mémoire de OneAgent, s’il est disponible pour la technologie, aide à localiser les allocations.

Comment vérifier que ça fonctionne

  • kubectl get pods -n boutique -w : la colonne RESTARTS doit cesser d’augmenter après le déploiement de la correction.
  • La requête de l’étape 3, relancée sur les dernières heures, ne doit plus renvoyer le workload.
  • Le ratio de l’étape 4 reste sous un seuil confortable (par exemple 80 %) pendant un pic de trafic.
  • Dans l’application Kubernetes (SaaS) ou la page du workload (Managed), le workload ne présente plus de problème de santé ouvert.

Bonnes pratiques

  • Alertez sur la tendance, pas sur l’incident : une alerte sur le ratio working set / limite au-dessus de 90 % prévient avant le premier OOMKilled. Gardez-la rare et actionnable pour ne pas nourrir le bruit.
  • Toujours définir des limites mémoire : un conteneur sans limite peut provoquer la pression mémoire du nœud entier et faire évincer ses voisins.
  • Sondes réalistes : un startupProbe évite qu’une liveness trop stricte tue un service lent à démarrer, ce qui ressemble à un CrashLoopBackOff sans OOM.
  • Postmortem sans blâme : conservez les requêtes DQL de l’enquête dans un Notebook partagé ; la prochaine astreinte gagnera du temps. Les patterns de logs aident à repérer les messages qui précèdent l’arrêt.

Questions fréquentes

Pourquoi le pod est OOMKilled alors que le nœud a de la mémoire libre ?

Parce que la limite s’applique au conteneur, pas au nœud. Dès que le conteneur dépasse sa propre limite, le noyau le tue, même si le nœud dispose de plusieurs gigaoctets libres.

Le statut CrashLoopBackOff disparaît puis revient : que se passe-t-il ?

Le kubelet redémarre le conteneur après chaque délai de back-off. Pendant qu’il tourne, le statut repasse à Running. Regardez le compteur de redémarrages et la raison du dernier arrêt plutôt que le statut instantané.

Ces requêtes fonctionnent-elles sur Dynatrace Managed ?

Non, la syntaxe DQL et Grail sont propres à SaaS. Sur Managed, utilisez les pages Kubernetes du workload, l’explorateur de données et les événements affichés sur l’entité pod.

Conclusion

Un CrashLoopBackOff OOMKilled se diagnostique en trois temps : confirmer la raison avec kubectl, mesurer l’ampleur et la forme de la consommation avec Dynatrace, puis corriger la vraie cause. Ajoutez une alerte de tendance et la panne suivante deviendra un ticket de dimensionnement, pas un réveil nocturne.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Les noms de métriques et d’écrans évoluent : vérifiez-les dans la documentation officielle et la documentation Kubernetes.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Migrer Managed vers SaaS : plan, outils et pièges de la bascule Dynatrace

Migrer Managed vers SaaS : plan, outils et pièges de la bascule Dynatrace

Next Post
Dynatrace Monaco : la configuration en code, pas à pas

Dynatrace Monaco : la configuration en code, pas à pas

Related Posts