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:

  1. 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.
  2. 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.
  3. 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 LoadBalancer Service 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 edit ClusterRole, 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.