Prepare and test your skills
Prepare and test your skills
Free sample question, answered and explained below. The Professional Cloud Architect practice bank has 2,335 more like it. Try 10 free: instant score, no account.
An enterprise operates an on-premises monolithic application running on virtual machines. The application consists of a public HTTP web frontend with unpredictable traffic spikes, along with a stateful inventory backend that requires specialized operational controls and custom storage configurations. Deployments currently suffer from long lead times, and resource utilization is inefficient because compute capacity must remain over-provisioned to handle peak traffic.
You are tasked with architecting a cloud-first modernization strategy on Google Cloud that refactors the architecture into cloud-native patterns to enhance agility, enable fine-grained autoscaling, and optimize compute resources.
Which refactoring strategy should you recommend?
This strategy decomposes a monolithic application into loosely coupled microservices by aligning specific application tiers with the most suitable cloud-native container execution environments. The user-facing HTTP components are refactored into stateless containers deployed to Cloud Run, while complex, stateful components are isolated and hosted on Google Kubernetes Engine (GKE).
Mixing Cloud Run for stateless HTTP microservices with GKE for stateful or orchestrator-dependent services is the recommended Google Cloud pattern for modular application modernization. It leverages serverless agility where elasticity is needed while retaining deep Kubernetes control where complex storage and operational configurations are required.
This strategy encapsulates an entire monolithic multi-tier application stack (frontend, backend, and background processes) into a single, bulky container image and executes it directly on a Compute Engine virtual machine instance.
The workload were a legacy monolithic utility application intended for a short-term development sandbox with zero high-availability or autoscaling requirements.
This option proposes rewriting every monolithic component into fine-grained Cloud Run functions (formerly Cloud Functions) while attempting to rely on the local runtime container's in-memory state to persist inventory session data across invocations.
concurrency = 1 or limited request scopes), which can be inefficient for sustained complex transactions.The workload consisted purely of independent, short-lived, event-triggered background tasks (such as processing an image upload or reacting to a Cloud Storage notification) with fully externalized state.
This approach represents a rehosting (lift and shift) or basic replatforming strategy. It packages the existing monolithic application VMs into Compute Engine custom images and deploys them across Compute Engine Managed Instance Groups (MIGs) with VM-level autoscaling policies.
The goal were an immediate, minimal-effort lift-and-shift migration without code modifications, or if the application depended on legacy kernel modules and third-party software that cannot be containerized.
Answer them yourself and get your score the moment you finish. No account needed.
Full access includes
Keep the momentum going with these hand-picked practice scenarios
Last updated Validated