For AI agents: The documentation index is at https://docs.digitalocean.com/llms.txt. Markdown versions of pages use the same URL with index.html.md in place of the HTML page (for example, append index.html.md to the directory path instead of opening the HTML document).

A node pool is a group of nodes in a DOKS cluster with the same configuration.

All the worker nodes within a node pool have identical resources, but each node pool can have a different worker configuration. This lets you have different services on different node pools, where each pool has the RAM, CPU, and attached storage resources the service requires.

You can create and modify node pools at any time. Worker nodes are automatically deleted and recreated when needed, and you can manually recycle worker nodes. Nodes in the node pool inherit the node pool’s naming scheme when you first create a node pool, however, renaming a node pool does not rename the nodes. Nodes inherit the new naming scheme when recycled or when resizing the node pool which creates new nodes.

A node pool’s machine size slug is immutable. To change a pool’s bundled size or move between a bundled plan and a v5 configuration, create a node pool with the target configuration, drain the old node pool, and remove it. You can still change the number of nodes in a pool directly or with autoscaling.

You can add custom tags to a cluster and its node pools. DOKS deletes any custom tags you added to worker nodes in a node pool (for example, from the Droplets page) to maintain consistency between the node pool and its worker nodes.

Add a Node Pool to a Cluster Using Automation

Use a size returned by the /v2/kubernetes/options endpoint or the doctl kubernetes options sizes command. DOKS supports a subset of standalone Droplet v5 configurations, so a v5 Droplet slug that is not in the Kubernetes options cannot be used for a node pool.

curl -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -d '{"size": "s-2vcpu-4gb","count": 1,"name": "pool-02","tags": ["web"], "labels": {"service": "web", "priority": "high"}}' \
  "https://api.digitalocean.com/v2/kubernetes/clusters/bd5f5959-5e1e-4205-a714-a914373942af/node_pools"

import (
    "context"
    "os"

    "github.com/digitalocean/godo"
)

func main() {
    token := os.Getenv("DIGITALOCEAN_TOKEN")

    client := godo.NewFromToken(token)
    ctx := context.TODO()

    createRequest := &godo.KubernetesNodePoolCreateRequest{
        Name:  "pool-02",
        Size:  "s-2vcpu-4gb",
        Count: 1,
        Tags:  []string{"web"},
        Labels:  map[string]string{"service": "web", "priority": "high"},
    }

    nodePool, _, err := client.Kubernetes.CreateNodePool(ctx, "bd5f5959-5e1e-4205-a714-a914373942af", createRequest)
}

require 'droplet_kit'
token = ENV['DIGITALOCEAN_TOKEN']
client = DropletKit::Client.new(access_token: token)

node_pool = DropletKit::KubernetesNodePool.new(
  name: 'pool-02',
  size: 's-2vcpu-4gb',
  count: 1,
  tags: ['web']
  labels: {service: 'web', priority: 'high'}
)

client.kubernetes_clusters.create_node_pool(node_pool, id: 'bd5f5959-5e1e-4205-a714-a914373942af')

import os
from pydo import Client

client = Client(token=os.environ.get("DIGITALOCEAN_TOKEN"))

req = {
  "size": "s-1vcpu-2gb",
  "count": 3,
  "name": "new-pool",
  "tags": [
    "frontend"
  ],
  "auto_scale": True,
  "min_nodes": 3,
  "max_nodes": 6
}

resp = client.kubernetes.add_node_pool(cluster_id="ba9d8da", body=req)

Add a GPU Worker Node to a Cluster

You can also add a GPU node pool to an existing cluster on versions 1.30.4-do.0, 1.29.8-do.0, 1.28.13-do.0, and later.

doctl kubernetes cluster node-pool create gpu-cluster --name gpu-worker-pool-1 --size gpu-h100x1-80gb --count 4

curl --location --request POST 'https://api.digitalocean.com/v2/kubernetes/clusters/{cluster_id}/node_pools' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer $DIGITALOCEAN_TOKEN' \
--data '{
    "node_pools": [
        {
            "size": "gpu-h100x1-80gb",
            "count": 4,
            "name": "new-gpu-worker-pool"
        }
}',

To run GPU workloads after you create a cluster, use the GPU nodes-specific labels and taint in your workload specifications to schedule pods that match. You can use a configuration spec, similar to the pod spec shown below, for your actual workloads:

apiVersion: v1
kind: Pod
metadata:
  name: gpu-workload
spec:
  restartPolicy: Never
  nodeSelector:
    doks.digitalocean.com/gpu-brand: nvidia
  containers:
    - name: cuda-container
      image: nvcr.io/nvidia/k8s/cuda-sample:vectoradd-cuda10.2
  tolerations:
    - key: nvidia.com/gpu
      operator: Exists
      effect: NoSchedule

The above spec shows how to create a pod that runs NVIDIA’s CUDA image and uses the labels and taint for GPU worker nodes.

You can use the cluster autoscaler to automatically scale the GPU node pool down to zero, or use the DigitalOcean CLI or API to manually scale the node pool down to zero. For example:

  doctl kubernetes cluster node-pool update <your-cluster-id> <your-nodepool-id> --count 0 

Add a Node Pool to a Cluster Using the Control Panel

To add additional node pools to an existing cluster, open the cluster’s More menu and select View Nodes. Click Add Node Pool. On the Add node pool(s) page, specify the following for the node pool:

• Node pool name: Choose a name for the node pool when it’s created. Nodes inside this pool inherit this naming scheme when they are created. If you rename the node pool later, the nodes only inherit the new naming scheme when they are recreated (when you recycle the nodes or resize the node pool).

• Choose the configuration type:

  • v5 configurations let you choose Shared for shared vCPUs or General Purpose for dedicated vCPUs, then size the worker’s resources independently. DOKS supports only the v5 options displayed in the Control Panel. v5 worker nodes have a 50 GiB or 80 GiB boot disk.

  • Bundled configurations use fixed resource ratios. Choose Shared CPUs for Basic Droplet plans or Dedicated CPUs for General Purpose, CPU-Optimized (Regular Intel CPU or Premium Intel CPU), and Memory-Optimized Droplet plans.

  • GPUs are built on GPU Droplets powered by AMD and NVIDIA GPUs. They are available in single-GPU and 8-GPU configurations.

  Note

  A cluster must have at least one CPU node pool to be fully operational. This pool is needed to host essential DOKS managed workloads such as CoreDNS, preventing them from running on more expensive GPU nodes. For high availability of these workloads, we recommend a minimum of two CPU nodes.

  For more information about shared and dedicated CPUs, see Shared CPU vs. Dedicated CPU.

  Choosing the right Kubernetes configuration depends on your workload. See Choosing the Right Kubernetes Plan for plan selection guidance.

  

  For a v5 node pool, you also select a Boot Disk size of 50 or 80 GiB. The boot disk is persistent NVMe storage that holds the operating system, container images, and emptyDir volumes for each node.

  

• Node configuration: Choose the specific bundled plan or v5 configuration you want for your worker nodes. Each worker in a node pool has identical resources.

  Some high-tier node plans are locked. To request access to those plans, click Submit a request. In the Request access to more nodes or higher-tier plans, specify the reason for the request and number of nodes you are requesting and click Submit.

• Select the Set node pool to autoscale option to enable autoscaling.

• Nodes: For a fixed-size cluster, choose how many nodes to include in the node pool. By default, three worker nodes are selected.

• Minimum nodes and Maximum nodes: For an autoscaling-enabled cluster, choose the minimum and maximum number of nodes for when the load decreases or increases.

Click Add Node Pool(s) to add additional node pools.

Click Save to apply your changes and provision your new nodes.