Study guide

4.4 Containers in the Cloud

Google Cloud Digital Leader Exam

Track your progress as you read

Finished sections get a check mark.

1 Introduction & Exam Overview

1.1 Current Exam Facts 1.2 How to Prepare & Use This Guide 1.3 What Changed in the August 12, 2026 Exam Update

2 Digital Transformation with Google Cloud

1.1 Why Cloud Technology Is Transforming Business 1.2 Fundamental Cloud Concepts 1.3 Cloud Computing Models and Shared Responsibility 1.4 Agentic AI, Open Standards, and Google Cloud's Differentiators

3 Exploring Data Transformation with Google Cloud

2.1 The Value of Data 2.2 Google Cloud Data Management Solutions 2.3 Making Data Useful and Accessible 2.4 Data Types, the Data Supply Chain, and Interoperability

4 Innovating with Google Cloud Artificial Intelligence

3.1 AI and ML Fundamentals 3.2 Google Cloud's AI and ML Solutions 3.3 Building and Using Google Cloud AI and ML Solutions 3.4 Gemini, the Agent Platform, and the AI Hypercomputer

5 Modernize Infrastructure and Applications with Google Cloud — Part 1

4.1 Cloud Modernization and Migration 4.2 Computing in the Cloud 4.3 Serverless Computing

6 Modernize Infrastructure and Applications with Google Cloud — Part 2

4.4 Containers in the Cloud 4.5 The Value of APIs 4.6 Hybrid and Multi-Cloud

7 Trust and Security with Google Cloud

5.1 Trust and Security in the Cloud 5.2 Google's Trusted Infrastructure 5.3 Google Cloud's Trust Principles and Compliance 5.4 Google Threat Intelligence, Security Command Center, and Google SecOps 5.5 Securing the AI Stack: AI Protection, Model Armor, and Zero Trust

8 Scaling with Google Cloud Operations

6.1 Financial Governance and Managing Cloud Costs 6.2 Operational Excellence and Reliability at Scale 6.3 Sustainability with Google Cloud 6.4 Cloud Observability, SLIs, SLOs, and the Four Golden Signals

4.4 Containers in the Cloud

Key Takeaways Explain This Topic AI

Containers package an application and its dependencies together, delivering portability, fast startup, high density, and consistent behavior across development and production environments

Virtual machines virtualize the hardware (each VM ships a full guest OS), while containers virtualize the OS kernel, making containers lighter, faster to start, and far more dense than VMs

Microservices decompose a monolith into independently deployable services, enabling independent scaling, technology flexibility, fault isolation, and faster, safer releases

Google Kubernetes Engine (GKE) provides managed Kubernetes for complex microservice architectures needing full orchestration control; Cloud Run provides serverless container execution with scale-to-zero and no cluster operations

Choose GKE for complex, long-running microservice platforms and team-operated clusters; choose Cloud Run for simple, event-driven, or spiky container workloads where you want zero infra management

Last updated: August 2026

Advantages of Modern Cloud Application Development

Modern cloud application development reframes how teams build, ship, and operate software. Instead of monolithic applications tied to specific servers and long release cycles, cloud-native development uses small, independent components, automation, and managed platforms to ship features faster and more safely.

The core advantages include:

Delivery velocity — Small, independent components and automated continuous integration / continuous deployment (CI/CD) pipelines let teams ship features in hours or days rather than quarterly releases.

Environment parity — The same artifact (for example, a container image) runs unchanged on a developer laptop, a staging cluster, and production, eliminating "works on my machine" defects.

Portability — Cloud-native artifacts are designed to run across environments and even across clouds, reducing vendor lock-in.

Independent scaling — Components scale to demand individually instead of scaling an entire monolith, which lowers cost.

Resilience — Failures in one component are isolated from the rest of the system, so a single bad service does not take down the whole application.

Operational leverage — Managed services and automation handle undifferentiated heavy lifting (patching, backups, scaling), freeing engineers for product work.

Virtual Machines vs. Containers

A virtual machine (VM) is a virtualized computer that includes a full guest operating system (OS) plus the application. A container is a packaged application plus its dependencies that shares the host OS kernel rather than running its own.

  • Dimension Virtual Machines Containers
  • Isolation level Hardware-level (hypervisor) OS-level (kernel shared)
  • Resource overhead High — full guest OS per VM Low — only app libraries packaged
  • Startup time Minutes (boot full OS) Seconds or milliseconds
  • Density Low (few VMs per host) High (hundreds of containers per host)
  • Portability Portable but heavy Highly portable across environments
  • OS sharing Each VM runs its own OS Containers share the host kernel
  • Use case Strong isolation, legacy apps Cloud-native microservices

VMs remain valuable when you need strong isolation, a different OS family, or to lift-and-shift a legacy application unchanged. Containers are the better fit when you want speed, density, portability, and a clean target for microservice architectures.

Benefits of Containers and Microservices for Application Modernization

Containers and microservices work together to modernize monolithic applications.

A microservice is a small, independently deployable service that owns its own data and implements one business capability. A monolith, by contrast, packages every feature of an application into a single deployable unit.

The combined benefits:

Independent deployment — Each microservice ships on its own cadence, so teams can release features without coordinating a full-application deploy.

Independent scaling — Only the service under load scales, instead of the whole application, which reduces cost.

Technology flexibility — Each service can use the language, framework, and datastore best suited to its job rather than a single stack across the whole monolith.

Fault isolation — A crash in the recommendation service does not take down the checkout flow.

Faster, safer releases — Smaller changesets mean smaller blast radius and easier rollback.

Team autonomy — Different teams own different services, reducing coordination overhead.

Containers are the ideal packaging format for microservices because they bundle each service with exactly the libraries it needs and run identically in every environment.

Deploying Containers on Google Cloud: GKE vs. Cloud Run

Google Cloud offers two primary platforms for running containers: Google Kubernetes Engine (GKE) and Cloud Run . GKE is sometimes abbreviated K8s orchestration as a managed service; Cloud Run is a serverless container platform.

Google Kubernetes Engine (GKE)

GKE is Google's managed Kubernetes service. Kubernetes is the industry-standard open-source container orchestration system. GKE removes the operational burden of managing the Kubernetes control plane while giving you full control over clusters, nodes, networking, and workloads.

GKE is the right choice when you need:

  • Full Kubernetes API compatibility and control
  • Complex microservice architectures with advanced routing, service meshes, and policy enforcement
  • Custom cluster sizing, node pools, and GPU/TPU workloads
  • Stateful workloads and persistent storage orchestration
  • A single platform to run many teams' workloads with strong multi-tenancy

GKE comes in two flavors: Autopilot , where Google manages the cluster and nodes for a serverless-like experience, and Standard , where you manage the node infrastructure yourself for more control.

Cloud Run

Cloud Run is a serverless container execution platform. You hand Google a container image and it runs, scales, and meters it. There are no clusters to provision, patch, or upgrade — Google handles all of it.

Cloud Run is the right choice when you need:

  • Simple, event-driven, or HTTP-driven container workloads
  • Scale-to-zero so you pay nothing when there is no traffic
  • Fast time-to-market without Kubernetes expertise
  • Automatic, granular scaling per request
  • Easy integration with Cloud Build, Eventarc, and Cloud Tasks
  • Use-Case to Product Decision Guide
  • Use Case Recommended Product Why
  • Complex microservice platform with service mesh and multi-tenancy GKE Full orchestration control
  • Long-running services with predictable load and custom node tuning GKE Standard Control over nodes and pools
  • Small team wanting K8s without node management GKE Autopilot Managed nodes, K8s compatibility
  • HTTP API with spiky, unpredictable traffic Cloud Run Scale-to-zero, per-request scaling
  • Event-driven image processing triggered by Cloud Storage Cloud Run Native event integration
  • Batch job that runs for a few minutes a day Cloud Run No idle cost when not running
  • Stateful service needing persistent volumes and fine control GKE Rich storage and scheduling

The practical rule: start with Cloud Run for simplicity and cost control; choose GKE when you outgrow serverless or need Kubernetes-specific features such as service meshes, custom controllers, or fine-grained workload scheduling.