What is the difference between Cluster Autoscaler and Karpenter?

Node autoscaling exists because pod demand changes faster than anyone wants to edit infrastructure by hand. When the Horizontal Pod Autoscaler adds replicas, or a batch job submits a hundred pods, the scheduler needs nodes with free CPU and memory to place them. Without a node autoscaler, you either over-provision the cluster permanently or watch pods sit in Pending until someone adds capacity.

Cluster Autoscaler works through node groups you define ahead of time. On AWS these are Auto Scaling groups, often created as EKS managed node groups. When pods are unschedulable, Cluster Autoscaler simulates whether adding a node from each group would let them schedule. It then raises the desired capacity of a suitable group, and the cloud provider launches the instance. The instance types, zones, and labels a pod can land on are limited to the groups you created.

Karpenter does not depend on pre-defined node groups. It reads the requirements of pending pods, such as resource requests, node selectors, affinities, tolerations, and topology spread constraints. It then picks an instance type that fits and launches it directly through the cloud provider's API, within the limits you set in a NodePool. Because the node shape comes from the pods instead of from a group template, one NodePool can cover workloads that would otherwise need many node groups.

Both tools react only to pods the scheduler cannot place. Neither changes how many replicas a workload runs. That remains the job of HPA or a similar pod-level autoscaler, which a node autoscaler complements and does not replace.

+---------------------------------------------------------------------+
| HPA / Jobs create or add pods (sets replica count)                  |
+----------------------------------+----------------------------------+
                                   |
                                   v
+---------------------------------------------------------------------+
| kube-scheduler: no node has room -> pods stay Pending               |
+---------------+-----------------------------------+-----------------+
                |                                   |
                v                                   v
+-------------------------------+  +----------------------------------+
| Cluster Autoscaler            |  | Karpenter                        |
| simulates a node from each    |  | reads pod requests, selectors,   |
| pre-defined node group        |  | affinities, tolerations, spread  |
+---------------+---------------+  +----------------+-----------------+
                | raise desired capacity            | pick fitting type
                v                                   v
+-------------------------------+  +----------------------------------+
| Node group (ASG)              |  | Cloud provider API               |
| fixed types, zones, labels    |  | launch instance directly         |
| from the group template       |  | within NodePool limits           |
+---------------+---------------+  +----------------+-----------------+
                | ASG launches instance             |
                v                                   v
+-------------------------------+  +----------------------------------+
| New node joins; pending       |  | New node sized to the pods;      |
| pods are scheduled            |  | pending pods are scheduled       |
+-------------------------------+  +----------------------------------+

Both autoscalers start from pods the scheduler cannot place. Cluster Autoscaler raises the desired capacity of a pre-defined node group, and Karpenter launches an instance sized to the pending pods directly through the cloud provider API.

How does node autoscaling work end to end?

Both tools are controllers that run inside the cluster and follow the same basic loop: watch, decide, act, then let the normal Kubernetes machinery finish the job.

  1. A pod becomes unschedulable. The kube-scheduler tries to place the pod and fails. It sets the pod's PodScheduled condition to False with the reason Unschedulable, and the pod stays Pending. Neither autoscaler places pods itself. They only watch for this signal.
  2. The autoscaler decides what capacity would help. Cluster Autoscaler checks each node group to see whether one more node from it would let the pod schedule. Karpenter calculates which instance types satisfy the combined constraints of the batch of pending pods and the NodePool.
  3. The autoscaler requests capacity from the cloud. Cluster Autoscaler changes a node group's desired size and leaves the launch to the group. Karpenter creates a NodeClaim object that represents the node it wants, then calls the cloud provider API to launch a matching instance.
  4. The node registers. The instance boots, the kubelet starts, and the node joins the cluster with the labels and taints from its template or NodePool. Until the node reports Ready, the pod keeps waiting. Instance boot and image pull time are why scale-up is never instant.
  5. The scheduler binds the pod. The kube-scheduler sees the new node and places the pending pod on it through its usual filtering and scoring.
  6. Scale-down runs as a separate loop. Both controllers also look for nodes they can remove. Cluster Autoscaler looks for underused nodes whose pods fit elsewhere. Karpenter looks for empty nodes and cheaper packings. Before deleting a node, each one cordons it and evicts its pods through the eviction API.

Steps 2, 3 and 6 are where the tools differ, and the rest of this article covers those steps.

How does each autoscaler decide what node to launch?

Cluster Autoscaler starts from the node groups you already defined. For each pending pod, it builds a template node for every group, using an existing node or, for a group scaled to zero, the group's launch configuration and tags. It then runs the scheduler's predicates against those templates. Every group whose template could host the pod becomes a candidate. An expander such as least-waste, most-pods, random or priority picks one group, and Cluster Autoscaler raises that group's desired count.

Karpenter skips templates. It batches pending pods, reads their resource requests, node selectors, node affinities, topology spread constraints and tolerations, and intersects those constraints with the requirements on your NodePools. The result is a set of allowed instance types. Karpenter bin-packs the pods onto the cheapest instance type that fits and launches it directly.

Aspect Cluster Autoscaler Karpenter
Unit of decision Node group Individual instance
Shape options Templates you predefined Any instance type the NodePool allows
Selection logic Scheduler simulation plus expander Constraint solving plus bin-packing
Pod too large for any option Stays pending Stays pending only if no allowed type fits

Both depend on accurate requests, because neither looks at actual usage. Fixed node group sizes can hide bad requests. An under-requested pod still fits on a large node and appears to work. When Karpenter shrinks nodes to match requests, the same pod gets throttled or evicted. The structural limit is in Cluster Autoscaler: it can never launch a shape you did not define in a template.

How do you configure Karpenter NodePools for EKS autoscaling?

Cluster Autoscaler can only add capacity that is already defined as a node group. Karpenter inverts that. Cluster Autoscaler discovers Auto Scaling groups by tags such as k8s.io/cluster-autoscaler/enabled and treats each group's launch template as a fixed shape. Karpenter reads a NodePool, which describes the space of acceptable nodes, and picks a concrete instance per scheduling decision.

A NodePool usually carries the following settings:

  • Requirements: well-known label keys constrain instance family or category, size, kubernetes.io/arch, karpenter.sh/capacity-type (spot or on-demand) and topology.kubernetes.io/zone.
  • Taints and labels: these are applied to every node the pool launches. They let workloads opt in to a pool, which a node group alone cannot enforce.
  • Limits: a cap on total CPU and memory for the pool.
  • Disruption settings: the consolidation policy, timing and budgets.

A separate node class (EC2NodeClass on AWS) holds the infrastructure details: subnet and security group selectors, AMI selection and the node IAM role. Keeping these apart lets several NodePools with different shapes share one network and image definition.

A conceptual example is a general-purpose pool with these settings:

  • Allows only the c, m and r categories.
  • Excludes sizes above 4xlarge.
  • Pins arch to amd64.
  • Permits spot and on-demand.
  • Is capped at a fixed vCPU total.

Check every field name against the Karpenter API version you run, because names have changed across releases.

Treat requirements as an allowlist. If you omit architecture, Karpenter may launch arm64 nodes, and amd64-only images will then fail to start on them. If you omit size or category, a single large pending pod can bring up a very large instance or a GPU instance. Pool limits are the backstop for these mistakes. Leaving them unset removes the only hard ceiling on spend.

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: general-purpose
spec:
  template:
    metadata:
      labels:
        workload-class: general        # applied to every node this pool launches
    spec:
      nodeClassRef:                    # infra details live in the node class below
        group: karpenter.k8s.aws
        kind: EC2NodeClass
        name: default
      taints:                          # pods must tolerate this to opt in
        - key: workload-class
          value: general
          effect: NoSchedule
      requirements:                    # treat as an allowlist
        - key: karpenter.k8s.aws/instance-category
          operator: In
          values: ["c", "m", "r"]     # excludes GPU and other categories
        - key: karpenter.k8s.aws/instance-cpu
          operator: Lt
          values: ["17"]              # caps c/m/r at 4xlarge (16 vCPU)
        - key: kubernetes.io/arch
          operator: In
          values: ["amd64"]           # amd64-only images won't start on arm64 nodes
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["spot", "on-demand"]
        - key: topology.kubernetes.io/zone
          operator: In
          values: ["us-east-1a", "us-east-1b"]
  limits:                              # backstop if requirements are too loose
    cpu: "200"
    memory: 800Gi
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 5m
    budgets:
      - nodes: "10%"                 # disrupt at most 10% of nodes at once
---
apiVersion: karpenter.k8s.aws/v1
kind: EC2NodeClass
metadata:
  name: default
spec:
  role: KarpenterNodeRole-my-cluster   # placeholder node IAM role name
  amiSelectorTerms:
    - alias: al2023@latest
  subnetSelectorTerms:
    - tags:
        karpenter.sh/discovery: my-cluster
  securityGroupSelectorTerms:
    - tags:
        karpenter.sh/discovery: my-cluster

A conceptual Karpenter v1 NodePool limited to c/m/r instances of 4xlarge or smaller, amd64 only, spot or on-demand, in two zones, with taints, labels, CPU and memory limits and disruption settings, plus a shared EC2NodeClass that selects subnets, security groups and the AMI.

How do scale-down, consolidation and disruption controls compare?

Cluster Autoscaler removes nodes by asking one question: is this node underused? A node becomes a scale-down candidate when the sum of its pods' requests falls below a configurable utilization threshold for a sustained period, and every pod on it can be rescheduled elsewhere. Karpenter goes further. Consolidation deletes empty nodes, and it can also replace several underused nodes with fewer or cheaper ones. That second step means a node can be disrupted even when it is not idle.

Control Cluster Autoscaler Karpenter
Removal trigger Request-based utilization below a threshold Empty nodes, or a cheaper packing exists (per NodePool policy)
Node replacement No, only removal Yes, launches a cheaper node, then drains the old ones
Pod-level opt-out cluster-autoscaler.kubernetes.io/safe-to-evict: "false" karpenter.sh/do-not-disrupt: "true"
Rate limiting Global scale-down settings Per-NodePool disruption budgets, optionally time-windowed
Node lifetime None built in Expiry recycles nodes after a maximum age

Both tools drain through the eviction API, so PodDisruptionBudgets apply to either one. Karpenter's disruption budgets add a second limit at the node level. They cap how many nodes a NodePool may disrupt at once, and you can scope them to business hours. Expiry is the exception. It exists to force node rotation for patching, so treat it as a hard upper bound rather than something budgets will always defer.

The trade-off is cost against pod churn. Tighter packing saves money because pods are rescheduled more often. Workloads with inflated requests make consolidation look safe when it isn't. Workloads with understated requests get packed onto nodes that later run short of resources. Without a PDB, all replicas can be evicted in the same pass. Without graceful SIGTERM handling, each eviction drops in-flight requests. These gaps matter less under Cluster Autoscaler because it disrupts nodes less often. Aggressive consolidation hits them repeatedly.

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: general-purpose
spec:
  template:
    spec:
      nodeClassRef:
        group: karpenter.k8s.aws
        kind: EC2NodeClass
        name: default
      # Recycle every node after 30 days so it picks up patched images.
      # Expiry is a hard bound, not something budgets reliably defer.
      expireAfter: 720h
  disruption:
    # Remove empty nodes AND repack underused ones onto fewer/cheaper nodes
    consolidationPolicy: WhenEmptyOrUnderutilized
    # Wait before acting, so short-lived dips do not cause churn
    consolidateAfter: 5m
    budgets:
      # Never disrupt more than 10% of this pool's nodes at once
      - nodes: "10%"
      # Block underutilization repacking during weekday business hours (UTC)
      - nodes: "0"
        reasons: ["Underutilized"]
        schedule: "0 9 * * mon-fri"
        duration: 8h
---
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: checkout-api
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: checkout-api

A Karpenter NodePool that limits consolidation with a percentage budget and a business-hours block, recycles nodes via expireAfter, and pairs with a PodDisruptionBudget that constrains evictions from either autoscaler.

How do spot capacity and operational footprint affect cost and engineering time?

Spot capacity changes the picture because interruptions add disruption you don't control. With Cluster Autoscaler, you diversify spot through mixed-instance policies or several node groups. Each group's instance types should have similar CPU and memory, because the autoscaler simulates scheduling against one template per group. Karpenter accepts a broad instance-type list per NodePool and picks from it at launch, so diversifying is cheaper to set up. Neither handles interruptions by default. Cluster Autoscaler setups usually add a separate termination handler. Karpenter needs its interruption queue, which receives spot warnings and rebalance events, configured explicitly.

The EKS prerequisites differ:

  • Cluster Autoscaler needs IAM permissions to describe and resize ASGs, plus discovery tags on each group.
  • Karpenter needs permissions to launch and terminate instances, pass a node IAM role, and read the interruption queue.

Run either controller on Fargate or a small dedicated node group, never on nodes it manages. Otherwise it can scale away its own node.

Collapsing many node groups into a few NodePools reduces template, AMI and tag maintenance. Karpenter bypasses ASGs, so you lose lifecycle hooks, warm pools, instance refresh and any tooling built around ASGs.

Illustrative estimate (assumed numbers, not a benchmark)

Monthly spot savings = nodes × hours × on-demand rate × Δspot share × spot discount

Assume:

  • 30 nodes
  • 730 hours per month
  • $0.20/hour on-demand rate
  • Spot share rising from 30% to 70%
  • 60% spot discount

30 × 730 × 0.20 × 0.40 × 0.60 ≈ $1,051/month.

On engineering time, going from 12 node groups to 2 NodePools at an assumed 1 hour per group per month saves 10 hours/month.

How do you migrate from Cluster Autoscaler to Karpenter?

The safest path runs both autoscalers side by side, with a hard boundary between the workloads each one owns.

  1. Install Karpenter on a small dedicated node group. Run the controller on a managed node group that neither autoscaler scales, or on Fargate. If Karpenter runs on nodes it manages, consolidation can evict the controller and leave nothing to provision replacements.

  2. Create NodePools that mirror existing constraints. Inventory the instance families, architectures, zones, capacity types and taints your current node groups provide, and express them as NodePool requirements. Workloads that rely on a GPU group or a zone-pinned group need an equivalent NodePool before they move. If one doesn't exist, those pods will sit Pending.

  3. Shift workloads incrementally. Put a taint and label on the Karpenter NodePool, then add the matching toleration and node selector to one low-risk deployment at a time. This scoping is what prevents conflicting decisions. Both autoscalers react to the same Pending pods, so a pod that fits both Karpenter and a Cluster Autoscaler group can trigger two launches. One of those nodes then sits idle until it is scaled down. Keep every pod schedulable by exactly one autoscaler.

  4. Scale down the old node groups. Once a group is empty of migrated workloads, remove it from Cluster Autoscaler's discovery tags or node group list. Cordon and drain its nodes while respecting PodDisruptionBudgets, then reduce it to zero.

For latency-sensitive services, add headroom. Deploy placeholder pods with a negative-priority PriorityClass so they hold spare capacity. When real pods arrive, the scheduler preempts the placeholders immediately. The evicted placeholders go Pending and trigger a new node in the background, so real traffic doesn't wait on instance boot time.

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: migrated-general
spec:
  template:
    metadata:
      labels:
        provisioner: karpenter        # opt-in label used by nodeSelector
    spec:
      nodeClassRef:
        group: karpenter.k8s.aws
        kind: EC2NodeClass
        name: default
      taints:
        - key: provisioner
          value: karpenter
          effect: NoSchedule          # only pods that tolerate this land here
      requirements:                   # mirror the old node group's constraints
        - key: kubernetes.io/arch
          operator: In
          values: ["amd64"]
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["on-demand"]
---
spec:
  template:
    spec:
      nodeSelector:
        provisioner: karpenter
      tolerations:
        - key: provisioner
          operator: Equal
          value: karpenter
          effect: NoSchedule

A tainted, labeled Karpenter NodePool paired with the matching toleration and nodeSelector, so each migrated pod can be scheduled by only one autoscaler.

Who should use Cluster Autoscaler, and who should use Karpenter?

Cluster Autoscaler suits teams that:

  • Run Kubernetes on more than one cloud, or on infrastructure where Karpenter has no provider. Cluster Autoscaler supports many more providers, so one tool and one mental model covers every cluster.
  • Already manage nodes through node groups and depend on group-level tooling, such as managed node group upgrades, ASG lifecycle hooks or instance refresh.
  • Run a small number of predictable workload shapes, where a handful of well-sized groups already packs pods efficiently.
  • Prefer conservative scale-down. Cluster Autoscaler only removes underused nodes and never replaces running nodes to save money.

Karpenter suits teams that:

  • Run on a supported provider, AWS being the most established, and accept provider-specific configuration in the node class.
  • Have diverse workloads, such as mixed CPU-heavy and memory-heavy services, GPU jobs, or both amd64 and arm64 images, that would otherwise need many node groups.
  • Use spot heavily and want broad instance-type diversification without maintaining many groups.
  • Have platform engineers who can tune disruption budgets, keep pod requests accurate and make workloads tolerate regular node replacement.

Neither is the right choice for:

  • Clusters with flat, predictable load where autoscaling adds moving parts without saving much.
  • Environments where node count is fixed by licensing, compliance or hardware, such as bare metal without an API to provision machines.

What are the alternatives to Cluster Autoscaler and Karpenter?

Node autoscaling is one way to match capacity to demand. Depending on the workload, these alternatives replace it or work alongside it:

  • Static capacity. Size node groups for peak load and don't autoscale. This is the simplest option and suits steady workloads. It also avoids provisioning delay, at the cost of paying for idle capacity during quiet periods.
  • Scheduled scaling of node groups. If demand follows a known calendar, such as business hours or nightly batch windows, you can change node group sizes on a schedule with the cloud provider's group scaling features. This needs no in-cluster controller, but it does not react to unexpected load.
  • Serverless pod capacity. On EKS, Fargate runs each pod on capacity the provider manages, so there are no nodes to scale. It suits isolated or bursty workloads. It does not support every workload type, DaemonSets for example, so check its constraints against your pods before adopting it.
  • Overprovisioning with headroom pods. Low-priority placeholder pods, described in the migration section, keep spare capacity warm. They are not an autoscaler on their own, but combined with static or scheduled capacity they absorb short spikes.
  • Pod-level rightsizing. The Vertical Pod Autoscaler adjusts pod requests to match observed usage. It does not add nodes, but it improves packing for any node autoscaler and makes consolidation decisions safer, because both tools act on requests.
  • Provider-managed node provisioning. Some managed Kubernetes services offer built-in node autoprovisioning that handles node selection for you. Evaluate these against the same criteria used in this article: how nodes are chosen, how they are replaced, and what control you keep over disruption.

When should you choose Cluster Autoscaler, Karpenter, or neither?

Headroom pods work with either autoscaler. The real decision is how nodes get selected and replaced, not whether scaling happens.

Situation Better fit Why
Clusters across several clouds or on-prem Cluster Autoscaler Supports far more providers, so behavior stays consistent everywhere
A few uniform pod shapes Cluster Autoscaler Pre-sized node groups already pack these well
Patching and upgrades run through managed node groups Cluster Autoscaler Existing node lifecycle tooling stays in charge
Mixed CPU, memory, GPU and architecture requests Karpenter Chooses instance types per batch of pending pods, not per group
Heavy spot usage Karpenter Spreads across many instance types, which lowers interruption exposure
Fragmented, underused nodes driving cost Karpenter Consolidation repacks pods and removes waste continuously

When to avoid Karpenter

  • You need portability. Karpenter supports fewer providers than Cluster Autoscaler. Its NodeClass resources are provider-specific, so your provisioning config won't move with you.
  • Your workloads are churn-sensitive. Examples are stateful services with slow rebalancing, pods with large warm caches, and batch jobs that can't checkpoint. Consolidation replaces nodes deliberately. You can restrict it with disruption budgets, but a heavily restricted Karpenter loses much of its cost advantage.

When to use neither

  • Static capacity suits steady, predictable load. It also fits when per-node licensing makes node counts a contract issue, and when any provisioning delay is unacceptable.
  • Managed node groups with Cluster Autoscaler remain the low-risk default for small clusters and teams without platform engineers.
  • Headroom pods with HPA cover spiky traffic on top of either option. You pay for the idle buffer in exchange for scaling that feels instant.

How OneEnv can help

Disclosure: OneEnv is the product behind this blog.

OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.

Applied to cluster autoscaler vs karpenter, this is where it helps:

Saves time

  • Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
  • One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
  • Changing a shared variable is one edit and one review instead of editing every service's .env by hand.

Saves cost

  • Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
  • Less duplicated configuration to maintain: one shared definition inherited by many services.
  • A wrong or stale value is caught at review time by the services it affects, not by a failed deploy.
  • OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.

These are qualitative benefits, not measured results — how much you save depends on how many services share the value.

Want to try it? Start at oneenv.io.