Prepare and test your skills

Prepare and test your skills

Free sample question with answers and detailed explanation below. The Professional Cloud Database Engineer practice bank has an additional 769 practice questions.Try 10 free realistic questions: instant score, no credit card, and no account required.
A high-throughput microservice running in Google Kubernetes Engine (GKE) uses the Go client library to send 50,000 queries per second (QPS) to Cloud Bigtable with a normal average latency of 10 ms. Recently, the application has experienced elevated latency and request timeouts. Your investigation shows the following:
CPU utilization (hottest node) high granularity remains below 45%.grpc.io/client/started_rpcs and grpc.io/client/completed_rpcs.Which action should you take to resolve this bottleneck?
Horizontal scaling in Cloud Bigtable involves manually adding compute nodes or enabling Bigtable autoscaling to adjust cluster node counts dynamically based on CPU utilization or storage utilization targets. Adding nodes increases total server-side compute capacity and allows Bigtable to redistribute tablets across more machines.
The cluster metrics show average CPU utilization at 38% and CPU utilization (hottest node) high granularity below 45%, both well under the recommended 60% maximum CPU threshold for latency-sensitive workloads. Because the Bigtable server nodes are not saturated, adding nodes will not relieve the gRPC stream saturation occurring between the client application and Google's middleware.
grpc.io/client/started_rpcs versus grpc.io/client/completed_rpcs.Cluster-wide average CPU utilization exceeded 60% (for latency optimization) or 90% (for throughput optimization) with traffic already balanced evenly across tablets and no client-side gRPC thread queuing.
When troubleshooting Bigtable latency, separating client-side blocking (such as undersized channel pools) from server-side overload prevents wasteful cluster over-provisioning.
Row key redesign uses techniques such as salting, field promotion, or timestamp reversal to prevent sequential writes or reads from concentrating on a single contiguous range of rows. In horizontally scalable databases like Cloud Bigtable, even distribution of row keys ensures tablets are balanced across all cluster nodes.
The diagnostic metrics explicitly rule out a distributed resource hotspot. Both Key Visualizer (showing even traffic across all row ranges) and the CPU utilization (hottest node) high granularity metric (staying below 45%) confirm that no single tablet or node is experiencing disproportionate load. Consequently, altering the schema will not fix the gRPC connection pool bottleneck.
CPU utilization (hottest node) high granularity was spiking toward 100% while average cluster CPU remained low, and Key Visualizer showed concentrated activity on a narrow row-key range.
Unlike cluster-wide CPU exhaustion, true hotspots cannot be fixed simply by adding nodes, making Key Visualizer essential before undertaking costly schema changes.
A connection pool (or channel pool) in Cloud Bigtable is a cache of reusable gRPC connections shared by a single data client in an application process. Each gRPC connection operates over an HTTP/2 subchannel and can support up to 100 concurrent streams (requests) simultaneously, a hard limit enforced by Google's middleware layer that cannot be reconfigured.
With an average request latency of 10 ms, a single stream can process 100 serial requests per second (1,000 / 10). Supporting 50,000 QPS therefore requires 500 concurrent requests (50,000 / 100). Because each gRPC connection caps at 100 concurrent streams, 4 connections can handle at most 400 concurrent requests. The remaining requests queue on gRPC threads and in middleware, producing the widening gap between grpc.io/client/started_rpcs and grpc.io/client/completed_rpcs.
To leave headroom for traffic fluctuations, optimal utilization is 10 to 50 concurrent streams per connection:
500 / 50 = 10 connections500 / 10 = 50 connectionsUnlike adding Bigtable cluster nodes or redesigning row keys, adjusting the channel pool size directly resolves the client-side gRPC stream exhaustion revealed by the metrics without unnecessary infrastructure costs or schema changes.
A Cloud Bigtable data client manages its own connection pool, metadata, and authentication state for an application process. Best practice is to create a single shared client per process (or one per app profile when routing distinct workloads) and reuse it across all worker threads or goroutines.
Instantiating a separate Bigtable client per concurrent goroutine is an expensive anti-pattern that introduces severe resource overhead and unpredictable tail latency. Each new client must establish and prime its own gRPC channels, consuming excess memory and CPU on the GKE pod while creating far more connections than needed.
You needed to isolate distinct workload types using separate app profiles or replication routing policies, in which case creating one shared client per app profile (not per goroutine) is appropriate.
Sharing a single Go data client while explicitly tuning its channel pool size to 10–50 connections provides predictable concurrency without client-creation overhead.
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