How to split shared Kubernetes cluster costs, and what FOCUS standardizes

In brief

Requests, usage or the higher of the two? A worked cluster example, where idle and overhead belong, and what FOCUS split cost allocation does and doesn't fix.

Steve Elliott

Steve Elliott · · 7 min read


On this page
  1. Requests, usage or the higher of the two?
  2. What happens to idle capacity, overhead and shared services?
  3. A worked example: one cluster, three teams, three methods
  4. What does FOCUS split cost allocation standardize?
  5. How do AWS, Google Cloud and Azure split cluster costs?
  6. What should you set up first?
  7. Sources

In our view, the fairest default for a shared Kubernetes cluster is to charge each workload for the higher of what it requested and what it used, and to keep idle capacity, system overhead and shared cluster services as separate, named lines. Teams then pay for capacity they blocked or consumed, and the cost of spare capacity stays with whoever sizes the cluster.

FOCUS 1.3 does not settle that choice for you. Its split cost allocation columns standardize how a provider reports a split and identifies the method it used, not which method to use. Below: one illustrative cluster, three methods, then the spec and the AWS, Google Cloud and Azure features.

Requests, usage or the higher of the two?

Each basis changes team behavior. The FinOps Foundation's Calculating Container Costs paper sets out the trade-off without picking a winner:

  • Requests. Teams are pushed to provision only what they need, though capacity nobody requested still needs a rule. Teams may under-specify, and some organizations set no requests.
  • Actual usage. Each team pays for what it consumed. The paper's open question: "Who pays for the rest (idle time / cycles)?" Teams may also over-provision when the excess is free.
  • The higher of the two. The OpenCost specification (OpenCost has been a CNCF incubating project since October 2024) says workload costs should be understood as max(request, usage) for CPU, memory and GPU, calculated at container level and then aggregated.

Providers differ too. GKE's Kubernetes cost allocation uses requests only. AWS split cost allocation data for EKS offers requests only, or the higher of requests and actual usage, with usage metrics from Amazon Managed Service for Prometheus or CloudWatch Container Insights.

We think max(request, usage) is the better default for chargeback because it closes both loopholes: the team that under-requests pays for its bursts, and the team that over-reserves pays for its reservation. The cost is predictability: a team's bill moves with its peaks, and it pays for bursts into capacity that would otherwise sit idle. Requests-only is a reasonable, easy-to-explain start for showback.

What happens to idle capacity, overhead and shared services?

A cluster's bill holds at least four kinds of cost that no single workload consumed:

  • Idle capacity. OpenCost defines cluster idle cost as resource allocation cost not allocated to any workload: idle resources at cluster level.
  • System overhead. Node capacity reserved for the kubelet, container runtime and other system processes. GKE reports it as kube:system-overhead; Azure's AKS cost analysis reports it as System.
  • Cluster fees and add-ons. Control plane or management fees and paid add-ons. AKS cost analysis reports items such as Uptime SLA and Microsoft Defender for Containers as Service charges.
  • Shared workloads. Monitoring, ingress and logging that every tenant uses. OpenCost cites kube-system pods.

No source mandates one treatment. OpenCost, whose overhead means cluster management and operating costs rather than node reservations, lists shared workload, idle and overhead costs as costs "that organizations can optionally distribute amongst tenants," uniformly, in proportion to use, or by a custom metric. The FinOps Foundation's allocation capability offers a similar menu for shared cloud costs: fixed, proportional or proxy-metric splits, or an "informed ignore" approach that budgets them centrally.

In our view, idle needs different handling from the other three. Overhead and shared services are a cost of running anything on the cluster, so spreading them by direct cost is fair. Idle results from node pool sizing, autoscaling and bin-packing, which the cluster's owning team decides. We would show it as that team's line, with a target, not spread it where nobody can act on it. The same four-line approach works for shared services outside Kubernetes, such as a shared database or storage tier.

A worked example: one cluster, three teams, three methods

These numbers are illustrative. For simplicity we price vCPU only, at a blended $50 per vCPU-month, and use monthly averages. Engines that use the higher of the two take it per container or pod (AWS does so hourly) and price CPU and memory separately; AWS weights a vCPU against a GB of memory 9:1, based on AWS Fargate prices.

The cluster: 1,000 vCPU of nodes at $50,000 a month after discounts, 40 vCPU reserved for the system, three teams.

TeamRequested vCPUAverage used vCPUHigher of the two
Checkout400300400
Search180250250
Data jobs15060150
Total730610800

How the $50,000 lands under each method:

LineRequestsUsageHigher of the two
Checkout$20,000$15,000$20,000
Search$9,000$12,500$12,500
Data jobs$7,500$3,000$7,500
System overhead (40 vCPU)$2,000$2,000$2,000
Idle or unrequested$11,500$17,500$8,000
Total$50,000$50,000$50,000

Under requests only, Search pays $9,000 while using 250 vCPU, because it under-requested; $3,500 of the unrequested line is capacity Search actually uses. Under usage only, Data jobs pays $3,000 while holding 150 vCPU nobody else can schedule onto. The higher-of-the-two method charges both, and idle falls to $8,000.

Add $6,000 of shared services (control plane fee, observability, ingress), for $56,000. Two ways to finish, from the higher-of-the-two figures:

LineA: spread everythingB: idle stays with the cluster owner
Checkout (50% of direct cost)$28,000$24,000
Search (31.25%)$17,500$15,000
Data jobs (18.75%)$10,500$9,000
Cluster owner: idle capacity$0$8,000
Total$56,000$56,000

A spreads $16,000 of overhead, idle and shared services by share of direct cost; B spreads only the $8,000 of overhead and shared services. We prefer B: the $8,000 of idle has an owner who can change it.

What does FOCUS split cost allocation standardize?

FOCUS 1.3, ratified December 5, 2025, added Data Generator-Calculated Split Cost Allocation, which the spec says is most common for nodes in shared Kubernetes or database clusters and for shared storage engines. The FinOps Foundation's announcement put the gain plainly: "Practitioners can now see the methodology, not just the output."

What the FOCUS specification fixes, as of v1.4 (ratified June 4, 2026):

  • The origin charge stays derivable. Allocated charges must sum to the origin charge for costs and quantities; dimensions and unit prices must match it.
  • The recipient is named. AllocatedResourceId identifies what received the cost. It must be null for the unallocated portion of the origin charge, which is where a remainder such as idle capacity can appear.
  • The method is identifiable. AllocatedMethodId must be present on every split charge, and it points to the provider's documentation of the method.
  • The ratios can be visible. AllocatedMethodDetails should carry each AllocatedRatio, and can add the UsageUnit and UsageQuantity behind it. Ratios for one origin charge must total 1.
  • Tags carry through. AllocatedTags holds the recipient's tags, such as namespace labels, without repeating tags already on the origin charge.

What it doesn't fix is the method: requests, usage or both, CPU-to-memory weights, or whether unused capacity is spread. It covers only splits the provider calculates; our $6,000 of shared services and the rule moving idle to the cluster owner stay your own logic.

In our view, check AllocatedMethodId first when combining clusters across clouds: splits from different methods aren't comparable until you know what each does. For how these columns feed a TBM model, see mapping FOCUS data into the TBM Taxonomy.

How do AWS, Google Cloud and Azure split cluster costs?

As of November 2026, per each provider's documentation:

AWS split cost allocation dataGKE cost allocationAKS cost analysis add-on
CoversECS and EKS tasks and pods, AWS PCS jobs, some networking and S3Standard clusters: vCPU, memory, GPU, some disk, TPU v4+Clusters, namespaces and assets
BasisEKS: requests only, or higher of requests and actual usage (Prometheus or Container Insights metrics)Requests onlyBuilt on OpenCost; Microsoft's page doesn't state the basis
Idle and overheadUnused cost reported in separate columns per podkube:unallocated and kube:system-overheadIdle, System, Unallocated and Service charges
Where the data landsLegacy CUR and CUR 2.0; not Cost ExplorerDetailed usage cost export to BigQueryCost analysis Kubernetes views
Notable limitsAccelerated instances use requests onlyPods with over 50 labels lose all labels in the data; no backfill; up to three days to appearStandard or Premium tier; EA and MCA offers; about 7,000 containers per cluster

Two AWS details matter in practice.

  • AWS separates split cost from unused cost. In the AWS Cost and Usage Report, split_line_item_split_cost and split_line_item_unused_cost are separate columns, and AWS's worked example apportions unused cost to pods. To run option B, charge teams the split cost and route the unused cost to the cluster owner (use the net_ columns if you have discounts).
  • AWS's FOCUS export doesn't yet carry these splits. Data Exports lists FOCUS 1.2 and 1.0 tables, which predate the 1.3 allocation columns.

What should you set up first?

  1. Fix ownership before formulas. The FinOps Foundation paper notes that assigning teams to namespaces aids chargeback. Map every namespace to an owner and cost center.
  2. Set requests on everything. AWS's requests option gives pods without requests no split cost data.
  3. Turn on the provider split and check its limits: GKE doesn't backfill, and AWS split data isn't in Cost Explorer.
  4. Choose the basis and write it down, with the method ID your provider reports.
  5. Name the four shared lines. Idle, system overhead, cluster fees and shared workloads, each with a written rule.
  6. Report idle monthly, with an owner and a target.

In our view, allocation only changes decisions when each line has someone who can move it. That is the case for an operating model in which cluster costs sit next to the teams, services and funding choices they belong to.

Sources

Frequently asked questions

Should Kubernetes costs be allocated by requests or by usage?

In our view, by the higher of the two for chargeback. Requests alone let teams that under-request avoid paying for bursts, and usage alone lets teams that over-reserve avoid paying for blocked capacity. The OpenCost specification treats workload cost as max(request, usage). Requests-only is a simpler, reasonable starting point for showback while request settings are still unreliable.

Who should pay for idle cluster capacity?

There is no standard answer. OpenCost and the FinOps Foundation both treat distribution as a choice, with even, proportional and metric-based options. We think idle capacity should usually stay visible as a line owned by the team that sizes the cluster, because node pools and autoscaling settings drive it. Overhead and shared services can be spread proportionally.

What does FOCUS split cost allocation add?

Introduced in FOCUS 1.3, it lets a provider report how it split a shared resource, such as a Kubernetes node, across workloads. Allocated rows must sum to the original charge, name the recipient in AllocatedResourceId, and point to a documented method through AllocatedMethodId, with ratios in AllocatedMethodDetails. It standardizes the format, not the allocation method.

Do AWS, Google Cloud and Azure split Kubernetes costs the same way?

No. As of November 2026, GKE cost allocation uses resource requests only. AWS split cost allocation data for EKS offers requests only, or the higher of requests and measured usage. Azure's AKS cost analysis add-on is built on OpenCost and reports idle, system, service and unallocated charges. Check each method before comparing clusters across clouds.

Free playbooks

In-depth guides for product and operations leaders.

Browse the playbooks
Steve Elliott

Steve Elliott

Published November 22, 2026

More on FinOps & Cloud

FOCUS, commitments, shared cost.