What is the managed Kubernetes control plane fee on EKS, GKE and AKS?
The control plane fee is what a provider charges to run the Kubernetes API server, etcd, and the controllers behind them. You never see those nodes, but you pay for their availability, backups, and patching. All three providers bill this separately from worker compute, and each structures it differently.
| Provider | Fee structure | What the paid tier adds |
|---|---|---|
| EKS | Flat hourly charge per cluster (R_eks), whether the cluster is busy or idle |
A single tier with the SLA included |
| GKE | Hourly management fee per cluster (R_gke), offset by a monthly free tier credit applied at the billing-account level |
SLA coverage that depends on cluster type and topology |
| AKS | Free tier with no financially backed SLA | Paid tiers (R_aks) add an uptime SLA and higher scale limits |
The fee buys four things:
- A managed API server and etcd. The provider handles replication, backups, and capacity.
- SLA eligibility. On AKS you only get this on a paid tier.
- Upgrade handling. The provider patches the control plane.
- A defined support window for each Kubernetes minor version.
That last item matters for cost. Some providers charge a higher rate for clusters that stay on a version past standard support. A cluster that misses its upgrade window can quietly multiply its own fee.
GKE's credit applies once per billing account, not once per cluster. It helps a single small cluster but does little for a fleet.
Treat R_eks, R_gke, and R_aks as variables, not constants. Tiers, credits, and extended-support terms change, so check each provider's current pricing page before you model anything.
How does the managed control plane and its fee work?
When you create a managed cluster, the provider runs the control plane components (API server, etcd, scheduler, controller manager) on infrastructure it owns and operates, outside the compute you are billed for directly. Your worker nodes run in your own network and talk to the control plane through the cluster's API endpoint, which can be public, private, or both depending on how you configure it. You do not get shell access to control plane machines and you cannot change their size directly. The provider scales and replicates them for you.
Billing follows the cluster object, not the nodes:
- Metering starts when the cluster exists. The provider records cluster-hours from creation until deletion. Scaling every node pool to zero does not stop the control plane charge, because the API server and etcd are still running and holding your cluster state.
- The rate depends on tier and version. On AKS, the tier you select on the cluster decides whether a fee applies at all. On EKS, the rate can rise if the cluster stays on a Kubernetes version past standard support. On GKE, the rate is offset by the billing-account credit until the credit runs out.
- Charges appear as their own line item. In billing exports, the control plane charge is listed separately from the compute, disk and network charges that the cluster's nodes and services create. That separation is why you can measure it per cluster, as the last section shows.
Everything else the cluster consumes, such as nodes, load balancers created by LoadBalancer Services, persistent disks, NAT and log ingestion, is billed through the provider's normal resource pricing. The control plane fee covers only the managed control plane, which is why it rarely tells the whole cost story on its own.
Why does the control plane fee matter at fleet scale?
The fee is billed per cluster-hour. It does not depend on node count, pod count, or request volume, so a cluster running one idle deployment costs the same in control plane fees as one running hundreds of services. Your workload size does not drive this line item. Your cluster count does.
To make that concrete, assume a flat rate of R = $0.10 per cluster-hour and about 730 hours per month. These are assumed inputs for arithmetic, not a quoted price. Each cluster then costs R × 730 ≈ $73 per month, whether it is busy or not.
| Topology (illustrative estimate) | Clusters (N) | Monthly fee (N × $73) | Annual fee |
|---|---|---|---|
| One cluster per environment (dev, staging, prod) | 3 | $219 | $2,628 |
| Per environment × 4 teams | 12 | $876 | $10,512 |
| Per environment × 4 teams × 3 regions | 36 | $2,628 | $31,536 |
Each dimension multiplies the others. Splitting by team or adding a region adds fixed recurring cost before any node is provisioned. Clusters that sit mostly idle, such as low-traffic staging or per-team dev, pay the full fee for very little use.
On a large fleet, the fee is usually still smaller than compute, but it is a useful signal. When the control plane line grows faster than workload, your topology is fragmenting, and the per-cluster overheads covered next are growing with it. Platform teams that own dozens of clusters should track this number. A team running one or two clusters can mostly ignore it.
Which costs outweigh the control plane fee, and how do they multiply per cluster?
On most bills the control plane fee is one of the smaller lines. These usually cost more:
- Worker node compute. This is the bulk of spend. Cluster count matters because of how capacity gets fragmented.
- Idle headroom. Every cluster reserves spare capacity for surges, rolling updates and node loss. Twelve clusters each keeping two spare nodes pay for 24 idle nodes. One cluster can share a smaller buffer, because workload peaks rarely line up.
- Load balancers. Each ingress controller or
LoadBalancerService provisions a cloud load balancer, billed hourly plus traffic. - NAT and network traffic. Private nodes reach the internet through NAT gateways, billed per hour and per GB. Multi-zone clusters also pay for cross-zone traffic.
- Persistent volumes. These are billed on provisioned size, not on what is actually used.
- Logging and monitoring ingestion. This is billed per GB. Every cluster ships its own system-component logs and metrics, even when it is idle.
Many small clusters One consolidated cluster
[CP][LB][NAT][spare spare] x12 [CP][LB][NAT]
[CP][LB][NAT][spare spare] [ns-a][ns-b]...[ns-l]
... [spare spare spare spare]
Illustrative estimate (assumed numbers, not a benchmark)
Per-cluster overhead = fee + (headroom nodes × node price) + LB + NAT + baseline observability
Assumed monthly inputs:
- Fee: $70
- Node price: $100
- Headroom: 2 nodes per cluster
- LB: $20
- NAT: $40, excluding data charges
- Baseline observability: $50
Per-cluster overhead is 70 + 200 + 20 + 40 + 50 = $380, so the fee is about 18% of it. Across 12 clusters, overhead is $4,560 per month.
A single cluster with a shared 4-node buffer costs 70 + 400 + 20 + 40 + 50 = $580 per month.
The fee accounts for only $770 of the $3,980 difference. Most of the savings come from the other per-cluster overheads.
MANY SMALL CLUSTERS (x12) ONE CONSOLIDATED CLUSTER
Internet Internet Internet
| | |
v v v
+-------------+ +-------------+ +-------------------------------+
| Control pl. | | Control pl. | | Control plane (one fee) |
| LB -> ingr. | | LB -> ingr. | | LB -> shared ingress |
| NAT gateway | | NAT gateway | | NAT gateway |
| logs+metrics| | logs+metrics| | logs+metrics (one baseline) |
|-------------| |-------------| ... |-------------------------------|
| app nodes | | app nodes | ====> | ns-a ns-b ns-c ... ns-l |
| [sp] [sp] | | [sp] [sp] | |-------------------------------|
+-------------+ +-------------+ | shared buffer: |
cluster 1 cluster 2 | [sp] [sp] [sp] [sp] |
(... to 12) +-------------------------------+
12 x (CP + LB + NAT + logs) 1 x (CP + LB + NAT + logs)
12 x 2 spare = 24 idle nodes 4 spare nodes, shared
[sp] = spare node held for surges, rolling updates and node loss
Each small cluster duplicates its own control plane, load balancer, NAT gateway, observability baseline and spare nodes, while one consolidated cluster pays for these once and shares a smaller headroom buffer across namespaces.
How do GKE Autopilot and EKS with Fargate change the cost model?
With Autopilot and Fargate, the control plane fee stops being the main variable. Both modes bill mainly for the CPU and memory that pods request, not for nodes. The provider owns node provisioning, OS patching and bin-packing, so the unused capacity on half-empty nodes is no longer your cost. The trade-off is that you pay for every unit you request, whether the pod uses it or not. Fargate also rounds each pod up to a supported size, so small pods can be billed above their request.
Illustrative estimate (assumed numbers, not a benchmark). Assume $0.04 per vCPU-hour, $0.005 per GiB-hour, 730 hours per month, and 30 pods each requesting 0.5 vCPU and 1 GiB.
Monthly cost = pods × hours × (vCPU request × vCPU rate + GiB request × GiB rate) = 30 × 730 × (0.5 × 0.04 + 1 × 0.005) = $547.50
If those pods actually use half of what they request, about $274 of that pays for idle capacity. Right-sizing requests matters more here than on nodes you manage yourself.
| Approach | You pay for | Engineering work removed | Costs more when |
|---|---|---|---|
| GKE Autopilot | Pod requests plus the cluster fee | Node pools, patching, bin-packing | Requests are padded, or workloads need privileged access or node-level tuning |
| EKS with Fargate | Per-pod vCPU and memory plus the cluster fee | Node groups, AMI patching, scaling | You rely on DaemonSets, privileged pods or GPUs, or run many small pods that get rounded up |
| Consolidated cluster, self-managed nodes | Nodes, whether used or idle | Duplicated add-ons and buffers | Node utilization stays low |
| Many clusters, self-managed nodes | Fees, nodes and buffers in every cluster | Little | Almost always, at fleet scale |
How do you consolidate clusters safely with namespaces, quotas and policies?
Consolidation is the lever that moves both columns of that table at once. Folding dev, test and staging into one shared non-production cluster removes the fixed fees, and it also removes duplicated system pods and the idle headroom each cluster keeps for spikes. One larger node pool with a single buffer packs workloads more tightly than several small pools that each hold their own spare capacity.
The risk is that teams which used to be separated by cluster boundaries now share one. You rebuild that separation in each team's namespace with four objects:
- ResourceQuota caps the namespace's total CPU and memory requests and limits, and can also cap object counts such as pods or LoadBalancer Services. A runaway deployment then exhausts its own team's budget instead of the shared node pool. Quota is also what makes bin-packing predictable, because the scheduler places pods by their requests.
- LimitRange sets default requests and limits for containers that omit them, and can set per-container minimums and maximums. This matters because once a quota covers requests, the API server rejects pods that do not declare them. Defaults keep existing manifests working.
- Default-deny NetworkPolicy selects every pod in the namespace and denies all ingress and egress, so all traffic has to be allowed explicitly. Add an egress rule for cluster DNS, or name resolution breaks. These policies are enforced only if the cluster's network plugin is configured to support NetworkPolicy. Without that support, the API server accepts the objects and nothing is blocked.
- RoleBinding grants the team's group a role, such as the built-in
editClusterRole, inside its own namespace only. Team members can deploy freely in their namespace but cannot read other teams' Secrets or change cluster-scoped resources.
apiVersion: v1
kind: ResourceQuota
metadata: {name: team-a-quota, namespace: team-a}
spec:
hard: # caps the namespace's totals so one team cannot drain the shared pool
requests.cpu: "8"
requests.memory: 16Gi
limits.cpu: "16"
limits.memory: 32Gi
pods: "50"
services.loadbalancers: "1"
---
apiVersion: v1
kind: LimitRange
metadata: {name: team-a-defaults, namespace: team-a}
spec:
limits:
- type: Container # fills in requests/limits so quota does not reject existing manifests
defaultRequest: {cpu: 100m, memory: 128Mi}
default: {cpu: 500m, memory: 512Mi}
max: {cpu: "2", memory: 4Gi}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: default-deny-allow-dns, namespace: team-a}
spec:
podSelector: {} # all pods; enforced only if the network plugin supports NetworkPolicy
policyTypes: [Ingress, Egress] # no ingress rules listed, so all ingress is denied
egress: # the only allowed egress is DNS to kube-system
- to:
- namespaceSelector: {matchLabels: {kubernetes.io/metadata.name: kube-system}}
ports: [{protocol: UDP, port: 53}, {protocol: TCP, port: 53}]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding # namespaced: the edit permissions apply only inside team-a
metadata: {name: team-a-edit, namespace: team-a}
roleRef: {apiGroup: rbac.authorization.k8s.io, kind: ClusterRole, name: edit}
subjects: [{apiGroup: rbac.authorization.k8s.io, kind: Group, name: team-a-devs}]
This sets up one team's namespace in a consolidated cluster with a ResourceQuota, default container requests and limits from a LimitRange, a default-deny NetworkPolicy that still allows DNS, and a RoleBinding that grants the built-in edit role in that namespace only.
When should you avoid consolidating clusters or choosing the cheapest tier?
That setup works well until the shared cluster itself becomes the problem. Consolidation trades a per-cluster fee for a shared failure domain. A control plane upgrade that removes an API some charts still use, a validating admission webhook with failurePolicy: Fail whose backing service is down, or one team's controller flooding the API server with list calls can each stall every tenant at once.
Namespaces provide soft isolation. Workloads still share nodes, the kernel and cluster-scoped resources such as CRDs. Auditors often won't accept a namespace as a boundary for regulated workloads or untrusted tenants. The same goes for a compliance scope you need to keep small, such as cardholder data. Those workloads usually justify a dedicated cluster.
Large shared clusters also reach limits sooner. Common ones are API server and etcd load, pod or service CIDRs that are hard to expand after creation, and per-cluster provider quotas. Paid tiers partly address this with better-scaled control planes. Free or no-SLA tiers also remove the contractual uptime guarantee. That matters if deploys and autoscaling in your own SLA depend on the API server.
Coordinated upgrades carry a hidden cost. When many teams must sign off, the cluster falls behind. It can drift into extended-support pricing that exceeds the fees you saved.
Some extra clusters are necessary. Multi-region or zone-failure resilience requires independent control planes.
Finally, don't pick a provider on control plane fees alone. Egress pricing, existing commitments and discounts, IAM integration and team familiarity usually outweigh the per-cluster fee.
What are the alternatives to paying a managed control plane fee per cluster?
If the fee, or the per-cluster overhead around it, is the problem, you have several options. Each one moves cost or work somewhere else.
- Self-managed Kubernetes on plain VMs. You install and run the control plane yourself, for example with
kubeadm. There is no management fee, but you pay for the control plane VMs and you take on etcd backups and restores, certificate rotation, API server high availability, and every version upgrade. For most teams this costs more in engineering time than the fee it saves. It is mainly worth considering where managed offerings are not available or where you need control over control plane flags that a provider does not expose. - Fewer, shared clusters. This is the consolidation approach from the previous sections. The fee stays, but you pay it fewer times, along with the duplicated headroom, load balancers, NAT and observability baselines.
- Pod-billed modes such as GKE Autopilot and EKS with Fargate. The cluster fee remains, but node management and idle node capacity largely disappear from your bill and your workload.
- The free AKS tier for non-production clusters. This removes the fee where you can accept no financially backed SLA, such as ephemeral CI or developer clusters.
- Virtual clusters inside a host cluster. Some tools run a separate API server per tenant as pods inside one physical cluster. Tenants get their own API surface, including their own CRDs, while sharing the host cluster's nodes and its single control plane fee. The trade-offs are another component to operate and isolation that is still weaker than separate physical clusters.
- Not using Kubernetes for some workloads. Each provider also offers container and function services that do not involve a Kubernetes control plane at all. For a small stateless service with no need for Kubernetes APIs, operators or Helm charts, running it outside a cluster avoids the fee and the cluster overhead entirely. You lose the shared Kubernetes tooling and portability.
| Alternative | Fee impact | Work you take on or remove |
|---|---|---|
| Self-managed control plane | No fee; you pay for control plane VMs | Adds etcd, certificates, HA and upgrades |
| Consolidation | Fewer fees | Adds tenant isolation work; removes duplicated add-ons and upgrades |
| Autopilot or Fargate | Fee unchanged | Removes node management |
| AKS free tier | No fee | Removes the SLA |
| Virtual clusters | One host fee for many tenants | Adds a component to operate |
| Non-Kubernetes container services | No cluster fee | Removes cluster operations; loses Kubernetes APIs |
How can managed control planes and consolidation save engineering time?
The fee is easier to see than the engineering hours around it, but the hours are often the larger cost. Three choices reduce them.
A managed control plane removes control plane operations. With any of the three providers you do not provision API server instances, back up or restore etcd, rotate control plane certificates, or keep the control plane highly available. You still choose when to upgrade, but the provider performs the control plane upgrade itself. A self-managed cluster puts all of that on your team, along with the on-call burden when etcd or the API server misbehaves.
Fewer clusters means fewer repeated tasks. Most cluster-level work scales with cluster count, not with workload size:
- Kubernetes minor version upgrades, including checking for removed APIs in your manifests and charts
- Installing and upgrading cluster add-ons such as ingress controllers, DNS, metrics and log agents, and policy tooling
- Rotating credentials, reviewing RBAC, and keeping cluster-level configuration in sync
- Investigating alerts from each cluster's system components
Pod-billed modes remove node work. Autopilot and Fargate take over node image patching, node pool sizing and much of the autoscaling setup. That removes recurring patch cycles and the tuning needed to keep nodes well packed.
Illustrative estimate (assumed numbers, not a benchmark). Assume upstream Kubernetes releases about three minor versions per year, and each cluster upgrade, including testing and rollout, takes 6 engineer-hours. Assume add-on maintenance takes 2 engineer-hours per cluster per month.
- 36 clusters: (36 × 3 × 6) + (36 × 2 × 12) = 648 + 864 = 1,512 engineer-hours per year
- 6 clusters after consolidation: (6 × 3 × 6) + (6 × 2 × 12) = 108 + 144 = 252 engineer-hours per year
Under these assumptions, consolidation saves about 1,260 engineer-hours per year before any change to the cloud bill. The real numbers depend heavily on your automation. If upgrades and add-ons are fully driven by infrastructure-as-code and a tested pipeline, the per-cluster hours shrink, and so does the gap. Consolidation also adds some work: tenant onboarding, quota tuning, and coordinating upgrade windows across teams, as the previous section describes. Count both sides before you decide.
How can you measure control plane cost and choose a tier for each cluster?
Start with an inventory. List clusters per account, project or subscription with aws eks list-clusters, gcloud container clusters list and az aks list --output table. Then use kubectl config get-contexts and kubectl get nodes --show-labels to confirm which node pools exist and how they are labelled. Each cluster needs an owner and an environment label on the cloud resource itself, not only on Kubernetes objects. Billing exports group costs by resource tags and labels, and that grouping is what lets you attribute spend.
From the billing export, pull three things per cluster: cluster-hours, the control plane line item, and total spend (nodes, load balancers, disks and logging). Two ratios show whether consolidation is worth the engineering effort:
- Control plane share = control plane fees ÷ total cluster cost
- Duplication share = (control plane fees + duplicated headroom) ÷ total cluster cost
Illustrative estimate (assumed numbers, not a benchmark): Assume 20 clusters, a fee of $0.10/hour, 730 hours/month and $40,000 in monthly cluster spend.
- Fees: 20 × 0.10 × 730 = $1,460, which is about 3.7% of spend.
- Duplicated headroom: assume each cluster runs two system nodes at $70/month, so 20 × 2 × 70 = $2,800.
- Combined: $4,260, which is about 10.7% of spend.
At 3.7%, the fee alone rarely justifies a migration. At around 11%, it might, if the clusters share a trust boundary.
| Cluster type | Tier | Reasoning |
|---|---|---|
| Ephemeral CI and preview | Free or no-SLA | These are short-lived and cheap to recreate. |
| Shared dev and staging | Free or no-SLA, unless staging gates releases | An outage here costs time but not revenue. |
| Production | Paid or SLA-backed | The fee is usually smaller than the cost of designing retries, failover and on-call procedures around a missing SLA. |
Tier names, fees and free allowances change. Check every figure against current provider pricing before you act on it.
#!/usr/bin/env bash
set -euo pipefail
for c in $(aws eks list-clusters --query 'clusters[]' --output text); do
echo "eks/$c tags: $(aws eks describe-cluster --name "$c" --query 'cluster.tags' --output json)"
done
gcloud container clusters list --format='table(name,location,resourceLabels)'
az aks list --query '[].{name:name, rg:resourceGroup, tags:tags}' --output json
kubectl config get-contexts
kubectl get nodes --show-labels
CLUSTERS=20 # cluster count from the inventory above
FEE_PER_HOUR=0.10 # control plane fee; check current provider pricing
HOURS=730 # hours per month
SYSTEM_NODES=2 # duplicated system nodes per cluster
NODE_MONTHLY=70 # assumed monthly cost per system node
TOTAL_SPEND=40000 # monthly cluster spend from billing export
awk -v c="$CLUSTERS" -v f="$FEE_PER_HOUR" -v h="$HOURS" \
-v n="$SYSTEM_NODES" -v m="$NODE_MONTHLY" -v t="$TOTAL_SPEND" 'BEGIN {
fees = c * f * h; headroom = c * n * m
printf "control plane fees: $%.0f (%.1f%% of spend)\n", fees, 100 * fees / t
printf "fees + headroom: $%.0f (%.1f%% of spend)\n", fees + headroom, 100 * (fees + headroom) / t
}'
This script lists EKS, GKE and AKS clusters along with their cloud-side tags or labels, checks node pool labels with kubectl, and computes the control plane share and duplication share from the section's assumed inputs, which are an illustrative estimate.
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 eks vs gke vs aks cost, 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.
- Reviewers see the exact diff and the list of affected services up front, so approval is a decision rather than an investigation.
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.
- Per-service approve/reject means a bad shared value can be refused where it would break something, before it is live.
- 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.