GCP Professional Cloud Architect Practice Test

The workload needs a fully managed, POSIX-compliant file system that can be mounted simultaneously by thousands of containers and deliver very high IOPS for small-file access. Filestore High Scale SSD is purpose-built for exactly this pattern, offering tens of GB/s throughput and hundreds of thousands of IOPS with immediate consistency. Cloud Storage classes are object stores lacking shared POSIX semantics. Cloud SQL and Bigtable are databases, not file systems, and using per-node persistent disks with manual synchronization would add complexity and likely bottleneck on I/O.

Using Apigee X addresses every stated need. You can deploy Apigee's runtime in a Google-managed project and connect it privately to the on-premises API through Cloud VPN or Cloud Interconnect, ensuring the legacy service is never directly exposed to the internet. External partners call an Apigee-managed HTTPS endpoint, while Apigee policies provide OAuth 2.0 enforcement, partner-specific quota management, and rich usage analytics without any code changes. Re-implementing the API on Cloud Functions would require redevelopment effort and a full migration. Forwarding traffic with an external TCP load balancer plus Cloud NAT would still leave OAuth, quota enforcement, and analytics to be implemented in the application stack, increasing maintenance. VPC Network Peering cannot make a private address reachable to an external partner and offers no API management features. Therefore, the Apigee-based approach is the only solution that satisfies all security and governance requirements while keeping operational overhead low.

Running the workload as Kubernetes CronJobs on a GKE Standard cluster whose sole node pool uses Compute Engine Spot VMs delivers the largest discount while still satisfying operational and technical constraints:

− GKE Standard supports creating node pools backed entirely by Spot VMs, which are up to 91% cheaper than regular on-demand VMs. When a Spot VM is preempted, the node pool's autoscaler automatically provisions a replacement, and the Kubernetes control plane reschedules the interrupted pods. Because the Spark job checkpoints to Cloud Storage every 10 minutes, the job can restart and still meet the four-hour SLA. − Nodes in the pool can be created without external IP addresses and reach the internet (if needed) through Cloud NAT, satisfying the no-public-IP requirement. − The Cloud Storage FUSE CSI driver (or gcsfuse in a container image) lets pods mount the bucket exactly as on the current VMs, so no code changes are required.

The other options fail to meet one or more constraints:

• A GKE Autopilot cluster does not allow you to specify Spot or preemptible capacity; although Google may run Autopilot on discounted infrastructure, pods are not exposed to preemption and the pricing discount is smaller, so cost-saving potential is lower.
• Migrating to Cloud Run jobs removes the ability to use gcsfuse mounts and may exceed CPU-second quotas, risking the four-hour SLA.
• Converting the existing MIG to Spot VMs keeps costs down, but you must build custom logic for instance replacement, health checks, and job restarts, increasing operational overhead compared with Kubernetes' built-in rescheduling.

Migration Center's discovery client (also called the MigrateOps Agent) can be installed on each VM to collect hardware, software, and process information. When network profiling is enabled, the agent records inbound and outbound connections over time, producing a traffic graph that identifies service dependencies. Running the profiling for at least one representative business cycle (often one to two weeks) is recommended to capture periodic spikes such as month-end jobs. Importing a static CMDB, relying only on firewall logs, performing one-time port sweeps, or using the Application Migration Service agent alone will not reliably reveal transient or east-west dependencies, risking missed links and poorly sequenced migration waves.

Editing the existing HTTPS rule so that it no longer allows all sources removes direct internet access while keeping the rule count low. Adding a separate SSH allow rule lets the operations subnet connect. Because the default-allow-internal rule (priority 65534) would still permit other RFC 1918 ranges, creating a targeted deny-all ingress rule with a lower priority number than 65534 ensures every packet not matched by the two precise allow rules is dropped only for VMs that carry the web-frontend tag. Other prod-vpc workloads keep using default-allow-internal because the new rules match only the tagged web servers. Deleting default-allow-internal (or relying on Cloud Armor) would risk breaking other internal traffic, and moving the servers to a new subnet is a larger change than required.

Chaos engineering is distinguished by the intentional and well-controlled introduction of failures or abnormal conditions while the team observes whether the application continues to meet its defined "steady-state" behavior. The purpose is to surface hidden weaknesses before they cause outages in production. Merely replaying peak traffic, performing canary releases, or running capacity-planning exercises can all improve reliability, but none of those activities purposefully inject faults to verify resilience, so they are not considered chaos engineering.

A single custom-mode Shared VPC hosted in a central project meets all stated goals. Because a VPC network is a global resource, subnets created in multiple regions share one private address space, and instances in those subnets can reach each other over Google's private backbone using internal IPs. Attaching the product teams' projects as service projects places their resources in the shared network while letting them keep separate billing and IAM boundaries. Central admins manage routes and firewall rules in the host project. This architecture uses no VPC peering links, so it cannot hit the peering-link quota.

The other options either create independent VPCs that must be interconnected with VPC Network Peering or Cloud VPN/Interconnect, adding operational overhead and consuming peering links or tunnel/quota, and they do not provide a single centrally managed network.

The Cost Optimization pillar focuses on continuously measuring, monitoring, and right-sizing resource usage so you pay only for what you actually need. Exporting Recommender data lets you programmatically surface idle or over-provisioned resources, and an automated workflow can apply rightsizing or turn off unused instances. Billing reports then verify the realized savings. The other options map to different Well-Architected pillars: autoscaling emphasizes reliability, over-provisioning for future growth targets performance optimization, and VPC Service Controls address security and compliance rather than direct cost reduction.

To satisfy the requirements:

• Global low-latency access and automatic cross-regional failover are provided by a global external HTTP(S) load balancer that can route traffic to multiple back-end regions.
• Flash-sale spikes are handled by Cloud Run, whose fully managed, serverless containers scale automatically from zero to thousands of instances with no capacity pre-provisioning.
• Google Cloud's global load-balancing edge mitigates large-scale L3/L4 DDoS attacks, while Cloud Armor security policies supply additional Layer 7 filtering for application-level threats.
• A multi-region Cloud Spanner instance supplies externally consistent, strongly consistent reads and writes across regions and continues serving during a regional outage.
• Both Cloud Run and Cloud Spanner are managed services, minimizing operational overhead.

The remaining designs fail key requirements: a single-region GKE/Cloud SQL deployment cannot survive a regional outage; Compute Engine managed instance groups with Bigtable do not provide global strong consistency and require significant capacity management; App Engine with Firestore in Datastore mode offers only eventual consistency. Therefore, deploying Cloud Run in multiple regions behind a global external HTTP(S) load balancer with Cloud Armor, backed by a multi-region Cloud Spanner database, is the only option that meets all objectives.

A multi-region Cloud Spanner instance (for example, the nam-eur3 configuration) automatically replicates data across multiple regions and uses synchronous Paxos commits to provide global strong consistency with an effective recovery point objective of zero and a 99.999 % availability SLA, meeting the RPO 0 / low-RTO requirement even during a regional outage. Spanner's horizontal scaling, automatic sharding, and online schema changes minimize operational overhead.

Cloud SQL with cross-region replicas is limited to a single primary region, offers only asynchronous replication (non-zero RPO) and requires manual sharding to scale. Cloud Bigtable provides petabyte scale and multi-cluster replication but is not relational and only guarantees eventual consistency for cross-region writes, so it cannot meet ACID requirements. Self-managed MySQL on Compute Engine imposes significant operational burden and uses asynchronous replication, resulting in data loss risk during regional failures. Therefore, a multi-region Cloud Spanner deployment is the only option that fulfills all stated requirements.

Running Cloud Workstations with the Cloud Code plugin lets developers access Gemini Code Assist for real-time completions and inline security recommendations while editing, without moving code outside the project. Adding a dedicated Cloud Build step that programmatically invokes the same Gemini model under the default Cloud Build service account lets the team prompt the model (for example, to scaffold unit tests or suggest refactors) during CI; all artifacts remain inside the project, and no third-party SaaS or out-of-region service is used. The other approaches either export code to external providers, run in regions that violate compliance, or transmit artifacts outside the project boundary, contradicting the stated constraints.

Using two Apigee organizations, each in its own Google Cloud project, gives hard separation of IAM policies, runtime quotas, and billing. Each organization contains one Apigee instance whose runtime nodes live in a dedicated VPC network (apigee-prod-vpc and apigee-nonprod-vpc). Peering each runtime VPC only with the corresponding service VPC lets the instance reach the private GKE clusters without exposing them publicly and avoids transitive connectivity between environments. Because Apigee X automatically manages the runtime VPCs, the only operational task is creating the two peering connections, so administration remains simple. The alternative designs either mix prod and non-prod traffic in the same Apigee org (reducing quota/ IAM isolation), rely on firewall rules alone without VPC peering (backend cannot be reached from a private Apigee runtime), or attempt to reuse a single runtime VPC for both instances (violates hard separation and introduces overlapping-IP risk).

End-to-end integration testing validates how independently built services work together by exercising real network calls and data contracts between them in an environment that mimics production. This exposes schema or protocol mismatches that are invisible to unit or component-level functional tests. Static application security testing focuses on code vulnerabilities, not cross-service compatibility. Component-level functional tests already exist and test logic in isolation, so they will not reveal integration bugs. Stress or load tests measure performance and scaling behaviour but do not ensure that services exchange data correctly. Therefore, introducing automated integration tests that spin up all dependent microservices in an ephemeral environment is the most effective way to catch the observed issues early.

A personal Google Account represents an individual human user and can be granted IAM roles directly. Granting the Logs Viewer role to Alice's Gmail-based Google Account lets her authenticate interactively with her own credentials, leverage Google's security features such as 2-Step Verification, and avoids distributing long-lived shared secrets. Service accounts are intended for non-human workloads, and sharing their keys violates best practices. A Google Group is primarily for aggregating multiple principals, not for a single external tester, and would still require managing membership. Workload identity federation issues short-lived credentials for external workloads, not for interactive console sessions by a human tester, and adds unnecessary complexity for a short engagement.

A bucket-level retention policy set to seven years enforces an immutable hold on every object: no one-including project owners-can delete or overwrite data until the retention period expires. Locking the policy makes it permanent and prevents privileged users from shortening or disabling it, satisfying the "must not be able to bypass" constraint. When the retention window elapses, the objects become eligible for deletion; a complementary Object Lifecycle Management rule that deletes objects whose age exceeds 2,555 days (~7 years) will automatically clean them up, eliminating manual effort. Enabling only versioning plus a lifecycle rule does not stop an administrator from deleting all versions ahead of schedule. Simply switching to the Archive class offers lower cost but no enforced retention. Default event-based holds still require someone to release the holds manually, so they do not ensure automatic deletion and introduce operational overhead. Therefore, applying and locking a seven-year retention policy and adding an age-based lifecycle delete rule is the correct approach.

Within the Google Cloud Well-Architected Framework, reliability is defined as the ability of a system to perform its required functions under stated conditions for a specified period. This wording highlights three key aspects that an SLO must capture: (1) correct functioning (the service does what users expect), (2) within declared operating conditions (such as load, dependencies, or infrastructure health), and (3) over a defined time window. Merely stating that the service is reachable describes availability, not full reliability. Focusing on data survival describes durability, and focusing on scaling or latency describes performance or elasticity. Therefore, the only option that aligns with the framework's definition of reliability is the statement that emphasizes sustained ability to meet functional requirements under specified conditions for a period of time.

Partner Interconnect lets a customer obtain private connectivity to Google through a service provider without installing equipment in a colocation site. When two VLAN attachments are placed in independent Partner Interconnect locations, Google provides a 99.9 % SLA for each attachment. Two 5 Gbps attachments satisfy the 10 Gbps throughput goal and can usually be provisioned quickly by the partner. Dedicated Interconnect requires physical cross-connects in a colocation facility that the company does not have and commonly takes longer to provision, although it offers a higher (99.99 %) SLA. HA VPN travels over the public internet and provides no bandwidth guarantees, while Private Service Connect exposes specific services rather than general network connectivity. Therefore, redundant Partner Interconnect VLAN attachments are the most suitable choice.

A service perimeter created with VPC Service Controls prevents BigQuery data from being read by resources that are outside the perimeter, even when IAM permissions are misconfigured, thereby blocking cross-project exfiltration. When you attach an Access Context Manager access level that requires requests to originate from company-managed devices, BigQuery queries succeed only from compliant laptops. Identity-Aware Proxy cannot front BigQuery, organization policies cannot stop BigQuery cross-project export, and hierarchical firewall rules are effective only for network traffic to or from VM instances, not for server-to-service API calls such as BigQuery.

Cloud Run (fully managed) provides a 99.95 % monthly availability SLA per region and completely abstracts VM management, so there is no operating-system patching burden. Deploying the service as a container to Cloud Run in more than one region and fronting it with the platform's global external HTTP(S) load balancer delivers cross-regional failover that meets the 99.95 % availability target. Setting a single minimum instance in each region keeps idle-time charges very low because additional instances are started only when traffic increases.

Using preemptible or spot VMs in regional managed instance groups reduces cost but offers no availability SLA and still requires image maintenance. GKE Autopilot reduces some operational work but incurs higher baseline costs than Cloud Run and still needs cluster management. App Engine flexible requires per-instance billing even when idle, so its steady-state cost is higher than Cloud Run with minimal instances. Therefore, the Cloud Run approach offers the required availability and operational simplicity at the lowest steady-state cost.

CogniPort is designed to parse build and test error output and generate automated remediation suggestions-such as updated dependency declarations or corrected test stubs-based on each run's logs. Adding a post-build CogniPort step inside the current Cloud Build pipeline lets it analyze every compilation and test log, open pull requests with proposed fixes, and keep the normal code-review workflow intact, thereby accelerating recovery from failures without changing the team's build system. Although CogniPort's native build service could also speed recovery, that approach would replace Cloud Build, contradicting the stated requirement. Running CogniPort only once or invoking it during kubectl apply would not provide continuous, code-level remediation.