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.
- A pod becomes unschedulable. The kube-scheduler tries to place the pod and fails. It sets the pod's
PodScheduledcondition toFalsewith the reasonUnschedulable, and the pod staysPending. Neither autoscaler places pods itself. They only watch for this signal. - 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.
- 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.
- 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. - 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.
- 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) andtopology.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.
-
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.
-
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.
-
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.
-
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
.envby 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.