You save $69.98
Professional Cloud Architect Premium Bundle
- Premium File 370 Questions & Answers
- Last Update: Nov 8, 2026
- Training Course 63 Lectures
- Study Guide 491 Pages
You save $69.98
A data science team builds a public web dashboard directly on a private VM and exposes SSH plus application ports to the internet for staff convenience. Which solution balances the business and technical requirements most defensibly?
The architecture should put the application behind Identity-Aware Proxy or another approved authenticated gateway and remove unmanaged public administration access. This addresses the scenario directly because an identity-aware access proxy authenticates users at the entry point; security depends on keeping direct bypass paths closed. The implementation is acceptable only if the team demonstrates: Authorized analysts reach the application through the identity gate, while unauthenticated requests and direct VM public exposure fail.
Move the dashboard behind a public load balancer but leave direct VM SSH open to all internet sources. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A data science team builds a public web dashboard directly on a private VM and exposes SSH plus application ports to the internet for staff convenience. The decisive dependency is that an identity-aware access proxy authenticates users at the entry point; security depends on keeping direct bypass paths closed. The better complete recommendation is: Put the application behind Identity-Aware Proxy or another approved authenticated gateway and remove unmanaged public administration access.
Rely only on VPC firewall source ranges for human dashboard authentication. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, an identity-aware access proxy authenticates users at the entry point; security depends on keeping direct bypass paths closed. The defensible decision is: Put the application behind Identity-Aware Proxy or another approved authenticated gateway and remove unmanaged public administration access. An implementation must be judged against: authorized analysts reach the application through the identity gate, while unauthenticated requests and direct VM public exposure fail.
Configure IAP on the load balancer but leave a bypass route directly to the application port. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A data science team builds a public web dashboard directly on a private VM and exposes SSH plus application ports to the internet for staff convenience. Put the application behind Identity-Aware Proxy or another approved authenticated gateway and remove unmanaged public administration access. is stronger because an identity-aware access proxy authenticates users at the entry point; security depends on keeping direct bypass paths closed. Source-case challenge: Enabling IAP but retaining direct VM ingress lets attackers bypass identity checks entirely.
A transactional app needs a backup plan with tested recovery and asks if a daily snapshot guarantees a 15-minute maximum data-loss objective. What is the most direct acceptance evidence for this design decision?
The acceptance evidence is: A controlled destructive test restores data within 15 minutes of the chosen failure time and records recovery duration. This validates the important boundary or service outcome rather than relying on a design assertion. The technical reason for requiring this evidence is: A daily backup can lose almost a full day's writes; a recovery point objective must match the actual restoreable transaction history.
A snapshot completed successfully the previous evening. That observation can be collected, but it does not exercise the service-level or security outcome named in the requirement. More direct end-to-end acceptance evidence is: A controlled destructive test restores data within 15 minutes of the chosen failure time and records recovery duration.
The restored database starts but no writes near the chosen outage time are reconciled. This is a limited configuration or proxy signal and could be green while the requested outcome still fails. A representative successful test instead requires: A controlled destructive test restores data within 15 minutes of the chosen failure time and records recovery duration. The causal issue is: A daily backup can lose almost a full day's writes; a recovery point objective must match the actual restoreable transaction history. Source-case challenge: A restored DB startup does not prove transaction state from fifteen minutes before failure is recoverable.
A backup dashboard stays green without a destructive restoration exercise. The outcome being observed is not equivalent to the original user requirement for a transaction, control or recovery property. The specific proof must show: A controlled destructive test restores data within 15 minutes of the chosen failure time and records recovery duration.
A deployment pipeline outside Google Cloud uses a downloadable long-lived service account key to write artifacts, and a developer accidentally commits the key to a public repository. Which unresolved concern deserves monitoring after the change?
A permissive federation attribute condition could still authorize a malicious branch or repository. Even when the immediate design intervention succeeds, a later condition can still invalidate its assumptions. This scenario requires monitoring that specific dependency rather than a generic project concern.
An external CI repository migration could require revalidating workload identity provider claims. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: A permissive federation attribute condition could still authorize a malicious branch or repository. The scenario is specifically: A deployment pipeline outside Google Cloud uses a downloadable long-lived service account key to write artifacts, and a developer accidentally commits the key to a public repository. Source-case challenge: An approved repository move needs remapping, but permissive federation trust can grant an attacker unauthorized impersonation directly.
An additional service account impersonation target could need a separate least-privilege review. It deserves normal operating controls, yet it is less directly evidenced by this case than: A permissive federation attribute condition could still authorize a malicious branch or repository. The relevant technical boundary is: Federated short-lived credentials reduce reusable secret exposure while principal and attribute restrictions define which external workload is trusted.
A provider certificate rotation might require updating pinned OIDC trust metadata. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. A permissive federation attribute condition could still authorize a malicious branch or repository is more specifically connected to the architecture because federated short-lived credentials reduce reusable secret exposure while principal and attribute restrictions define which external workload is trusted.
A multinational organization grants editor permissions at its organization root so application teams can deploy quickly, causing cross-business access. Which architecture recommendation best addresses the stated requirements and constraints?
The architecture should use the resource hierarchy to grant narrowly scoped roles at project or folder level and add conditions where justified. This addresses the scenario directly because inherited IAM roles extend downward in the hierarchy, so a broad organization-level binding creates reach far beyond the intended service. The implementation is acceptable only if the team demonstrates: A permission simulation confirms the app team can deploy only to its allowed project, with unrelated project changes denied.
Keep the organization-root Editor grant and add an activity dashboard for visibility. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A multinational organization grants editor permissions at its organization root so application teams can deploy quickly, causing cross-business access. The decisive dependency is that inherited IAM roles extend downward in the hierarchy, so a broad organization-level binding creates reach far beyond the intended service. The better complete recommendation is: Use the resource hierarchy to grant narrowly scoped roles at project or folder level and add conditions where justified.
Clone the same broad Editor role at every folder to make access reviews easier. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, inherited IAM roles extend downward in the hierarchy, so a broad organization-level binding creates reach far beyond the intended service. The defensible decision is: Use the resource hierarchy to grant narrowly scoped roles at project or folder level and add conditions where justified. An implementation must be judged against: a permission simulation confirms the app team can deploy only to its allowed project, with unrelated project changes denied. Source-case challenge: Duplicating Editor at each folder preserves cross-business overprivilege instead of minimizing resource scope.
Create one highly privileged shared app-team service account to bypass IAM inheritance complexity. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A multinational organization grants editor permissions at its organization root so application teams can deploy quickly, causing cross-business access. Use the resource hierarchy to grant narrowly scoped roles at project or folder level and add conditions where justified. is stronger because inherited IAM roles extend downward in the hierarchy, so a broad organization-level binding creates reach far beyond the intended service.
A document approval service runs on Cloud Run and has sporadic traffic; the first request after idle is too slow for a 300-millisecond interactive target. Which future condition could invalidate the proposed solution despite its initial success?
Sudden traffic beyond warm capacity can still cause new-instance startup and elevated tail latency. Even when the immediate design intervention succeeds, a later condition can still invalidate its assumptions. This scenario requires monitoring that specific dependency rather than a generic project concern.
The approval service could incur higher baseline cost from keeping its warm instance pool available. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: Sudden traffic beyond warm capacity can still cause new-instance startup and elevated tail latency. The scenario is specifically: A document approval service runs on Cloud Run and has sporadic traffic; the first request after idle is too slow for a 300-millisecond interactive target.
A dependency call may become slow despite otherwise stable container startup times. It deserves normal operating controls, yet it is less directly evidenced by this case than: Sudden traffic beyond warm capacity can still cause new-instance startup and elevated tail latency. The relevant technical boundary is: Keeping a minimum pool warm can reduce scale-from-zero startup latency, although it adds idle cost and does not cure slow request handlers. Source-case challenge: Dependency call delay can also hurt requests, but the documented cold first request leaves burst-created cold starts as direct residual.
Client-side JavaScript initialization could add latency outside Cloud Run's container cold start. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. Sudden traffic beyond warm capacity can still cause new-instance startup and elevated tail latency is more specifically connected to the architecture because keeping a minimum pool warm can reduce scale-from-zero startup latency, although it adds idle cost and does not cure slow request handlers.
An AI product team wants to add retrieval-augmented answers to a legal document portal, but it currently assumes a public text-generation endpoint can read all documents. What remaining exposure should the architecture review continue to track?
Prompt injection and hallucinated citations remain possible despite correct retrieval authorization. Even when the immediate design intervention succeeds, a later condition can still invalidate its assumptions. This scenario requires monitoring that specific dependency rather than a generic project concern.
A newer embedding model may change search relevance for authorized, nonconfidential documents. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: Prompt injection and hallucinated citations remain possible despite correct retrieval authorization. The scenario is specifically: An AI product team wants to add retrieval-augmented answers to a legal document portal, but it currently assumes a public text-generation endpoint can read all documents.
A summarization feature may format legal citations differently across model versions. It deserves normal operating controls, yet it is less directly evidenced by this case than: Prompt injection and hallucinated citations remain possible despite correct retrieval authorization. The relevant technical boundary is: A retrieval pipeline can leak restricted source documents unless the search index and tool calls enforce each user's entitlements.
Translation of specialist legal terms may require separate validation even when retrieval entitlements work. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. Prompt injection and hallucinated citations remain possible despite correct retrieval authorization is more specifically connected to the architecture because a retrieval pipeline can leak restricted source documents unless the search index and tool calls enforce each user's entitlements. Source-case challenge: Translation requires QA, but prompt injection and fabricated citations are specifically unresolved even after secure document retrieval.
A company shares Terraform state over email so two teams can apply incompatible production plans simultaneously. How should the team demonstrate the intended security or reliability outcome?
The acceptance evidence is: Two concurrent deployment attempts serialize safely; a policy-violating plan cannot apply and state access is audited. This validates the important boundary or service outcome rather than relying on a design assertion. The technical reason for requiring this evidence is: Concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials.
One team applies a small resource change successfully. That observation can be collected, but it does not exercise the service-level or security outcome named in the requirement. More direct end-to-end acceptance evidence is: Two concurrent deployment attempts serialize safely; a policy-violating plan cannot apply and state access is audited.
Two sequential applies pass, with no test of a concurrent lock attempt. This is a limited configuration or proxy signal and could be green while the requested outcome still fails. A representative successful test instead requires: Two concurrent deployment attempts serialize safely; a policy-violating plan cannot apply and state access is audited. The causal issue is: Concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials.
A state file exists in Cloud Storage but access and locking were never validated. The outcome being observed is not equivalent to the original user requirement for a transaction, control or recovery property. The specific proof must show: Two concurrent deployment attempts serialize safely; a policy-violating plan cannot apply and state access is audited. Source-case challenge: A state object existing in a bucket does not prove authorized writers are serialized and permissions protect the state.
An internal analytics cluster has private VM addresses and must download security updates without accepting inbound internet connections. Which solution balances the business and technical requirements most defensibly?
The architecture should use Cloud NAT for eligible private instance egress with firewall rules and logging rather than assigning public IPs. This addresses the scenario directly because cloud NAT supports outbound translation for private instances; it does not by itself create inbound public listeners. The implementation is acceptable only if the team demonstrates: A private VM retrieves approved package updates through its egress path while unsolicited inbound internet probes cannot open a connection.
Assign public IP addresses to every patching VM while denying only inbound SSH. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: An internal analytics cluster has private VM addresses and must download security updates without accepting inbound internet connections. The decisive dependency is that cloud NAT supports outbound translation for private instances; it does not by itself create inbound public listeners. The better complete recommendation is: Use Cloud NAT for eligible private instance egress with firewall rules and logging rather than assigning public IPs.
Enable Private Google Access and expect it to reach arbitrary external software update repositories. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, cloud NAT supports outbound translation for private instances; it does not by itself create inbound public listeners. The defensible decision is: Use Cloud NAT for eligible private instance egress with firewall rules and logging rather than assigning public IPs. An implementation must be judged against: a private VM retrieves approved package updates through its egress path while unsolicited inbound internet probes cannot open a connection. Source-case challenge: Private Google Access covers supported Google APIs, not arbitrary internet package repositories; Cloud NAT is the relevant egress path.
Open all egress destinations and disable flow logging after deploying NAT. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: An internal analytics cluster has private VM addresses and must download security updates without accepting inbound internet connections. Use Cloud NAT for eligible private instance egress with firewall rules and logging rather than assigning public IPs. is stronger because cloud NAT supports outbound translation for private instances; it does not by itself create inbound public listeners.
A healthcare practice wants structured fields extracted from varied scanned forms while preserving human review for uncertain handwriting. What should the architect recommend as the primary implementation decision?
The architecture should evaluate Document AI processors and human-review workflows with field-level confidence and privacy controls, rather than expecting a general chatbot to provide deterministic extraction. This addresses the scenario directly because specialized document processing returns structured extraction results and quality signals, but low-confidence forms require escalation to avoid silently wrong records. The implementation is acceptable only if the team demonstrates: A labeled sample yields acceptable field accuracy and routes uncertain fields to review without leaking patient data.
Use a general chat completion prompt as the only extraction engine and skip structured-field validation. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A healthcare practice wants structured fields extracted from varied scanned forms while preserving human review for uncertain handwriting. The decisive dependency is that specialized document processing returns structured extraction results and quality signals, but low-confidence forms require escalation to avoid silently wrong records. The better complete recommendation is: Evaluate Document AI processors and human-review workflows with field-level confidence and privacy controls, rather than expecting a general chatbot to provide deterministic extraction.
Automatically accept low-confidence handwriting fields because the output JSON schema parses. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, specialized document processing returns structured extraction results and quality signals, but low-confidence forms require escalation to avoid silently wrong records. The defensible decision is: Evaluate Document AI processors and human-review workflows with field-level confidence and privacy controls, rather than expecting a general chatbot to provide deterministic extraction. An implementation must be judged against: a labeled sample yields acceptable field accuracy and routes uncertain fields to review without leaking patient data. Source-case challenge: Accepting every syntactically valid low-confidence field converts handwriting uncertainty into silently incorrect clinical records.
Send scanned patient forms to an unapproved third-party OCR service without reviewing privacy contracts. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A healthcare practice wants structured fields extracted from varied scanned forms while preserving human review for uncertain handwriting. Evaluate Document AI processors and human-review workflows with field-level confidence and privacy controls, rather than expecting a general chatbot to provide deterministic extraction. is stronger because specialized document processing returns structured extraction results and quality signals, but low-confidence forms require escalation to avoid silently wrong records.
A company links two VPCs with peering and assumes they can transit through a third peered VPC to reach a database. Which architecture recommendation best addresses the stated requirements and constraints?
The architecture should design the necessary direct routes or service-specific Private Service Connect access, rather than relying on nontransitive VPC peering. This addresses the scenario directly because vPC Network Peering exchanges selected routes between peers but is not a general transitive routing backbone. The implementation is acceptable only if the team demonstrates: A controlled network test confirms the intended service is reachable without unintended reachability to third-party subnets.
Create a third VPC peering connection and assume both existing peers become transitively reachable. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A company links two VPCs with peering and assumes they can transit through a third peered VPC to reach a database. The decisive dependency is that vPC Network Peering exchanges selected routes between peers but is not a general transitive routing backbone. The better complete recommendation is: Design the necessary direct routes or service-specific Private Service Connect access, rather than relying on nontransitive VPC peering. Source-case challenge: Adding a third peer cannot create transitive VPC routing; peers exchange routes only for their own direct connection.
Advertise a default route in the middle VPC and use peering as a hub-and-spoke router. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, vPC Network Peering exchanges selected routes between peers but is not a general transitive routing backbone. The defensible decision is: Design the necessary direct routes or service-specific Private Service Connect access, rather than relying on nontransitive VPC peering. An implementation must be judged against: a controlled network test confirms the intended service is reachable without unintended reachability to third-party subnets.
Switch to one broad shared subnet without evaluating overlapping IP ranges or access boundaries. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A company links two VPCs with peering and assumes they can transit through a third peered VPC to reach a database. Design the necessary direct routes or service-specific Private Service Connect access, rather than relying on nontransitive VPC peering. is stronger because vPC Network Peering exchanges selected routes between peers but is not a general transitive routing backbone.
An e-commerce application publishes a new image to an old container tag and cannot identify which version caused increased checkout failures. Which mechanism best explains the failure mode in this situation?
Versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running. That causal principle explains the original failure and supports the recommended intervention: Deploy immutable image digests into versioned revisions, expose them incrementally and automate rollback on SLO regression. An observed effect alone is not a substitute for the mechanism.
A mutable image tag always maps to the same bytes across deployments. It offers an appealing simple explanation but attributes the problem to a condition not established by the source-case facts. The mechanism that actually connects the requirement to the architecture is: Versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running. Source-case challenge: Mutable tags are pointers; repushing the tag can change bytes without changing deployment metadata.
A deployment timestamp uniquely identifies the source image after a tag is overwritten. This overstates an architectural component or confuses a convenient symptom with its cause. The case instead depends on: versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running. This is why the appropriate intervention is: Deploy immutable image digests into versioned revisions, expose them incrementally and automate rollback on SLO regression.
Autoscaling alone can safely roll back database schema and code changes. The claim would leave the essential causal condition unexplained for this scenario: An e-commerce application publishes a new image to an old container tag and cannot identify which version caused increased checkout failures. The correct underlying technical relationship is: Versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running.
or Guarantee your success by buying the full version which covers the full latest pool of questions. (370 Questions, Last Updated on Nov 8, 2026)
Please check your mailbox for a message from support@examlabs.com and follow the directions.