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_
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_
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_
c3x estimates the pool from node_
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_.
| Dimension | Unit | What's being charged |
|---|---|---|
| Node instances | per instance-hour | node_ $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_ |
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_ cost without changing the workload.
Enable cluster autoscaling and scale to zero where possible
30 to 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 to 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_
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_
Does the estimate include the GKE cluster fee?
No. The $0.10/hour cluster management fee bills on google_
How does c3x handle autoscaling node pools?
It uses node_
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
More Google Cloud resources
Further reading
- GKE Autopilot cost optimization: you pay for requests, not usage
Autopilot bills pod resource requests (~$0.0445/vCPU-hour), not nodes, so oversized requests are the overspend. Here's how to right-size requests, use Spot Pods, and pick compute classes.
- GKE Standard vs Autopilot: which mode for your workload
Autopilot bills per-pod (vCPU, memory, ephemeral storage). Standard bills per-node. The break-even is around 50-55% node utilization. Here's the actual pricing math with n2-standard-4 nodes, when each mode wins, and how to migrate without surprises.
- Cloud Run vs GKE cost: when serverless beats a node pool
Cloud Run bills per request-second and scales to zero; GKE bills for nodes 24/7. The cheaper option comes down to utilization. Here's the crossover, the min-instances trap, and where Autopilot fits.
- GCP Spot VMs: 60-91% off if you design for preemption
Spot VMs run 60-91% below on-demand for the same machine type, preemptible at any time. Here's what belongs on Spot, how it differs from preemptible, Spot GKE pools, and how to design for preemption.
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_.