Google Kubernetes Engine (GKE)

Google Kubernetes Engine (GKE) is Google Cloud’s managed Kubernetes service that runs containerized applications without needing to install and operate your own Kubernetes control plane. GKE automates cluster management, scaling, and security — letting you focus on application development.

How GKE Fits In

flowchart LR
    A[Your Application] --> B[Container Image]
    B --> C[GKE Cluster]
    C --> D[Google Infrastructure]
    D --> E[Users]

    subgraph "GKE manages"
        C
    end

GKE eliminates the operational overhead of running Kubernetes yourself. Google manages the control plane (API server, scheduler, etcd, controller manager), and depending on your cluster mode, can also manage the worker nodes.

Key Capabilities

• Auto-upgrade — Control plane and nodes can be upgraded automatically on a schedule you control
• Auto-repair — Unhealthy nodes are automatically detected and replaced
• Built-in logging & monitoring — Integration with Cloud Logging and Cloud Monitoring via Managed Prometheus
• Workload Identity Federation for GKE — Securely associate Kubernetes service accounts with IAM service accounts
• Binary Authorization — Enforce deploy-time policies on container images (signed, verified)
• Shielded GKE nodes — Secure boot, integrity monitoring, encrypted boot disk
• GKE Enterprise (formerly Anthos) — Multi-cluster management, fleet-level policy, hybrid cloud

GKE Architecture Overview

flowchart TB
    subgraph Control["Control Plane (Google-managed)"]
        API["API Server"]
        ETCD["etcd"]
        SCHED["Scheduler"]
        CTRL["Controller Manager"]
    end

    subgraph NodePool1["Node Pool 1"]
        N1["Node 1"]
        N2["Node 2"]
    end

    subgraph NodePool2["Node Pool 2 (GPU)"]
        N3["Node 3"]
    end

    API --> N1
    API --> N2
    API --> N3

    N1 --> P1["Pods"]
    N2 --> P2["Pods"]
    N3 --> P3["GPU Pods"]

Control Plane

The control plane runs the Kubernetes core components. In GKE, this is fully managed by Google:

• API Server — The entry point for all Kubernetes API calls (kubectl, gcloud, client libraries)
• etcd — Consistent, highly-available key-value store for all cluster state
• Scheduler — Assigns pods to nodes based on resource requirements and constraints
• Controller Manager — Runs core controllers (deployment, replica set, node lifecycle)

Nodes and Node Pools

Nodes are Compute Engine VMs that run your workloads. Nodes are organized into node pools — groups of nodes with identical configuration (machine type, labels, taints).

Key Insight: You can have multiple node pools in a cluster to handle different workload types — e.g., one pool for general workloads and another for GPU-accelerated workloads.

GKE Cluster Modes

Tip: Start with Autopilot unless you need custom node configuration, unsupported hardware, OS image choice, or kernel modules.

See Autopilot vs Standard for a detailed comparison.

Core Concepts at a Glance

See Core Kubernetes Concepts for deeper coverage.

Common GKE Operations

# List clusters
gcloud container clusters list
 
# Get credentials for kubectl
gcloud container clusters get-credentials CLUSTER_NAME --region REGION
 
# View cluster details
gcloud container clusters describe CLUSTER_NAME --region REGION
 
# View node pools
gcloud container node-pools list --cluster=CLUSTER_NAME --region REGION
 
# Check cluster status
kubectl get nodes
kubectl get pods -A

Pricing Summary

As of May 2026, for us-central1 pricing:

Note: Autopilot still accrues the GKE cluster management fee. For general-purpose Autopilot workloads, pod compute billing is based on the resource requests in running or creating pods.

Best Practices

Common Pitfalls and Gotchas

Warning: GKE cluster deletion is irreversible. All workloads, persistent data, and configurations are permanently lost. Always verify before deleting.

Guide Overview

This guide covers GKE from fundamentals to production best practices:

TL;DR

• GKE is a managed Kubernetes service — Google handles the control plane and can manage nodes (Autopilot)
• Start with Autopilot unless you need custom node configuration
• Always set resource requests and limits on pods
• Use regional clusters for production workloads
• Enable Workload Identity Federation for GKE instead of storing service account keys
• GKE includes auto-upgrade, auto-repair, integrated logging/monitoring, and security features out of the box

Resources

• GKE Documentation
• GKE Best Practices
• GKE Pricing
• Kubernetes Official Documentation
• GCP Managed Compute Services