Node Pool Reference

Node Pools use the following API schema definitions:

Node Pool

Node Pool is the schema for the Node Pools API.

Field	Type	Description	Default
apiversion	string	The version of the Kubernetes API that the Node Pool uses.	compute.coreweave.com/v1alpha1
kind	string	The type of resource being defined, such as a Node Pool	Node PoolList
metadata	ListMeta	See the Kubernetes API documentation for metadata
spec	Node PoolSpec	The desired state of the Node Pool.
status	Node PoolStatus	The observed state of the Node Pool. See Node PoolStatus.

Node Pool Spec

Node PoolSpec defines the desired state of Node Pool.

Field	Type	Description	Default	Validation
instanceType	string	Instance Type for the Nodes in this Node Pool (Note: instanceType is immutable and unchangeable)	N/A	Required
targetNodes	integer	The quantity of desired Nodes in the Node Pool	N/A	Required
minNodes	integer	The minimum number of TargetNodes allowed by the autoscaler	N/A	Optional
maxNodes	integer	The maximum number of TargetNodes allowed by the autoscaler	N/A	Optional
nodeLabels	object (keys:string, values:string)	List of labels associated with the Nodes in the Node Pool	N/A	Optional
nodeAnnotations	object (keys:string, values:string)	List of annotations associated with the Nodes in the Node Pool	N/A	Optional
nodeTaints	Taint Array	List of taints associated with the Nodes in the Node Pool	N/A	Optional
image	Image	The image to use for the Nodes in the Node Pool.	N/A	Optional
autoscaling	boolean	Enable or disable cluster autoscaling	false	Optional
lifecycle.scaleDownStrategy	enum (IdleOnly, PreferIdle)	Options for removing Nodes when scaling down to reach targetNodes. IdleOnly removes only idle Nodes. PreferIdle removes idle Nodes first and then active Nodes if needed.	IdleOnly	Optional

Important

CoreWeave plans to add a cluster Autoscaler in a later release of CKS. Please note that minNodes and maxNodes have Autoscaler as a prerequisite, and as such aren't yet functional parameters for Node Pools.

Image

Image defines what boot image the Node PoolSpec uses.

Warning

Image should be omitted from Node PoolSpec unless directed by CoreWeave support.

Field	Type	Description	Default	Validation
kernel	string	Kernel version for this Node Pool		Optional
name	string	Name of the image for this Node Pool		Optional
releaseTrain	string	The release channel or track for the image	stable	Optional Enum: [stable latest]

NVSHMEM + GDRCopy support

If you need an image with NVSHMEM + GDRCopy support, you can request to use ncore-image v2.10.1. You'll need to apply a patch to ibgda in your container, enable GDRCopy, and contact Support to get access to this new image.

See the release note for full details.

Node PoolStatus

Node PoolStatus is the observed state of Node Pool.

Field	Type	Description	Validation
allocatedNodes 1	integer	Number of Nodes allocated to the Node Pool	Optional Minimum
inProgress	integer	Number of Nodes that have been assigned, but have not yet fully booted into the cluster	Optional Minimum
currentNodes	integer	Number of Nodes for this Node Pool present in the cluster	Optional Minimum
nodeProfile	string	NodeProfile represent string of the NodeProfile	Optional
conditions	Condition Array	All conditions associated with the Node Pool	Optional

¹ Deprecated and replaced by inProgress.

Conditions

Node Conditions

CoreWeave sets the following conditions on Nodes in a Node Pool.

Condition Name	Type	Description
CWActive	bool	true if the Node is active. If false, and the Node Pool is being scaled down, the Node may be selected for removal.
CWRegistered	bool	true if the Node is registered. If false, the Node is not registered. Nodes are registered when they enter a customer cluster as part of the Node lifecycle.
CWNodeRemoval	bool	true if the Node is pending removal.

Node Pool Conditions

Node Pool condition transition

Transition note

CoreWeave is updating the Node Pool conditions to provide a better user experience and clearer semantics for understanding the state of Node Pools. These changes involve deprecating existing conditions, introducing new ones, and renaming others.

Click to expand: Node Pool condition transition details

This reference table describes the old Node Pool conditions and their new counterparts (where applicable), their purpose, and the reasons for these changes:

Old Condition Name	New Condition Name (if applicable)	Purpose and Meaning	Reason for Change and Relationship to Old Condition
Accepted	Validated	Indicates whether the Node Pool's configuration is valid and ready for further processing.	The new term provides better semantics by focusing on the Node Pool configuration, separating out quota-related concerns.
Allocated	AtTarget	Indicates whether the Node Pool has the appropriate number of Nodes. This means all requested Nodes have been allocated and are ready for use, or more specifically, if CurrentNodes equals TargetNodes.	The new condition has better semantics by indicating if the targetNodes count has been met. It also prevents InternalError from being reported for OverQuota issues and clarifies its reliance on CurrentNodes.
SufficientCapacity	Capacity	Indicates whether there is enough capacity available for the requested number of Nodes in the specified instance type.	The change is primarily for clarity. The reasons and statuses of this condition remain unchanged.
(None directly equivalent)	Quota	A new condition to track the last quota check run for the Node Pool's instance type and indicate if there is quota available for the instance type for the specific organization.	This new condition was created to explicitly expose quota issues. These were previously handled through events or reported less clearly as InternalError under SufficientCapacity, or as NoQuota errors through the Accepted condition.
NodesRemoved	N/A (Remains as is)	Applied to a Node Pool when it is pending deletion and Nodes are in the process of being removed. Once all Nodes are removed, the Node Pool will be deleted.	This condition retains the same meaning.

Here is the new kubectl get nodepools output, showing some of the new conditions:

New Node Pool

$ kubectl get nodepools
NAME        INSTANCE TYPE      TARGET   INPROGRESS   CURRENT   VALIDATED   CAPACITY     QUOTA    AGE
test-pool   gd-8xa100-i128     1        0            1         Valid       Sufficient   Under    24h

Some of the old conditions are still visible with -o wide:

New Node Pool, showing some old conditions with '-o wide'

$ kubectl get nodepools -o wide
NAME        INSTANCE TYPE      TARGET   INPROGRESS   CURRENT   VALIDATED   CAPACITY     QUOTA    ALLOCATEDNODES   ALLOCATED   ALLOCATEDREASON   ACCEPTED   AGE
test-pool   gd-8xa100-i128     1        0            1         Valid       Sufficient   Under    -                -           -                 -          24h

A new Node Pool in a healthy state looks like this when described:

New Node Pool, showing new conditions with 'describe'

$ kubectl describe nodepools test-pool
Name:         test-pool
Namespace:
Labels:       <none>
Annotations:  <none>
API Version:  compute.coreweave.com/v1alpha1
Kind:         NodePool

Metadata:
  Creation Timestamp:        2025-06-09T14:48:54Z
  Generation:                1
  Resource Version:          857370
  UID:                       9311678d-4064-45b8-8439-b943250e5852

Spec:
  Autoscaling:               false
  Instance Type:             gd-8xa100-i128
  Lifecycle:
    Disable Unhealthy Node Eviction:  true
    Scale Down Strategy:              IdleOnly
  Target Nodes:              1

Status:
  Conditions:
    Last Transition Time:    2025-05-30T17:36:00Z
    Message:                 NodePool configuration is valid.
    Reason:                  Valid
    Status:                  True
    Type:                    Validated

    Last Transition Time:    2025-05-30T17:36:00Z
    Message:                 Sufficient capacity available for the requested instance type.
    Reason:                  Sufficient
    Status:                  True
    Type:                    Capacity

    Last Transition Time:    2025-05-30T17:36:00Z
    Message:                 NodePool is within instance type quota.
    Reason:                  Under
    Status:                  True
    Type:                    Quota

    Last Transition Time:    2025-05-30T17:36:00Z
    Message:                 NodePool has reached its target node count.
    Reason:                  TargetMet
    Status:                  True
    Type:                    AtTarget

  Current Nodes:             1
  In Progress:               0

Events:                      <none>

CoreWeave sets the following conditions on a Node Pool after the Node Pool resource has been created.

Condition: Accepted

Note: This condition is deprecated and has been replaced by Validated. See the Node Pool condition transition details.

The Accepted condition indicates whether or not the Node Pool's configuration is accepted. If a Node Pool's condition is Accepted, it means that the Node Pool has a valid configuration, and any requests for changes to the number of Nodes are ready for further processing. This response indicates one of the following conditions:

Status	Meaning
Accepted	The Node Pool is valid and ready for further processing.
InternalError	The Node Pool encountered an issue trying to validate the resource. Unlike Invalid below, this implies an error with the validation process, rather than the configuration itself.
Invalid	The Node Pool's configuration is not considered valid.
PolicyViolation	The Node Pool's configuration is considered invalid because of a specific policy violation, such as a certain Instance Type being unavailable at the specified Region.

Condition: Validated

This condition answers the question: "Is the Node Pool configuration valid?" It has three possible statuses:

Status	Description
Valid	The Node Pool configuration is correct.
Invalid	The Node Pool configuration has errors, such as an unsupported instance type or incorrect Node affinity.
InternalError	A system error occurred during validation, so the Node Pool couldn't be fully checked.

Condition: Allocated

Note: This condition is deprecated and has been replaced by AtTarget. See the Node Pool condition transition details.

The Allocated condition indicates whether or not the Node Pool has the appropriate number of Nodes in it. This response indicates one of these conditions:

Status	Meaning
Complete	The Node Pool has the appropriate number of Nodes. This means that all requested Nodes have been allocated and are ready for use.
PendingDelete	The Node Pool is pending deletion; Nodes are being removed from the Node Pool and the Node Pool will be deleted once that process is complete.
OverTarget	The current Node count exceeds the target Node count.
UnderTarget	Fewer Nodes exist in the Node Pool than the target number outlined in the CR.
InternalError	An internal error occurred while determining the allocated Nodes for the NodePool.
Unknown	The current status of the Node Pool is unknown.

Condition: AtTarget

This condition shows whether the Node Pool has the expected number of active Nodes. The AtTarget condition has five possible values:

Status	Description
TargetMet	The Node Pool has exactly the number of Nodes specified in the target.
PendingDelete	The Node Pool is being deleted, and its Nodes will be removed.
OverTarget	More Nodes exist than the target. Extra Nodes will be removed using the ScaleDownStrategy.
UnderTarget	Fewer Nodes exist than the target. New Nodes will be created if resources are available.
InternalError	A system error occurred while retrieving Node information for the Node Pool.

Condition: NodesRemoved

The condition NodesRemoved is applied to a Node Pool when it is pending deletion and Nodes are in the process of being removed. Once all Nodes are removed, the Node Pool will be deleted. This response indicates one of the following conditions:

Status	Meaning
Complete	All Nodes have been removed from the Node Pool, and the Node Pool's deletion is imminent.
Pending	Nodes are in the process of being removed from the Node Pool.
InternalError	An internal error has occurred while trying to remove Nodes from the Node Pool.

Condition: SufficientCapacity

Note: This condition is deprecated and has been replaced by Capacity. See the Node Pool condition transition details.

The SufficientCapacity condition indicates whether there is enough capacity available for the requested number of Nodes in the requested instance type. This response indicates one of the following conditions:

Status	Meaning
Sufficient	All Nodes have been removed from the Node Pool, and the pool's deletion is imminent.
Partial	Partial capacity exists in the designated Region to fulfill the request, but not to completely fulfill it.
NoneAvailable	No Nodes are available of the requested type in the given Region.
InternalError	CoreWeave Kubernetes Service is unable to determine capacity due to an internal error occurring while attempting to process the updated Node Pool.

Condition: Capacity

The Capacity condition indicates whether there is enough capacity available for the requested number of Nodes in the requested instance type. This response indicates one of the following conditions:

Status	Meaning
Sufficient	All Nodes have been removed from the Node Pool, and the pool's deletion is imminent.
Partial	Partial capacity exists in the designated Region to fulfill the request, but not to completely fulfill it.
NoneAvailable	No Nodes are available of the requested type in the given Region.
NoneAvailableNodeAffinity	No Nodes are available for the requested instance type due to Affinity constraints.
PartialNodeAffinity	Partial capacity is available to fulfill the requested targetNodes, full capacity is not available due to Affinity constraints.
InternalError	An internal error has occurred while attempting to check capacity.

Condition: Quota

Quota has four statuses.

Status	Meaning
Under	The organization is under quota for the Node Pool's instance type.
Over	The organization is over quota for the Node Pool's instance type.
NotSet	The organization does not have a quota set for the Node Pool's instance type.
InternalError	An internal error has occurred attempting to check the quota.

Events

Node events

Event Name	Related resource	Occurs when
CWNodeRegistered	Node	Fired when Node registration succeeds.
CWRegistrationFailedEvent	Node	Fired when Node registration fails; see provided message for additional details.

Node Pool events

Event Name	Resource	Description
CWDrainNode	NodePool	Fired when a Node is being drained.
CWInstanceTypeNotInZone	NodePool	Fired when a Node Pool has an instance type not in its Zone.
CWInsufficientCapacity	NodePool	Fired when there is not sufficient capacity for a Node Pool.
CWInvalidInstanceType	NodePool	Fired when a Node Pool contains an invalid instance type.
CWNodeAssigned	NodePool	Fired when a Node is assigned to a Node Pool.
CWNodeDeleted	NodePool	Fired to indicate a Node has been deleted.
CWNodeDeletionRequestSuccess	NodePool	Fired when Node Pool Operator receives a request to delete a Node.
CWNodeDeliverFail	NodePool	Fired when Node allocation to a Node Pool fails due to misconfigured Node Pool settings or internal issues.
CWNodePoolCreated	NodePool	Fired when a Node Pool is created.
CWNodePoolDeleted	NodePool	Fired when a Node Pool is deleted.
CWNodePoolMetadata	NodePool	Fired when metadata is updated for a Node Pool.
CWNodePoolNodesRemoved	NodePool	Fired when Nodes are removed from the Node Pool.
CWNodePoolNodesRemoveError	NodePool	Fired when an error occurs during Node removal.
CWNodePoolNodesRequestFailed	NodePool	Fired when an error is returned when updating the Node Pool.
CWNodePoolQuotaCheckFailed	NodePool	Fired when there is an internal error checking the quota.
CWNodePoolRemoveNodes	NodePool	Fired when attempting to scale down a Node Pool.
CWNodePoolScaledDown	NodePool	Fired when a Node Pool is scaled down.
CWNodePoolScaledUp	NodePool	Fired when a Node Pool is scaled up.
CWNodeRegistered	Node, NodePool	Fired when Node registration succeeds.
CWNodeRegistrationFailed	Node	Fired when Node registration fails. See the message for additional details.
CWNodeRequestQueued	NodePool	Fired when a request is submitted to add Nodes to a Node Pool.
CWOverQuota	NodePool	Fired when the quota is insufficient for the Node Pool's targetNodes.