PerfectScale

Le blocage vient-il de votre NodePool ou de vos workloads ?

Apprenez à déterminer si un nœud Karpenter bloqué provient d'une limite de NodePool ou d'un blocage côté workload, et identifiez le responsable du correctif grâce à un arbre de décision en 4 questions.

Cette page est également disponible en English, Deutsch, Español, Italiano, 日本語 et Português.

Tania Duggal
By Tania Duggal
Nov 12, 202613 min read

Un nœud qui continue de tourner après une baisse de la demande est bloqué par quelque chose. Ce blocage se situe dans votre NodePool ou dans vos workloads, et la réponse détermine qui doit le corriger.

Une limite de NodePool est un paramètre qui indique à Karpenter de ne pas consolider. Exemples : la politique, le délai d'attente et un budget de disruption. L'équipe plateforme est propriétaire du NodePool. Un blocage côté workload est un pod qui ne peut pas quitter son nœud. Exemples : un PodDisruptionBudget (PDB), une annotation do-not-disrupt et une règle de placement. L'équipe applicative est propriétaire de ces objets.

Si vous désignez le mauvais propriétaire, la demande part à la mauvaise équipe et le nœud reste en place. Cet article vous propose un arbre de décision en quatre questions. Répondez-y dans l'ordre. Le premier oui identifie la catégorie du blocage, son propriétaire et l'étape suivante.

Deux types de blocages

Karpenter ne retire un nœud que lorsque deux conditions sont réunies : le NodePool autorise l'opération, et chaque pod présent sur le nœud peut en partir. Chaque condition a son propre responsable :

  1. Limite de NodePool : un paramètre du NodePool empêche Karpenter d'agir. Le correctif est une modification du NodePool, et l'équipe plateforme en est responsable.
  2. Blocage côté workload : un pod ne peut pas quitter le nœud, ou n'a aucun autre endroit où s'exécuter. Le correctif est une modification du workload, et l'équipe applicative en est responsable.

Karpenter n'agit que sur les nœuds qu'il a créés. Un nœud créé par un autre outil constitue un troisième cas, et aucun paramètre Karpenter ne peut y remédier. Un nœud peut aussi cumuler plusieurs blocages : corrigez-en un, puis vérifiez à nouveau le nœud.

L'arbre de décision

Partez d'un nœud qui subsiste après une baisse de la demande. Répondez aux quatre questions dans l'ordre. Arrêtez-vous au premier oui, car cette réponse identifie la catégorie du blocage et le responsable du correctif.

media

Chaque question s'accompagne d'une vérification rapide qui prouve la réponse. Exécutez-la avant de demander la moindre modification à qui que ce soit.

Question 1 : le nœud a-t-il été créé par un autre outil ?

Karpenter n'agit que sur les nœuds qu'il a créés : vérifiez donc d'abord le propriétaire. Un nœud sans NodeClaim n'est jamais candidat à la consolidation. Le label karpenter.sh/nodepool indique quel NodePool a créé le nœud. Remplacez $NODE par le nom du nœud :

kubectl get node $NODE -L karpenter.sh/nodepool

Une colonne NODEPOOL vide signifie que Karpenter n'a pas créé le nœud, et qu'il ne le consolidera donc jamais. Corrigez le problème dans l'outil qui a créé le nœud, par exemple un groupe de nœuds managé.

Question 2 : les paramètres du NodePool bloquent-ils actuellement la consolidation ?

Quatre paramètres du NodePool peuvent empêcher la consolidation. Lisez d'abord le bloc disruption : il affiche la politique, le délai d'attente et les budgets en une seule sortie. Remplacez $NODEPOOL par le nom du NodePool :

kubectl get nodepool $NODEPOOL -o jsonpath='{.spec.disruption}{"\n"}'

Vérifiez ces quatre paramètres :

  1. consolidationPolicy : la valeur WhenEmpty ne considère que les nœuds vides ; un nœud qui héberge des pods reste donc en place. Les valeurs Balanced et WhenEmptyOrUnderutilized considèrent aussi les nœuds qui hébergent des pods. Balanced ignore les déplacements dont la disruption ne justifie pas les économies.
  2. consolidateAfter : c'est le délai d'attente. Karpenter réinitialise le compteur lorsqu'un pod est ajouté au nœud ou en est retiré ; une valeur longue exclut donc un nœud actif de la consolidation. La valeur Never désactive la consolidation pour le NodePool.
  3. budgets : un budget avec nodes: '0' bloque toute disruption volontaire. Un budget avec une planification et une durée la bloque pendant cette fenêtre. Les planifications utilisent toujours l'heure UTC.
  4. requirements et limits : un nœud de remplacement doit respecter les requirements et les limits du NodePool. Si aucun nœud moins cher ne convient, Karpenter ne peut pas remplacer le nœud.

Cette commande affiche les limits et les requirements :

kubectl get nodepool $NODEPOOL -o jsonpath='{.spec.limits}{"\n"}{.spec.template.spec.requirements}{"\n"}'

Utilisez les événements pour identifier le paramètre en cause. Ces commandes lisent les événements du NodePool et de l'ensemble du cluster :

kubectl describe nodepool $NODEPOOL
kubectl get events -A --field-selector reason=Unconsolidatable --sort-by=.lastTimestamp
kubectl get events -A --field-selector reason=DisruptionBlocked --sort-by=.lastTimestamp

Chaque paramètre laisse sa propre trace :

Paramètre Ce que vous observez Changement minimal
consolidationPolicy est WhenEmpty NodePool "<name>" has consolidation policy WhenEmpty, but node is not empty Passez la politique à WhenEmptyOrUnderutilized
consolidateAfter est Never NodePool "<name>" has consolidation disabled Définissez une durée, par exemple 15m
consolidateAfter est long Aucun événement. La condition Consolidatable du NodeClaim est False Réduisez la durée
budgets No allowed disruptions for disruption reason Underutilized due to blocking budget, on the NodePool Remplacez nodes: '0' par un pourcentage, ou limitez le budget à zéro à une fenêtre horaire
Requirements et limits Can't replace with a cheaper node Autorisez davantage de types d'instances, ou augmentez la limite

Un délai d'attente long ne génère aucun événement. Pour lire la condition Consolidatable, remplacez $NODECLAIM par le nom du NodeClaim :

kubectl get nodeclaim $NODECLAIM -o jsonpath='{.status.conditions[?(@.type=="Consolidatable")].status}{"\n"}'

La valeur False signifie que le nœud n'est pas encore candidat à la consolidation.

Chaque correctif consiste à modifier un seul champ. Le premier diff permet à Karpenter de considérer les nœuds qui hébergent des pods :

spec:
disruption:
- consolidationPolicy: WhenEmpty
+ consolidationPolicy: WhenEmptyOrUnderutilized

Le diff suivant raccourcit le délai d'attente :

spec:
disruption:
consolidateAfter: 15m # previously 2h

Le dernier diff supprime un budget à zéro. Consultez d'abord l'équipe plateforme, car un budget à zéro protège souvent une mise en production :

spec:
disruption:
budgets:
- - nodes: "0"
+ - nodes: "10%"

C'est l'équipe plateforme qui effectue ces modifications, car elle est propriétaire du NodePool.

Question 3 : un pod ou le nœud refuse-t-il la disruption ?

Avant toute disruption d'un nœud, Karpenter vérifie chacun des pods qu'il héberge. Un pod peut refuser de deux façons : un PDB n'a plus de marge, ou le pod porte l'annotation karpenter.sh/do-not-disrupt. Le nœud peut lui aussi porter cette annotation. Les événements indiquent la cause :

Message Signification Responsable
Pdb prevents pod evictions (PodDisruptionBudget=[<namespace>/<name>]) Un PDB n'a plus de marge pour un pod du nœud. Équipe applicative
MultiplePodDisruptionBudgets Deux PDB sélectionnent le même pod. Les versions récentes de Kubernetes écrivent cet événement sur le pod, et Karpenter peut n'afficher aucun événement. Équipe applicative
Pod has "karpenter.sh/do-not-disrupt" annotation (Pod=<namespace>/<name>) Un pod du nœud porte l'annotation. Équipe applicative
Disruption is blocked through the "karpenter.sh/do-not-disrupt" annotation Le nœud lui-même porte l'annotation. Équipe plateforme

Pour confirmer un PDB, listez chaque PDB avec ses disruptions autorisées :

kubectl get pdb -A -o custom-columns='NAMESPACE:.metadata.namespace,NAME:.metadata.name,MIN:.spec.minAvailable,MAXUNAVAIL:.spec.maxUnavailable,ALLOWED:.status.disruptionsAllowed'

Une valeur ALLOWED de 0 signifie qu'aucun pod couvert par ce PDB ne peut partir pour le moment. Un pod ne doit avoir qu'un seul PDB. Si deux PDB sélectionnent le même pod, Kubernetes refuse l'éviction, même lorsque les deux PDB ont de la marge.

Pour confirmer une annotation, listez les pods et les nœuds qui la portent. Ces commandes utilisent jq :

# Find pods with the karpenter.sh/do-not-disrupt annotation
kubectl get pods -A -o json | jq -r '.items[] | select(.metadata.annotations["karpenter.sh/do-not-disrupt"] != null) | "\(.metadata.namespace)/\(.metadata.name) node=\(.spec.nodeName) value=\(.metadata.annotations["karpenter.sh/do-not-disrupt"])"'
# Find nodes with the karpenter.sh/do-not-disrupt annotation
kubectl get nodes -o json | jq -r '.items[] | select(.metadata.annotations["karpenter.sh/do-not-disrupt"] != null) | .metadata.name'

L'annotation fonctionne comme un PDB pour un seul pod. La valeur "true" protège le pod définitivement. Une durée telle que "30m" le protège pendant ce laps de temps après son démarrage.

Chaque correctif est une petite modification. Pour un Deployment avec 3 réplicas, utilisez maxUnavailable: 1 plutôt que minAvailable: 3, car maxUnavailable suit le nombre de réplicas :

spec:
minAvailable: 3
maxUnavailable: 1

Si l'équipe applicative accepte qu'un pod puisse être déplacé après 30 minutes, remplacez l'annotation permanente par une durée :

template:
metadata:
annotations:
karpenter.sh/do-not-disrupt: "30m"

Il arrive qu'un pod en crash loop bloque l'éviction. Conservez le PDB et définissez-y unhealthyPodEvictionPolicy: AlwaysAllow. Ce champ est stable depuis Kubernetes v1.31.

Lorsque Karpenter draine un nœud, il n'évince pas les pods statiques, les pods qui tolèrent le taint karpenter.sh/disrupted:NoSchedule, ni les pods terminés avec succès ou en échec.

L'équipe applicative effectue la plupart de ces modifications, car elle est propriétaire du PDB et du pod. L'équipe plateforme est responsable d'une annotation posée sur un nœud.

Question 4 : un pod n'a-t-il aucun autre nœud où s'exécuter ?

Karpenter simule où les pods peuvent s'exécuter avant de retirer un nœud. Si tous les pods tiennent sur la capacité libre des autres nœuds, il supprime le nœud. S'ils tiennent sur la capacité libre plus un nœud moins cher, il remplace le nœud. Si un seul pod ne tient nulle part, le nœud reste. Les événements ne nomment pas toujours ce pod : c'est dans les specs des pods que vous le trouverez.

Pour voir ce qui rattache chaque pod du nœud à son emplacement, listez les détails de tous ses pods :

kubectl get pods -A --field-selector spec.nodeName=$NODE -o json | jq '.items[] | {pod: "\(.metadata.namespace)/\(.metadata.name)", owner: (.metadata.ownerReferences[0].kind // "none"), nodeSelector: .spec.nodeSelector, requiredAntiAffinity: (.spec.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution != null), topologySpread: [.spec.topologySpreadConstraints[]? | {key: .topologyKey, maxSkew: .maxSkew, whenUnsatisfiable: .whenUnsatisfiable}], claims: [.spec.volumes[]? | select(.persistentVolumeClaim != null) | .persistentVolumeClaim.claimName]}'

Recherchez ces causes :

  1. Une request supérieure à la capacité libre des autres nœuds.
  2. Un nodeSelector qui ne correspond qu'à ce groupe de nœuds.
  3. Une règle d'anti-affinité obligatoire.
  4. Une règle de topology spread que les autres nœuds ne peuvent pas satisfaire.
  5. Un volume lié à une seule zone.
  6. Un taint sur les autres nœuds que le pod ne tolère pas.

Les règles d'anti-affinité et de topology spread en mode preferred peuvent aussi réduire l'efficacité de la consolidation, car Karpenter tente de les satisfaire lorsqu'il retire un nœud.

Commencez par la première cause. Karpenter place les pods selon leurs requests, pas selon leur utilisation réelle. Cette requête compare l'utilisation CPU réelle aux requests CPU de chaque namespace. Elle s'appuie sur les métriques du kubelet et de kube-state-metrics :

query: sum by (namespace) (rate(container_cpu_usage_seconds_total{container!=""}[5m])) / sum by (namespace) (kube_pod_container_resource_requests{resource="cpu"})

Un ratio bien inférieur à 1 signifie que les requests sont trop élevées. Chaque nœud héberge alors moins de pods qu'il ne le pourrait, et vous payez pour de l'espace inutilisé.

Si les données révèlent une request surdimensionnée, ramenez-la au besoin réel. Ne modifiez que la valeur mise en évidence :

resources:
requests:
cpu: "4"
cpu: "2"

Vérifiez aussi la présence de pods sans contrôleur. Ils ne bloquent pas Karpenter, mais rien ne les redémarre après une éviction.

Si aucune question n'obtient de oui

Karpenter peut aussi ignorer un nœud pour des raisons brèves et normales : le compteur consolidateAfter n'est pas arrivé à son terme, le nœud est encore en démarrage, le nœud est déjà en cours de suppression, ou Karpenter vient de choisir ce nœud pour un pod en attente. Revérifiez le nœud après quelques minutes.

Qui corrige quoi

Chaque catégorie a un seul responsable et un seul changement minimal : la bonne équipe reçoit ainsi la bonne demande.

media

Ce tableau réunit la preuve, le responsable et la modification :

Catégorie Preuve Responsable Changement minimal
Nœud non créé par Karpenter Une colonne NODEPOOL vide Le propriétaire de l'autre outil Une modification du nœud dans cet outil
Limite de NodePool Un paramètre du bloc disruption, et un événement sur le NodePool ou le nœud Équipe plateforme Un champ du NodePool
Blocage workload : PDB ou annotation Un événement DisruptionBlocked, la valeur ALLOWED, ou le filtre d'annotations Équipe applicative, ou équipe plateforme pour une annotation de nœud Un champ du PDB ou une valeur d'annotation
Blocage workload : placement Un événement Unconsolidatable ou aucun événement, et le filtre de placement des pods Équipe applicative Une request ou une règle

Envoyez au responsable un diff et mentionnez la preuve dans votre demande. Il n'aura ainsi qu'un seul champ à examiner au lieu d'un long rapport.

Comment PerfectScale peut vous aider

PerfectScale by DoiT ne remplace pas l'arbre de décision. Il aide votre équipe à identifier le responsable et le correctif avec moins de travail manuel.

media

Voici comment PerfectScale peut vous aider :

1. Commencez par le right-sizing des requests : des requests surdimensionnées empêchent les pods de tenir sur d'autres nœuds, et les recommandations de Karpenter dépendent des requests des workloads en cours d'exécution. PerfectScale recommande de commencer par le right-sizing des workloads. Vous pouvez appliquer ses recommandations vous-même ou activer l'automatisation.

2. Visualisez le NodePool et chacune de ses modifications : les paramètres de Karpenter évoluent au fil du temps ; il est donc utile de voir ce qui a changé et quand. PerfectScale détecte Karpenter dans le cluster et affiche la configuration du NodePool et de la node class, avec un historique des modifications. Vous pouvez vérifier la politique, le délai d'attente et les budgets au même endroit.

media

3. Recevez des recommandations pour les paramètres du NodePool : PerfectScale fournit des recommandations d'optimisation Karpenter pour les paramètres qui déterminent la vitesse à laquelle Karpenter retire des nœuds. Ses recommandations vous aident à :

  • Revoir la politique de consolidation et le délai d'attente.
  • Donner à Karpenter davantage d'options d'instances lorsqu'il provisionne de nouveaux nœuds.
  • Repérer les limites de NodePool qui laissent trop peu de marge pour de nouvelles capacités.

Une vue YAML affiche la configuration actuelle et la configuration recommandée, et vous pouvez copier le résultat.

media

4. Identifiez les pods qui empêchent le retrait des nœuds : la vue bin packing montre quels pods empêchent le retrait des nœuds. Pour chacun, PerfectScale explique pourquoi le pod ne peut pas être évincé et comment y remédier. Il fournit des recommandations sous forme de diffs YAML classées par impact sur les coûts, chacune assortie d'un niveau de confiance et d'un niveau de risque. Vous pouvez désactiver une alerte lorsqu'elle correspond à un choix délibéré.

media

Chaque équipe obtient sa propre liste. L'équipe plateforme travaille depuis la vue NodePool, et l'équipe applicative depuis les pods.

Un agent comme Claude peut également interroger les données PerfectScale grâce au skill d'agent IA PerfectScale. Après chaque modification, utilisez l'historique des changements dans votre revue pour voir ce qui a évolué et ce qu'il faut automatiser ensuite.

Check-list à retenir

Utilisez ces listes pour chaque modification et copiez-les dans la pull request. Une modification comporte trois étapes, chacune avec ses propres vérifications :

Avant la modification

Tous ces points doivent être vrais avant d'appliquer la modification :

  • Karpenter a créé le nœud.
  • La catégorie du blocage est identifiée : limite de NodePool ou blocage côté workload.
  • Un événement, un champ ou une annotation prouve le blocage.
  • La modification ne touche qu'un champ ou un objet.
  • Le propriétaire de cet objet a approuvé la modification.
  • Un budget ou une fenêtre horaire limite le nombre de nœuds déplaçables en même temps.
  • La modification a d'abord été testée sur un cluster de test ou un NodePool sandbox.
  • La procédure de retour en arrière et le critère d'annulation sont documentés.

Pendant la modification

Exécutez ces commandes de surveillance dans des terminaux séparés jusqu'à la fin de la modification :

kubectl get nodeclaims -w
kubectl get events -A --field-selector reason=DisruptionBlocked -w
kubectl get pods -A --field-selector=status.phase!=Running,status.phase!=Succeeded -w

Ces vérifications restent actives jusqu'à la fin de la modification :

  • Les événements Karpenter ne montrent aucun nouveau blocage.
  • Les pods quittent le nœud au rythme autorisé par les PDB.
  • Les dashboards de service restent dans les objectifs de niveau de service (SLO).

Après la modification

Ces vérifications clôturent la modification :

  • Le nombre de nœuds correspond au résultat attendu.
  • Aucun pod n'attend ou ne redémarre sans cause connue.
  • La valeur ALLOWED de chaque PDB est supérieure à 0 pour les services qui doivent être déplacés.
  • L'enregistrement de la modification est complet.

Voyez l'arbre à l'œuvre avec un agent lors du workshop

La prochaine fois qu'un nœud subsiste, commencez par la première question. Un agent peut vous aider pour les premières vérifications, car il lit les événements, la configuration et les métriques bien plus vite que vous. Il peut aussi donner une réponse différente à chaque sollicitation. C'est pourquoi une personne doit relire chaque modification, et pourquoi ce sont des règles fixes, et non un agent, qui doivent l'appliquer en production.

Le workshop Agentic Karpenter: Using kagent + Claude to Tune Your Autoscaling aura lieu le 17 novembre 2026 à 11 h (heure de l'Est). Vikram Seshadri et Ramesh Mathikumar y montrent comment un agent lit ce type d'événements et rédige le diff, et où les règles fixes prennent le relais. Inscrivez-vous au workshop.

Des nœuds qui refusent de s'arrêter ? Notre équipe peut vous aider à identifier le blocage, relire la modification et récupérer de la capacité sans compromettre la fiabilité. Échangez avec nos experts ou créez un compte gratuit et essayez par vous-même.