Node Pool fields
The Node Pool fields show the desired state and status of the Nodes in a Node Pool. To see these fields, runkubectl get nodepool.
Example output
The following is an example output from runningkubectl get nodepool.
Example output
- The
VALIDATED,CAPACITY, andQUOTAcolumns summarize the Node Pool’s conditions. - In a healthy, fully delivered Node Pool,
CURRENTequalsTARGET, and bothINPROGRESSandQUEUEDare0. PREFILLcounts the Nodes marked for prefill and being replaced. It is0unless prefill is enabled and one or more Nodes are being replaced. To see the prefill state of an individual Node, check itsPrefillcondition. See Prefill condition reasons.- While a Node Pool is scaling up, the difference between
CURRENTandTARGETis split betweenINPROGRESS(Nodes that are booting) andQUEUED(Nodes that are waiting for capacity). Note that a new Node can take up to 15 minutes to boot before it counts towardCURRENT.
Rack-based Node Pool fields
For rack-based instance types such as GB200 and GB300, the Node Pool also tracks rack counts, where each rack contains 18 Nodes. These fields are populated only for rack-based instance types and appear only in the wide output. To see them, usekubectl get nodepool -o wide:
Node Pool full status
For the full status of a single Node Pool, including its conditions and recent events, usedescribe:
Example command
[NODE-POOL-NAME] with the name of your Node Pool.
Each condition answers one question about the Node Pool. The conditions most useful for diagnosing missing Nodes are the following.
A healthy Node Pool shows
Validated: Valid, Capacity: Sufficient, Quota: Under, and AtTarget: TargetMet.
For the complete list of conditions and every possible status value, see Node Pool conditions.
Common capacity and quota states
The bottom ofkubectl describe nodepool [NODE-POOL-NAME] lists recent events. The following events and condition states explain most cases where a Node Pool does not reach its target.
Quota events and conditions:
Run a Node Pool health check
When a Node Pool isn’t doing what you expect, collect its counts, conditions, events, and the state of its Nodes before you change anything. The diagnosis steps in the next section refer to these outputs.Node Pool health check
[NODE-POOL-NAME] with the name of your Node Pool.
To inspect one Node, run kubectl describe node [NODE-NAME]. Replace [NODE-NAME] with the name of the Node. The CWActive condition’s message lists the Pods that keep the Node active, and the node.coreweave.cloud/cordonReason annotation records why CoreWeave cordoned a Node.
To watch Node Pool status over time instead of polling kubectl, use the Node Pools page in the Cloud Console (https://console.coreweave.com/zones/[ZONE-NAME]/clusters/[CLUSTER-NAME]/node-pools, with your zone and cluster names in the path) or the NodePools and Cluster Autoscaler dashboard in CoreWeave Grafana.
Diagnose a Node Pool that is not at target
SupposeTARGET is 10 but CURRENT is 8. The two missing Nodes are queued, in progress, or nowhere at all, and each case has a different cause and fix. Run kubectl get nodepool, then work through the section that matches what you see. The last two sections cover cases where no Nodes are missing: a pool at target while Pods stay Pending, and a pool above target.
Nodes are queued
If the missing Nodes appear inQUEUED and the CAPACITY column shows QueuedAwaitingCapacity, CKS accepted the request and fills it automatically as capacity becomes available. To learn what this state means and when to contact support, see Common capacity and quota states.
Quota also limits how deep the queue can be. Quotas count your whole organization’s Nodes for an instance type, compute class, and zone, so Nodes in one Node Pool consume headroom that another pool might be waiting for. If QUEUED is smaller than you expect (TARGET minus CURRENT minus INPROGRESS), sum the TARGET column across every Node Pool with the same instance type and compute class. Include pools in your organization’s other clusters in the same zone. Then compare the total to your quota before you suspect a capacity or delivery problem. See Resource quotas.
A short QUEUED count is the normal result of a quota cap, not an error. When targetNodes exceeds the quota and headroom remains, CKS queues only the headroom and discards the remainder. No warning event fires, but the CWNodeRequestQueued event reports how many Nodes CKS queued, which is the fastest way to confirm a cap.
Headroom subtracts both the Nodes your organization already has assigned and the Nodes it already has queued for that instance type, compute class, and zone. A sibling pool with a deep queue leaves you less headroom, not more. Only the request being checked stays out of that total, so CKS doesn’t count it twice.
On rack-scale instance types, the cap rounds down to whole NVLink domains. A domain holds 18 Nodes on GB200 and GB300, so headroom of fewer than 18 Nodes queues nothing on those types.
Nodes are in progress
If the missing Nodes appear inINPROGRESS, they’re assigned and booting. Delivering a bare-metal GPU Node takes 5 to 15 minutes from the request to the Node joining the cluster. In the Node Pool’s events, CWNodeAssigned marks the assignment, and CWNodeRegistered marks the Node joining the cluster, which is when CURRENT increases.
Replacements follow the same path. If a Node is removed, for example because you deleted an unhealthy Node, CKS queues and delivers a replacement on its own: The events show CWNodeRequestQueued followed by CWNodeAssigned. You don’t need to request the replacement.
If INPROGRESS hasn’t moved in well over 30 minutes for a GPU Node Pool, or 15 minutes for a CPU Node Pool, check the events for CWNodeDeliverFail. CKS retries failed deliveries automatically. See Common capacity and quota states.
Nothing is queued or in progress
IfCURRENT is below TARGET while QUEUED and INPROGRESS are both 0, read the conditions from the health check:
Validated: Invalid: CKS rejected the configuration, most often an instance type that isn’t offered in the zone (the events showCWInstanceTypeNotInZone) or a Node affinitymatchFieldsrequirement on a key other thanmetadata.name(the events showCWNodePoolInvalidNodeAffinity). This check readsmatchFieldsonly. A brokenmatchExpressionsblock, such as anInoperator with an empty value list, leavesValidatedatValidand surfaces on theCapacitycondition instead. Applying the manifest still succeeds. These checks run after the API server accepts the Node Pool, sokubectl apply, Helm, and Terraform all report success while the Node Pool sits atInvalid. Check the conditions after every change. To confirm an instance type is offered in a zone, see the Availability matrix.Quota: Over: The organization-wide total oftargetNodesfor this instance type, compute class, and zone exceeds your quota and no headroom is left, so CKS queued nothing for the request. A request that exceeds the quota while headroom remains behaves differently: CKS caps it to the headroom, queues that many Nodes, and leaves theQuotacondition atUnder. SeeingOvermeans the headroom is gone, not that the request was trimmed. See Resource quotas and the quota events table earlier on this page.Quota: NotSet: Your organization has no quota for this instance type, compute class, and zone. CKS queues nothing and emits aCWNoQuotaorCWOverQuotaevent with the messageQuota limit is 0. To request a quota, contact support.Capacity: PartialorNoneAvailable: The zone is short of the instance type. TheCWInsufficientCapacityevent message reports what was assigned, for exampleAssigned (8 out of 10), whileCURRENTreports what has joined. CKS keeps what it assigned and retries the rest automatically. See Common capacity and quota states.Capacity: PartialNodeAffinityorNoneAvailableNodeAffinity: The Node Pool’s affinity constraints ruled out some or all of the Nodes of that instance type in the zone. An affinity that matches nothing lands here rather than onValidated: Invalid, and so do two broken affinities: one CKS can’t interpret, and one that targets a different InfiniBand fabric than the fabric assigned to the cluster. Both of those also emitCWNodePoolInvalidNodeAffinity, so read the event message before you start hunting for zone capacity. See theCapacitycondition.
Show the fabric for each Node in the pool
[NODE-POOL-NAME] with the name of your Node Pool. Build new scripts and dashboards on backend.coreweave.cloud/fabric. The second column covers existing InfiniBand clusters that still carry the older ib.coreweave.cloud/fabric label. CWNodeAssigned events also name the fabric each Node landed on. If your reserved capacity and the pool’s existing Nodes are on different fabrics, contact support to plan the move. For more information about fabric labels, see InfiniBand and RoCE labels.
At target but Pods will not schedule
IfCURRENT equals TARGET and the conditions are healthy but Pods stay Pending, the missing capacity is on the Nodes, not the Node Pool. Cordoned Nodes still count toward CURRENT but accept no new Pods. List the pool’s Nodes and look for SchedulingDisabled:
Find cordoned Nodes in the pool
[NODE-POOL-NAME] with the name of your Node Pool. CoreWeave cordons Nodes for health and maintenance reasons. Read the node.coreweave.cloud/cordonReason annotation and see Node cordoning for what to do next.
To see what’s waiting, list the Pending Pods with kubectl get pods --all-namespaces --field-selector status.phase=Pending. Compare their GPU requests against what the schedulable Nodes can hold, and either scale the Node Pool up or reduce replicas while CoreWeave replaces the cordoned Nodes.
Current is above target
IfCURRENT is above TARGET, a scale-down is pending. CKS removes Nodes according to the Node Pool’s scaling strategy, and a delay of a few minutes after you lower the target is normal. If prefill is enabled, CURRENT also runs above TARGET while CKS provisions replacement Nodes. Check the PREFILL column before you diagnose a stuck scale-down.
If the Node Pool stays above target and its events repeat CWNodePoolRemoveNodes with the message No nodes eligible for removal right now, the default IdleOnly strategy found no idle Nodes to remove. Check the CWActive condition on each Node with the health check commands, then run kubectl describe node [NODE-NAME] on an active Node. The CWActive message lists the Pods keeping it active, up to five names followed by a count of the rest.
Any Pod in the Running or Pending phase counts as activity unless CKS exempts it. Exemptions include DaemonSet Pods and Pods labeled interruptible. Two cases might surprise you:
- A Pod stuck in
CrashLoopBackOffkeeps its Node active even though it does no useful work. Delete the Pod, or scale down the Deployment that recreates it. - Idle GPUs don’t make idle Nodes. With
IdleOnly, a Node is eligible for removal only when every counted Pod is gone. Workloads spread thinly across many Nodes can block scale-down even when most GPUs sit unused. Consolidate workloads, or switch the strategy toPreferIdle.
spec.minNodes. With autoscaling enabled, the autoscaler never takes the pool below it.
If every Node shows CWActive: False and the Node Pool still hasn’t scaled down after about 10 minutes, contact support.
When to contact support
Some states aren’t yours to fix. Contact support when you see any of the following:- A
CWNodePoolDisabledevent. Despite the event message about configuration issues, repeated delivery failures usually cause this state. The disabled object is the Node Pool’s Node Profile, which support re-enables or replaces. QUEUEDthat doesn’t move and no Nodes reachingINPROGRESS, whileQuotaisUnder.- Any condition stuck at
InternalErrorthat doesn’t clear on its own. AtTarget: UnderTargetwhileCapacityisSufficientand nothing is queued or in progress.- Idle Nodes (
CWActive: False) that CKS still hasn’t removed about 10 minutes into a scale-down.