Kubernetes Pricing: What It Actually Costs to Run in 2026

Kubernetes pricing is a slightly misleading phrase, because Kubernetes itself is free open-source software. What you actually pay for is everything underneath it: a managed control plane if you use one, the compute nodes your pods run on, the storage they mount, and the network traffic they generate. On a real cluster the nodes are 80 to 95 percent of the bill, the control plane is a rounding error, and the surprises are all in networking and idle capacity. This guide breaks Kubernetes pricing into those parts, compares the managed-service control-plane fees for EKS, GKE, and AKS, and puts live node rates from all three clouds side by side. Every VM rate below is a live snapshot of the same dataset that powers DevZero's instance pricing explorer.

Last updated: 2026-09-13. EKS / GKE / AKS node VM pricing from the DevZero instances dataset (us-east-1, us-central1, East US).

What a Kubernetes bill is made of#

Whether you run managed or self-hosted, a Kubernetes bill has the same four parts:

• Control plane. The API server, scheduler, and etcd. Free if you run it yourself on your own nodes; a flat per-cluster fee on most managed services.
• Worker nodes. The VMs your pods actually run on. This is the overwhelming majority of the cost and the only part that scales with your workload.
• Networking. Load balancers, NAT gateways, cross-zone traffic, and internet egress.
• Storage. Persistent volumes, plus snapshots and backups.

The control-plane fee is the number people quote, and it is the least important. The node bill is the one worth optimizing.

Managed control-plane pricing: EKS vs GKE vs AKS#

These are per-cluster fees for the managed control plane only; nodes are extra. Rates are from each provider's published pricing page as of 2026-09-06 and are list prices, not a live feed.

Service	Control-plane fee	Notes
Amazon EKS	$0.10/hour per cluster (~$73/month)	Same fee for every cluster; EKS Auto Mode adds a management fee charged as a percentage on top of the EC2 node cost
Google GKE (Standard)	$0.10/hour per cluster (~$73/month)	One free zonal or Autopilot cluster per billing account; GKE Enterprise edition costs more per cluster and per vCPU
Google GKE (Autopilot)	No separate cluster fee beyond the free one	You pay for pod resource requests (vCPU, memory, ephemeral storage) instead of for nodes
Azure AKS (Free)	$0	No uptime SLA; fine for dev and test
Azure AKS (Standard)	$0.10/hour per cluster (~$73/month)	Financially backed uptime SLA
Azure AKS (Premium)	$0.60/hour per cluster (~$438/month)	Adds Long-Term Support for old Kubernetes versions

For one production cluster the control plane is about $73 a month on any of the three. The reason it still matters: teams run many clusters (per environment, per team, per region), and every one is another $73 whether or not it is busy.

Live node pricing across the three clouds#

Nodes are where the money is. The table below prices one comparable general-purpose SKU (roughly 4 vCPU / 16 GiB) on each cloud, from the same dataset behind DevZero's /instances pages.

A few things this makes concrete:

• The three clouds price comparable hardware within a fairly narrow band on-demand, so the managed service you pick is rarely decided by raw VM rate.
• Spot / preemptible pricing is a much bigger lever than cross-cloud rate differences, often a 60 to 90 percent discount on the same instance.
• The monthly figure assumes the node runs 24/7. Most clusters have nodes that should scale to zero overnight and do not.

Auto modes: EKS Auto Mode, GKE Autopilot, AKS Node Auto Provisioning#

All three clouds now offer a "you stop managing nodes" mode. They change the pricing shape, not just the operations:

• EKS Auto Mode provisions and manages nodes for you (compute, networking, and add-ons) and charges a management fee as a percentage on top of the underlying EC2 cost. You trade a modest premium for AWS handling node lifecycle, patching, and right-capacity.
• GKE Autopilot removes nodes from the bill entirely: you are billed for the CPU, memory, and ephemeral storage your pods request, not for the VMs. This is efficient if your requests are tight and wasteful if they are padded, because padded requests are billed directly.
• AKS Node Auto Provisioning (NAP) is a Karpenter-based autoscaler that picks the cheapest VM SKU that fits pending pods, including Spot, and consolidates aggressively. There is no fee for NAP itself; you pay for the VMs it provisions, usually fewer and better-packed than a static node pool.

The common thread: auto modes make bin-packing and request accuracy the thing that determines your bill. Sloppy pod requests cost more under every one of them.

What the pricing pages don't tell you#

• The control-plane fee is a distraction. Optimizing which tier or edition you are on saves tens of dollars; optimizing node utilization saves thousands.
• Requests, not usage, set the node count. Kubernetes schedules on what pods request. If every service requests 2 vCPU and uses 0.4, you are running, and paying for, five times the nodes you need.
• Autoscalers scale up fast and down slow. Cluster Autoscaler leaves nodes running well after the load that justified them is gone, because scale-down is deliberately conservative.
• System overhead is real. DaemonSets, the kubelet, and reserved capacity mean a node never gives 100 percent of its vCPU to your workloads. Small nodes lose a larger percentage to overhead.

Hidden and egress costs#

• Load balancers. Every LoadBalancer Service provisions a cloud load balancer with its own hourly and per-GB or per-rule charge. A cluster with 20 exposed services has 20 of them unless you consolidate behind an Ingress.
• Cross-zone traffic. Spreading a cluster across availability zones for resilience adds a per-GB charge on pod-to-pod traffic that crosses a zone boundary, on all three clouds.
• Internet egress. Outbound to the internet is billed per GB after a small free tier on every cloud. Image pulls from public registries, log and metric shipping, and API responses all count.
• NAT gateway / Cloud NAT. Private node subnets route outbound through a managed NAT with an hourly charge plus per-GB processing.
• Persistent volumes and snapshots. PVCs bill by provisioned size, not usage, and volume snapshots bill on top. Orphaned PVs from deleted StatefulSets keep charging.

None of these are on the Kubernetes pricing page, because they are not Kubernetes charges; they are cloud charges your cluster triggers.

Worked example: a 30-node production cluster#

Take a production cluster of 30 general-purpose nodes (about 4 vCPU / 16 GiB each) running 24/7 on one managed service, plus 10 LoadBalancer services, three availability zones, roughly 5 TB/month of internet egress, and 8 TB of persistent volumes.

Control plane: ~$73/month (EKS, GKE Standard, or AKS Standard).

Nodes: call the live on-demand rate for your cloud's row in the table above R dollars per hour. Thirty nodes at 730 hours is 30 x 730 = 21,900 node-hours, so compute is 21,900 x R. Read R off the table on this page; it is by far the largest term.

Load balancers: roughly $18 to $25 each per month depending on cloud and traffic, so about $200 to $250/month for 10.

Cross-zone + egress: a chatty three-zone cluster plus ~5 TB egress is commonly $400 to $700/month, and it varies more by application behavior than by cloud.

Storage: 8 TB of SSD-class persistent volumes is roughly $800 to $1,000/month, flat regardless of how full the volumes are.

Monthly total: $73 + (21,900 x R) + ~$225 + ~$550 + ~$900. Compute dominates, and it is the term you have the most leverage over: moving steady-state nodes to a 1-year commitment cuts R by 30 to 50 percent, and moving interruptible workloads to Spot cuts their share by 60 to 90 percent. The control-plane fee never moves the needle.

DevZero's angle#

Kubernetes pricing rewards one discipline above all others: paying for capacity you actually use. Most cluster spend is idle nodes and padded pod requests: a cluster provisioned for peak that never scales down, services that request far more CPU and memory than they touch. DevZero rightsizes Kubernetes workloads across EKS, GKE, and AKS by matching nodes and pod requests to real usage, so the node-hours you pay for are node-hours you need. See Kubernetes cost optimization for how that works in practice.

Last updated#

Last updated: 2026-09-13. EKS / GKE / AKS node VM pricing from the DevZero instances dataset (us-east-1, us-central1, East US).

The node VM rates on this page are a live snapshot from the same dataset that powers DevZero's /instances pages and refresh on every deploy. Control-plane fees, load balancer rates, egress per-GB figures, and storage pricing cite each provider's published pricing pages as of 2026-09-06 and should be re-checked against your own region. For the per-service deep dives, see EKS pricing, AKS pricing, and GKE pricing; for a raw three-cloud rate comparison, AWS vs Azure vs GCP pricing.