> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Create a Node Pool

> Create a Node Pool to manage Nodes as a single entity

To add Nodes to <Tooltip tip="CoreWeave Kubernetes Service (CKS) is CoreWeave's managed Kubernetes service." cta="Learn more" href="/glossary#coreweave-kubernetes-service-cks">CKS</Tooltip> clusters, you must first create and deploy a Node Pool to associate with a given cluster.

Node Pools are deployed as Kubernetes <Tooltip tip="A Custom Resource (CR) is the deployed instance of an object defined by a CRD." cta="Learn more" href="/glossary#custom-resource-cr">Custom Resources (CRs)</Tooltip>, which allocate the number, type, and regional placement of Nodes for use by a specified CKS cluster.

Node Pools can be deployed either directly [using Kubernetes](#create-a-node-pool-using-kubernetes), or on the Cloud Console using [the Node Pools dashboard](#create-a-node-pool-using-the-cloud-console).

## Prerequisites

* An active CoreWeave account
* A [CKS cluster](/products/cks/clusters/create)
* `kubectl` installed locally
* An active [API Access Token](/security/authn-authz/managed-auth/api-access), with an associated Kubeconfig

## Create a Node Pool using the Cloud Console

1. In Cloud Console, navigate to [Node Pools](https://console.coreweave.com/node-pools). If you do not yet have any CKS clusters, you need to [create a cluster](/products/cks/clusters/create) first.

2. Select the CKS cluster to which the Node Pool should be added from the drop-down menu at the top of the page.

   <img src="https://mintcdn.com/coreweave-dbfa0e8d/tk0Jf62-ZaeUJuQx/products/cks/_media/node-pool-cluster-select.png?fit=max&auto=format&n=tk0Jf62-ZaeUJuQx&q=85&s=aa17cd015b4ef759f5bfab0fbce4a0b9" alt="A closeup of the cluster selection dropdown on the dashboard for creating and customizing Node Pools." width="2552" height="690" data-path="products/cks/_media/node-pool-cluster-select.png" />

3. Click the **Create Node Pool** button at the top right corner of the dashboard.

   <img src="https://mintcdn.com/coreweave-dbfa0e8d/tk0Jf62-ZaeUJuQx/products/cks/_media/node-pool-create.png?fit=max&auto=format&n=tk0Jf62-ZaeUJuQx&q=85&s=72eb110d68b92441dcf7301ddd513fdd" alt="The homepage of a user Cloud Console account with the Node Pools tab highlighted." width="2552" height="690" data-path="products/cks/_media/node-pool-create.png" />

4. The creation page features a YAML editor on the right-hand side, with a corresponding GUI on the left-hand side.

   <img src="https://mintcdn.com/coreweave-dbfa0e8d/tk0Jf62-ZaeUJuQx/products/cks/_media/node-pool-create-console.png?fit=max&auto=format&n=tk0Jf62-ZaeUJuQx&q=85&s=b374a72611a9f94acf3786e3223b15e0" alt="The dashboard for creating and customizing Node Pools and its equivalent CR manifest." width="2548" height="1576" data-path="products/cks/_media/node-pool-create-console.png" />

5. Configure the essential aspects of the Node Pool as desired:

   | Field             | Type    | YAML Field          | Description                                                   |
   | ----------------- | ------- | ------------------- | ------------------------------------------------------------- |
   | **Name**          | String  | `metadata.name`     | The name of the Node Pool                                     |
   | **Cluster**       | String  | `spec.cluster`      | The cluster to which the Node Pool will be added              |
   | **Compute Class** | String  | `spec.computeClass` | The compute class of the Node Pool.                           |
   | **Target Nodes**  | Integer | `spec.targetNodes`  | The quantity of desired Nodes in the Node Pool (minimum: `0`) |
   | **Instance Type** | String  | `spec.instanceType` | The desired instance type for the Node Pool                   |

### Node Pool quotas

Every time `targetNodes` is set, whether you are creating a new Node Pool or scaling an existing one, the organization's quota is checked. If the total request exceeds the organization's quota for that instance type and zone, the Node Pool is filled up to the allowed quota. Error messages are displayed in the output of `kubectl describe` on the `nodepool` resource:

```text theme={"system"}
Type     Reason                         Age                  From              Message
----     ------                         ----                 ----              -------
Warning  CWOverQuota                    2m6s (x21 over 47m)  nodePoolOperator  TargetNodes pushes org over quota by <OVERAGE>. Quota limit is <QUOTA> for instance type <INSTANCE_TYPE> in zone <ZONE>
Warning  CWNodePoolQuotaCheckFailed     2m6s (x21 over 47m)  nodePoolOperator  Internal quota error
```

<Warning>
  Quota enforcement applies to both new and existing Node Pools. If `targetNodes` exceeds the organization's quota, the Node Pool is filled only up to the allowed quota. For example, if the quota maximum is `10` and `targetNodes` is set to `15`, the Node Pool requests only 10 nodes.

  To check the current quota status for a Node Pool, run `kubectl get nodepool` and look at the `QUOTA` column. An `Over` status means the Node Pool's `targetNodes` exceeds the organization's quota.
</Warning>

For more information, see [the Node Pool reference page](/products/cks/reference/node-pool#events).

For more details regarding your organization's quota, please contact your CoreWeave representative.

### Configure taints, labels, and annotations

At the bottom of the creation page, configure any desired taints, annotations, or labels for the Node Pool.

<img src="https://mintcdn.com/coreweave-dbfa0e8d/tk0Jf62-ZaeUJuQx/products/cks/_media/node-pool-taints-and-labels.png?fit=max&auto=format&n=tk0Jf62-ZaeUJuQx&q=85&s=2adf9fddc9881c0bf75bc036945eb24a" alt="The dashboard for creating and customizing Node Pools and its equivalent CR manifest." width="988" height="1324" data-path="products/cks/_media/node-pool-taints-and-labels.png" />

<Info>
  For more information about Node taint scheduling, see [Taints and Tolerations](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration) in the official Kubernetes documentation. For information about the valid syntax for labels and annotations in CKS and vanilla Kubernetes, see [Labels and Selectors](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels) in the official Kubernetes documentation.
</Info>

### Deploy the Node Pool

1. Once the Node Pool is ready to deploy, click the **Submit** button to deploy the Node Pool. If you need to make changes, click the **Reset** button to clear all fields and start over.

2. Once you click the **Submit** button, you will be directed back to the Node Pools dashboard. The new Node Pool is listed in a `Pending` state until it has completed deployment, when its status changes to `Healthy`.

   <img src="https://mintcdn.com/coreweave-dbfa0e8d/tk0Jf62-ZaeUJuQx/products/cks/_media/node-pool-all-statuses.png?fit=max&auto=format&n=tk0Jf62-ZaeUJuQx&q=85&s=aeccf1e7e61d9518b62e8483c85bfaba" alt="Screenshot of Node Pool statuses on the Cloud Console" width="5922" height="1578" data-path="products/cks/_media/node-pool-all-statuses.png" />

<Info>
  To learn more about other Node Pool conditions, see [the Node Pool reference on conditions](/products/cks/reference/node-pool#conditions).
</Info>

## Create a Node Pool using Kubernetes

First, configure a Node Pool manifest. Here's an example of a `default` Node Pool:

```yaml title="example-nodepool.yaml" theme={"system"}
apiVersion: compute.coreweave.com/v1alpha1
kind: NodePool
metadata:
  name: example-nodepool
spec:
  computeClass: default
  autoscaling: false
  instanceType: gd-8xh100ib-i128
  maxNodes: 0
  minNodes: 0
  targetNodes: 2
  nodeLabels:
    my-label/node: "true"
  nodeAnnotations:
    my-annotation/node: "true"
  nodeTaints:
    - key: node-taint
      value: "true"
      effect: NoSchedule
```

The fields in this manifest map to the following values:

| Field          | Type    | Description                                                                                                          | Default   |
| -------------- | ------- | -------------------------------------------------------------------------------------------------------------------- | --------- |
| `computeClass` | String  | The compute class of the Node Pool.                                                                                  | `default` |
| `instanceType` | String  | [GPU Instance](/platform/instances/gpu-instances) or [CPU Instance](/platform/instances/cpu-instances) type          | N/A       |
| `autoscaling`  | Boolean | Whether a cluster has [autoscaling](/products/cks/nodes/autoscaling) enabled                                         | `false`   |
| `targetNodes`  | Integer | The quantity of desired Nodes in the Node Pool (minimum `0`)                                                         | N/A       |
| `minNodes`     | Integer | The minimum number of Nodes in the cluster (Optional if `autoscaling: false`)                                        | `0`       |
| `maxNodes`     | Integer | The maximum number of Nodes in the cluster (Optional if `autoscaling: false`)                                        | `0`       |
| `nodeLabels`   | Map     | Labels to apply to the Nodes in the Node Pool, to organize Nodes for specific purposes and Pod scheduling (Optional) | N/A       |
| `nodeTaints`   | Map     | Taints to apply to the Nodes in the Node Pool, to schedule only Pods with matching tolerations (Optional)            | N/A       |

In the example above, the Node Pool manifest creates a Node Pool with the following characteristics:

| Key            | Example value                                                     | Description                                                                                                                                           |
| -------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`         | `example-nodepool`                                                | The name of the Node Pool                                                                                                                             |
| `computeClass` | `default`                                                         | The compute class of the Node Pool, in this case a default Node Pool for Reserved and On-Demand instances                                             |
| `autoscaling`  | `false`                                                           | [Autoscaling](/products/cks/nodes/autoscaling) is not enabled                                                                                         |
| `instanceType` | `gd-8xh100ib-i128`                                                | The type of instances to include in the Node Pool, in this case 8 GPU-count H100s with InfiniBand (`gd-8xh100ib-i128`)                                |
| `minNodes`     | `0`                                                               | The minimum number of Nodes that *must* be in the Node Pool - in this case, that number is not set (set to `0`)                                       |
| `maxNodes`     | `0`                                                               | The maximum number of Nodes that *must* be in the Node Pool - in this case, that number is not set (set to `0`)                                       |
| `targetNodes`  | `2`                                                               | The number of desired Nodes that should be in the Node Pool, in this case `2`                                                                         |
| `nodeLabels`   | `my-label/node: "true"`                                           | The [label](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#built-in-node-labels) to place on all Nodes within the Node Pool |
| `nodeTaints`   | `[{ key: "my-label/node", value: "true", effect: "NoSchedule" }]` | The [taint](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/) to place on all Nodes in the Node Pool                     |

#### Autoscaling

To enable autoscaling for a Node Pool, set `autoscaling: true`. The autoscaler will then adjust `targetNodes` based on workload demand, keeping it between `minNodes` and `maxNodes`. See [Autoscale Node Pools](/products/cks/nodes/autoscaling) for details.

### Apply the manifest

Once you have configured the manifest, apply it with `kubectl`:

```bash theme={"system"}
kubectl apply -f example-nodepool.yaml
```

When the manifest is applied, CKS provisions the cluster with a Node Pool comprised of Nodes that match the manifest's specifications.

### Verify the Node Pool

Verify that the Node Pool resource has been created properly by using `kubectl get` on the `nodepool` resource. For example:

```bash title="Example command" theme={"system"}
kubectl get nodepool example-nodepool
```

The output displays details about the Node Pool name, including the type and number of instances it contains:

```text title="Example output" theme={"system"}
NAME                INSTANCE TYPE     TARGET   QUEUED   INPROGRESS   CURRENT   VALIDATED    CAPACITY    QUOTA    AGE
example-nodepool    gd-8xg100-i128    2        0        0            0         Valid        Sufficient   Under    24h
```

### List all available Node Pools

To view all available Node Pools in a cluster, use `kubectl get nodepool`. This returns a list of all current Node Pools in the cluster, as well as their current condition. For example:

```bash title="Example command" theme={"system"}
kubectl get nodepool
```

```text title="Example output" theme={"system"}
NAME                INSTANCE TYPE      TARGET   QUEUED   INPROGRESS   CURRENT   VALIDATED    CAPACITY                  QUOTA    AGE
example-nodepool    gd-8xg100-i128     2        0        0            0         Valid        Sufficient                 Under    24h
NodePool-2          cd-hp-a96-genoa    2        1        0            1         Valid        QueuedAwaitingCapacity    Under    2d22h
NodePool-3          gd-8xh100ib-i128   3        0        1            2         Valid        Sufficient                 Under    2d15h
```

### View the Node Pool

To see additional details on any Node Pool, target the Node Pool with `kubectl describe`.

For example, where the Node Pool's `metadata.name` is `example-nodepool`:

```bash title="Example command" theme={"system"}
kubectl describe nodepool example-nodepool
```

```yaml title="Example output" theme={"system"}
Name:         example-nodepool
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
  Max Nodes:                 0
  Min Nodes:                 0
  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
  Queued Nodes:              0
Events:                      <none>
```

<Info>
  For more information on Node Pool `conditions`, see [Node Pool Reference: `conditions`](/products/cks/reference/node-pool#conditions).
</Info>

| Field name      | Description                                                         |
| --------------- | ------------------------------------------------------------------- |
| `INSTANCE TYPE` | The instance type of all Nodes in the Node Pool.                    |
| `TARGET`        | The number of Nodes in the Node Pool spec being requested.          |
| `QUEUED`        | The count of queued Nodes waiting to be assigned.                   |
| `INPROGRESS`    | The count of Nodes assigned and progressing into the Node Pool.     |
| `CURRENT`       | The count of Nodes in-cluster associated with the Node Pool.        |
| `VALIDATED`     | Displays the result of Node Pool validation.                        |
| `CAPACITY`      | Displays the last result for capacity checks for the instance type. |
| `QUOTA`         | Displays the last result for quota checks for the instance type.    |
| `AGE`           | Indicates how long ago the Node Pool was created.                   |

<Info>
  For more information on Node Pool creation, see [the Node Pool reference page](/products/cks/reference/node-pool).
</Info>