Google ACE Practice Test 8 — 10 Questions

Question 1

A GKE Deployment must be updated to a new container image version with zero downtime — old Pods should be replaced gradually, not all at once. Which update strategy should be configured?

Accepted Answer

RollingUpdate strategy. The RollingUpdate strategy is correct because it gradually replaces old Pods with new ones while keeping the Deployment available, ensuring zero downtime. By default, it uses a `maxSurge` of 25% and `maxUnavailable` of 25%, allowing a controlled, incremental rollout that matches the requirement of replacing Pods gradually rather than all at once.

Answer

Recreate strategy

Answer

Blue-green deployment using a separate Deployment and Service selector swap

Answer

Canary deployment with a traffic-splitting ingress

Question 2

A public API receives global traffic but has been targeted by both volumetric DDoS attacks and SQL injection attempts in HTTP request parameters. Which single GCP service provides protection against both threats?

Accepted Answer

Cloud Armor security policies on the load balancer. Cloud Armor security policies, when attached to a Google Cloud HTTPS Load Balancer, provide both Layer 7 DDoS protection (via pre-configured WAF rules like 'modsecurity-crs' to block SQL injection) and volumetric DDoS defense (via rate limiting and adaptive protection). This makes it the single GCP service that directly addresses both threats mentioned in the question.

Answer

VPC firewall rules with deny rules for known attacker IPs

Answer

Cloud NAT to hide backend IP addresses

Answer

Identity-Aware Proxy (IAP) to require authentication before accessing the API

Question 3

A team needs to export all Cloud Logging entries from a production GCP project to a BigQuery dataset for long-term analysis and compliance. The export must be near-real-time and include future log entries automatically. Which approach achieves this?

Accepted Answer

Create a log sink (Log Router) that routes all logs from the project to the BigQuery dataset. A log sink (Log Router) in Cloud Logging can be configured to route log entries in near-real-time to a BigQuery dataset. This approach automatically includes all future log entries without requiring any scheduled jobs or manual intervention, making it ideal for long-term analysis and compliance.

Answer

Schedule a daily Cloud Function to query the Logging API and write results to BigQuery

Answer

Use BigQuery Data Transfer Service to pull logs from Cloud Logging on a schedule

Answer

Enable VPC Flow Logs and stream them directly to BigQuery

Question 4

A platform engineer is deploying a Kubernetes Job that processes a batch of records. The Job should run 10 parallel workers, each processing a subset of records, and complete when all workers finish successfully. Which Job spec configuration achieves this?

Accepted Answer

Set parallelism: 10 and completions: 10 in the Job spec. In Kubernetes, a Job's `parallelism` field specifies the number of Pods that can run concurrently, and `completions` specifies the total number of successful Pod completions required for the Job to be considered finished. Setting both to 10 ensures exactly 10 Pods run in parallel, each processing a subset of records, and the Job completes only when all 10 have succeeded.

Answer

Set replicas: 10 in the Job spec

Answer

Create 10 separate Job objects — one per worker

Answer

Set concurrency: 10 in the Job spec

Question 5

A Cloud Function must execute automatically every time a new object is written to a specific Cloud Storage bucket. Which trigger type should be configured for the function?

Accepted Answer

Cloud Storage trigger (object finalized event). The Cloud Storage trigger (object finalized event) is the correct choice because Cloud Functions natively supports Cloud Storage events via the `google.storage.object.finalize` event type, which fires when a new object is created or an existing object is overwritten in a bucket. This trigger automatically invokes the function without requiring any intermediary service, directly binding the function to the bucket's notification system.

Answer

HTTP trigger

Answer

Pub/Sub trigger

Answer

Cloud Scheduler trigger

Question 6

A DevOps team uses Terraform to manage GCP infrastructure and wants to store Terraform state in a shared location that all team members can access securely, with state locking to prevent concurrent modifications. Which backend configuration achieves this?

Accepted Answer

gcs backend storing state in a Cloud Storage bucket. The `gcs` backend is the correct choice because it stores Terraform state in a Google Cloud Storage bucket, which provides secure, shared access via IAM policies and supports state locking natively through object versioning and write-preconditions. This ensures that only one team member can modify the state at a time, preventing conflicts and corruption.

Answer

gcp backend storing state in a BigQuery table

Answer

remote backend connected to a Cloud SQL database

Answer

local backend with a path shared over Cloud Filestore

Question 7

You want to use Kustomize to manage environment-specific Kubernetes configurations (dev, staging, prod) from a single base set of manifests. How does Kustomize achieve environment customization without duplicating YAML files?

Accepted Answer

Kustomize uses overlays that patch a shared base: environment-specific differences are expressed as patches without duplicating base manifests.. Kustomize uses a base set of Kubernetes manifests and applies environment-specific overlays that contain patches. These patches modify only the differences (e.g., replicas, image tags, namespaces) without copying or altering the original base YAML files. This approach avoids duplication and keeps the base clean, with each overlay representing a distinct environment.

Answer

Kustomize duplicates all YAML files per environment, then applies find-and-replace on values.

Answer

Kustomize uses Helm charts with values files per environment for templating.

Answer

Kustomize requires a separate Git branch per environment where manifests are committed.

Question 8

You need to deploy a new version of an App Engine standard environment application. The new version should receive 10% of traffic while the current version continues to receive 90%. Which command achieves this?

Accepted Answer

`gcloud app services set-traffic default --splits v1=0.9,v2=0.1`. The `gcloud app services set-traffic` command explicitly splits traffic between versions of an App Engine service. By specifying `--splits v1=0.9,v2=0.1`, you direct 90% of requests to version v1 and 10% to version v2, without deploying a new version or promoting it. This is the standard method for gradual traffic migration in App Engine standard environment.

Answer

`gcloud app deploy --version=v2 --no-promote`

Answer

`gcloud app versions migrate v2`

Answer

`gcloud app deploy --version=v2 --promote --stop-previous-version`

Question 9

You have an Artifact Registry repository for Python packages (`format: python`). A developer needs to publish a new Python package to this repository. Which tool and configuration allows them to publish?

Accepted Answer

Use `twine upload` with the Artifact Registry Python repository URL as the repository target.. B is correct because `twine` is the standard tool for uploading Python packages to package indices, and Artifact Registry's Python repositories are compatible with the PyPI API. By specifying the Artifact Registry repository URL as the `--repository-url` target in `twine upload`, the developer can authenticate via a service account or OAuth token and publish the package directly.

Answer

Use `pip install` pointing to the Artifact Registry URL to upload the package.

Answer

Use `docker push` to push the Python package as a container layer.

Answer

Use `gsutil cp` to copy the wheel file to the Artifact Registry bucket.

Question 10

A developer needs to forward traffic from their local port 5432 to a PostgreSQL service running in GKE on port 5432, to test database queries locally without exposing the database externally. Which kubectl command achieves this?

Accepted Answer

kubectl port-forward svc/postgres-service 5432:5432. `kubectl port-forward` creates a local tunnel from port 5432 on the developer's machine to the specified service's port 5432 inside the GKE cluster. This allows the developer to connect to the PostgreSQL service as if it were running locally, without exposing it to the internet via a LoadBalancer or Ingress.

Answer

kubectl expose pod postgres-pod --type=LoadBalancer --port=5432

Answer

kubectl tunnel --local=5432 --remote=postgres-service:5432

Answer

gcloud container ssh postgres-pod --port-forward=5432:5432