Google has the deepest container expertise of any cloud provider — Google invented Kubernetes in 2014 and open-sourced it. GCP's container services range from fully managed serverless (Cloud Run) to full cluster control (GKE Standard).
Google Kubernetes Engine (GKE)
GKE is a managed Kubernetes service. Google manages the Kubernetes control plane (API server, etcd, scheduler); you manage your workloads.
GKE offers two modes of operation:
Standard Mode
- You provision and manage worker nodes (VM instances)
- Full control over node type, OS, and configuration
- Pay for nodes whether or not pods are running
- Best for: complex workloads, specific hardware requirements, teams with Kubernetes expertise
Autopilot Mode
- Google manages nodes automatically — you only define pods
- You pay per pod resource request, not per node
- Google handles node provisioning, scaling, and security hardening
- Best for: teams that want Kubernetes without infrastructure management overhead
Cloud Run
Cloud Run is a fully managed serverless platform for running stateless containers. You provide a container image; Google handles everything else — servers, OS, scaling, load balancing, SSL certificates.
Key characteristics:
- Any language, any library. Since you bring a container, there are no runtime restrictions.
- Scale to zero. When no requests are coming in, Cloud Run scales down to zero instances. You pay only for request processing time.
- Fast autoscaling. Handles sudden traffic spikes by spinning up instances in milliseconds.
- HTTP and gRPC. Cloud Run serves HTTP/HTTPS and gRPC traffic natively.
Cloud Run vs GKE
| Factor | Cloud Run | GKE |
|---|---|---|
| Infrastructure management | None (fully managed) | Shared (control plane managed) |
| Scaling to zero | Yes | No (nodes always running) |
| Stateful workloads | Limited | Yes (StatefulSets) |
| Best for | Web APIs, microservices, event-driven | Complex, multi-service applications |
| Pricing model | Per request / per CPU-second | Per node (Standard) / per pod (Autopilot) |
Cloud Functions
Cloud Functions is Google's Function-as-a-Service (FaaS) offering. Write a function in Node.js, Python, Go, Java, Ruby, or PHP — Google manages everything including the container, OS, and runtime.
- Triggered by HTTP requests, Pub/Sub messages, Cloud Storage events, Firestore changes, etc.
- Maximum execution time: 60 minutes (2nd gen)
- Scale to zero; pay per invocation and compute time
- Best for: event handlers, lightweight APIs, glue code between services
App Engine
App Engine is GCP's original PaaS, now in two flavors:
- Standard Environment: Language-specific sandboxed runtimes. Scales to zero. Fast cold starts. Less flexibility.
- Flexible Environment: Runs Docker containers. More control, but minimum 1 instance always running.
App Engine is less commonly used in new projects compared to Cloud Run, but it remains a valid option and appears on certification exams.