Google ACE Practice Question: A Cloud Run service calls external third-party…

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

• ✗

  Set Cloud Run max-concurrency to 1 so each instance handles one request

  Why it's wrong here

  Setting Cloud Run max-concurrency to 1 means each instance can handle only one request at a time, which forces the autoscaler to instantiate more instances to accommodate the same request volume. With each instance running its own copy of the application logic and making its own third-party API calls, the total number of outbound calls actually increases due to duplicated requests across instances. This magnifies the problem by multiplying the number of cold instances and independent API calls. It does nothing to reduce the number of calls per request, so it is the opposite of the desired effect.

• ✓

  Cache third-party API responses in Cloud Memorystore (Redis) with appropriate TTL

  Why this is correct

  Caching third-party API responses in Cloud Memorystore (Redis) with an appropriate TTL is the correct solution because Memorystore is a shared, in-memory data store accessible to all Cloud Run instances. When one instance fetches a third-party response and caches it, subsequent requests from any instance can read the cached value, eliminating redundant outbound API calls and reducing both latency and API consumption. Setting a TTL (e.g., 60 seconds) balances data freshness with cache hit ratio, directly addressing the root cause of duplicate external requests. This is particularly effective for high-traffic services where the same third-party data is requested repeatedly.

• ✗

  Enable Cloud CDN on the Cloud Run service to cache outbound requests

  Why it's wrong here

  Enabling Cloud CDN on the Cloud Run service only caches responses to inbound client requests that pass through the CDN before reaching Cloud Run. It has no visibility into outbound requests that Cloud Run instances make to third-party APIs, because those connections originate from inside the Google network and never traverse the CDN edge. Therefore, Cloud CDN cannot reduce the number of outbound third-party API calls; it would merely serve cached HTTP responses to your own users. The correct approach for outbound caching is a shared distributed cache like Cloud Memorystore.

• ✗

  Migrate to Cloud Functions with a lower default concurrency limit

  Why it's wrong here

  Migrating to Cloud Functions with a lower default concurrency limit changes the execution model but does not alter the fact that every request still triggers a third-party API call unless responses are cached. A lower concurrency limit simply increases the number of function instances running in parallel, which can lead to even more duplicate outbound calls. The root cause—repeated identical API calls for the same data—remains untouched by migration or concurrency tuning. Only a shared cache, such as Cloud Memorystore, addresses the root cause by allowing multiple instances to reuse previously fetched responses.

Go deeper

Related to this question