Study Google Cloud ACE Serverless Apps: key concepts, common traps, and exam decision cues.
This lesson is about knowing when Google Cloud’s managed serverless runtimes are a better fit than VMs or full Kubernetes. ACE expects you to separate container-serving needs from function-style event handling.
Event-driven application: App path that runs because an event occurred, such as a Pub/Sub message or object change notification.
Revision: Deployed Cloud Run version that can receive traffic independently from other versions.
Cloud Run functions: Current Google Cloud managed functions path. Older material may still say Cloud Functions.
ACE wants you to separate:
This page is mainly about service fit. Questions about rollout percentages or revision traffic control belong later in the Cloud Run operations lane.
| If the question is mainly about… | Strongest first lane |
|---|---|
| a containerized app that should run on a fully managed serverless platform | Cloud Run |
| small code that should react to events like Pub/Sub or storage changes | Cloud Run functions |
| avoiding VM or cluster management for request-driven app code | Cloud Run |
| event-triggered code path without managing long-running servers | Cloud Run functions |
| Question | Cloud Run | Cloud Run functions |
|---|---|---|
| Main purpose | run containerized services | run function-style code in response to events or lightweight HTTP triggers |
| Strongest first when | the workload is clearly a containerized application | the workload is best expressed as a function handler |
| Common trap | treating every event-driven requirement as a container-service problem | treating every containerized web app as a function |
Google Cloud now treats functions as the Cloud Run functions family, so the real exam skill is still the same: recognize when the workload is a function-shaped event handler and when it is a fuller service-shaped application.
flowchart LR
A["Storage or Pub/Sub event"] --> B["Cloud Run functions handler"]
C["HTTP request"] --> D["Cloud Run service"]
That is the fastest split to keep in your head. If the trigger is an event and the work is lightweight and handler-shaped, the function lane becomes strong. If the workload is a containerized service responding to normal requests, Cloud Run is the stronger first answer.
| Trap | Better reading |
|---|---|
| “Serverless means Cloud Run and functions are interchangeable.” | ACE usually wants you to distinguish a containerized service from an event-driven handler. |
| “If it uses containers, it must go to GKE.” | Cloud Run is often the stronger fit when the stem wants managed serverless container execution. |
| “Any event means Pub/Sub is the whole answer.” | Pub/Sub can be the trigger, but the runtime choice still matters. |
| “Cloud Functions is a different exam topic from Cloud Run functions now.” | Older wording persists, but the practical service-fit reasoning is the same. |
A team needs a small handler that should run when an object lands in Cloud Storage, and they do not want to manage servers or package a larger containerized web service. Which lane is strongest first?
Correct answer: B. The requirement is an event-driven handler, not a long-running server or VM fleet.