Skip to main content
Technology areas
close
AI and ML
Application development
Application hosting
Compute
Data analytics and pipelines
Databases
Distributed, hybrid, and multicloud
Industry solutions
Migration
Networking
Observability and monitoring
Security
Storage
Cross-product tools
close
Access and resources management
Costs and usage management
Infrastructure as code
SDK, languages, frameworks, and tools
/
Console
English
Deutsch
Español
Español – América Latina
Français
Indonesia
Italiano
Português
Português – Brasil
עברית
中文 – 简体
中文 – 繁體
日本語
한국어
Sign in
Google Kubernetes Engine (GKE)
Start free
Overview
Guides
Reference
Samples
Resources
Technology areas
More
Overview
Guides
Reference
Samples
Resources
Cross-product tools
More
Console
Discover
Product overview
Explore GKE documentation
Overview
Main GKE documentation
GKE AI/ML documentation
GKE networking documentation
GKE security documentation
GKE fleet management documentation
Use GKE or Cloud Run?
Try it
Create a cluster in the console
Create a cluster with Terraform
Explore your cluster
Fine-tune GKE services with Gemini assistance
Learn fundamentals
Start learning about GKE
Learn Kubernetes fundamentals
Start learning about Kubernetes
Introducing containers
Kubernetes comic
Kubernetes.io
Video playlist: Learn Kubernetes with Google
Learn GKE essentials
GKE modes of operation
Video playlist: GKE Essentials
Common GKE user roles and tasks
Get started
Cluster lifecycle
Cluster administration overview
Cluster configuration
Deploying workloads
GKE cluster architecture
Workflows and tools
gcloud CLI overview
GKE in the Google Cloud console
Provision GKE resources with Terraform
Install kubectl and configure cluster access
Simplify deployment using your IDE
Use the GKE remote MCP server
Learning path: Containerize your app
Overview
Understand the monolith
Modularize the monolith
Prepare for containerization
Containerize the modular app
Deploy the app to a cluster
Learning path: Scalable apps
Overview
Create a cluster
Monitor with Prometheus
Scale workloads
Simulate failure
Centralize changes
Production considerations
Design and plan
Code samples
Best practices for GKE
Architectures
Develop and deliver apps with Cloud Code, Cloud Build, and Google Cloud Deploy
Address continuous delivery challenges
Set up GKE clusters
Plan clusters for running your workloads
Compare features in GKE Autopilot and Standard
About regional clusters
About feature gates
About alpha clusters
About machine support with GKE clusters
Design your GKE cluster with Gemini
Design for resource obtainability with Gemini
Set up Autopilot clusters
About GKE Autopilot
Create Autopilot clusters
Extend the run time of Autopilot Pods
Set up Standard clusters
Create a zonal cluster
Create a regional cluster
Create an alpha cluster
Create a cluster using Windows node pools
Prepare to use clusters
Use labels to organize clusters
Manage GKE resources using Tags
Configure node pools
About node pools
Add and manage node pools
About node images
About Containerd images
Specify a node image
About Arm workloads on GKE
Create Standard clusters and node pools with Arm nodes
Plan GKE Standard node sizes
About Spot VMs
About Windows Server containers
Auto-repair nodes
Automatically bootstrap GKE nodes with DaemonSets
Update Kubernetes node labels and taints for node pools
Use nested VMs with GKE Standard clusters
Set up clusters for multi-tenancy
About cluster multi-tenancy
Plan a multi-tenant environment
Prepare GKE clusters for third-party tenants
Set up multi-tenant logging
Use fleets to simplify multi-cluster management
About fleets
Create fleets
Enhance scalability for clusters
About GKE scalability
Plan for scalability
Plan for large GKE clusters
Plan for large workloads
About capacity buffers
Configure capacity buffers
Provision extra compute capacity for rapid Pod scaling
Consume reserved zonal resources
About quicker workload startup with fast-starting nodes
Reduce and optimize costs
Design and configure GKE clusters for cost optimization
Configure autoscaling for workloads
Scaling deployed applications
Autoscale workloads horizontally
About horizontal Pod autoscaling
Autoscale deployments using horizontal Pod autoscaling
Collect horizontal Pod autoscaler event logs
About autoscaling workloads based on metrics
Expose custom metrics
Configure autoscaling for LLM workloads on GPUs
Configure autoscaling for LLM workloads on TPUs
Scale to zero using KEDA
Autoscale workloads vertically
About vertical Pod autoscaling
Scale container resource requests and limits
Collect vertical Pod autoscaler event logs
Configure multidimensional Pod autoscaling
Accelerate application startup using CPU startup boost
Configure autoscaling for infrastructure
About cluster autoscaling
Configure cluster autoscaling
View cluster autoscaling events
About node pool auto-creation
Configure node pool auto-creation
Configure granular resource limits
Run fault-tolerant workloads at lower costs
Use Spot Pods on Autopilot clusters
Use Spot VMs to run workloads on GKE Standard clusters
Use preemptible VMs to run workloads
View GKE costs
View cluster costs breakdown
View cost-related optimization metrics
Optimize GKE costs
Right-size your GKE workloads at scale
Reduce costs by scaling down GKE clusters during off-peak hours
Identify underprovisioned and overprovisioned GKE clusters
Identify idle GKE clusters
Identify underprovisioned and overprovisioned workloads
Provision storage
About storage for GKE clusters
Use Kubernetes features, primitives, and abstractions for storage
Use persistent volumes and dynamic provisioning
Use StatefulSets
About volume snapshots
Use volume expansion
Populate volumes with data from Cloud Storage
About the GKE Volume Populator
Automate data transfer to Hyperdisk ML
Block storage
Provision and use Persistent Disks
Using the Compute Engine Persistent Disk CSI driver
Persistent volume attach limits
Using pre-existing persistent disks
Manually install a CSI driver
Using persistent disks with multiple readers (ReadOnlyMany)
Persistent disks backed by SSD
Regional persistent disks
Increase stateful app availability with Stateful HA Operator
Provision and use Hyperdisk
About Hyperdisk
Scale your storage performance using Hyperdisk
Optimize storage performance and cost with Hyperdisk Storage Pools
Accelerate AI/ML data loading using Hyperdisk ML
Provision and use GKE Data Cache
Accelerate read performance of stateful workloads with GKE Data Cache
Manage your persistent storage
Configure a boot disk for node file systems
Clone persistent disks
Back up and restore Persistent Disk storage using volume snapshots
Optimize disk performance
About optimizing disk performance
Monitor disk performance
Local SSD and ephemeral storage
About Local SSD storage for GKE
Provision Local SSD-backed ephemeral storage
Provision Local SSD-backed raw block storage
Create a Deployment using an EmptyDir Volume
Use dedicated Persistent Disks as ephemeral volumes
File storage
Provision and use Lustre volumes
About Managed Lustre for GKE
Create and use a volume backed by Managed Lustre
Access existing Managed Lustre instances
Expand Managed Lustre volumes
Provision Managed Lustre on GKE using XPK
Provision and use Filestore
About Filestore support for GKE
Access Filestore instances
Deploy a stateful workload with Filestore
About Filestore multishares for GKE
Optimize multishares for GKE
Back up and restore Filestore storage using volume snapshots
Object storage
Quickstart: Cloud Storage FUSE CSI driver for GKE
About the Cloud Storage FUSE CSI driver for GKE
Set up the Cloud Storage FUSE CSI driver
Mount Cloud Storage buckets as ephemeral volumes
Mount Cloud Storage buckets as persistent volumes
Configure the Cloud Storage FUSE CSI driver sidecar container
Optimize Cloud Storage FUSE performance
Automate performance tuning with performance profiles
Manual performance tuning
Deploy and manage workloads
Deploy Autopilot workloads
Plan resource requests for Autopilot workloads
About Autopilot workloads in GKE Standard
Run Autopilot workloads in Standard clusters
Configure node attributes with ComputeClasses
About GKE ComputeClasses
About built-in ComputeClasses in GKE
About custom ComputeClasses
Control autoscaled node attributes with custom ComputeClasses
Apply ComputeClasses to Pods by default
About Balanced and Scale-Out ComputeClasses in Autopilot clusters
Choose predefined ComputeClasses for Autopilot Pods
Best practices for ComputeClasses
Deploy workloads on optimized hardware
Minimum CPU platforms for compute-intensive workloads
Configure Pod bursting in GKE
Analyze CPU performance using the PMU
Run high performance computing (HPC) workloads with H4D
Best practices for running HPC workloads
Deploy workloads that have special security requirements
About privileged workload admission in Autopilot mode
Create allowlists for privileged workloads in Autopilot mode
GKE Autopilot partners
Privileged open source workloads in Autopilot mode
Restrict privileged Autopilot workloads in organizations
Control privileged workload admission in Autopilot mode
Troubleshoot privileged Autopilot workloads and allowlists
Deploy workloads that require specialized devices
About dynamic resource allocation (DRA) in GKE
Prepare your GKE infrastructure for DRA
Deploy DRA workloads
Snapshot and restore workloads with Pod snapshots
About Pod snapshots
Prepare for Pod snapshots
Trigger a Pod snapshot
Restore a workload from a Pod snapshot
Troubleshoot Pod snapshots
Migrate workloads
Identify Standard clusters to migrate to Autopilot
Prepare to migrate to Autopilot clusters from Standard clusters
Manage workloads
Place GKE Pods in specific zones
Simulate zone failure
Improve workload efficiency using NCCL Fast Socket
About container image digests
Using container image digests in Kubernetes manifests
Improve workload initialization speed
Use streaming container images
Use secondary boot disks to preload data or container images
Isolate your workloads using namespaces
Continuous integration and delivery
Plan for continuous integration and delivery
Create a CI/CD pipeline with Azure Pipelines
GitOps-style continuous delivery with Cloud Build
Modern CI/CD with GKE
A software delivery framework
Build a CI/CD system
Apply the developer workflow
Deploy workloads by application types
AI/ML workloads
AI/ML orchestration on GKE
About GKE Hypercluster
Databases, caches, and data streaming workloads
Data on GKE
Plan your database deployments on GKE
Managed databases
Deploy an app using GKE Autopilot and Spanner
Deploy WordPress on GKE with Persistent Disk and Cloud SQL
Analyze data on GKE using BigQuery, Cloud Run, and Gemma
Kafka
Deploy Apache Kafka to GKE using Strimzi
Deploy Apache Kafka to GKE using Confluent
Redis
Create a multi-tier web application with Redis and PHP
Deploy a Redis cluster on GKE
Deploy Redis to GKE using Redis Enterprise
Optimize Redis performance on GKE
MySQL
Deploy a stateful MySQL cluster
Migrate your MySQL data from Persistent Disk to Hyperdisk using snapshots
Migrate your MySQL data from Persistent Disk to Hyperdisk using Backup for GKE
Optimize MySQL performance on GKE
PostgreSQL
Deploy a highly-available PostgreSQL database
Deploy PostgreSQL to GKE using Zalando
Deploy PostgreSQL to GKE using CloudNativePG
SQL Server
Deploy single instance SQL Server 2017 on GKE
Memcached
Deploy Memcached on GKE
Vector databases
Build a RAG chatbot using GKE and Cloud Storage
Deploy a Qdrant database on GKE
Deploy an Elasticsearch database on GKE
Deploy a PostgreSQL vector database on GKE
Deploy a Weaviate vector database on GKE
Web servers and applications
Plan for serving websites
Deploy a stateful app
Ensure workloads are disruption-ready
Deploy a stateless app
Allow direct connections to Autopilot Pods using hostPort
Run Django
Deploy an application from Cloud Marketplace
Run full-stack workloads at scale on GKE
Deploy a containerized web server app
Game Servers
Get support for Agones and Game Servers issues
Isolate the Agones controller in your GKE cluster
Deploy Arm workloads
Prepare an Arm workload for deployment to Standard clusters
Build multi-arch images for Arm workloads
Deploy Autopilot workloads on Arm architecture
Migrate x86 application on GKE to multi-arch with Arm
Microsoft Windows
Deploy a Windows Server application
Build Windows Server multi-arch images
Deploy ASP.NET apps with Windows Authentication in GKE Windows containers
Manage and optimize clusters
Manage cluster lifecycle changes to minimize disruption
Optimize your usage of GKE with insights and recommendations
Manage a GKE cluster
Configure a cluster and workload for staging
Optimize workload performance
Upgrade clusters and node pools
About GKE cluster upgrades
Plan for cluster upgrades
About release channels
Use release channels
About Autopilot cluster upgrades
About Standard cluster upgrades
Auto-upgrade nodes
Manually upgrade a cluster's control plane or node pools
About node upgrade strategies
Configure node upgrade strategies
About maintenance windows and exclusions
Configure maintenance windows and exclusions
About rollout sequencing with custom stages
Sequence the rollout of cluster upgrades with custom stages
About cluster upgrades with rollout sequencing
Sequence the rollout of cluster upgrades
Control the frequency of disruption from auto-upgrades
Get notifications for cluster events
About cluster notifications
Receive cluster notifications through Pub/Sub
Configure cluster to receive email notifications
Configure cluster notifications for third-party services
Get visibility into cluster upgrades
Manage nodes
Ensure resources for node upgrades
Resize clusters by adding or removing nodes
Define compact placement for nodes
Migrate nodes to a different machine type
Manage host maintenance
Understand how to do host maintenance on GKE
Monitor maintenance events
Perform host maintenance for nodes running training and inference workloads
Migrate nodes to Linux cgroupv2
Configure writable cgroups for containers
Customize containerd configuration
Customize node system configuration
Configure nodes to use disk space as virtual memory
Configure Windows Server nodes to join a domain
Simultaneous multi-threading (SMT) for high performance compute
Delete clusters
Use Kubernetes beta APIs with GKE clusters
Ensure control plane stability when using webhooks
Use Backup for GKE
Monitor
Observability for GKE
Set up Google Cloud Managed Service for Prometheus
Use Managed OpenTelemetry
Managed OpenTelemetry overview
Deploy Managed OpenTelemetry
