Google Professional Cloud Developer (PCD) — Questions 226–300

The recommended approach is to export Redshift data to S3, then use BigQuery Data Transfer Service for Redshift to load data directly into BigQuery, or use Cloud Storage as intermediate. The most efficient is to use the BigQuery Data Transfer Service which can read from S3 directly (via a transfer config) or use Cloud Storage as a staging area.

Cloud Spanner is the only Google Cloud database that provides strong ACID transactions across multiple regions with 99.999% availability and automatic failover. It uses a globally distributed architecture with synchronous replication and the TrueTime API to ensure external consistency, making it ideal for a global payment system that requires strict consistency and high availability.

BigQuery Data Transfer Service for Teradata supports scheduled transfers. The correct setup is to configure a transfer config with a schedule (e.g., daily) and specify the dataset and table mappings. The service handles incremental loads based on a watermark column.

Cloud Monitoring alerting policies use a Metric Threshold condition type to evaluate a metric against a static threshold. Setting the trigger to 'For 5 minutes' ensures the condition is met only when the CPU utilization exceeds 80% consistently over the specified duration, preventing false alarms from transient spikes.

Dataflow is a serverless, fully managed service for executing Apache Beam pipelines, which can read from and write to various databases (e.g., Cloud Spanner, BigQuery, Cloud SQL) while performing transformations in a unified streaming or batch model. It is specifically designed for data movement and transformation between different data sources and sinks, making it a correct choice for building a data pipeline that transforms and moves data between databases.

Enabling container concurrency allows a single Cloud Run container instance to handle multiple requests simultaneously, up to the configured concurrency limit (default 80, max 1000). This improves throughput and resource utilization during traffic spikes without requiring additional instances. Option D is correct because setting max instances to a high value ensures the service can scale out to handle sudden load by creating more container instances, up to the configured maximum, preventing cold starts and request queuing.

Cloud Run's autoscaling allows min instances to be set to 0, enabling the service to scale down to zero when idle (cost-efficient), and max instances to 1000 to handle unpredictable traffic spikes by scaling out horizontally. This configuration ensures the service can start from zero and automatically add instances up to the maximum limit as demand increases, which is ideal for unpredictable workloads.

Cloud Storage is the source of events (uploaded images). Cloud Pub/Sub is used to deliver notifications from Cloud Storage to the Cloud Function. Cloud Tasks, Cloud Scheduler, and Eventarc are not required for this pattern.

Secret Manager provides a centralized and secure way to store and manage sensitive configuration values such as API keys, database passwords, and certificates. By using Secret Manager, you avoid hardcoding secrets in source code or configuration files, reducing the risk of exposure. It integrates with IAM for fine-grained access control and supports automatic rotation, ensuring that secrets are protected at rest and in transit.

The most likely cause of pods failing to start due to insufficient memory is misconfigured resource requests and limits. If the memory request (spec.containers[].resources.requests.memory) is set too high, the scheduler cannot find a node with enough allocatable memory, leaving pods in a Pending state. Similarly, if the limit is set too low, the pod may be OOMKilled after starting, but the question specifically states 'failing to start,' pointing to a scheduling failure due to requests exceeding node capacity.

For a 500 GB database with a 2-hour downtime window, a one-time migration (offline) is sufficient because the dump and restore can complete within the window. Continuous migration is used for minimal downtime but adds complexity. Database Migration Service supports both one-time and continuous jobs.

Using request.auth.uid to match the document owner ensures users can only access their own data.

Cloud Spanner is the only Google Cloud database that provides global strong consistency, horizontal scaling, and relational schema support at massive transaction volumes. Cloud SQL is limited to a single region, Bigtable does not support relational data, and Firestore is document-based with limited transaction support.

Firestore is the correct choice: it is serverless, document-based, provides offline sync for mobile apps, and has Security Rules for access control.

BigQuery Data Transfer Service supports scheduled transfers from Teradata (and other sources) to BigQuery.

Cloud Monitoring supports custom metrics and provides built-in aligners, including a 99th percentile aligner, which can be applied directly in a dashboard chart. This allows you to compute the 99th percentile latency for each service over the last 7 days without manual calculation or exporting logs. Custom metrics are the appropriate mechanism for business metrics like order processing time, as they are designed for numeric time-series data.

To alert on the 99th percentile of latency, you must create a custom distribution metric, which stores a histogram of values and allows percentile calculations. A metric-threshold alert policy can then be configured to evaluate the 99th percentile value against the 500ms threshold over a 5-minute window.

Cloud Spanner is a globally distributed, strongly consistent relational database that scales horizontally. It supports multiple regional configurations and auto-scaling. Bigtable is not relational, Cloud SQL does not scale horizontally, and Firestore is not relational.

The '--no-traffic' flag deploys the new revision without serving any traffic, and then 'gcloud run services update-traffic --to-revisions=REVISION=5' allows you to send exactly 5% of traffic to that revision for canary testing. Option B is also correct because it describes the same two-step process: deploy with '--no-traffic' to avoid immediate traffic, then use 'update-traffic' to gradually increase the percentage, which is the standard canary deployment pattern on Cloud Run.

Database Migration Service (DMS) is specifically designed for minimal-downtime migrations from on-premises MySQL to Cloud SQL. It uses continuous replication (CDC) to keep the source and target synchronized, allowing a short cutover window after the initial 500 GB data load. This approach avoids the downtime required by export/import or file-copy methods.

For microservices, each service should own its database. To maintain consistency across services, they should implement compensating transactions (sagas) rather than distributed transactions. Cloud Spanner can be used if strong consistency is required across global scales, but for microservices, the pattern is to use eventual consistency with sagas.

The liveness probe has an initialDelaySeconds of 30 seconds, which is less than the application's initialization time of 45 seconds. Therefore, the liveness probe will start checking the /healthz endpoint at 30 seconds, fail, and Kubernetes will restart the pod before it becomes ready. The readiness probe does not prevent the liveness probe from running and causing restarts.

Secondary indexes in Cloud Spanner allow point-reads to be served directly from the index table, avoiding a full table scan and reducing latency. Interleaved tables store child rows physically adjacent to their parent row, enabling efficient single-row lookups without cross-node coordination.

For a zero-downtime cutover, you must first stop writes to the source database, then promote the Cloud SQL replica. The error indicates writes are still happening; stopping them allows the CDC to catch up and then cutover.

It combines an uptime check (to measure total requests) with a log-based metric for errors (to count failed requests), allowing the SLI formula (successful requests / total requests) to compute availability. This approach directly aligns with the 99.9% availability target over a 30-day rolling window, using Cloud Monitoring's native capabilities without external tools or irrelevant latency metrics.

Memorystore for Redis provides low-latency in-memory data storage with support for pub/sub and rate limiting patterns. It is ideal for session stores.

A global external HTTP(S) Load Balancer is the correct choice because it provides a single anycast IP address that routes traffic from users worldwide to the nearest GKE backend, minimizing latency. It supports cross-regional failover and integrates with Cloud CDN for caching static content, making it ideal for a global e-commerce platform. Regional load balancers cannot serve traffic across multiple regions with a single IP, which is required for global low-latency access.

The External HTTP(S) Load Balancer is the correct choice because it is a global, proxy-based Layer 7 load balancer that terminates HTTP/HTTPS traffic at Google's edge points of presence (PoPs) and routes requests to the nearest healthy backend. This provides low-latency access for users worldwide by leveraging Google's global network and anycast IPs, while also offering built-in high availability, SSL offloading, and content-based routing.

Cloud SQL (or Spanner) for relational ACID, Bigtable for time-series, BigQuery for analytics. The question asks for two, but three are mentioned; the best pair for the first two requirements is Cloud SQL and Bigtable. However, since it asks for TWO, we select Cloud SQL for transactions and Bigtable for time-series.

DMS provides a CDC phase that continuously replicates changes from the source to the destination. Only after the replica catches up and the application can be stopped can you promote the replica. The full dump is the first step, then CDC ensures consistency.

Cross-region read replicas can be promoted in a disaster, but they may have data loss. To minimize loss, use Cloud SQL HA in the primary region plus a cross-region read replica. Automated backups provide point-in-time recovery but not automatic failover.

Cloud Bigtable is a fully managed, scalable NoSQL database designed for large analytical and operational workloads, handling petabytes of data with consistent single-digit millisecond latency at high throughput. Its key-value and wide-column architecture, combined with native time-series optimization via row key design (e.g., inverted timestamps), makes it the ideal choice for IoT sensor data requiring millions of reads per second.

Cloud Composer (D) is the correct choice because it is a fully managed workflow orchestration service built on Apache Airflow, designed to schedule, monitor, and retry batch jobs with complex dependencies. It can trigger a Cloud Storage file processing job, enforce a 2-hour execution window, and automatically retry on failure using Airflow's built-in retry mechanisms and SLA monitoring.

During migration from Oracle to Cloud SQL for PostgreSQL using DMS, the following mappings are correct: RAW maps to BYTEA (A), NUMBER maps to NUMERIC (C), CLOB maps to TEXT (D), and Oracle packages are converted to PostgreSQL schemas containing functions (E). Option B is incorrect because Oracle DATE includes time components and should map to TIMESTAMP, not DATE.

Field promotion places the highest-cardinality field first in the row key, which spreads writes across many tablet servers. In Bigtable, rows are sorted lexicographically by row key, so a high-cardinality prefix ensures that successive writes do not concentrate on a single tablet, avoiding hotspots.

To avoid hotspots, the row key should start with a field that has high cardinality and even distribution. A common approach is to prepend a hash or a nonce derived from the timestamp or sensor ID to spread writes across tablets.

Bigtable managed backups are cluster-level and support cross-cluster restore, including to a different region.

Pull subscriptions with synchronous acknowledgment (option B) ensure that a message is not acknowledged until the subscriber has successfully processed it. This prevents premature acknowledgment and message loss, because Cloud Pub/Sub will redeliver the message if the acknowledgment deadline expires without a synchronous ack. This is a core pattern for reliable processing.

An alerting policy with a metric threshold condition is the correct approach because Cloud Monitoring evaluates a metric (e.g., error rate) against a threshold (1%) over a specified window (5 minutes) and triggers a notification when the condition is met. This directly fulfills the requirement to be notified when the error rate exceeds the threshold, as alerting policies are designed for proactive notification based on metric data.

Locking a retention policy in Cloud Storage enforces immutable storage for the specified duration (7 years). Once locked, the retention policy cannot be removed or shortened, ensuring compliance with regulations that require data to be preserved in its original state and not modifiable or deletable until the retention period expires.

The load balancer's built-in 'request_count' metric directly provides the number of active requests per instance without requiring any additional instrumentation or agents. This metric is automatically collected by Cloud Monitoring for Google Cloud HTTP(S) load balancers, making it the most straightforward approach for a stateless application on Compute Engine.

Enabling point-in-time recovery is important for data protection. Enforcing TLS ensures encrypted connections. These are common security and operational requirements.

A Cloud Build trigger is set up by connecting a repository and configuring the conditions for automatic builds.

Cloud Build executes each step as a container, and the build step's success or failure is determined by the exit code of the command run inside that container. If the test command (e.g., `npm test` or `pytest`) returns a non-zero exit code when tests fail, Cloud Build will automatically mark that step as failed and stop the build. No special configuration or custom builder is required beyond ensuring the test command itself propagates the failure exit code.

PostgreSQL does not have a direct equivalent of Oracle packages. The recommended approach is to convert package procedures and functions to individual functions in a schema, and package variables to session-level variables or temporary tables. Ora2Pg can attempt conversion but often requires manual adjustments.

Managed instance groups (MIGs) with autoscaling based on CPU utilization are the most cost-effective solution for a stateless web app with traffic spikes because they automatically add or remove VM instances in response to real-time CPU load, ensuring you only pay for the compute resources you actually use. This approach directly matches the stateless nature of the app, allowing instances to be created and destroyed without data loss, and avoids over-provisioning or under-utilizing resources.

When enabling auto-scaling for Cloud Spanner, you must set the minimum and maximum processing units (or nodes) and the target high-priority CPU utilization. Scaling increments and scaling limits are not direct parameters. The instance type is fixed.

The App Engine flexible environment runs your application in a Docker container based on a Google-provided runtime image. To install system packages like libssl-dev that are not included in the default image, you must customize the container by creating a Dockerfile that starts FROM the base runtime image and then runs apt-get install. This is the standard method for adding OS-level dependencies in the flexible environment.

Cloud Spanner is the only globally distributed, strongly consistent relational database that can handle millions of operations per second across multiple continents.

BigQuery federated queries can create an external table that references Cloud SQL PostgreSQL. This allows querying Cloud SQL data directly from BigQuery and joining with BigQuery tables.

Datastream can write to Pub/Sub, which then can be consumed by the application. Alternatively, Datastream can write to GCS (Avro/JSON) and then Pub/Sub or Dataflow can be used. The direct approach is to stream to Pub/Sub.

Memorystore for Redis is a managed Redis service that supports caching and pub/sub. Memorystore for Memcached only supports caching. Cloud SQL and Firestore are not caching services.

A rolling update on a managed instance group allows the developer to update instances incrementally, applying security patches without downtime. The TCP load balancer automatically distributes traffic only to healthy instances, so as each instance is updated and passes health checks, traffic is seamlessly redirected away from instances being patched.

Monotonically increasing keys like UUIDs or timestamps cause hotspots. Using a composite key with a hash prefix or swapping columns to distribute writes is recommended.

Datastream is a Google Cloud serverless change data capture (CDC) and replication service specifically designed to continuously replicate data from sources like Oracle databases to BigQuery. It handles schema drift, supports log-based CDC, and provides low-latency streaming, making it the correct choice for real-time analytics.

BigQuery federated queries allow you to query Cloud SQL, Cloud Spanner, and Bigtable directly using standard SQL without data movement, making it the correct solution. BigQuery Omni is designed for querying data across AWS and Azure, not for in-GCP databases like Cloud SQL, Cloud Spanner, or Bigtable. Therefore, only option B is correct.

To avoid hot spotting, row key design should incorporate a nonce or sharding prefix to distribute writes across tablets. Salting row keys with a calculated hash or a field with high cardinality spreads the load. The Key Visualiser confirms the hotspot; redesigning the key is the correct fix.

The error 'context deadline exceeded' in App Engine flexible environment indicates that the container did not start within the allowed startup timeout. The default timeout for container startup in App Engine flexible is 10 minutes, and if the application takes longer (e.g., due to slow initialization, large dependency downloads, or database migrations), the platform kills the container and logs this error. The previous version continues serving because the new version failed to become healthy.

STORING allows storing additional columns in the index, enabling index-only scans and avoiding a join back to the base table, improving query performance.

`unittest.mock` allows the developer to replace the actual HTTP request calls (e.g., `requests.get`) with mock objects that return controlled responses, preventing any real network traffic. This is essential for unit testing Cloud Functions where external API calls must be isolated to ensure tests are fast, deterministic, and do not depend on external services.