# What to check when Karpenter won't give you nodes — retained record

> Retained reddit record from reddit:kubernetes.

Canonical: https://highsignal.app/data/records/5c5fdaaaa0661805

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:kubernetes)  published 2026-09-28 18:24 ingested 2026-09-29 02:42

[original source ↗](https://www.reddit.com/r/kubernetes/comments/1wsmi9f/what_to_check_when_karpenter_wont_give_you_nodes/)

## retained text



```
While adding Karpenter support to Radar, the open-source tool we maintain, we kept hitting the same debugging problem: the useful error is often nowhere near the Pending pod. About as fun as it sounds. So we thought it might be useful to share how each failure leaves its evidence, as far as we've found.

On a fixed set of nodes, a Pending pod is a question about the nodes you have. On a Karpenter cluster there's a second question underneath it: did Karpenter consider provisioning one and decline, or try and fail? The scheduler's message only answers the first.

Went through the failure modes we hit most and where the answer actually is:

| Symptom / message | Usual cause | Where the evidence is |
|---|---|---|
| `didn't match Pod's node affinity/selector` | pod requires a label no NodePool declares | NodePool `requirements` + template labels |
| `had untolerated taint {k: v}` | NodePool template taints, pod has no toleration | `spec.template.spec.taints` vs tolerations |
| `Insufficient cpu` / `memory` | existing nodes are full, says nothing about what could be provisioned | allocatable vs requests, then Karpenter's own event |
| pending, no NodeClaim | usually limits reached, or every pool ruled it out | Karpenter's `FailedScheduling` event names which |
| NodeClaim, no node | launch failed, or launched and never registered | NodeClaim conditions / NodePool `NodeRegistrationHealthy` |
| nodes launch then vanish | most often registration timeout | `NodeRegistrationHealthy` |
| pending, no scheduler attempt | scheduling gate | `spec.schedulingGates` |
| nodes not consolidating | disruption blocked or budgets | `DisruptionBlocked` / `Unconsolidatable` |

Three failure modes worth calling out:

**A NodePool can report Ready while the nodes it launches never register.** Registration health lives on `NodeRegistrationHealthy` (Karpenter v1.4+), which is tracked separately from the pool's `Ready` condition. Nodes come up, miss the registration timeout, get deleted, repeat, and anything reading `Ready` shows green throughout.

Worth separating this from a broken NodeClass, which is the case people assume: that one fails `NodeClassReady`, and `NodeClassReady` *does* roll into `Ready`, so the pool goes not-Ready and you find it the normal way. The Ready-but-failing case is further down the path. The NodeClass resolved fine, the instance launched, and the node never joined. User data dying before the kubelet starts, or a security group that resolves but blocks the kubelet from reaching the API server.

**The per-claim launch evidence is short-lived by design.** Karpenter deletes timed-out NodeClaims and the claim's own conditions go with them. The cause is not lost, since once the pool trips its registration-health threshold Karpenter records the reason on `NodeRegistrationHealthy`, but the history is, so a run of `VCPULimitExceeded` reads as one condition rather than five failures. Chase intermittent ones through events, not objects.

**Limits leave a Pending pod with nothing attached, except Karpenter does say so.** When `spec.limits` is hit the scheduler records `node limits have been exhausted for nodepool` or `all available instance types exceed limits for nodepool` and publishes it as a `FailedScheduling` event. The number it checks is `status.resources`, which already includes in-flight claims, so headroom is `limit - provisioned`, not `limit - allocatable`. A pool can be at its limit with almost no registered nodes.

Correcting something I assumed going in: Karpenter is not quiet about most of this. It emits `FailedScheduling` events naming the pools it ruled out and often the constraint that did it. What no scheduling event does is join that verdict to the health of the pool that should have worked. It tells you nothing matched, not that one of those pools has been failing to launch nodes since Tuesday. That fact does exist, on the pool's own conditions, a couple of objects away from your pod.

Radar is an Apache-2.0 Kubernetes UI, and its Capacity view automates these checks. The writeup includes the equivalent kubectl checks and screenshots: https://radarhq.io/blog/karpenter-troubleshooting

If you've hit a Karpenter failure mode that isn't in there, add it, especially cloud-provider-specific ones, that list is nowhere near complete.
```



document fetched 2026-09-29 00:38 · canonical https://reddit.com/r/kubernetes/comments/1wsmi9f/what_to_check_when_karpenter_wont_give_you_nodes
