PerfectScale

Il blocco è nel NodePool o nei workloads?

Scopra come capire se un nodo Karpenter bloccato dipende da un limite del NodePool o da un blocco nei workloads, e chi deve risolverlo con un albero decisionale in 4 domande.

Questa pagina è disponibile anche in English, Deutsch, Español, Français, 日本語 e Português.

Tania Duggal
By Tania Duggal
Nov 12, 202613 min read

Un nodo che resta in esecuzione anche dopo il calo della domanda ha un blocco. Il blocco si trova nel NodePool o nei workloads, e la risposta determina chi deve risolverlo.

Un limite del NodePool è un'impostazione che indica a Karpenter di non consolidare. Alcuni esempi sono la policy, il tempo di attesa e un disruption budget. Il team di piattaforma è responsabile del NodePool. Un blocco nei workloads è un pod che non può lasciare il proprio nodo. Alcuni esempi sono un PodDisruptionBudget (PDB), un'annotazione do-not-disrupt e una regola di posizionamento. Il team applicativo è responsabile di questi oggetti.

Se si individua il responsabile sbagliato, la modifica arriva al team sbagliato e il nodo resta attivo. Questo articolo propone un unico albero decisionale con quattro domande. Risponda alle domande in ordine: il primo "sì" identifica la classe del blocco, il responsabile e il passo successivo.

Due tipi di blocchi

Karpenter rimuove un nodo solo quando due condizioni sono soddisfatte: il NodePool consente l'operazione e ogni pod sul nodo può lasciarlo. Ogni condizione ha un proprio responsabile:

  1. Limite del NodePool: un'impostazione nel NodePool impedisce a Karpenter di agire. La soluzione è una modifica al NodePool, di competenza del team di piattaforma.
  2. Blocco nel workload: un pod non può lasciare il nodo oppure non ha un altro posto dove essere eseguito. La soluzione è una modifica al workload, di competenza del team applicativo.

Karpenter agisce solo sui nodi che ha creato. Un nodo creato da un altro strumento è un terzo caso, e nessuna impostazione di Karpenter può risolverlo. Un nodo può inoltre avere più di un blocco: risolto il primo, verifichi nuovamente il nodo.

L'albero decisionale

Parta da un nodo che resta attivo dopo il calo della domanda. Risponda alle quattro domande in ordine e si fermi al primo "sì", perché quella risposta identifica la classe del blocco e il responsabile della soluzione.

media

Ogni domanda prevede una breve verifica che conferma la risposta. Esegua la verifica prima di chiedere a chiunque di modificare qualcosa.

Domanda 1: il nodo è stato creato da un altro strumento?

Karpenter agisce solo sui nodi che ha creato, quindi verifichi prima il proprietario. Un nodo senza NodeClaim non è mai un candidato al consolidamento. L'etichetta karpenter.sh/nodepool indica quale NodePool ha creato il nodo. Sostituisca $NODE con il nome del nodo:

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

Una colonna NODEPOOL vuota significa che Karpenter non ha creato il nodo, quindi non lo consoliderà mai. Intervenga nello strumento che ha creato il nodo, ad esempio un managed node group.

Domanda 2: le impostazioni del NodePool bloccano il consolidamento in questo momento?

Quattro impostazioni del NodePool possono impedire il consolidamento. Legga prima il blocco disruption: mostra la policy, il tempo di attesa e i budget in un unico output. Sostituisca $NODEPOOL con il nome del NodePool:

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

Verifichi queste quattro impostazioni:

  1. consolidationPolicy: il valore WhenEmpty considera solo i nodi vuoti, quindi un nodo che ospita pod resta attivo. I valori Balanced e WhenEmptyOrUnderutilized considerano anche i nodi che ospitano pod. Balanced salta gli spostamenti in cui la disruption non vale il risparmio.
  2. consolidateAfter: è il tempo di attesa. Karpenter azzera il timer quando un pod viene aggiunto o rimosso dal nodo, quindi un valore elevato esclude dal consolidamento un nodo con molta attività. Il valore Never disattiva il consolidamento per il NodePool.
  3. budgets: un budget con nodes: '0' blocca ogni disruption volontaria. Un budget con una pianificazione e una durata la blocca all'interno di quella finestra. Le pianificazioni usano sempre il fuso UTC.
  4. requirements e limits: un nodo sostitutivo deve rispettare i requirements e i limits del NodePool. Quando nessun nodo più economico è compatibile, Karpenter non può sostituire il nodo.

Questo comando stampa i limits e i requirements:

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

Usi gli eventi per capire quale impostazione è in gioco. Questi comandi leggono gli eventi del NodePool e dell'intero 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

Ogni impostazione lascia una traccia specifica:

Impostazione Cosa si vede Modifica minima
consolidationPolicy è WhenEmpty NodePool "<name>" has consolidation policy WhenEmpty, but node is not empty Imposti la policy su WhenEmptyOrUnderutilized
consolidateAfter è Never NodePool "<name>" has consolidation disabled Imposti una durata, ad esempio 15m
consolidateAfter è lungo Nessun evento. La condizione Consolidatable del NodeClaim è False Riduca la durata
budgets No allowed disruptions for disruption reason Underutilized due to blocking budget, on the NodePool Sostituisca nodes: '0' con una percentuale, oppure limiti il budget a zero a una finestra temporale
Requirements e limits Can't replace with a cheaper node Consenta più opzioni di istanza o aumenti il limite

Un tempo di attesa lungo non lascia eventi. Per leggere la condizione Consolidatable, sostituisca $NODECLAIM con il nome del NodeClaim:

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

Il valore False significa che il nodo non è ancora un candidato al consolidamento.

Ogni soluzione è una modifica a un singolo campo. Il primo diff consente a Karpenter di considerare i nodi che ospitano pod:

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

Il diff successivo riduce il tempo di attesa:

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

L'ultimo diff rimuove un budget a zero. Consulti prima il team di piattaforma, perché un budget a zero spesso protegge un rilascio:

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

Queste modifiche spettano al team di piattaforma, che è responsabile del NodePool.

Domanda 3: un pod o il nodo rifiuta la disruption?

Prima di eseguire la disruption di un nodo, Karpenter controlla ogni pod presente. Un pod può rifiutarla in due modi: un PDB non ha margine, oppure il pod ha l'annotazione karpenter.sh/do-not-disrupt. Anche il nodo può avere l'annotazione. Gli eventi indicano la causa:

Messaggio Significato Responsabile
Pdb prevents pod evictions (PodDisruptionBudget=[<namespace>/<name>]) Un PDB non ha margine per un pod sul nodo. Team applicativo
MultiplePodDisruptionBudgets Due PDB selezionano lo stesso pod. Le versioni recenti di Kubernetes scrivono questo evento sul pod, e Karpenter potrebbe non mostrare alcun evento. Team applicativo
Pod has "karpenter.sh/do-not-disrupt" annotation (Pod=<namespace>/<name>) Un pod sul nodo ha l'annotazione. Team applicativo
Disruption is blocked through the "karpenter.sh/do-not-disrupt" annotation Il nodo stesso ha l'annotazione. Team di piattaforma

Per confermare un PDB, elenchi tutti i PDB con le disruption consentite:

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

Un valore ALLOWED pari a 0 significa che nessun pod coperto da quel PDB può lasciare il nodo in questo momento. Un pod deve avere un solo PDB. Se due PDB selezionano lo stesso pod, Kubernetes rifiuta l'eviction anche quando entrambi i PDB hanno margine.

Per confermare un'annotazione, elenchi i pod e i nodi che la hanno. Questi comandi usano 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'annotazione funziona come un PDB per un singolo pod. Il valore "true" protegge il pod in modo permanente. Una durata come "30m" lo protegge per quel periodo dopo l'avvio dell'esecuzione.

Ogni soluzione è una piccola modifica. Per un Deployment con 3 repliche, usi maxUnavailable: 1 invece di minAvailable: 3, perché maxUnavailable segue il numero di repliche:

spec:
minAvailable: 3
maxUnavailable: 1

Se il team applicativo concorda che un pod possa spostarsi dopo 30 minuti, sostituisca l'annotazione permanente con una durata:

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

A volte un pod in crash loop blocca l'eviction. Mantenga il PDB e imposti al suo interno unhealthyPodEvictionPolicy: AlwaysAllow. Questo campo è stabile da Kubernetes v1.31.

Quando Karpenter esegue il drain di un nodo, non esegue l'eviction dei pod statici, dei pod che tollerano il taint karpenter.sh/disrupted:NoSchedule, né dei pod completati con successo o falliti.

La maggior parte di queste modifiche spetta al team applicativo, che è responsabile del PDB e del pod. Un'annotazione su un nodo è invece di competenza del team di piattaforma.

Domanda 4: c'è un pod che non ha un altro nodo su cui essere eseguito?

Prima di rimuovere un nodo, Karpenter simula dove possono essere eseguiti i pod. Se tutti i pod trovano posto nella capacità libera degli altri nodi, elimina il nodo. Se trovano posto nella capacità libera più un nodo a prezzo inferiore, sostituisce il nodo. Se un pod non trova posto da nessuna parte, il nodo resta. Gli eventi non sempre indicano quel pod, quindi va individuato nelle specifiche dei pod.

Per vedere cosa lega ciascun pod del nodo alla sua posizione, elenchi i dettagli di ogni pod presente:

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]}'

Cerchi queste cause:

  1. Una request più grande della capacità libera degli altri nodi.
  2. Un nodeSelector che corrisponde solo a questo gruppo di nodi.
  3. Una regola di anti-affinity obbligatoria (required).
  4. Una regola di topology spread che gli altri nodi non possono soddisfare.
  5. Un volume vincolato a una singola zona.
  6. Un taint sugli altri nodi che il pod non tollera.

Anche le regole di anti-affinity e topology spread di tipo preferred possono ridurre l'efficacia del consolidamento, perché Karpenter cerca di soddisfarle quando rimuove un nodo.

Parta dalla prima causa. Karpenter posiziona i pod in base alle loro request, non all'uso effettivo. Questa query confronta l'uso reale di CPU con le request di CPU per ciascun namespace, utilizzando le metriche del kubelet e di 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 rapporto molto inferiore a 1 significa che le request sono troppo grandi. Ogni nodo ospita così meno pod di quanto potrebbe, e si paga per lo spazio inutilizzato.

Se i dati mostrano una request sovradimensionata, la riduca al fabbisogno reale. Modifichi solo il valore indicato dai dati:

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

Verifichi anche la presenza di pod senza controller: non bloccano Karpenter, ma dopo un'eviction nulla li riavvia.

Se nessuna domanda ha risposta affermativa

Karpenter può saltare un nodo anche per motivi temporanei e del tutto normali: il timer di consolidateAfter non è ancora scaduto, il nodo è ancora in fase di avvio, il nodo è già in eliminazione, oppure Karpenter ha appena scelto il nodo per un pod in attesa. Verifichi di nuovo il nodo dopo qualche minuto.

Chi risolve il problema

Ogni classe ha un responsabile e una modifica minima, così la richiesta giusta arriva al team giusto.

media

Questa tabella riunisce prova, responsabile e modifica:

Classe Prova Responsabile Modifica minima
Non creato da Karpenter Una colonna NODEPOOL vuota Il responsabile dell'altro strumento Una modifica al nodo in quello strumento
Limite del NodePool Un'impostazione nel blocco disruption e un evento sul NodePool o sul nodo Team di piattaforma Un campo del NodePool
Blocco nel workload: PDB o annotazione Un evento DisruptionBlocked, il valore ALLOWED o il filtro delle annotazioni Team applicativo, o team di piattaforma per un'annotazione sul nodo Un campo del PDB o un valore di annotazione
Blocco nel workload: posizionamento Un evento Unconsolidatable o nessun evento, e il filtro di posizionamento dei pod Team applicativo Una request o una regola

Invii al responsabile un diff e citi la prova nella richiesta. Il responsabile potrà così rivedere un singolo campo invece di un lungo report.

Come può aiutare PerfectScale

PerfectScale by DoiT non sostituisce l'albero decisionale: aiuta il suo team a individuare il responsabile e la soluzione con meno lavoro manuale.

media

Ecco come PerfectScale può aiutarla:

1. Prima il right-sizing delle request: le request sovradimensionate impediscono ai pod di trovare posto su altri nodi, e le raccomandazioni di Karpenter dipendono dalle request dei workloads in esecuzione. PerfectScale consiglia di fare prima il right-sizing dei workloads. Può applicare le raccomandazioni manualmente oppure attivare l'automazione.

2. Visibilità sul NodePool e su ogni sua modifica: le impostazioni di Karpenter cambiano nel tempo, quindi è utile vedere cosa è cambiato e quando. PerfectScale rileva Karpenter nel cluster e mostra la configurazione del NodePool e della node class, con la cronologia delle modifiche. Può controllare la policy, il tempo di attesa e i budget in un unico posto.

media

3. Raccomandazioni per le impostazioni del NodePool: PerfectScale fornisce raccomandazioni di ottimizzazione per Karpenter per le impostazioni che determinano quanto rapidamente Karpenter rimuove i nodi. Le sue raccomandazioni aiutano a:

  • Rivedere la policy di consolidamento e il tempo di attesa.
  • Dare a Karpenter più opzioni di istanza quando effettua il provisioning di nuovi nodi.
  • Individuare i limiti del NodePool che lasciano troppo poco spazio a nuova capacità.

Una vista YAML mostra la configurazione attuale e quella consigliata, e il risultato può essere copiato.

media

4. Individuare i pod che impediscono la rimozione dei nodi: la vista di bin packing mostra quali pod impediscono la rimozione dei nodi. Per ciascuno, PerfectScale spiega perché il pod non può essere sottoposto a eviction e come risolvere. Fornisce raccomandazioni sotto forma di diff YAML ordinate per impatto sui costi, ognuna con un livello di confidenza e un livello di rischio. Può silenziare una segnalazione quando è intenzionale.

media

Ogni team ha la propria lista: il team di piattaforma lavora dalla vista NodePool, il team applicativo parte dai pod.

Un agente come Claude può inoltre interrogare i dati di PerfectScale con la skill per agenti AI di PerfectScale. Dopo ogni modifica, usi la cronologia delle modifiche nella revisione per vedere cosa è cambiato e cosa automatizzare in seguito.

Checklist riepilogativa

Usi queste liste per ogni modifica e le copi nella pull request. Una modifica ha tre fasi, ognuna con i propri controlli:

Prima della modifica

Tutte queste condizioni devono essere vere prima che la modifica venga applicata:

  • Il nodo è stato creato da Karpenter.
  • La classe del blocco è stata identificata: limite del NodePool o blocco nel workload.
  • Un evento, un campo o un'annotazione dimostra il blocco.
  • La modifica riguarda un solo campo o un solo oggetto.
  • Il responsabile di quell'oggetto ha approvato la modifica.
  • Un budget o una finestra temporale limita quanti nodi possono spostarsi contemporaneamente.
  • La modifica è stata eseguita prima su un cluster di test o su un NodePool sandbox.
  • La procedura di rollback e il motivo per eseguirla sono documentati.

Durante la modifica

Esegua questi comandi di watch in terminali separati fino al termine della modifica:

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

Questi controlli restano attivi fino al termine della modifica:

  • Gli eventi di Karpenter non mostrano nuovi blocchi.
  • I pod lasciano il nodo al ritmo consentito dai PDB.
  • Le dashboard dei servizi restano entro il service level objective (SLO).

Dopo la modifica

Questi controlli chiudono la modifica:

  • Il numero di nodi corrisponde al risultato atteso.
  • Nessun pod è in attesa o si riavvia senza una causa nota.
  • Il valore ALLOWED di ogni PDB è superiore a 0 per i servizi che devono spostarsi.
  • La documentazione della modifica è completa.

Veda l'albero decisionale in azione con un agente nel workshop

La prossima volta che un nodo resta attivo, parta dalla prima domanda. Un agente può aiutare con le prime verifiche, perché legge eventi, configurazioni e metriche molto più velocemente di una persona. Può però anche dare una risposta diversa a ogni richiesta. Per questo ogni modifica va rivista da una persona, e per questo in produzione dovrebbero applicarla regole fisse, non un agente.

Il workshop Agentic Karpenter: Using kagent + Claude to Tune Your Autoscaling si terrà il 17 novembre 2026 alle 11:00 ET. Vikram Seshadri e Ramesh Mathikumar mostrano come un agente legge eventi come questi e prepara la bozza del diff, e dove subentrano le regole fisse. Si iscriva al workshop.

Alle prese con nodi che restano in esecuzione? Il nostro team può aiutarla a individuare il blocco, rivedere la modifica e recuperare capacità senza compromettere l'affidabilità. Parli con i nostri esperti oppure si registri gratuitamente e provi in prima persona.