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.
| Dimension | Unit | What's being charged |
|---|---|---|
| Node instances | per instance-hour | node_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 disks | per GB-month | Each node's boot disk (pd-balanced ~$0.10/GB-month, pd-ssd more) bills separately as a Compute Engine disk. |
| Cluster management fee | per hour | Billed 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.53Optimization tips
Common ways to reduce google_container_node_pool cost without changing the workload.
Enable cluster autoscaling and scale to zero where possible
30–50% on bursty workloadsA 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–55% on baselineA 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 podsA Spot node pool (node_config { spot = true }) runs 60–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-dependentAutopilot 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–91% off.
Related resources
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.