Google Kubernetes Engine

Overview

Google Kubernetes Engine (GKE) is Google Cloud's managed service for deploying and managing containerized applications using Kubernetes. GKE simplifies the operation of Kubernetes clusters by automating infrastructure management tasks, including control plane upgrades, node provisioning, and patching. This allows development teams to focus on application logic rather than underlying infrastructure. GKE is built on the open-source Kubernetes project, which originated at Google, and provides direct access to Kubernetes APIs and tools [Google Kubernetes Engine overview].

GKE offers two primary modes of operation: Standard and Autopilot. In Standard mode, users have control over cluster configuration, including node types, sizes, and scaling parameters. This mode provides flexibility for environments requiring specific resource configurations or custom node pool setups. Autopilot mode, conversely, takes a more hands-off approach, fully managing the cluster infrastructure, including worker nodes, scaling, and patching. Pricing in Autopilot is based on the consumed pod resources rather than underlying virtual machines, simplifying cost management and optimizing resource utilization [GKE Autopilot overview].

GKE is designed for a range of use cases, from deploying stateless web applications to orchestrating complex microservices architectures and running machine learning workloads. Its integration with other Google Cloud services, such as Cloud Load Balancing, Cloud Logging, and Cloud Monitoring, provides a unified platform for building, observing, and scaling applications [GKE Integrations guide]. For organizations pursuing hybrid or multi-cloud strategies, GKE Enterprise extends Kubernetes management across diverse environments, including on-premises and other cloud providers, offering a consistent control plane and policy enforcement [GKE Enterprise overview].

The service targets developers and technical buyers who require a scalable, reliable, and secure platform for container orchestration. Its compliance certifications, including SOC 1, SOC 2, ISO 27001, and PCI DSS, address security and regulatory requirements for enterprise deployments [GKE Security and Compliance]. The developer experience is supported by client libraries in multiple languages, including Go, Python, and Node.js, and a consistent command-line interface through the gcloud tool [GKE API reference].

Key features

• Automated Cluster Management: GKE automates the management of the Kubernetes control plane, including upgrades, patching, and scaling, reducing operational overhead [GKE Control Plane upgrades].
• Autopilot Mode: A fully managed operational mode that automates node provisioning, scaling, and patching, with resource-based pricing [GKE Autopilot overview].
• Node Pools: Allows creation of groups of nodes within a cluster, enabling different machine types and configurations for varied workloads [GKE Node Pools documentation].
• Vertical and Horizontal Pod Autoscaling: Automatically adjusts the number of pods and resource requests/limits based on CPU utilization and other custom metrics to meet demand [GKE Vertical Pod Autoscaling].
• Integrated Logging and Monitoring: Seamless integration with Google Cloud's operations suite, including Cloud Logging and Cloud Monitoring, for centralized observability [GKE Logging and Monitoring].
• Workload Identity: Provides a secure way for Kubernetes service accounts to access Google Cloud services, leveraging IAM for granular permissions [GKE Workload Identity].
• VPC-Native Clusters: GKE clusters can operate directly on a Virtual Private Cloud (VPC) network, enabling private IP communication and enhanced network control [GKE Private Clusters].
• GKE Enterprise: Extends GKE's capabilities to manage Kubernetes clusters across hybrid and multi-cloud environments with a consistent control plane [GKE Enterprise overview].

Pricing

GKE pricing is based on cluster management fees and the consumption of underlying compute resources. A free tier is available, offering a specific amount of free usage for both Standard and Autopilot clusters [GKE Pricing page]. The following table summarizes the starting paid tiers (prices effective as of May 7, 2026):

Common integrations

• Google Cloud Load Balancing: Integrates for ingress and service exposure, providing global load balancing for GKE applications [GKE Ingress with Load Balancer].
• Cloud Logging and Monitoring: Automatic collection of logs and metrics from clusters, nodes, and pods for observability [GKE Logging and Monitoring].
• Artifact Registry: Used for storing and managing Docker container images and other artifacts for deployment to GKE [Artifact Registry Docker Push].
• Cloud SQL: Managed relational database service, commonly integrated as a backend for applications running on GKE [Cloud SQL with GKE].
• Cloud Memorystore for Redis: Managed in-memory data store, used for caching or session management with GKE applications [Cloud Memorystore with GKE].
• Cloud Build: Continuous integration/continuous delivery (CI/CD) service that can automate building and deploying container images to GKE [Cloud Build to GKE deployments].
• Velero: An open-source tool for backing up and restoring Kubernetes cluster resources and persistent volumes [Velero documentation]. This provides disaster recovery capabilities across cloud environments, including GKE.

Alternatives

• Amazon Elastic Kubernetes Service (EKS): AWS's managed Kubernetes service, offering integration with the AWS ecosystem.
• Azure Kubernetes Service (AKS): Microsoft Azure's managed Kubernetes offering, with deep integration into Azure services.
• Red Hat OpenShift Dedicated: A managed service of Red Hat OpenShift, an enterprise Kubernetes platform with additional developer tools and enterprise features.
• DigitalOcean Kubernetes: A managed Kubernetes offering known for its developer-friendly interface and transparent pricing.
• Linode Kubernetes Engine (LKE): Managed Kubernetes service from Linode, focusing on simplicity and cost-effectiveness.

Getting started

To get started with Google Kubernetes Engine, you typically begin by installing the Google Cloud CLI and configuring it. The following steps demonstrate creating a new GKE cluster and deploying a simple Nginx application using gcloud and kubectl in Python. This example creates a Standard mode cluster in the us-central1-c zone.

# Ensure gcloud CLI is authenticated and project is set
# gcloud auth login
# gcloud config set project YOUR_PROJECT_ID

# Create a GKE Standard cluster
# This command will take several minutes to complete
print("Creating GKE cluster 'my-gke-cluster'...")
subprocess.run([
    "gcloud", "container", "clusters", "create", "my-gke-cluster",
    "--zone", "us-central1-c",
    "--num-nodes", "1",
    "--machine-type", "e2-medium"
], check=True)
print("Cluster 'my-gke-cluster' created.")

# Get cluster credentials for kubectl
print("Getting cluster credentials...")
subprocess.run([
    "gcloud", "container", "clusters", "get-credentials", "my-gke-cluster",
    "--zone", "us-central1-c"
], check=True)
print("Kubectl configured for 'my-gke-cluster'.")

# Deploy a sample Nginx application
# Create a Deployment for Nginx
print("Deploying Nginx application...")
nginx_deployment_manifest = """
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
"""

# Pipe the manifest to kubectl apply
process = subprocess.Popen(["kubectl", "apply", "-f", "-"], stdin=subprocess.PIPE, text=True)
process.communicate(nginx_deployment_manifest)
process.wait()
print("Nginx deployment created.")

# Expose the Nginx deployment as a LoadBalancer service
print("Exposing Nginx service with LoadBalancer...")
nginx_service_manifest = """
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
"""

process = subprocess.Popen(["kubectl", "apply", "-f", "-"], stdin=subprocess.PIPE, text=True)
process.communicate(nginx_service_manifest)
process.wait()
print("Nginx service exposed.")

# Get the external IP of the Nginx service
print("Waiting for external IP address...")
import time
external_ip = None
for _ in range(30): # Allow up to 5 minutes for IP to be assigned
    result = subprocess.run(["kubectl", "get", "service", "nginx-service", "-o", "jsonpath='{.status.loadBalancer.ingress[0].ip}'"], capture_output=True, text=True)
    ip_output = result.stdout.strip().strip("'")
    if ip_output and ip_output != '':
        external_ip = ip_output
        break
    time.sleep(10)

if external_ip:
    print(f"Nginx application is accessible at: http://{external_ip}")
else:
    print("Could not retrieve external IP. Check service status with 'kubectl get service nginx-service'")

# Clean up resources (optional)
# print("Cleaning up resources...")
# subprocess.run(["kubectl", "delete", "service", "nginx-service"], check=True)
# subprocess.run(["kubectl", "delete", "deployment", "nginx-deployment"], check=True)
# subprocess.run(["gcloud", "container", "clusters", "delete", "my-gke-cluster", "--zone", "us-central1-c", "--async"], check=True)
# print("Resources deleted/deletion initiated.")