Free Google Apigee-API-Engineer Actual Exam Questions - Question 2 Discussion
back-end system for a new API runs in both data centers You want to implement a proxy that handles
failover between these data centers What should you do?
Makes sense to avoid relying on health checks, so C.
This one’s tricky but I’d go with C here. Using two service callouts lets you explicitly control the order of calls and handle failures more granularly without relying on LoadBalancer health checks that the question doesn’t mention. It feels more straightforward for guaranteed failover. D sounds nice but without info on health checks it could just end up retrying blindly. B is clean but depends on FaultRules which might not be as flexible if you want to add logic later. So, I’d say C makes the failover explicit and manageable.
B imo since FaultRule is straightforward and handles failover cleanly without extra setup.
B makes sense since it uses a FaultRule to handle failure without extra code.
D feels right since it leverages built-in failover with fallback targets, no custom code needed. D
It’s D because setting up Target Servers with a LoadBalancer and using the Is Fallback property is a cleaner, built-in way to manage failover. Unlike A or C, which rely on manual callouts and extra logic, D uses Apigee’s native features to handle it more seamlessly. B depends heavily on fault rules which might introduce unnecessary latency when failing over. Plus, with D you get better control over routing between datacenters without complicating the proxy flow. This approach feels more robust for hot-warm setups where failover needs to be automatic and transparent.
This one’s tricky, but I think D makes the most sense. Setting up Target Servers for each datacenter and using a LoadBalancer with the fallback flag sounds like it handles failover more cleanly by automatically switching when the hot datacenter is down. A and C feel too manual or complicated, and B’s FaultRule might not be as seamless or automatic, which could cause delays during failover. D should give better resilience without extra coding or complex callouts.
B/D? B seems simpler, but D gives more control with automatic fallback handling.
Option A feels too manual with Java code, which can get complex and harder to maintain. FaultRules or LoadBalancer-based fallback seem more efficient for automatic failover.
B imo, using a FaultRule to switch targets on failure feels cleaner and more straightforward than juggling multiple callouts or Java code. It fits the failover use case neatly.
Makes sense to use load balancing with a fallback option here, so I’d go with D for handling failover smoothly.