Skip to content

Diagnostic questions: Designing and Planning a Cloud Solution Architecture :Preparing for your Professional Cloud Architect Journey (Preparing for Google Cloud Certification: Cloud Architect Professional Certificate) Answers 2025

Question 1

Processing drone telemetry, keeping data rarely accessed β†’ Managed, streaming pipeline β†’ Dataflow + Nearline

🟩 Ingest with ClearBlade IoT Core β†’ Pub/Sub β†’ Dataflow β†’ store in Nearline Cloud Storage
❌ Ingest with IoT Core β†’ store in BigQuery
❌ IoT Core β†’ Dataprep β†’ Coldline
❌ IoT Core β†’ Pub/Sub β†’ BigQuery β†’ Standard storage

Explanation:
You need managed services, real-time processing, and cheap long-term storage.
Nearline is ideal for data accessed monthly.


Question 2

KPI for SLO must be measurable and time-bound (latency or success rate).

🟩 Low latency for >85% of requests when aggregated over 1 minute
❌ 85% success aggregated over 1 min (not tied to UX)
❌ 85% success (not time-bound)
❌ 85% satisfied users (subjective)

Explanation:
Latency is the most important SLO metric for user experience.


Question 3

Application needs 30 GB RAM β†’ cheapest is a custom machine β†’ not preemptible.

🟩 Stop VM β†’ set-machine-type β†’ 2-custom-4-30720 β†’ Start VM
❌ Use e2-standard-8 + preemptible
❌ Custom + preemptible
❌ e2-standard-8

Explanation:
You need 30 GB RAM + lowest cost β†’ Custom machine.
Preemptible instances are NOT appropriate for production workloads.


Question 4

You want custom IP ranges with RFC 1918 class B (172.16.0.0/12).

🟩 Create new project β†’ delete default VPC β†’ create custom VPC β†’ use 172.16.x.x
❌ Auto mode VPC
❌ Leave default VPC
❌ Use 192.168.x.x + peering

Explanation:
To avoid conflicts for future Interconnect β†’ always use custom mode + your own private CIDR planning.


Question 5

Two different GCP organizations β†’ need private, low-latency connectivity β†’ VPC Peering allowed across orgs.

🟩 Ensure no IP overlap β†’ enable VPC Network Peering
❌ Same IP ranges
❌ Carrier Peering
❌ Shared VPC (same org required)

Explanation:
Shared VPC does NOT work across different organizations.
VPC Peering enables private, low latency communication without egress charges.


Question 6

Your network cannot meet Google’s peering requirements.
You only need access to Google Workspace and Google APIs.

🟩 Use Carrier Peering
❌ Partner Interconnect
❌ Dedicated Interconnect
❌ Direct Peering

Explanation:
Carrier Peering is for public Google services like Workspace, YouTube, Maps, and does NOT require special conditions.


Question 7

Need managed NoSQL, low-latency, petabyte-scale β†’ Bigtable

🟩 Create Bigtable β†’ migrate MongoDB β†’ import into Bigtable
❌ Firestore Native
❌ Firestore Datastore
❌ BigQuery

Explanation:
Bigtable is a wide-column, massively scalable, low-latency NoSQL managed database.


Question 8

Legacy VM app stores lots of filesystem data β†’ needs stable identity + persistent storage.

🟩 Create a StatefulSet
❌ Container build
❌ Deployment
❌ Single Pod

Explanation:
StatefulSets provide persistent volume claims, ordered startup, and stable network IDs.


Question 9

Migrate VMs β†’ containers β†’ automated pipeline.

🟩 Use Migrate for Anthos
❌ Manual GKE + Anthos
❌ Cloud Build
❌ Migrate for Compute Engine

Explanation:
Migrate for Anthos = VM β†’ container migration automation.


Question 10

Monolith VM, need to scale-out instead of scaling-up.

🟩 Use containers + GKE autoscaling deployment
❌ Move code + attach volumes
❌ MIG + startup script
❌ VMs + persistent volumes

Explanation:
GKE horizontal pod autoscaling allows scale-out.


🧾 Summary Table

Q# Correct Answer Key Concept
1 IoT Core β†’ Pub/Sub β†’ Dataflow β†’ Nearline Streaming + rare access = Nearline
2 Latency >85% KPI for SLO
3 Custom machine type Cheapest way to increase RAM
4 Custom VPC + 172.16.x.x Avoid IP conflicts
5 VPC Peering (no overlap) Private cross-org access
6 Carrier Peering Public Google services
7 Bigtable Massive NoSQL scaling
8 StatefulSet Persistent pod storage
9 Migrate for Anthos VM β†’ container automation
10 GKE autoscaling Scale-out microservices