SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
ACE · Domain 3

Ensuring the successful operation of a cloud solution practice questions

Ensuring the successful operation of a cloud solution is worth 30% of the ACE exam — the heaviest of the 4 domains. Managing compute, storage/data, and networking resources day-to-day, plus monitoring and logging. Official (approximate) weighting ~30%. 6 fully worked examples are further down this page, answers included.

Exam weight
30%
the heaviest of the 4 domains
Questions
146
across 4 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 4 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Ensuring the successful operation of a cloud solution questions, fully explained

Questions from the ACE bank mapped to domain 3, with the answer key and the reasoning behind every option. None of them repeat the examples on the main ACE practice page.

Question 1Ensuring the successful operation of a cloud solution

A Compute Engine VM serves files from a 2 TB zonal persistent disk. Operations wants a backup of that disk taken every day, with each backup kept for 14 days and then removed. The solution must need the least ongoing operational effort. What should you do?

Choose one.

  • a
    Add a nightly cron job on the VM that snapshots the disk and prunes those past 14 days.

    This works, but the script, the VM's credentials and the cron entry are all yours to maintain, and backups stop if the VM is down.

  • b
    Have Cloud Scheduler trigger a function that snapshots the disk daily and prunes after 14 days.

    This also works, but it adds a scheduler job and function code to deploy, secure and maintain for something Compute Engine does natively.

  • c
    Attach a snapshot schedule resource policy with daily runs and 14-day retention to the disk. Correct

    A snapshot schedule is a resource policy that takes the snapshot on the set cadence and deletes snapshots older than the retention period, with no code to run.

  • d
    Create a machine image of the VM each day and delete those older than 14 days.

    Machine images have no built-in schedule or retention, so this is a manual daily task, and it captures the whole VM rather than just the data disk.

The concept

Snapshot schedules are Compute Engine resource policies that create incremental snapshots of a disk on a fixed cadence and delete them after a retention window.

Why that’s the answer

All four options produce daily backups with 14-day expiry; the constraint is the least ongoing effort. A snapshot schedule attached to the disk does both halves natively: Compute Engine takes the snapshot and deletes copies past the retention window, with no code. A cron job and a Cloud Scheduler-triggered function both work but leave scripts, credentials and infrastructure to maintain. Machine images have no schedule or retention policy, so they would be created and deleted by hand.

How to reason it out
  1. Create the policy: gcloud compute resource-policies create snapshot-schedule daily-backup --daily-schedule --start-time=03:00 --max-retention-days=14 --region=REGION.
  2. Attach it: gcloud compute disks add-resource-policies DISK --resource-policies=daily-backup --zone=ZONE.
  3. Check that snapshots appear daily with gcloud compute snapshots list and that older ones expire.

Exam tip: Scheduled disk backups with automatic expiry = a snapshot schedule resource policy attached to the disk.

Managing Compute Engine, GKE, and Cloud Run: Day-2 Operations — the lesson that teaches this.

Question 2Ensuring the successful operation of a cloud solution

You hardened a Compute Engine VM and installed monitoring agents and the application runtime. Operations must launch dozens of VMs with exactly this build, in several regions, through instance templates and managed instance groups. What should you create from the VM's boot disk?

Choose one.

  • a
    A snapshot that each team restores into a new disk before attaching it.

    Snapshots are backups; restoring one per VM is a manual step that instance templates and MIGs would not perform for you.

  • b
    A disk clone in each region that new instances attach as their boot disk.

    A disk clone is a single disk in the same location as its source; one disk cannot be the boot disk of many VMs, and clones do not cross regions.

  • c
    A custom image used as the boot disk source for the new VMs. Correct

    A custom image is the reusable golden build: instance templates and MIGs create every boot disk from it, in any region.

  • d
    A tar.gz export in Cloud Storage that startup scripts unpack at boot.

    Unpacking an archive at every boot is slow and fragile and does not reproduce the hardened OS itself.

The concept

Custom images capture a configured boot disk as a reusable template (a golden image) for creating identical Compute Engine VMs in any region.

Why that’s the answer

Creating a custom image from the prepared boot disk gives one artefact that instance templates and managed instance groups can reference, so every new VM boots the same hardened build wherever it runs. Snapshots are for backup and restore, disk clones produce a single disk next to the source, and archive-plus-startup-script rebuilds are slow and drift over time.

How to reason it out
  1. Stop the VM (or accept the --force risk) so the boot disk is consistent.
  2. Create the image: gcloud compute images create golden-v1 --source-disk=DISK --source-disk-zone=ZONE.
  3. Reference the image (or its image family) in the instance template used by the MIGs.
  4. Launch VMs from the template in each region.

Exam tip: Golden build for templates and MIGs = custom image; snapshot = backup.

Managing Compute Engine, GKE, and Cloud Run: Day-2 Operations — the lesson that teaches this.

Question 3Ensuring the successful operation of a cloud solution

Snapshot storage charges keep rising because manual snapshots of disks that were deleted months ago were never removed. You need to find every snapshot in the project created before 1 July 2026 and delete the ones no longer required, using the gcloud CLI. Which approach works?

Choose one.

  • a
    List with gcloud compute snapshots list --filter="creationTimestamp<'2026-07-01'", then delete each with gcloud compute snapshots delete. Correct

    Snapshots are their own resources: snapshots list with a creationTimestamp filter finds the old ones and snapshots delete removes them.

  • b
    List with gcloud compute snapshots list --filter="creationTimestamp>'2026-07-01'", then delete each with gcloud compute snapshots delete.

    The comparison is inverted: creationTimestamp>'2026-07-01' returns snapshots created after the cutoff, so this deletes the recent ones.

  • c
    List with gcloud compute snapshots list --filter="creationTimestamp<'2026-07-01'", then delete each with gcloud compute images delete.

    The list is correct, but images and snapshots are separate resource types; gcloud compute images delete cannot remove a snapshot.

  • d
    List with gcloud compute snapshots list --sort-by=~creationTimestamp --limit=50, then delete each with gcloud compute snapshots delete.

    Sorting by ~creationTimestamp puts the newest first, so --limit=50 returns the 50 most recent snapshots rather than those older than the cutoff.

The concept

Snapshots are standalone project resources managed with the gcloud compute snapshots command group; they survive deletion of their source disk and keep billing until deleted.

Why that’s the answer

gcloud compute snapshots list accepts --filter expressions on fields such as creationTimestamp; creationTimestamp<'2026-07-01' returns snapshots created before the cutoff, and gcloud compute snapshots delete removes them (it accepts several names). The near-misses each break one token: the inverted comparison selects recent snapshots, the images command group cannot delete snapshots, and a descending sort with a limit returns the newest snapshots instead of filtering by date.

How to reason it out
  1. Find candidates: gcloud compute snapshots list --filter="creationTimestamp<'2026-07-01'" --format="value(name)".
  2. Confirm none are needed for restores or retention obligations.
  3. Delete them: gcloud compute snapshots delete SNAP1 SNAP2.
  4. Prevent recurrence with snapshot schedules that set --max-retention-days.

Exam tip: Orphaned snapshots keep billing after their disks are gone; find them with snapshots list --filter and remove them with snapshots delete.

Managing Compute Engine, GKE, and Cloud Run: Day-2 Operations — the lesson that teaches this.

Question 4Ensuring the successful operation of a cloud solution

You have just been granted access to an existing GKE cluster. Before making changes, you want a quick inventory of every Pod running in the cluster, across all namespaces, including which node each Pod is scheduled on. Which command should you run after fetching cluster credentials?

Choose one.

  • a
    kubectl get nodes -o wide

    get nodes lists the cluster's nodes and their versions/IPs, but shows nothing about which Pods are running.

  • b
    kubectl get pods --all-namespaces -o wide Correct

    get pods --all-namespaces lists Pods in every namespace, and -o wide adds the node name, Pod IP, and other placement details.

  • c
    gcloud container clusters describe CLUSTER_NAME

    clusters describe returns cluster-level configuration (node pools, networking, versions) from the GKE control plane, not the live Pod workload inventory.

  • d
    kubectl describe deployment --all-namespaces

    Describing Deployments shows replica counts and events for Deployment objects only; it misses Pods from StatefulSets, DaemonSets, and Jobs and doesn't produce a per-Pod node listing.

The concept

Cluster inventory in GKE is a kubectl task: gcloud manages the cluster resource itself, while kubectl queries the Kubernetes API for live objects like nodes, Pods, and Services.

Why that’s the answer

kubectl get pods --all-namespaces (or -A) is the one command that enumerates every Pod regardless of namespace or owning controller, and the -o wide output format appends the NODE column you need. Node listings, gcloud describe output, and Deployment summaries each answer a different question and would miss Pods or their placement.

How to reason it out
  1. Fetch credentials: gcloud container clusters get-credentials CLUSTER_NAME --region=REGION.
  2. Run kubectl get pods --all-namespaces -o wide to list every Pod with its node, IP, and status.
  3. Follow up on any anomaly with kubectl describe pod POD -n NAMESPACE for events and details.

Exam tip: kubectl get pods -A -o wide is the fastest full-cluster Pod inventory, including node placement.

Managing Compute Engine, GKE, and Cloud Run: Day-2 Operations — the lesson that teaches this.

Question 5Ensuring the successful operation of a cloud solution

A new GKE Standard cluster in project team-apps runs Pods whose images live in an Artifact Registry repository in project shared-registry. The repository already serves clusters in other projects. The new Pods stay in ImagePullBackOff, and their events show a 403 Forbidden on the pull. The image path and tag are correct. Security policy forbids creating service account keys. What should you do?

Choose one.

  • a
    Grant the node service account roles/artifactregistry.reader in shared-registry. Correct

    Nodes pull as the node pool's service account; a 403 from a repository in another project means that account has no read grant there.

  • b
    Grant the node service account roles/artifactregistry.reader in team-apps.

    The right role in the wrong project: permission must be granted where the repository lives, not where the cluster runs.

  • c
    Add an imagePullSecrets entry holding an exported service account key to each Pod.

    An imagePullSecret built from an exported key would authenticate the pull, but creating that key breaks the security policy in the stem; an IAM grant to the node service account needs no key at all.

  • d
    Enable the Artifact Registry API in shared-registry and recreate the failing Pods.

    The repository already serves other clusters, so the API is enabled there; a disabled API would also give a different error than a 403 on the image.

The concept

GKE nodes authenticate to Artifact Registry as the node pool's service account. Pulls from a repository in another project need an explicit Artifact Registry read grant in the repository's project.

Why that’s the answer

A 403 on pull is an authorisation failure: the node service account from team-apps has no roles/artifactregistry.reader binding on the repository in shared-registry. Granting it there (on the repository or the project) lets the kubelet pull. The tempting near-twin grants the same role in the cluster's own project, which has no effect on another project's repository. An imagePullSecret would need an exported service account key, which the security policy forbids, and the API is evidently already enabled.

How to reason it out
  1. Read the symptom: 403 Forbidden means authentication worked but authorisation failed.
  2. Find the node service account: gcloud container node-pools describe POOL --cluster=CLUSTER --format="value(config.serviceAccount)".
  3. Grant it read access where the images live: gcloud artifacts repositories add-iam-policy-binding REPO --project=shared-registry --location=LOCATION --member=serviceAccount:NODE_SA --role=roles/artifactregistry.reader.
  4. Delete or wait for the Pods to retry the pull and confirm they reach Running.

Exam tip: Cross-project ImagePullBackOff with a 403: grant the node service account roles/artifactregistry.reader in the project that owns the repository.

Managing Compute Engine, GKE, and Cloud Run: Day-2 Operations — the lesson that teaches this.

Question 6Ensuring the successful operation of a cloud solution

Your GKE Standard cluster runs general-purpose workloads on its default node pool. A data science team now needs to run inference Pods that require NVIDIA GPUs. The nodes in the default pool must not be recreated or modified. What should you do?

Choose one.

  • a
    Update the default node pool with --accelerator so its nodes are recreated with GPUs.

    You cannot add GPUs to an existing node pool, and recreating the default pool's nodes is exactly what the stem forbids.

  • b
    Create a GPU node pool and target it with a gke-accelerator node selector. Correct

    GPUs are set when a node pool is created; a separate GPU pool leaves the default pool untouched, and the cloud.google.com/gke-accelerator selector plus nvidia.com/gpu requests place the Pods there.

  • c
    Add nvidia.com/gpu limits to the Pods and let the default pool supply the GPUs.

    In GKE Standard a GPU limit does not add hardware to existing nodes; with no GPU nodes the Pods stay Pending.

  • d
    Create a TPU node pool and target it with a gke-tpu-accelerator node selector.

    TPUs are Google's own accelerators, not NVIDIA GPUs, so Pods built for CUDA on NVIDIA hardware would not run on them.

The concept

In GKE Standard, accelerators are a property of a node pool fixed at creation. Heterogeneous hardware is served by several node pools in one cluster.

Why that’s the answer

Creating a dedicated GPU node pool adds GPU nodes beside the existing pool without touching it. GKE installs the NVIDIA driver by default, and the Pods request nvidia.com/gpu and use the cloud.google.com/gke-accelerator node selector to land on those nodes. GPUs cannot be added to an existing pool, a GPU limit alone does not create GPU hardware in Standard mode, and a TPU pool provides the wrong accelerator family.

How to reason it out
  1. Note the constraint: the default pool's nodes stay as they are.
  2. Create the pool: gcloud container node-pools create gpu-pool --cluster=CLUSTER --machine-type=g2-standard-8 --accelerator=type=nvidia-l4,count=1 --num-nodes=1.
  3. Add resources.limits nvidia.com/gpu: 1 and a cloud.google.com/gke-accelerator node selector to the inference Pods.
  4. Verify placement with kubectl get pods -o wide.

Exam tip: GPUs in GKE Standard come from a new GPU node pool; you can't add GPUs to an existing pool.

Managing Compute Engine, GKE, and Cloud Run: Day-2 Operations — the lesson that teaches this.

What ACE domain 3 tests, topic by topic

The official exam guide breaks Ensuring the successful operation of a cloud solution into 4 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published ACE practice questions per topic in Ensuring the successful operation of a cloud solution
TopicWhat it coversQuestions
Managing compute resourcesOfficial ACE exam-guide sub-section. Remotely connecting to Compute Engine; viewing running instances; snapshots and images (create/view/delete/schedule); viewing GKE inventory (nodes, Pods, Services); configuring GKE access to Artifact Registry; working with node pools (add/edit/remove, autoscaling); working with Kubernetes resources (Pods, Services, StatefulSets); horizontal/vertical Pod autoscaling; GKE Autopilot Pod resource requests; deploying new Cloud Run versions; traffic splitting (Cloud Run, functions, GKE); Cloud Run autoscaling; attaching GPUs/TPUs; deploying an agent to Agent Runtime; managing notebooks (Workbench, BigQuery); managing developer environments (Cloud Workstations).36
Managing storage and data solutionsOfficial ACE exam-guide sub-section. Managing and securing objects in Cloud Storage buckets; object lifecycle management policies; executing queries against data instances (Cloud SQL, BigQuery, Bigtable, Spanner, Firestore, AlloyDB); estimating storage costs; backing up and restoring database instances; reviewing job status (Dataflow, BigQuery); using Database Center to manage the database fleet; configuring customer-managed encryption keys (CMEK).36
Managing networking resourcesOfficial ACE exam-guide sub-section. Resizing a subnet's IPv4 range; reserving static external or internal IP addresses; adding custom static routes in a VPC; using Cloud DNS and Cloud NAT; managing VPC firewall rules and Cloud NGFW policies.36
Monitoring and loggingOfficial ACE exam-guide sub-section. Creating Cloud Monitoring alerts on resource metrics; creating and ingesting custom metrics; configuring audit logs (VPC Flow Logs, audit logs, firewall logs); exporting logs to external systems; configuring log buckets, log analytics, and log routers; viewing and filtering logs in Cloud Logging; using diagnostic tools (Cloud Trace, Cloud Profiler, Query Insights); Personalized Service Health; configuring Ops Agent; deploying Managed Service for Prometheus; using Gemini Cloud Assist for Monitoring; Active Assist; Cloud Hub.38
Total146

Revise Ensuring the successful operation of a cloud solution before you drill it

Other ACE domains

Ensuring the successful operation of a cloud solution: your questions

Ensuring the successful operation of a cloud solution is domain 3 of the ACE exam guide and carries 30% of the scored content — the heaviest of the 4 domains. On a 55-question paper that works out to roughly 17 questions, though Google Cloud does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official ACE exam guide.