Free Google Professional Cloud DevOps Actual Exam Questions

A/B? I’d rule out D and C since they’re way looser than current metrics, which doesn’t seem right if users expect fast responses. Between A and B, B matches what customers already experience, so it feels safer.

A/B? B matches current experience exactly, which customers like, but A sets a tighter goal that could push for better performance. Not sure if that risk is worth it given current satisfaction.

D imo, Binary Authorization is built specifically for GKE to enforce trusted images at deploy time, which fits the security team's needs without extra overhead. C feels more complex and less integrated.

D

It’s D for sure. Blue/green deployment means you have both environments ready to go, so if the new version messes up, you just flip the traffic back to the old one immediately. Rolling or canary deployments don't give that instant rollback because they gradually replace pods, which can take time and risk partial outages. Plus, the question highlights needing an instant rollback, and blue/green is designed exactly for that scenario. Even if it might cost more to run two environments briefly, it’s worth it when uptime and quick recovery are priorities.

C/D? Canary lets you test gradually but rollback isn’t instant since old pods get replaced. Blue/green keeps both live, so switching back is immediate if issues pop up.

Option B feels right because if you’ve got a big error budget left over, you can afford to push releases more often or take a few risks without breaking your SLO. That helps balance speed and reliability. Alongside that, D is smart since adding more SLIs can give a fuller picture of how the app really performs from different angles before making any SLO changes. Just tightening the SLO without better measurement might be rushing it.

D definitely, and also B to balance reliability with faster releases.

Probably D here too. Using the exact sha256 digest means you’re locking in the precise image that worked before, avoiding any tag confusion. Tags like ‘latest’ can move around, so switching back to a tag (like in A or B) might not guarantee the same image. Building a new container from an old Git tag (C) could work, but it takes extra steps and might introduce build inconsistencies. Just pointing to the digest keeps it simple and reliable for rollback.

D, because using the digest guarantees the exact image without relying on tags.

Cloud KMS in C and D is more about encryption keys, not storing API keys directly. So those options don’t fit here. Using Secret Manager like in A is really the best practice for managing secrets securely in Cloud Run.

I’m with A on this one. Cloud Run has built-in support for pulling secrets from Secret Manager directly into environment variables, which is super straightforward and secure. Mounting secrets like in B isn’t even supported in Cloud Run, so that option’s kind of a non-starter. Using Cloud KMS like in C or D makes things complicated since you’d have to handle encryption/decryption yourself, and Google recommends Secret Manager for managing secrets properly. So A makes the most sense here for both security and simplicity.

A imo, Stackdriver Profiler can help identify performance bottlenecks inside the applications themselves, not just the HTTP calls. While Trace focuses on request latency, Profiler gives a CPU and memory usage perspective which can highlight inefficient code causing slowness. This can be useful when dependent apps are slow internally, not just in network timing. It’s a different angle than tracing or logging HTTP times and complements those approaches. If you have control over all apps, profiling might reveal issues you wouldn’t catch with logs or traces alone.

Probably B here. If you can instrument all services with Stackdriver Trace, you get detailed visibility into each HTTP request across services, which helps pinpoint the exact bottleneck. D is practical if you can’t touch dependent apps, but B gives a more comprehensive view and helps anticipate issues before they become big problems. Even if some services are third-party, you can often still trace the calls from your app side, which is better than just logging times locally.

Maybe E and B. E lets you gradually send a small portion of real user traffic to the new version, so you can catch issues early without fully switching over. B is good because deploying with a tag and no traffic means QA can test the new revision manually without affecting users. This combo balances real traffic testing and manual checks while keeping rollback simple. A or C don’t really help with controlled traffic management, and D seems risky since it routes traffic directly to the new version’s URL without proper control.

Not C, because deploying without a tag but no traffic still exposes risk if traffic is accidentally routed. B keeps it isolated, and E lets you control traffic split for safe rollout and quick rollback.

Maybe A, rollback first to stop the issue before digging deeper.

Option A makes the most sense; stop the problem fast before diving into details.

Maybe C—smaller steps can run in parallel and spot slow parts fast.

C is worth considering here because breaking the build into smaller steps can help identify bottlenecks and potentially run some steps in parallel, speeding up the overall process without needing extra resources. It also doesn’t increase costs like bigger VMs would, and it’s less complex than setting up Jenkins agents. Plus, smaller steps can sometimes let you skip unnecessary parts if nothing changed there, indirectly reducing build time. This approach keeps things simple while still aiming to cut down total execution time, which fits the goal of minimizing development effort and cost.

This one’s tricky, but I think C is a solid backup plan. Exporting logs to BigQuery then moving to Google Sheets for visualization lets you build something quickly and share easily, especially if you want something familiar. It might not be great for real-time updates or huge data, but for quarterly aggregation it works. Plus, Sheets dashboards can be interactive enough for basic needs without the overhead of learning Data Studio or custom apps. So I’d say C could be good if you want a straightforward, no-frills approach that’s easy to manage.

Maybe D if you want full customization, but A is way simpler and more scalable.

Makes sense to include B since data loss is serious, plus C for internal visibility. C

Are we assuming that any failure detected by monitoring (D) counts as a major enough incident for a postmortem? Because sometimes instances fail but the service is still up. Also, does a rollback triggered by the CD pipeline (E) always imply an outage or data loss, or could it just be a safe precaution? The question doesn’t clarify if these are threshold-level incidents or minor blips. Without that, it’s tricky to pick which should definitely trigger a postmortem.

Makes sense to avoid B since a public website needs high availability. D might take too long per task to risk preemption. C could work but depends on the quorum setup, so A is the safer bet. A

A imo, caching systems handle sudden shutdowns way better than rendering or databases.

D imo. Setting up a Google Cloud HTTP Load Balancer as Ingress can help optimize traffic routing and reduce unnecessary outgoing network hops, which should lower network costs. It’s designed for handling external HTTP traffic efficiently, and GKE integrates well with it.

Options like A and B don’t directly address network cost reduction from the HTTP traffic perspective, and C (Private Cluster) is more about security/isolation rather than cost savings on incoming user requests. So, D feels like the most solid bet here.

Probably B here. Using Standard Tier for network services is cheaper than Premium Tier, so switching to Standard Tier should cut network costs. The question doesn’t mention any particular security or performance needs that require Premium Tier, so this seems like a straightforward way to reduce cost without changing the cluster setup.

Also, the Private Cluster (C) mainly helps with security and internal access, but it doesn’t directly reduce network egress costs for user HTTP requests coming from outside. So B feels more aligned with just lowering cost.

B/D? Labels (B) seem more reliable for cost allocation since they’re designed for that, while VM names (D) could be less consistent. Also, labels work well with billing export, making analysis smoother.

I’m wondering if relying on labels in B might miss costs like network egress that aren’t tied directly to instances. Would option A’s built-in Cost Breakdown capture those broader costs better?