How do you allocate Kubernetes costs to teams?
Kubernetes cost allocation is splitting the price of shared nodes, storage and network across the teams whose Pods use them. A cost tool multiplies each Pod’s share of a node’s CPU, memory and GPU by that node’s price, then sums the result per namespace or label. The hard part is not the arithmetic but two policy choices: whether a team pays for what it requests or what it uses, and who pays for capacity that no Pod claims.
Why the cloud bill cannot do it alone
A cloud invoice lists virtual machines, disks and load balancers. One node runs Pods from several teams, so the invoice line for that node has no single owner. Allocation therefore needs data from the cluster (which Pods ran where, with what requests and usage) joined with prices from the provider. Persistent volumes are simpler, because each one belongs to a claim in a namespace.
Requests, usage, or the larger of the two
| Basis | A team pays for | Strength | Weakness |
|---|---|---|---|
| Requests | Capacity its Pods reserve | Matches what the scheduler blocks on the node; stable month to month | Ignores bursts above the request |
| Usage | Capacity its Pods consume | Feels fair for bursty workloads | Over-requesting costs the team nothing, so waste moves to the shared idle bucket |
| Max of request and usage | The reservation, plus any burst above it | Charges both reserved and burst capacity | Harder to forecast; idle capacity still needs an owner |
The OpenCost specification uses the third option: workload costs are max(request, usage) for CPU, memory and GPU. GKE cost allocation is based on resource requests, not resources consumed. Requests are usually the better default for chargeback, because they are what the node bill follows. A Pod that requests 4 vCPU and uses 0.5 still keeps 4 vCPU off the market. Kubernetes resource requests and limits explains why.
Idle and shared costs
After workloads are charged, two buckets remain:
- Idle capacity. Node capacity that no Pod requested. OpenCost calls it cluster idle cost: asset costs minus workload costs. GKE reports it as
kube:unallocated, and capacity reserved for the kubelet and container runtime askube:system-overhead. - Shared costs. Control plane fees, system namespaces such as
kube-system, monitoring and ingress controllers, DaemonSets on every node, shared load balancers and egress.
The OpenCost specification lists three ways to spread them: evenly across tenants, in proportion to each tenant’s own costs, or by a custom metric such as network egress bytes. Proportional spreading is the common default. Some organizations keep idle cost in the platform team’s budget instead, because packing nodes is the platform team’s job. That choice puts the pressure on bin packing and consolidation rather than on application teams. Whatever you choose, report idle as its own line, because a growing idle share means requests or node shapes need work.
Namespaces and labels as the unit
The namespace is the simplest unit: one team or one application per namespace, and every Pod in it is charged to that owner. Labels add finer splits, such as team, cost-center, app and environment, and they work when one namespace holds several owners.
Labels only help if every workload carries them. Enforce required labels at admission with a policy engine or a ValidatingAdmissionPolicy, and report unlabeled spend as its own line until it reaches zero. Provider exports have their own limits: GKE drops all Kubernetes labels from billing data for a Pod with more than 50 labels.
Showback and chargeback
Showback reports each team’s cost without moving money. Chargeback books that cost against the team’s budget. Most organizations start with showback, because teams need a few months to trust the numbers and fix their requests before they are billed for them. Chargeback then follows for teams with their own budgets.
This sits inside the FinOps Framework, which runs in three phases: Inform (cost and usage data), Optimize (finding savings) and Operate (making the changes). Allocation is the core of Inform. Organizations that combine several providers can normalize their bills with FOCUS, an open specification for billing data. As of November 2026 its latest version is 1.4, and AWS, Google Cloud and Microsoft Azure publish FOCUS 1.2 exports.
Tools: Kubecost vs OpenCost
| OpenCost | Kubecost | |
|---|---|---|
| Owner | CNCF incubating project since October 25, 2024 | IBM, which acquired Kubecost in September 2024 and sells it next to Apptio Cloudability |
| License | Apache 2.0 | Commercial, with a free tier |
| Free scope | All features, any cluster size | Foundations tier: clusters up to 250 cores in total, 15-day metric retention, community support |
| Paid editions | None; vendors build products on it | Enterprise Self-hosted and Enterprise Cloud, priced through sales |
| Pricing data | AWS, Azure and Google Cloud billing APIs; custom prices for on-premises nodes | Reconciles costs with cloud bills |
OpenCost was originally developed and open-sourced by Kubecost and was accepted into the CNCF on June 17, 2022. It allocates cost per container, Pod, namespace and label, and it also tracks out-of-cluster cloud costs. IBM Kubecost adds features for larger organizations, such as role-based access control, unlimited metric retention and dedicated support, in the paid editions (as of November 2026). OpenCost covers showback for most teams. Kubecost fits organizations that want a supported product or already use IBM’s FinOps tools.
Managed services also have built-in options. GKE writes namespace and label data into the Cloud Billing export to BigQuery. AWS split cost allocation data adds Pod-level CPU, memory and accelerator costs for EKS to the Cost and Usage Report, with tags such as aws:eks:namespace. Both cover only their own clusters, so a tool that runs in every cluster gives one view across providers.
Allocation shows where money goes. Lowering it is the work described in how to reduce Kubernetes costs and, across providers, in optimizing costs across hybrid and multi-cloud.
Cost allocation on Cloudfleet
One Cloudfleet Kubernetes Engine (CFKE) cluster can run nodes from several clouds and on-premises servers, so one set of namespace and label rules covers all of them. Cloudfleet itself bills per cluster with a monthly breakdown, as described on the pricing page.