Description

This rule verifies that each DigitalOcean Kubernetes (DOKS) node pool maintains a minimum scale limit greater than one worker node, so that the workloads scheduled on the pool always have more than a single node to run on. For a pool with autoscaling enabled it inspects the min-nodes floor; for a fixed-size pool it inspects the node count.

DigitalOcean requires that every node pool always has at least one node, but one node provides no redundancy. This rule flags any production or availability-sensitive pool whose effective minimum is one, so that a single node failure, drain, or surge-upgrade event cannot take the whole pool's pods offline at once.

  • Autoscaling node pools whose min-nodes is set to 1.

  • Fixed-size node pools running a single node (count = 1).

  • Production workloads pinned (via nodeSelector/affinity) to a pool that can collapse to one node.

Rationale

A node pool that can shrink to, or is fixed at, a single node has no failure domain redundancy. When that node is lost to hardware failure, a routine drain, or a rolling upgrade, every pod on the pool is evicted simultaneously and there is nowhere for the Kubernetes scheduler to place the replacements, producing a full outage for that pool's workloads.

Keeping a floor of at least two nodes lets the scheduler reschedule pods onto surviving capacity during node loss and lets pod anti-affinity and PodDisruptionBudgets function as intended, turning a single node failure into a degradation rather than an outage.

  • Single-node pools defeat replica-based high availability.

  • Node maintenance and surge upgrades cycle nodes; a one-node floor means unavoidable downtime windows.

Impact

Pros:

  • Workloads survive the loss or recycling of any single node in the pool.

  • PodDisruptionBudgets and anti-affinity rules can actually be honored during drains and upgrades.

  • Smoother, near-zero-downtime node replacements during upgrades and resizes.

Cons:

  • A minimum of two or more nodes costs more than running a single node at idle.

  • Right-sizing multiple small pools requires more capacity planning than one big node.

  • Very small non-critical or dev workloads may not need the extra node.

Default Value

DigitalOcean requires every node pool to have at least one node, and new pools are created with a fixed count and autoscaling off unless you opt in, so there is no enforced minimum above one.

Pre-Requisite

  • Access to the DigitalOcean Control Panel with a role that can view and resize Kubernetes clusters (e.g. account Owner or a Member with Kubernetes access).

  • Or a DigitalOcean API token / authenticated doctl (v1.115.0+ recommended) with read/write on Kubernetes.

  • Knowledge of which node pools carry production or availability-sensitive workloads.

  • Sufficient Droplet quota to run the higher node count (default account limit is 25 Droplets).

Remediation

Test Plan

Using the DigitalOcean Control Panel:

  1. Sign in to cloud.digitalocean.com and open Kubernetes from the left menu.

  2. Select the cluster and open the Resources (Nodes) tab to list its node pools.

  3. For each node pool, open the three-dot menu and choose 'Resize or Autoscale'.

  4. Read the setting: an autoscaling pool shows Minimum/Maximum node values; a fixed pool shows a single node count.

  5. Pass: every production node pool has an autoscale minimum of 2 or more, or a fixed count of 2 or more.

  6. Fail: any production node pool has an autoscale minimum of 1, or is a fixed pool with a single node.

Using doctl or the API:

Inspect the min/max or fixed count of every node pool in the cluster. (doctl's --format has no AutoScale/MinNodes/MaxNodes columns, so read the full JSON with -o json.)

doctl kubernetes cluster node-pool list <cluster-id> -o json | jq '.[] | {name, count, auto_scale, min_nodes, max_nodes}'
curl -s -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" "https://api.digitalocean.com/v2/kubernetes/clusters/$CLUSTER_ID/node_pools" | jq '.node_pools[] | {name, count, auto_scale, min_nodes, max_nodes}'

Pass if, for every production pool, either auto_scale is true with min_nodes >= 2, or auto_scale is false with count >= 2. Fail if any production pool has auto_scale true with min_nodes = 1, or auto_scale false with count = 1.

Implementation Steps

Using the DigitalOcean Control Panel:

  1. In the cluster's Resources (Nodes) tab, open the node pool's three-dot menu and choose 'Resize or Autoscale'.

  2. For an autoscaling pool, raise the Minimum node value to 2 (or higher) and confirm the Maximum is at least that.

  3. For a fixed-size pool, either raise the node count to 2 or more, or switch to Autoscale with a minimum of 2.

  4. Click Save and wait for the new node(s) to reach Ready.

Using doctl or the API:

Raise the pool floor with doctl or the node-pool update endpoint (the PUT body requires the pool name).

doctl kubernetes cluster node-pool update <cluster-id> <pool-id> --auto-scale --min-nodes 2 --max-nodes 5
doctl kubernetes cluster node-pool update <cluster-id> <pool-id> --count 2   # fixed-size pool
curl -s -X PUT -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" -H 'Content-Type: application/json' -d '{"name":"<pool-name>","auto_scale":true,"min_nodes":2,"max_nodes":5}' "https://api.digitalocean.com/v2/kubernetes/clusters/$CLUSTER_ID/node_pools/$POOL_ID"

Backout Plan:

  1. Re-open 'Resize or Autoscale' for the pool (or call node-pool update again).

  2. Lower the Minimum node value or fixed count back to its prior value.

  3. Save; DigitalOcean drains and removes the surplus nodes. Do this only for pools confirmed to be non-critical.

References:

  1. DOKS - Autoscale a cluster

  2. DOKS - Add / resize node pools

  3. doctl kubernetes cluster node-pool reference