Node-Level Scaling - Node Groups, Cluster Autoscaler vs Karpenter, Over-Provisioning, PDBs & Drains

"""Simulation: node-group autoscaling (Cluster Autoscaler style) vs groupless
provisioning (Karpenter style) for the same burst of pending pods.

Instance shapes and hourly prices are EXAMPLE numbers, not a price list.
CA logic follows its FAQ: a template node per node group, simulate whether the
pending pods fit, then an expander (default least-waste) picks the group.
Karpenter logic: pick instance types from a broad catalog to bin-pack the
pending pods at the lowest price, then consolidate when utilisation drops.
"""
DAEMON = (0.2, 0.5)                     # per-node DaemonSet overhead: vCPU, GiB
CATALOG = {                              # name: (vCPU, GiB, $/h)  EXAMPLE values
    "c-2x4":   (2, 4, 0.085),  "g-4x16": (4, 16, 0.192), "c-8x16": (8, 16, 0.340),
    "g-16x64": (16, 64, 0.768), "m-8x64": (8, 64, 0.504),
}
pending = [(1.5, 3)] * 6 + [(3.5, 12)] * 2 + [(0.5, 1)] * 10   # (vCPU, GiB) requests

def pack(pods, shape):
    """first-fit decreasing onto identical nodes of one shape; returns node loads"""
    cpu, mem, _ = CATALOG[shape]
    nodes = []
    for c, m in sorted(pods, reverse=True):
        if c > cpu - DAEMON[0] or m > mem - DAEMON[1]:
            return None                  # pod can never fit this shape
        for n in nodes:
            if n[0] + c <= cpu - DAEMON[0] and n[1] + m <= mem - DAEMON[1]:
                n[0] += c; n[1] += m; break
        else:
            nodes.append([c, m])
    return nodes

def report(label, shape, nodes):
    cpu, mem, price = CATALOG[shape]
    used = sum(n[0] for n in nodes) + DAEMON[0] * len(nodes)
    print(f"  {label:<26} {len(nodes)} x {shape:<8} ${price * len(nodes):.3f}/h  "
          f"cpu util {100 * used / (cpu * len(nodes)):.0f}%")
    return price * len(nodes)

req_cpu = sum(c for c, _ in pending); req_mem = sum(m for _, m in pending)
print(f"pending: {len(pending)} pods, {req_cpu} vCPU, {req_mem} GiB requested\n")

print("Cluster Autoscaler: the node groups someone created earlier are c-8x16 and g-16x64; expander=least-waste")
options = {}
for group in ("c-8x16", "g-16x64"):
    nodes = pack(pending, group)
    idle = CATALOG[group][0] * len(nodes) - sum(n[0] for n in nodes) - DAEMON[0] * len(nodes)
    options[group] = (idle, nodes)
    print(f"  simulate +{len(nodes)} {group}: idle cpu after scale-up {idle:.1f}")
choice = min(options, key=lambda g: options[g][0])
ca_cost = report(f"least-waste picks {choice}", choice, options[choice][1])

def groupless(pods):
    """toy heuristic: open one node at a time, choosing the shape with the lowest
    price per packed vCPU for the pods still waiting (mixed shapes allowed)"""
    left, fleet = sorted(pods, reverse=True), []
    while left:
        best = None
        for shape, (cpu, mem, price) in CATALOG.items():
            load, took = [0.0, 0.0], []
            for p in left:
                if load[0] + p[0] <= cpu - DAEMON[0] and load[1] + p[1] <= mem - DAEMON[1]:
                    load[0] += p[0]; load[1] += p[1]; took.append(p)
            if took and (best is None or price / load[0] < best[0]):
                best = (price / load[0], shape, took)
        fleet.append(best[1])
        for p in best[2]:
            left.remove(p)
    return fleet

def fleet_report(label, fleet):
    from collections import Counter
    cost = sum(CATALOG[s][2] for s in fleet)
    print(f"  {label:<26} {dict(Counter(fleet))}  ${cost:.3f}/h")
    return cost

print("\nKarpenter: NodePool allows the whole catalog (groupless), mixed shapes allowed")
k_cost = fleet_report("launch", groupless(pending))

print("\nlater: the 10 small pods finish; 1.5-vCPU and 3.5-vCPU pods remain")
remaining = [(1.5, 3)] * 6 + [(3.5, 12)] * 2
ca_nodes = pack(remaining, choice)
print(f"  CA: scale-down removes a node only if its requests are < 50% of allocatable and its pods fit elsewhere,")
print(f"      after 10 min unneeded -> at best {len(ca_nodes)} x {choice} ${CATALOG[choice][2] * len(ca_nodes):.3f}/h")
fleet_report("Karpenter consolidation ->", groupless(remaining))
print(f"\nburst cost: CA ${ca_cost:.3f}/h vs Karpenter ${k_cost:.3f}/h (example prices)")

pending: 18 pods, 21.0 vCPU, 52 GiB requested

Cluster Autoscaler: the node groups someone created earlier are c-8x16 and g-16x64; expander=least-waste
  simulate +4 c-8x16: idle cpu after scale-up 10.2
  simulate +2 g-16x64: idle cpu after scale-up 10.6
  least-waste picks c-8x16   4 x c-8x16   $1.360/h  cpu util 68%

Karpenter: NodePool allows the whole catalog (groupless), mixed shapes allowed
  launch                     {'g-16x64': 1, 'g-4x16': 1, 'c-2x4': 2}  $1.130/h

later: the 10 small pods finish; 1.5-vCPU and 3.5-vCPU pods remain
  CA: scale-down removes a node only if its requests are < 50% of allocatable and its pods fit elsewhere,
      after 10 min unneeded -> at best 3 x c-8x16 $1.020/h
  Karpenter consolidation -> {'g-16x64': 1, 'c-2x4': 1}  $0.853/h

burst cost: CA $1.360/h vs Karpenter $1.130/h (example prices)

// Simulation: the latency budget from "traffic spike" to "new pod serving".
// Stage values marked FAQ come from the Cluster Autoscaler FAQ (HPA ~1 min typical,
// CA reaction < 30 s in most cases, GCE node provisioning usually 3-4 min).
// Values marked EXAMPLE are assumptions for illustration; measure your own.
type Stage = { name: string; seconds: number; source: "FAQ" | "EXAMPLE" };

const hpa: Stage = { name: "HPA notices load and raises replicas", seconds: 60, source: "FAQ" };
const ca: Stage = { name: "autoscaler sees Pending pod, requests node", seconds: 30, source: "FAQ" };
const boot: Stage = { name: "VM boots, kubelet registers, CNI ready", seconds: 210, source: "FAQ" };
const pull: Stage = { name: "image pull on a cold node", seconds: 40, source: "EXAMPLE" };
const pullWarm: Stage = { name: "image already cached on node", seconds: 2, source: "EXAMPLE" };
const ready: Stage = { name: "app start + readiness probe passes", seconds: 20, source: "EXAMPLE" };
const preempt: Stage = { name: "preempt a pause pod (grace 0) and bind", seconds: 2, source: "EXAMPLE" };

const total = (s: Stage[]) => s.reduce((a, b) => a + b.seconds, 0);
function show(title: string, stages: Stage[]) {
  console.log(`${title}: ${total(stages)} s`);
  for (const s of stages) console.log(`   ${String(s.seconds).padStart(4)} s  ${s.name} [${s.source}]`);
}

const cold = [hpa, ca, boot, pull, ready];
const buffered = [hpa, preempt, pullWarm, ready];
show("A) no spare capacity", cold);
show("B) over-provisioned with low-priority pause pods", buffered);
console.log("   (the evicted pause pod goes Pending and triggers a node add in the background)");

// What does the buffer cost? EXAMPLE: buffer = 2 nodes at $0.192/h
const bufferNodes = 2, price = 0.192, hoursPerMonth = 730;
console.log(`\nbuffer cost: ${bufferNodes} nodes x $${price}/h x ${hoursPerMonth} h = $${(bufferNodes * price * hoursPerMonth).toFixed(2)}/month (example price)`);

// Where should you spend effort? Show each stage's share of the cold path.
console.log("\nshare of cold path:");
for (const s of cold) console.log(`   ${((100 * s.seconds) / total(cold)).toFixed(0).padStart(3)}%  ${s.name}`);

A) no spare capacity: 360 s
     60 s  HPA notices load and raises replicas [FAQ]
     30 s  autoscaler sees Pending pod, requests node [FAQ]
    210 s  VM boots, kubelet registers, CNI ready [FAQ]
     40 s  image pull on a cold node [EXAMPLE]
     20 s  app start + readiness probe passes [EXAMPLE]
B) over-provisioned with low-priority pause pods: 84 s
     60 s  HPA notices load and raises replicas [FAQ]
      2 s  preempt a pause pod (grace 0) and bind [EXAMPLE]
      2 s  image already cached on node [EXAMPLE]
     20 s  app start + readiness probe passes [EXAMPLE]
   (the evicted pause pod goes Pending and triggers a node add in the background)

buffer cost: 2 nodes x $0.192/h x 730 h = $280.32/month (example price)

share of cold path:
    17%  HPA notices load and raises replicas
     8%  autoscaler sees Pending pod, requests node
    58%  VM boots, kubelet registers, CNI ready
    11%  image pull on a cold node
     6%  app start + readiness probe passes