Study guide

4.1 Choosing the Right Compute Option: GCE vs. GKE vs. Cloud Run vs. Cloud Functions

Google Cloud Associate Cloud Engineer ACE

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Introduction & Exam Overview

1.1 About the GCP Associate Cloud Engineer Exam 1.2 How to Use This Study Guide & Build a Study Plan

2 Chapter 2: Resource Hierarchy, IAM Basics & Cloud Identity

2.1 The GCP Resource Hierarchy: Organizations, Folders & Projects 2.2 Organization Policies & Granting IAM Roles 2.3 Cloud Identity: Managing Users and Groups

3 Chapter 3: APIs, Quotas & Billing Configuration

3.1 Enabling APIs and Provisioning Cloud Operations Suite 3.2 Assessing and Requesting Quota Increases 3.3 Billing Accounts, Project Linking & Billing Exports 3.4 Billing Budgets and Alerts

4 Chapter 4: Planning Compute & Storage Resources

4.1 Choosing the Right Compute Option: GCE vs. GKE vs. Cloud Run vs. Cloud Functions 4.2 Spot VMs, Custom Machine Types & Cost-Optimized Compute Planning 4.3 Choosing a Data Storage Product: Cloud SQL, BigQuery, Firestore, Spanner & Bigtable 4.4 Cloud Storage Classes & Persistent Disk Types

5 Chapter 5: Planning Network Resources

5.1 Load Balancing Options and Use Cases 5.2 Regional Resource Placement & High Availability Planning 5.3 Network Service Tiers: Premium vs. Standard

6 Chapter 6: Deploying Compute Engine Workloads

6.1 Launching Compute Engine Instances: Disks, SSH Keys & Availability Policies 6.2 Managed Instance Groups, Instance Templates & Autoscaling 6.3 OS Login and VM Manager for Fleet Configuration

7 Chapter 7: Deploying Google Kubernetes Engine Workloads

7.1 Installing and Configuring kubectl 7.2 Deploying GKE Clusters: Autopilot, Regional, Private & GKE Enterprise 7.3 Deploying Containerized Applications to GKE

8 Chapter 8: Deploying Serverless & Event-Driven Applications

8.1 Deploying Applications to Cloud Run and Cloud Functions 8.2 Event-Driven Architectures: Pub/Sub, Cloud Storage Triggers & Eventarc

9 Chapter 9: Deploying Data Solutions

9.1 Deploying Data Products: Cloud SQL, Firestore, Spanner, BigQuery & AlloyDB 9.2 Deploying Pub/Sub, Dataflow & Loading Data into Google Cloud

10 Chapter 10: Deploying Networking Resources & Infrastructure as Code

10.1 Creating VPCs, Subnets & Shared VPC 10.2 Firewall Rules, Cloud VPN & VPC Network Peering 10.3 Infrastructure as Code: Terraform, Config Connector, Cloud Foundation Toolkit & Helm

11 Chapter 11: Managing Compute Engine & GKE in Production

11.1 Connecting to and Managing Running Compute Engine Instances 11.2 Working with Snapshots and Custom Images 11.3 Managing GKE Clusters: Node Pools, Workloads & Artifact Registry Access 11.4 Horizontal and Vertical Pod Autoscaling in GKE

12 Chapter 12: Managing Cloud Run, Storage & Database Operations

12.1 Managing Cloud Run Revisions, Traffic Splitting & Scaling 12.2 Managing and Securing Cloud Storage Objects & Lifecycle Policies 12.3 Querying, Estimating Costs, Backup & Job Monitoring for Databases (Cloud SQL, BigQuery, Spanner, Dataflow)

13 Chapter 13: Networking Operations, Monitoring & Logging

13.1 Networking Operations: Subnets, Static IPs, Cloud DNS & Cloud NAT 13.2 Cloud Monitoring: Alerts, Custom Metrics & Dashboards 13.3 Cloud Logging: Buckets, Log Analytics, Routers & Filtering 13.4 Diagnostics, Ops Agent, Managed Service for Prometheus & Audit Logs

14 Chapter 14: IAM Policies & Role Types

14.1 IAM Policies: Structure, Bindings & Policy Hierarchy 14.2 IAM Role Types: Basic, Predefined & Custom Roles

15 Chapter 15: Service Accounts & Security Configuration

15.1 Creating Service Accounts & Assigning Least-Privilege Permissions 15.2 Assigning Service Accounts to Resources & Managing SA IAM Policies 15.3 Service Account Impersonation & Short-Lived Credentials

16 Chapter 16: Exam Readiness — Scenarios & Test-Day Strategy

16.1 Common ACE Exam Scenarios & Decision Frameworks 16.2 Test-Day Logistics, Time Management & Final Review Checklist

4.1 Choosing the Right Compute Option: GCE vs. GKE vs. Cloud Run vs. Cloud Functions

Key Takeaways Explain This Topic AI

Compute Engine (IaaS VMs) is billed per second for provisioned resources regardless of use; it is the right choice for legacy OS/kernel/licensing constraints.

GKE is a managed Kubernetes control plane; choose it for multi-service, orchestration-heavy, or hybrid/multi-cloud container workloads.

Cloud Run is serverless container hosting for stateless HTTP(S) services, billed per request, with request timeouts up to 3,600 seconds (60 minutes).

Cloud Run functions is Google Cloud's FaaS product for single-purpose event/HTTP handlers, capped at 9 minutes for event triggers and 60 minutes for HTTP triggers.

The ACE exam tests this choice as a repeated scenario pattern: match workload shape (VM/container/function) and orchestration need to the simplest product that satisfies the constraints.

Last updated: July 2026

Why This Section Matters

The official ACE exam guide lists "Planning and configuring a cloud solution" as its own 17.5%-weighted section, and the very first bullet under it is selecting appropriate compute choices for a given workload . In practice this means the exam constantly hands you a one- or two-sentence scenario — a legacy Windows app, a stateless REST API, a Kubernetes-native microservice mesh, a function that resizes an uploaded image — and asks which Google Cloud compute product you would deploy it on. Getting this decision right (and fast) is one of the highest-leverage skills you can build for the ACE exam, because the same reasoning reappears throughout Domain 3 (deploying) and Domain 4 (operating) questions later in this guide.

The Four Core Compute Products

Compute Engine (GCE) is Google Cloud's Infrastructure-as-a-Service (IaaS) offering: virtual machines (VMs) you fully control, down to the kernel, OS image, and installed software. You are billed per second for the VM's provisioned vCPUs and memory whether or not the VM is actively doing work.

Google Kubernetes Engine (GKE) is a managed Kubernetes control plane and node-pool service. Kubernetes is a container-orchestration system that schedules, scales, and self-heals groups of containers (Pods). GKE is the right call when a workload is genuinely container-native, has multiple interacting services, needs advanced scheduling (affinity rules, DaemonSets, StatefulSets), or must run identically across on-premises, other clouds, and Google Cloud.

Cloud Run is a fully managed, serverless platform for stateless HTTP(S) containers. You supply any container image built from any language or runtime, and Cloud Run handles provisioning, scaling (including scale-to-zero when idle), and load balancing. Cloud Run is billed per request/per 100ms of CPU and memory actually used , not per provisioned instance-hour.

Cloud Run functions (the current name for what was previously branded Cloud Functions 2nd gen) is Google Cloud's Function-as-a-Service (FaaS) product: you write a single function and Google Cloud builds and runs the container for you, triggered by an HTTP request or an event (a new object in a Cloud Storage bucket, a Pub/Sub message, a Firestore write). It is built on the same underlying infrastructure as Cloud Run but optimized for single-purpose, short-lived, event-reactive code rather than general-purpose services.

Comparison Table

  • Dimension Compute Engine GKE Cloud Run Cloud Run functions
  • Abstraction level Full VM (IaaS) Managed Kubernetes Serverless container Serverless single function

You manage OS, patching, scaling Workload manifests (Autopilot also hides nodes) Container image only Function code only

Billing model Per-second, resource-based Per-node (Standard) or per-Pod (Autopilot) Per-request / CPU-time used Per-invocation / execution time

Scale to zero No No (Standard); yes for Pods on some setups Yes Yes

Best for Legacy apps, custom kernels, licensing tied to hardware, sole-tenant needs Multi-service container platforms, hybrid/multi-cloud portability Stateless HTTP APIs and web front ends Single-purpose event handlers

Max request/timeout N/A (always-on) N/A (app-defined) Up to 3,600 seconds (60 min) per request 60 min (HTTP triggers) / 9 min (event triggers)

A Simple Decision Framework

Work through these questions in order, and the right product usually falls out immediately:

Is the workload one small, single-purpose piece of code reacting to an event or a simple HTTP call, with no need to manage a container image yourself? Choose Cloud Run functions .

Is it a containerized, stateless HTTP(S) service (an API, a web app, a webhook receiver)? Choose Cloud Run — you get autoscaling and scale-to-zero without managing servers or a cluster.

Does the workload need multiple coordinated containers, custom scheduling, StatefulSets, GPUs/TPUs at fleet scale, service mesh, or the ability to run identically on-prem or in another cloud? Choose GKE .

Does it require full OS-level control, a specific kernel module, legacy or hardware-bound software licensing, or sustained, predictable throughput with no cold starts? Choose Compute Engine .

Realistic Exam Scenario

A company runs a monolithic .NET Framework application that checks a hardware dongle for its license and must run on a specific Windows Server build. It needs no autoscaling and runs 24/7. The correct answer is Compute Engine — the licensing and OS constraints rule out every serverless option, and there is no meaningful container-orchestration need that would justify GKE's operational overhead.

Contrast that with: "A team wants to run 12 microservices that must scale independently, communicate over gRPC, and eventually also run on AWS for disaster recovery." That combination — multiple services, advanced networking, multi-cloud portability — points straight at GKE , not Cloud Run, because Cloud Run does not give you the fine-grained scheduling or hybrid-cloud consistency Kubernetes manifests provide.

Common Traps

Assuming "serverless" always means Cloud Run functions. Cloud Run (the container product) is also serverless — the distinguishing question is single-function code versus a full container image.

Choosing GKE by default because it "can run anything." GKE is correct only when the scenario mentions genuine orchestration needs (multiple services, custom scheduling, hybrid/multi-cloud). If the scenario only describes one stateless container, Cloud Run is simpler and is very likely the intended answer.

Forgetting that Cloud Run functions event triggers cap out at 9 minutes — a scenario describing a long-running batch job (say, 30 minutes) triggered by a file upload is not a fit for an event-triggered function and should push you toward Cloud Run (up to 60 minutes) or a Compute Engine/Dataflow job instead.