Prepare and test your skills
Prepare and test your skills
Free sample question, answered and explained below. The Professional Cloud DevOps Engineer practice bank has 1,455 more like it. Try 10 free: instant score, no account.
A production microservices application running on Google Kubernetes Engine (GKE) is experiencing severe tail latency during peak checkout periods. A DevOps engineer investigates the issue across Google Cloud Observability tools and observes the following telemetry:
checkout service spends over 3.2 seconds waiting on a specific internal span inside the payment-auth service, while downstream database calls within that span complete in less than 15 milliseconds.payment-auth service exhibits very low CPU time, but shows extremely high Wall time and Contention concentrated on a shared synchronization mutex routine in the application runtime.Which root cause and diagnostic conclusion do these correlated telemetry signals indicate?
Network latency bottlenecks occur when packet loss, bandwidth throttling, cross-region egress transit, or suboptimal TCP/MTU parameters introduce significant transmission delay between distributed microservices across a network fabric.
Cloud Trace showed a substantial time gap between the client initiating an RPC and the server receiving the request, with Network Intelligence Center reporting elevated inter-zone RTT and packet drops.
Compute resource starvation occurs when running processes demand more CPU cycles than are physically available on the host machine or allocated within container cgroup limits, causing CPU throttling, high run-queue lengths, and degraded throughput.
container_cpu_cfs_throttled_seconds_total.Cloud Monitoring showed sustained 100% CPU utilization with active CPU throttling and Cloud Profiler attributed the delay to high CPU time in mathematical or data-processing routines.
Thread contention or lock contention occurs when multiple concurrent threads attempt to acquire an exclusive lock (such as a synchronized block, mutex, or semaphore) simultaneously. When one thread holds the lock, all other competing threads are placed into a blocked or waiting state, stalling execution without executing active instructions on the host CPU.
Correlating data across Google Cloud Observability tools pinpoints this exact pathology:
Recognizing that low CPU utilization paired with high wall/contention time reflects code-level locking allows developers to optimize data structures, reduce synchronization scope, or adopt non-blocking asynchronous patterns rather than misattributing latency to GKE capacity or database throughput.
Database resource exhaustion occurs when a backing datastore suffers from high CPU utilization, disk I/O bottlenecks, lock waits on database tables, or inefficient query execution plans, resulting in elevated query response times.
Cloud Trace showed that the database child span took over 3 seconds to return and the database metrics reported saturated CPU utilization or disk throttling.
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