Skip to content
Google CloudGoogle Kubernetes EngineContainers

google_container_node_pool cost estimation

Compute Engine worker nodes for a GKE cluster. Bills as the VMs it runs: node_count × machine_type. 3× e2-standard-4 is ~$294/month.

A google_container_node_pool is where the GKE bill lives. On a Standard cluster the node pool bills as plain Compute Engine VMs, node_count × the on-demand rate for node_config.machine_type, exactly as if you'd created the instances yourself. The cluster management fee ($0.10/hour per cluster, with one zonal cluster free per billing account) is small next to the nodes.

Three e2-standard-4 nodes (4 vCPU, 16 GiB, ~$0.134/hour) running 24/7 is $0.134 × 3 × 730 = $293.53/month. The e2 family is the cost-efficient default; n2 and c2 cost more per vCPU for higher or more consistent performance. Each node also carries a boot disk (a google_compute_disk) that bills separately.

GKE has two modes and they bill very differently. In Standard mode you pay for nodes whether or not pods fill them, so a half-empty node pool is wasted money. In Autopilot mode you pay per pod resource request instead of per node, which removes the waste but changes the cost model entirely. This page covers Standard node pools; Autopilot clusters don't use node pools at all.

The classic GKE overspend is a node pool sized for peak with autoscaling disabled, or min_node_count set equal to max_node_count. Cluster autoscaler scaling the pool to real demand, plus committed-use discounts on the baseline, is where the savings are.

c3x estimates the pool from node_count (or initial_node_count for autoscaling pools) and node_config.machine_type, at the on-demand rate. Spot/preemptible nodes float and are priced at the on-demand ceiling.

Terraform example

A minimal but realistic configuration that C3X can estimate.

resource "google_container_node_pool" "primary" {
  name       = "primary-pool"
  cluster    = google_container_cluster.main.id
  node_count = 3

  node_config {
    machine_type = "e2-standard-4"
    disk_size_gb = 100
    disk_type    = "pd-balanced"

    oauth_scopes = [
      "https://www.googleapis.com/auth/cloud-platform",
    ]
  }

  autoscaling {
    min_node_count = 3
    max_node_count = 10
  }
}

Pricing dimensions

What you actually pay for when you provision google_container_node_pool.

DimensionUnitWhat's being charged
Node instancesper instance-hournode_count × the on-demand rate for node_config.machine_type. Autoscaling pools use initial_node_count as the baseline.
$0.134/hour for e2-standard-4 → 3 nodes ≈ $293.53/month
Node boot disksper GB-monthEach node's boot disk (pd-balanced ~$0.10/GB-month, pd-ssd more) bills separately as a Compute Engine disk.
Cluster management feeper hourBilled on google_container_cluster: $0.10/hour per cluster, with one zonal cluster free per billing account.

Sample C3X output

A 3-node e2-standard-4 pool, on-demand, running 24/7:

google_container_node_pool.primary
└─ Node instances (on-demand)   2190 instance-hours   $293.53
                                Monthly               $293.53

Optimization tips

Common ways to reduce google_container_node_pool cost without changing the workload.

Enable cluster autoscaling and scale to zero where possible

30 to 50% on bursty workloads

A pool with autoscaling that scales down idle nodes (and to zero for batch pools) only pays for nodes pods actually need. Pools left at a fixed peak size are the most common GKE overspend.

Buy committed-use discounts for baseline nodes

37 to 55% on baseline

A 1-year committed-use discount on the vCPU/memory your pool always runs is ~37% off; 3-year is ~55%. GCP also applies automatic sustained-use discounts on top for long-running nodes.

Use Spot VMs for fault-tolerant pods

Up to 91% on spot pods

A Spot node pool (node_config { spot = true }) runs 60 to 91% below on-demand. Right for stateless and batch workloads that tolerate preemption; keep system pods on a standard pool.

Consider GKE Autopilot for spiky or small workloads

Workload-dependent

Autopilot bills per pod resource request, not per node, so you stop paying for empty node headroom. For clusters that are hard to bin-pack, it's often cheaper than a Standard pool sized for peak.

FAQ

Why is my GKE node pool billed as Compute Engine?

Standard-mode node pools are Compute Engine VMs, there's no separate node-pool meter. c3x prices node_count × the machine_type on-demand rate, which is what appears under Compute Engine on your bill.

Does the estimate include the GKE cluster fee?

No. The $0.10/hour cluster management fee bills on google_container_cluster (with one zonal cluster free per account). The node-pool line is purely the worker VMs.

How does c3x handle autoscaling node pools?

It uses node_count, or initial_node_count when the pool autoscales, as the baseline. Actual cost rises and falls as the autoscaler adds and removes nodes between min_node_count and max_node_count.

Are Spot/preemptible nodes priced at the discount?

No. Spot prices float, so c3x prices them at the on-demand ceiling and flags it. Your real Spot cost will be substantially lower, typically 60 to 91% off.

Related resources

Google Cloud
google_container_cluster

The cluster the node pool belongs to ($0.10/hour fee)

Google Cloud
google_compute_instance

Node pools run Compute Engine VMs; same per-hour pricing

Estimate this resource in your own Terraform

Free, open source, no API key. C3X parses your Terraform and shows line-item cost for every resource, including google_container_node_pool.

Get StartedStar on GitHub
← Browse all Google Cloud resources