mediumMultiple ChoiceObjective-mapped
Google ACE Practice Question: A startup is building a web application using…
A startup is building a web application using Cloud Run. They want to deploy multiple independent services that can communicate with each other internally, but each service should be deployed and scaled independently. Which deployment strategy should they use?
⚠ Common exam trap
Google Cloud often tests the misconception that Cloud Run supports multiple containers per service (like a pod in Kubernetes), but Cloud Run services are single-container per revision, and multiple containers require separate services or a different platform like Cloud Run for Anthos.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Create multiple Cloud Run services and use internal endpoints for communication
Cloud Run natively supports deploying multiple independent services, each with its own URL and scaling configuration. Internal communication between these services can be achieved using Cloud Run's built-in internal endpoints (e.g., using the `run.app` domain with internal traffic routing), which avoids exposing services to the public internet. This approach allows each service to scale independently based on its own request load, meeting the startup's requirement for independent deployment and scaling.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
Create multiple Cloud Run services and use internal endpoints for communication
Why this is correct
Each Cloud Run service is an independently managed, container-based microservice that autoscales from zero based on its own traffic, so building multiple services naturally satisfies the independent scaling and deployment requirement. Cloud Run provides internal HTTPS endpoints (such as the automatically generated per-service URL or requests routed through a VPC connector) that allow services to communicate without exposing traffic to the public internet. You can also use Cloud Run's service-to-service authentication to restrict calls between trusted services, ensuring secure and low-latency internal communication.
- ✗
Deploy the application to App Engine Standard Environment
Why it's wrong here
App Engine Standard is a separate serverless product that does not run arbitrary containers; it requires runtime-specific code (e.g., Python, Java) and has its own scaling model, so it cannot be used to deploy a Cloud Run application. Even though it can host independently scaling microservices, the startup's explicit requirement is to use Cloud Run, and App Engine's non-container execution environment, along with its different networking and versioning semantics, makes it an invalid replacement.
- ✗
Use a single GKE cluster with multiple deployments and services
Why it's wrong here
A single GKE cluster introduces shared control-plane overhead and node-pool coupling, violating the requirement that each service be deployed and scaled independently; scaling one deployment can starve others of cluster resources unless complex node auto-provisioning and resource quotas are meticulously configured. This option is tempting because GKE deployments and services natively handle internal service-to-service communication via DNS and ClusterIP, making it a natural choice for microservices that do not require strict independent scaling, where a unified cluster with careful resource management would suffice.
- ✗
Deploy a single Cloud Run service with multiple containers
Why it's wrong here
Cloud Run's service model is built around a single container image per revision, and while optional sidecar containers can be attached, they are tightly coupled and scale as one unit, not as independent microservices. Deploying all functionality as one Cloud Run service would force all containers into the same instance, sharing CPU, memory, and network resources, so one component's burst traffic could starve the others. This coupling directly contradicts the need for each service to be deployed and scaled independently.
Go deeper
Related to this question
Learn chapter
Google Cloud Platform Overview
Key term
Service
A service is a software component or system that performs a specific function and is available to be used by other programs or users over a network.
Key term
Cloud Run
Cloud Run is a fully managed compute platform from Google Cloud that lets you run containerized applications in a serverless environment, automatically scaling from zero to thousands of requests.
About these practice questions
One of 769 original ACE practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This ACE practice question is part of Courseiva's free Google Cloud certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the ACE exam.