Prepare and test your skills
Prepare and test your skills
The Google Cloud Well-Architected Framework (opens in a new tab) is a set of validated recommendations for building secure, efficient, resilient, high-performing, cost-effective, and sustainable topologies. The recommendations apply to cloud-first workloads, migrated on-premises workloads, hybrid deployments, and multi-cloud environments. The framework organizes guidance into pillars for single areas such as operations or reliability and perspectives that cut across pillars for technologies such as AI and ML or sectors such as financial services.
The framework defines six pillars that work together:
Operational excellence is the discipline of deploying, operating, monitoring, and managing workloads in a consistent and efficient way. Operationally excellent architectures use automation instead of repeated manual steps, so deployments, configuration changes, and responses happen the same way every time. Continuous monitoring provides visibility into workload health, which lets teams detect problems early and keep operations stable as systems change.
Operational excellence also depends on designing for change and documenting the architecture fundamentals (opens in a new tab). Designing for change means delivering small changes regularly and getting fast feedback on each change, often tracked with DevOps Research and Assessment (DORA) delivery metrics for speed, ease, and safety. Documenting the architecture creates a common language and standards, so cross-functional teams can visualize deployments and collaborate as the system evolves.
Reliability is the ability to design and operate workloads that stay resilient and highly available through inevitable failures. Reliable design starts by planning for failure, because natural disasters, fiber cuts, and complex infrastructure failures will cause outages even on very reliable infrastructure. At cloud scale, architects plan around the stated reliability of Google Cloud products rather than single servers, and they use Recovery Time Objective (RTO) for allowed downtime and Recovery Point Objective (RPO) for allowed data loss to choose infrastructure and disaster recovery (DR) mechanisms.
Core principles support both operational excellence and reliability by making systems easier to change, operate, and recover. Simplified, decoupled, and stateless designs limit the impact of a failure or update in one part, while small frequent changes and clear documentation keep risk low and teams aligned. Disaster recovery planning extends this by defining how workloads survive zone or region loss and return to normal, including business constraints such as data residency that limit where workloads can fail over and therefore shape achievable RTO and RPO.
Exam tip: Availability is the ability for a product to be meaningfully accessed and used over time, while reliability is broader and includes availability plus attributes such as durability and correctness.
Cost and performance optimization is the joint practice of meeting demand without paying for idle capacity. Over-provisioning creates unnecessary cost because idle capacity is still billed, while under-provisioning causes bottlenecks that hurt application performance and user experience. Efficient design also supports sustainability, because work that finishes faster holds compute for less time and the hardware consumes fewer kilowatt-hours of energy.
Right-sizing and autoscaling implement this balance in different situations. Right-sizing continuously monitors utilization and adjusts allocation to fix a steady mismatch, with data flowing from Cloud Monitoring to Recommender, which analyzes history and suggests changes such as reducing machine size. Autoscaling handles demand that rises and falls over time by defining minimum and maximum capacity and adding capacity when demand rises and removing it when demand falls.
| Option | What it scales | How scaling is triggered |
|---|---|---|
| Compute Engine managed instance groups (MIGs) | Group of virtual machines (VMs) managed as one entity | Policy adds VMs when CPU utilization reaches a threshold and removes VMs when it drops |
| Google Kubernetes Engine (GKE) | Cluster nodes and Pod replicas | Cluster Autoscaler, Horizontal Pod Autoscaler, Vertical Pod Autoscaler, and Node Auto-Provisioning respond to Pod demands and usage patterns |
| Cloud Run | Serverless container instances | Built-in autoscaling adjusts instances up as traffic increases and down as traffic decreases |
Selecting resource types and cost models further controls spend without harming peaks. Managed and serverless options shift work to Google, while committed use discounts (CUDs) reward one-year or three-year commitments, sustained use discounts reward consistent Compute Engine use, and Spot VMs offer unused capacity at lower cost. Cloud Billing budgets, alerts, and tagging by project or department track spending by owner so high-usage areas can be found and resized.
Security, privacy, and compliance (opens in a new tab) integration means building protection, privacy, and regulatory requirements into every stage of the architecture. The pillar requires collaboration across security architects, developers, DevSecOps teams, and compliance and risk managers. It covers cloud-first, migrated, hybrid, and multi-cloud workloads that must align with standards such as HIPAA and GDPR.
The shared responsibility model divides security ownership between Google and the customer. Google secures the underlying infrastructure, physical facilities, and foundational services, while the customer secures data, applications, identities, configurations, and access controls. Customer responsibility grows from software as a service (SaaS) to platform as a service (PaaS) to infrastructure as a service (IaaS), and Google adds shared-fate help such as blueprints, Assured Workloads, Security Command Center, organization policies, and risk programs.
Least privilege through Identity and Access Management (IAM) enforces zero trust, a never trust, always verify approach where every request is authenticated, authorized, and continuously verified. Verification flows from a central identity, federated from Active Directory or managed in Cloud Identity or Google Workspace, through context checks on role, device, and location before Identity-Aware Proxy (IAP) or resource IAM allows the connection. Data protection completes the model across three states, data at rest, in transit, and in use, where VPC Service Controls contains API calls inside a perimeter, Cloud Key Management Service (Cloud KMS) manages keys for stored data, and Confidential Computing encrypts data during processing.
Continue with this study guide: Familiarity with the Google Cloud Well-Architected Framework
High availability and fail-over design is the practice of keeping applications reachable through hardware, software, zone, and region failures without manual action. In Google Cloud, resilient systems (opens in a new tab) combine Cloud Load Balancing to steer traffic, health checks to decide which backends can receive traffic, and Compute Engine managed instance groups (MIGs) to replace failed virtual machines (VMs) and adjust capacity. Traffic flows from clients to surviving zones or regions when a failure occurs.
Cloud Load Balancing distributes traffic across backends so no single VM, zone, or region becomes a single point of failure. A forwarding rule defines one entry point using an external IP address, and the load balancer spreads requests from that entry point across configured backends. When a backend or location becomes unreachable, the load balancer automatically steers traffic to remaining healthy capacity.
A left-to-right process flow showing a client request entering the closest Google Front End via one anycast IP, passing Cloud Armor edge policies and Cloud CDN cache check, then backend policy check to healthy regional MIG backends.
Health checks provide the signal that controls this steering. Traffic flows from the client to the forwarding rule, then from the load balancer to backend VMs that pass health checks and away from VMs that fail them. Health checking covers both a stopped VM and a running VM whose application is frozen, crashed, or out of memory, so business-critical steering depends on the data plane continuing to avoid unhealthy backends. MIGs add self-repair behind this steering through autohealing, which deletes and recreates unhealthy VMs from an instance template, and autoscaling, which adds or removes VMs on demand signals.
| Option | Traffic scope | Failover behavior |
|---|---|---|
| Regional load balancer | Spreads traffic across VMs in multiple zones within one region | Survives zone failure inside the region; cross-region recovery uses Cloud DNS routing to point clients to the load balancer in the failover region |
| Global load balancer | Receives traffic at the edge nearest the client and distributes it across regions | Automatically diverts traffic to another region if a region is unreachable, keeping the same external IP address |
Exam tip: A global load balancer keeps the same external IP address during automatic cross-region failover, while a regional load balancer in a failover region requires a Cloud DNS routing change to send clients to the new region.
Regional and multi-regional redundancy places copies of compute and storage in different failure boundaries so no single outage stops the application. Google Cloud targets 99.9% availability for single-zone, 99.99% for multi-zone, and 99.999% for multi-region deployments, with a minimum of three distinct zones in every general-purpose region designed to minimize correlated failure. Resource scope defines which outage a resource can survive based on where its copies run.
Compute Engine VMs are zonal resources that run in one zone, so a zone outage can make them unavailable. Regional resources such as regional buckets, regional Persistent Disk, regional MIGs, VPC subnets, regional external Application Load Balancers, regional Spanner instances, and Cloud Run services are redundantly deployed across zones in one region for higher availability. Managed multi-regional resources such as multi-region Cloud Storage buckets, multi-region Spanner instances, Firestore, and BigQuery are distributed within and across regions to keep functioning after loss of a single region, while global resources such as VPC networks, Cloud DNS zones, global load balancers, Pub/Sub topics, and IAM policies do not depend on any single region.
A single point of failure (SPOF) is any component that depends on one resource, so failure of that resource makes the whole stack fail. SPOFs are removed by distributing resources across locations and deploying redundant capacity in each tier, so the load balancer forwards requests to remaining instances in other zones or regions and a regional MIG creates a new VM to maintain minimum count. Regional strategies keep data flow inside one region for low latency and no cross-region transfer cost, using regional MIGs, regional Google Kubernetes Engine (GKE) clusters, regional Persistent Disk with synchronous replication across two zones, and Cloud SQL high availability (HA) with synchronous standby in another zone. Multi-regional strategies keep independent stacks or replicated data in more than one region for region loss, at higher cost and complexity, which fits business-critical workloads where high availability is essential.
Data persistence and disaster recovery planning keeps stateful data durable, available, and recoverable after zonal, regional, or corruption events. Recovery is measured with Recovery Time Objective (RTO) for how long data can stay unavailable and Recovery Point Objective (RPO) for how much written data can acceptably be lost. Synchronous replication favors low RPO by confirming writes in multiple locations, while asynchronous replication favors distance and cost but leaves a lag that affects RPO and RTO.
Firestore in regional mode synchronously replicates across at least three zones, while Firestore in multi-region mode synchronously replicates across five zones in three regions with two serving regions and one witness region for 99.999% availability versus 99.99% regional. Cloud Storage confirms an object write after redundant storage in one initial region across at least two zones, then asynchronously replicates object data to a second place for dual-region and multi-region buckets while metadata is written synchronously. Default replication targets 99.9% of new objects within one hour and 100% within 12 hours, while turbo replication on dual-region buckets targets 100% within 15 minutes, and dual-region and multi-region buckets serve from an available region with a designed RTO of zero and no manual failover.
Stateful database recovery combines continuous replication for outages with backups and point-in-time recovery (PITR) for corruption or deletion. Cloud SQL uses automated backups with binary logging for PITR to a fresh instance, HA with cross-region replicas, and Enterprise Plus for zero-data-loss cross-regional failover. Spanner supports export to Avro in Cloud Storage with Dataflow re-import, incremental backups, managed backup retained up to one year, and PITR up to seven days in the past. BigQuery replicates data to two zones in one region, so corruption or regional loss still needs time travel within seven days, cross-region dataset copies, or original data kept in Cloud Storage for reload.
Continue with this study guide: High availability and fail-over design
Flexibility of cloud resources is the ability to match capacity to actual demand and to run workloads where they fit best without rewriting them. In Google Cloud, portability comes from a common runtime layer, while cost flexibility comes from right-sizing, autoscaling, and choice of provisioning model. Together these practices let an architecture stay movable and stay efficient as needs change.
A portable workload is an application that moves between computing environments without major changes to code or to how it is deployed and managed. Portability requires consistent deployment, configuration, visibility, and security across environments so operations work the same way everywhere. Portable design does not prevent cloud-first design, so teams can still use managed services while keeping the option to move.
Containers and Kubernetes create a common runtime layer that hides infrastructure differences between edge, on-premises, and cloud. Containers decouple applications from the underlying host, so software runs reliably when it moves, while Kubernetes handles orchestration, deployment, scaling, and management through the same services and APIs in cloud and private environments. Kubernetes is open source governed by the Cloud Native Computing Foundation (CNCF), widely adopted so teams reuse expertise and third-party support, and supports Container Runtime Interface (CRI) implementations that are not tied to one vendor.
Google Kubernetes Engine (GKE) is the managed Kubernetes platform for running modern applications at scale on Google Cloud, on-premises, at the edge, and in other clouds. GKE Autopilot manages cluster configuration including nodes, scaling, and security with preconfigured settings and per-cluster limits. For multicluster use, GKE organizes clusters as fleets, which are logical groupings with consistent security, configuration, and service management, and Google Distributed Cloud extends the model to on-premises and edge, including connected clusters linked to Google Cloud.
| Option | When to use it | What it provides |
|---|---|---|
| GKE hybrid environment | Build cloud-like experiences on-premises or transition toward Google Cloud | Unified solution for running and migrating workloads between on-premises and Google Cloud |
| GKE Multi-Cloud | Run and govern clusters across multiple public clouds | Consistent governance, operations, and security posture across clouds |
Portability still has limits after containerization because compute, security, networking, and proximity to dependencies differ between environments. Moving a workload can require moving data because storage services differ, and load balancer behavior provisioned through Kubernetes can also differ. Consistent operations reduce this friction through a central management plane, identical binaries and CI/CD tooling such as Tekton pipelines, common identity across boundaries, encryption with virtual private network (VPN) or Transport Layer Security (TLS), and Apigee as a unifying facade that shields clients from backend changes.
Resource optimization matches Google Cloud capacity to real demand so performance stays strong without paying for idle resources. Right-sizing means continuously monitoring utilization and adjusting allocation, where over-provisioning creates cost and under-provisioning creates bottlenecks. Cloud Monitoring provides real-time visibility into CPU, memory, network, and disk I/O, Recommender analyzes that data to suggest more efficient machine types, and custom metrics and alerts let administrators adjust before performance suffers.
Provisioning models reduce the billing rate in exchange for commitment or tolerance for interruption. Pricing models change over time, so architectures should be reviewed regularly for better-performing or lower-cost alternatives. Enterprise discounts add negotiated savings on total spend, on top of which committed use discounts (CUDs) can add further savings, while reservations guarantee capacity in a specific zone for a chosen machine type.
| Provisioning option | Commitment | Discount scope | Choose when |
|---|---|---|---|
| Spot VMs | No commitment; Compute Engine can preemptively stop or delete VMs | Per VM, more than 80% cheaper than regular VMs | Workload is fault-tolerant and flexible, such as batch jobs that tolerate preemption |
| Resource-based CUDs | Commit to minimum Compute Engine resources for one or three years | Specific region, with sharing across projects in most billing accounts | Usage is stable and regionally predictable |
| Spend-based CUDs | Commit to minimum spend on a product for one or three years | Billing account level, regionally or globally by product | Spending is predictable but needs regional or global flexibility |
Exam tip: Choose Spot VMs for interruptible, fault-tolerant work that can be stopped, and choose CUDs for stable, long-running usage that will consume a one-year or three-year commitment.
Elastic scaling is the ability to add and remove capacity automatically as demand rises and falls. Managed Instance Groups (MIGs) are homogeneous groups of Compute Engine VMs that operate as one scalable unit, where the autoscaler adds VMs when load increases and removes VMs when load decreases. A regional MIG distributes VMs across zones in a region to keep capacity if one zone is disrupted, while a zonal MIG keeps all VMs in one zone.
Automated scaling in Compute Engine adjusts MIG size in response to real-time signals from Cloud Monitoring, which ingests events, metrics, and metadata and exposes them through dashboards and alerts. The autoscaler watches a configured signal, compares it to a target, and adds or removes VMs to hold performance steady during peaks and save cost during dips. MIGs combine this scaling with autohealing, where health checks detect unhealthy VMs and recreate them, and the load balancer sends traffic only to healthy VMs so a failed VM receives no user requests during replacement.
| Autoscaling signal | What the autoscaler watches | Choose when |
|---|---|---|
| CPU utilization | Average processor use across VMs | Demand correlates closely with processor load |
| Cloud Monitoring metrics | Standard or custom metrics such as requests, latency, or queue depth | Processor use alone does not reflect user experience |
| Load-balancing serving capacity | Utilization or requests per second in the backend service | VMs sit behind a load balancer and become over or under capacity |
| Schedules | Time of day, week, or known events | Load follows a predictable calendar such as business hours |
Traffic flows from clients to a forwarding rule, from the forwarding rule to Cloud Load Balancing, and from the load balancer to healthy VMs in backend MIGs. Reliable elasticity also needs capacity planning with N+1 redundancy beyond forecast minimum, benchmarking under normal and peak load, quota management for resource quotas on maximum resources and rate quotas on API requests, reservations for assured capacity, and fast startup through pre-baked images and containerization so new capacity becomes ready in seconds to minutes.
Continue with this study guide: Flexibility of cloud resources
Scalability to meet growth requirements is the ability of databases, storage, compute, and traffic management to handle more users, transactions, and data without redesigning the application. In Google Cloud, patterns for scalable and resilient apps (opens in a new tab) grow the data tier through horizontal or vertical scaling, grow compute through autoscaling and serverless elasticity, and spread traffic through global load balancing with quota safeguards. Together these controls keep latency low during rapid growth and keep backends from becoming bottlenecks.
Choosing a database for growth is a decision between horizontal scale across regions and vertical scale within a region. Cloud Spanner scales throughput and storage horizontally by distributing data across many replicas that all serve traffic. Cloud SQL scales vertically by moving the primary to a larger machine and scales reads horizontally with replicas.
| Service | Scaling model | Replication and availability |
|---|---|---|
| Cloud Spanner | Horizontal, multi-region scale for reads and writes | Built-in synchronous replication across zones and regions in an active-active topology |
| Cloud SQL | Vertical scale plus read replicas for read-intensive workloads | High availability (HA) with primary and standby, plus cross-region and cascading read replicas that require promotion on failover |
A regional Spanner configuration maintains three read-write replicas in different zones, each holding a full copy that can serve reads and writes, while a multi-region configuration extends across regions with read-write replicas plus a witness replica. Traffic flows from application tiers in any region to the multi-region instance while Spanner keeps copies consistent. A Cloud SQL HA instance, also called a regional instance, holds a primary in one zone and a synchronous standby in another zone with automatic failover on the same endpoint, while cross-region replicas offload reads and can be promoted to a new primary, with their own HA and cascading replicas for continued protection.
Expanding storage for massive growth means selecting block, file, and object storage that replicates as capacity increases. Zonal Persistent Disk volumes store data in one zone, while regional Persistent Disk provides synchronous replication across two zones for zone-outage resilience. Hyperdisk Balanced lets teams provision input/output operations per second (IOPS) and throughput separately, regional Cloud Storage buckets replicate synchronously across zones, dual-region or multi-region buckets store data redundantly in at least two places with turbo replication for a 15-minute RPO on dual-region buckets, and Filestore regional instances share data across VMs with synchronous replication across three zones.
Exam tip: Choose Cloud Spanner when the workload needs horizontal scaling of both reads and writes across regions; choose Cloud SQL with read replicas when the need is vertical growth of one primary plus scaling of reads.
Compute autoscaling adjusts capacity dynamically so resources are added where needed without permanent over-provisioning. Horizontal scaling adds more replica instances to distribute load, while vertical scaling replaces components with larger ones that have more CPU, memory, and storage. Horizontal scaling is preferred for most cloud-first applications because it is more resilient, more cost-efficient for variable load, and virtually unlimited compared to the hard limits of one large VM.
Compute Engine managed instance groups (MIGs) are groups of VMs managed and scaled as one entity under an autoscaling policy that defines minimum and maximum VMs and scaling conditions. When average demand exceeds the target, the autoscaler creates instances, and when demand falls, it removes unneeded instances. A MIG autoscaler can respond to CPU utilization such as 75%, load balancer serving capacity, request latency, or Cloud Monitoring custom metrics such as queue depth, so a queue worker scales on queue depth while a web front end scales on utilization.
Reactive, predictive, and scheduled scaling control timing. Reactive scaling responds to real-time load but can take minutes to add VMs and lag a sudden surge, predictive autoscaling forecasts from historical trends and recomputes every few minutes, and scheduled scaling pre-provisions ahead of known demand such as business hours or seasonal sales. Cloud Run scales stateless containers automatically between minimum and maximum on incoming traffic and scales to zero when idle, while Cloud Run functions (formerly Cloud Functions) provides the same request-driven elasticity for event-driven code. Stateless design with session state in Memorystore for Redis and modular services that scale independently on their own bottleneck metric let both MIGs and serverless platforms add or remove instances without data loss.
Global traffic management spreads user requests across regions for low latency while quotas and reserved capacity prevent bottlenecks. Global external Application Load Balancer is a proxy-based Layer 7 load balancer that advertises a single anycast IP implemented by many proxies on Google Front Ends (GFEs), so a request goes to the closest GFE and then to a healthy backend with capacity. In a typical design, regional MIGs serve as backends in different regions, and the global load balancer sends each request based on availability, capacity, and proximity.
A request through the programmable front end moves in a fixed order where filtering and caching happen before backend compute is used. First, traffic arrives at the closest GFE and is evaluated by Google Cloud Armor edge policies. Second, Cloud CDN checks for cached content and returns it on a hit. Third, backend security policies evaluate the request on a cache miss. Fourth, the request flows from the load balancer to the selected backend in Compute Engine, GKE, Cloud Run, or another supported backend. This order matters because malicious traffic and repeatable content do not consume application capacity during growth.
| Option | Backend scope | Choose when |
|---|---|---|
| Global load balancer | Backends in multiple regions | External traffic must shift across regions for proximity, capacity, and high availability |
| Regional load balancer | Backends in a single region | All backends are in one region and global distribution is not needed |
Health checks keep traffic on backends that can actually serve requests, because a VM can be in the RUNNING state while its application has crashed. The load balancer routes only to responsive backends, while MIG autohealing deletes unavailable VMs and creates replacements. Network Service Tiers control entry path, where Premium Tier carries traffic on the Google network from the point of presence (PoP) closest to the sender for lower latency at higher cost, versus Standard Tier over the public internet. Rate limiting, graceful degradation with early request drops and Apigee API controls, quota reviews before launch, and a Cloud DNS bypass with regional backup load balancers protect against surges and global load balancer misconfiguration.
Continue with this study guide: Scalability to meet growth requirements
Performance and latency optimization is the practice of proving where requests wait and then cutting that wait through monitoring, network path choice, and right-sized compute and storage. In Google Cloud, metrics flow from workloads into Managed Service for Prometheus and Cloud Monitoring, traffic enters through Network Service Tiers and global front ends, and instances perform up to the limits of machine type and disk size. The observe, identify, and adjust loop protects both throughput and user-perceived delay.
Observing load with Google Cloud Managed Service for Prometheus (opens in a new tab) and Cloud Monitoring means proving that traffic metrics flow from workloads into visible graphs. Managed Service for Prometheus scrapes metrics from Pods such as a vLLM model server and stores them for analysis, using the format vllm:metric_name such as vllm:gpu_cache_usage_perc for cache use. Data flows from the Pods to Managed Service for Prometheus and then to Cloud Monitoring, where a PromQL query in Metrics explorer graphs the result and a rising graph after load confirms scraping works.
Identifying bottlenecks for inference means watching queued requests and KV cache exhaustion together. The KV cache holds active request state, and when it fills, the queue of waiting requests grows. The Horizontal Pod Autoscaler (HPA) depends on one Prometheus metric with an averageValue target set experimentally, and scaling follows a fixed order where the HPA first scales the LeaderWorkerSet/vllm target, then GKE schedules another Pod, which triggers the node pool autoscaler to add a node before deploying the replica.
| Metric | What it measures | Choose when |
|---|---|---|
| num_requests_waiting | Number of requests waiting in the model server queue | Optimizing for throughput and cost, and latency targets are met at maximum throughput |
| gpu_cache_usage_perc | KV cache utilization, which correlates to requests per inference cycle | Workloads are latency-sensitive and queue-based scaling is not fast enough |
Verifying cache efficiency for cross-cloud and storage caches shows whether repeated reads avoid remote fetches. Intelligent Lakehouse caching stores remote blocks locally, so the first query fetches from remote object storage such as AWS Amazon S3 over TLS and later queries read from local Google Cloud storage. BigQuery JobStatistics2 reports cloud_provider, cache_bytes_read from local cache, and object_storage_bytes_read from remote storage per provider, where high cache bytes relative to remote bytes means the cache is working. Cloud Storage charts for bytes in cache, byte eviction rate, hit rate operations, and cache throughput benefit show whether low hit rates or high evictions explain repeated remote reads.
Network optimization cuts end-to-end latency for dispersed users by choosing the network entry path, edge termination point, and cache location. Network Service Tiers control how traffic moves between the internet and Google Cloud. With Premium Tier, inbound traffic enters the private high-performance Google network at the point of presence (PoP) closest to the sender, travels inside Google to the VM, and exits at the PoP closest to the destination. With Standard Tier, traffic travels over transit internet service providers (ISPs) and enters near the destination region with more hops and latency.
Global load balancing distributes external traffic to backends in multiple regions through one anycast IP. Each client is directed to the Google Front Ends (GFEs) closest to entry, which are software-defined systems in edge PoPs that terminate Transmission Control Protocol (TCP) or Transport Layer Security (TLS) at the edge and proxy requests to healthy backends with capacity. If a region fills, new connections spill to the next closest region with capacity while existing connections stay, and if a region fails, traffic fails over automatically. In a test with backends only in us-central1 and a user in Germany, direct access showed about 230 ms Time To First Byte (TTFB), while the global external Application Load Balancer showed about 1 ms ping to the nearby GFE and about 123 ms TTFB because the handshake ended at the edge.
| Option | Traffic flow | Scope |
|---|---|---|
| Global external Application Load Balancer | Terminates TCP or TLS at GFEs and proxies HTTP(S) with URL mapping and Secure Sockets Layer (SSL) offloading | Global |
| External passthrough Network Load Balancer | Forwards TCP, UDP, ESP, GRE, and ICMP packets unchanged using Maglev hashing on IP, port, and protocol | Regional, with global preview for multi-region backends |
Cloud CDN (Content Delivery Network) works with the front end so cacheable content returns from edge PoPs instead of the backend region. Traffic flows from the user to the closest GFE, through Google Cloud Armor edge policies, then to the Cloud CDN cache, where a hit returns directly and a miss goes through backend policy checks to the backend server. End-to-end latency has four segments, last-mile from device to ISP, frontend and edge PoP travel, Compute Engine region travel from edge to region, and app processing including database calls, where fiber sets a floor of about 200,000 km per second and region choice matters most when last-mile and app time are small.
Exam tip: Ping to a global external Application Load Balancer measures only to the nearby GFE, about 1 ms in the Germany test, while curl TTFB measures true latency to the backend, about 123 ms versus 230 ms without edge termination.
High-performance configuration matches machine type, disk size, and disk type to required input/output operations per second (IOPS), throughput, and memory. Storage capacity sets the default IOPS and throughput for an instance, while machine type sets the maximum the instance can reach. For Cloud SQL instances using Hyperdisk Balanced, the minimum is 3,000 IOPS and 140 MiB/s regardless of machine type, and custom IOPS and throughput can modify values on Hyperdisk Balanced.
Maximum limits by machine series grow with vCPU count, but high-availability storage has lower throughput ceilings at large sizes. The C4A machine series scales from 50,000 IOPS and 800 MiB/s at 2 vCPUs to 160,000 IOPS and 2,400 MiB/s at 48 to 72 vCPUs, while the N4 machine series scales to 80,000 to 160,000 IOPS and 1,200 to 2,400 MiB/s at 16 vCPUs and above. A 32-vCPU C4A instance allows 120,000 IOPS and 2,400 MiB/s with Hyperdisk Balanced but only 100,000 IOPS and 1,200 MiB/s with Hyperdisk Balanced High Availability. Default performance by disk size grows with capacity, from 4,000 IOPS and 170 MiB/s at 20 to 256 GB to 16,000 IOPS and 750 MiB/s over 1 TB to 4 TB, until very large disks are capped by the minimum of the size default or the machine-type maximum.
| Machine series | Maximum IOPS | Maximum throughput |
|---|---|---|
| C4A machine series | 160,000 IOPS at 48+ vCPUs | 2,400 MiB/s, or 1,200 MiB/s with high availability (HA) |
| C4 machine series | 50,000 IOPS at 2 to 8 vCPUs | 400 MiB/s at 2 to 4 vCPUs, 800 MiB/s at 8 vCPUs |
| N4 machine series | 160,000 IOPS at 48+ vCPUs | 2,400 MiB/s, or 1,200 MiB/s with HA |
Google Cloud Hyperdisk is durable network-attached block storage where data flows from the instance to the volume over the network. Available types fit different shapes, including Hyperdisk Balanced for general purpose, Balanced High Availability with synchronous replication across two zones, Extreme for higher IOPS where provisioned IOPS determines throughput, Throughput for sequential work, and ML for machine learning. Volumes can be shared, pooled, resized in use, and asynchronously replicated to a secondary region for regional failover with torn-write protection. Throughput stays flat until a bottleneck such as CPU exhaustion, lock contention, I/O wait, or network limits appears, when latency rises and operations per second fall, which a latency histogram reveals as a long tail or two clusters such as buffer-pool hits versus storage reads.
Continue with this study guide: Performance and latency
Gemini Cloud Assist (opens in a new tab) is an AI collaborator that turns natural language requirements into deployable architectures and helps operate, optimize, and secure them. The workflow pairs Gemini Cloud Assist with Application Design Center, an application design and deployment service for authoring, customizing, exporting, and deploying applications. Together they produce Terraform infrastructure as code (IaC) that follows Google Cloud best practices and can be deployed in a built-in or personal pipeline.
Generating designs from natural language prompts starts in the Cloud Assist panel, opened from the Google Cloud console toolbar and available from any console page. You describe what you want in plain language, and Gemini Cloud Assist returns a suggested architecture built from supported resource types. Detailed initial prompts produce better-aligned designs, and complex systems can be built across turns by defining one subsystem at a time, such as Cloud Run with Cloud SQL and a load balancer in a region, a data pipeline for asynchronous events, or a highly available Java web app with MySQL for bursty traffic.
Generating IaC templates and CLI scripts iteratively creates deployment artifacts through conversation in Application Design Center and Cloud Assist chat. Artifacts include Terraform code, Google Cloud CLI commands, and kubectl manifests, plus IaC for organizational policies that can be simulated in chat before deployment. Each recommendation explains the purpose of every product in the stack, but because Gemini Cloud Assist can generate plausible but incorrect output, every recommendation, Terraform snippet, and CLI command must be validated before use.
Moving from chat to a reusable design uses an ordered workflow:
Deploying the provisioned infrastructure starts by creating an application instance from the template, which carries the refined architecture and Terraform into deployment. Gemini Cloud Assist does not support applications created in a host project or a single-project boundary. If Application Design Center is unavailable, the design opens in preview mode for visualization and refinement, then Get Code downloads the Terraform for use with your own tools.
| Deployment path | How infrastructure is provisioned | Choose when |
|---|---|---|
| Deploy from the Google Cloud console | Application Design Center deploys the template and tracks changes and revisions | Centralized tracking of revisions in the console is needed |
| Download and deploy Terraform | Terraform configuration is downloaded and applied with your own tools | Existing pipelines or custom workflows must provision the infrastructure |
Exam tip: If you prompt while an Application Design Center template is open, suggested changes are applied directly to the canvas design; if you prompt outside a template, you receive an architecture diagram and must choose Edit App Design to load it into a template.
Operational monitoring with Gemini Cloud Assist uses AI assistance to explain errors, analyze logs, find root causes, and apply fixes that reduce downtime. Interactive troubleshooting with Cloud Assist chat provides quick explanations inside the console using project ID, organization ID, page context awareness, and session memory. Data flows from the current console page, including URL and visible text, to the chat response, so opening the resource page before asking gives more accurate help for issues such as a GKE Pod in CrashLoopBackoff, high latency for a GKE api-gateway service, a GKE node in NotReady status, or Cloud Run HTTP 429, 404, or 5XX errors.
Gemini Cloud Assist Investigations is the automated, in-depth analysis tool that acts as a user-guided site reliability engineer for complex failures. An investigation ingests signals from logs, metrics, and configurations, explores multiple hypotheses in parallel, and traces probable causes across multi-tier topologies down to application code. An investigation follows an ordered workflow where each stage depends on the previous result:
Proactive alert investigations are automatic investigations triggered by Cloud Alerting policies without a person asking. When an alert fires, data flows from the alerting policy to Gemini Cloud Assist, which analyzes the issue in the background, clusters related alerts, and generates preliminary root-cause analysis. Using investigations requires the Investigation Creator or Investigation Owner role, and transferring results to a case requires an enrolled support package.
Infrastructure optimization with Gemini Cloud Assist uses AI assistance to lower cost, improve performance, and harden security. Cost and resource recommendations depend on the Recommender API and Recommender Viewer role, which let Gemini read recommendation data to surface estimated savings, flag quotas near limits, and point to idle VMs or BigQuery datasets that should be partitioned or clustered. Cost analysis in Cloud Hub depends on the App Optimize API and Cloud Hub Operator role, which let Gemini summarize spending changes and report cost for a specific application or project.
Cost totals in responses are based on contract prices before committed-use discounts (CUDs) or other credits, and application totals include only resources fully used by that application, excluding shared resources. Database Center and AI troubleshooting extend this to Cloud SQL for PostgreSQL and MySQL, AlloyDB, BigQuery, Managed Service for Apache Spark, and Spanner by finding slow queries, managing slot reservations, and checking CPU, latency, error logs, and compliance issues. Security help links detection to action, where findings flow from the detection service to Gemini, Gemini explains risk and fix, and the team applies the change.
| Security capability | What Gemini reviews | How Gemini helps |
|---|---|---|
| Security worker | Findings from Security Command Center | Translates risks into steps to resolve exposure, secure service accounts, and improve compliance |
| Artifact Analysis | Vulnerabilities identified by Artifact Analysis | Answers questions about specific vulnerabilities to guide remediation |
| Artifact Registry | Repositories and images in Docker-format repositories | Lists inventory so teams can trace affected images |
Continue with this study guide: Gemini Cloud Assist
Backup and recovery is the practice of protecting stateful data so it survives zonal outages, regional outages, and logical corruption and can be restored within business limits. In Google Cloud, architecting disaster recovery for cloud infrastructure outages (opens in a new tab) uses cold, warm, and hot standby patterns, Persistent Disk snapshots with lifecycle-managed Cloud Storage backups, and database backups with point-in-time restoration. Recovery is measured with Recovery Time Objective (RTO) for allowed downtime and Recovery Point Objective (RPO) for allowed data loss, where smaller targets cost more because more infrastructure must stay running and more data must be continuously copied.
Recovery objectives and geographic scope define how fast recovery must be and what size of failure must be survived. High availability covers one region with synchronous replication between zones, while disaster recovery covers multiple regions with usually asynchronous replication and manual or semi-automated failover. Compute Engine VMs and Persistent Disk are zonal resources in one zone, regional resources span zones in one region and serve from another zone if one fails, and multi-regional resources are distributed across regions to survive regional loss with trade-offs in latency, consistency, and cost.
The cold standby pattern keeps no live application servers and restores everything from backups only after a disaster. Data flows from production to Cloud Storage through scheduled backups, while configuration is stored as custom Compute Engine images and a Deployment Manager template. Recovery follows an ordered sequence that first rebuilds compute, then restores data, then moves traffic:
The warm standby pattern keeps a minimal live recovery system so failover is faster than cold but cheaper than hot. A small database in Google Cloud runs at all times and receives replicated transactions through asynchronous or semi-synchronous replication, while web and application tiers are preserved as snapshots and custom images and scaled out with Deployment Manager during failover. Connectivity flows from on-premises to the virtual private cloud (VPC) over Cloud Interconnect with a self-managed virtual private network (VPN), data flows continuously to the standby replica, and Cloud DNS reroutes users on failure while the already-running database is promoted.
The hot standby pattern keeps two full environments active, with traffic flowing from clients to Cloud Load Balancing across zones or regions and data flowing between active databases through continuous replication. Managed multi-regional services such as Spanner and Cloud Storage provide built-in redundancy without manual restores, and RPO-zero designs write data in multiple locations before committing, which reduces loss but increases latency. Hot standby delivers the lowest RTO and RPO, often near zero, but carries the highest cost and complexity.
| Pattern | Readiness before disaster | Choose when |
|---|---|---|
| Cold standby | Only backups, snapshots, images, and templates; no running app servers | Higher RTO and RPO are acceptable and minimizing running cost matters most |
| Warm standby | Small live database replica with continuous replication; app tier scaled down | Moderate RTO and RPO are needed without full duplication |
| Hot standby | Two live environments with load balancing and continuous replication | Minimal downtime and data loss are required for critical operations |
Exam tip: Cold restores from backups after the disaster, warm keeps a live database replica while the app tier scales on failover, and hot keeps both environments live behind load balancing.
Persistent disks and snapshots provide durable block storage and point-in-time copies that remain independent of VM instances. Persistent Disk attaches to Compute Engine instances but can be detached and kept after deletion, with built-in redundancy against equipment failure. Snapshots capture only changed blocks after the first complete snapshot, take only minutes even on running instances, and can be copied across regions to recreate disks after a disaster. Snapshot copies flow from the source disk to snapshot storage and then to a new disk in the recovery zone or region, where multi-region snapshot locations remain available outside a failed region.
Automated snapshot schedules and retention control how much data can be lost and how far back recovery can go. Backup frequency determines RPO because time since the last backup is the maximum data at risk, while retention determines how far back the recovery point can move. The snapshot lifecycle follows an ordered sequence of schedule trigger at hourly, daily, or weekly intervals, incremental storage of only changed blocks, retention expiration that deletes snapshots to limit cost, and restore by creating a new disk from the selected snapshot. Consistency is controlled only at the block level, so file-system writes should be suspended during snapshots, and a 24-hour schedule can lose almost 24 hours if failure occurs just before the next backup.
Cross-region replication and regional durability determine whether recovery needs a restore step or can fail over directly. Regional Persistent Disk synchronously replicates writes across two zones in the same region, so a backup VM in the secondary zone can force-attach the disk after a zonal outage without restoring a snapshot. Persistent Disk Asynchronous Replication provides cross-region active-passive replication with low RPO and RTO, while snapshots in multi-region locations and managed multi-regional services such as Cloud Storage and Spanner cover regional rebuilds and active-active needs.
Cloud Storage lifecycle management moves backup copies through progressively lower-cost tiers as access becomes less frequent. Nearline is designed for backup accessed at most about once a month, Coldline for infrequent archival data, and Archive for lowest-frequency long-term retention, with lower storage cost traded for higher retrieval costs and longer minimum durations. Soft Delete preserves deleted objects for a period, object holds prevent deletion, and Bucket Lock enforces retention, so frequency and retention length must be balanced against durability needs.
Database recovery brings a relational or non-relational database back to a specific moment before failure, error, or disaster. Recovery combines a full backup with transaction or archive logs that record every change after that backup, where backup frequency controls RPO and readiness of infrastructure, software, and data at the recovery site controls RTO. A database recovery must also mirror production configuration with the same version and disk layout, then apply the full backup followed by later transaction logs, so a high-availability-first design with a nearby replica achieves smaller RTO and RPO than file copies alone.
Cloud SQL automated backups provide scheduled, managed backups without managing infrastructure, extended by point-in-time recovery (PITR) into a near-continuous model that restores to a specific temporal state between backups. The backup schedule must align with RPO, so a 15-minute RPO needs backups at least every 15 minutes, with consistency checks and restoration tested in non-production before it is needed. Spanner PITR recovers data from a specific timestamp up to a maximum of 7 days for logical errors such as wrong writes or bad rollouts, complemented by Spanner backups for longer retention and copies to another project or table.
Bigtable backups save a copy of a table schema and data for restore to a new table, handled entirely by the service with no import or export, sharing storage incrementally and expiring after user-defined retention. Restoration always flows from the backup copy to a newly created table, then requests are re-routed to the new table. Backups can be created as automated daily backups on every cluster, on-demand backups from the console, gcloud CLI, or client library, or copies stored in a different project, instance, region, or zone. Standard backups optimize for long-term retention and need extra optimization to reach production performance on SSD, while hot backups optimize for disaster readiness with the most efficient restoration to low-latency serving.
Self-managed recovery for MySQL, PostgreSQL, or SQL Server on Compute Engine combines regular VM backups through Backup and DR Service with frequent standalone Persistent Disk backups of a dedicated log disk for archive logs. The log-disk schedule sets granularity such as every 15 minutes or hourly, with minimum retention covering the required window. Recovery flows from the backup vault to a restored instance and forward through logs by restoring the base VM that precedes the target time, attaching log-disk snapshots up to the target time, running the database roll-forward over SSH, and updating configuration if names or paths changed before bringing the application online.
Continue with this study guide: Backup and recovery
Cold standby keeps only backups, snapshots, images and templates with no running application servers and restores everything after a disaster, warm standby keeps a small live database replica with continuous replication while the application tier is scaled out during failover, and hot standby keeps two full live environments with Cloud Load Balancing and continuous replication. Hot standby delivers the lowest Recovery Time Objective (RTO) and Recovery Point Objective (RPO), often near zero, but carries the highest cost and complexity, while cold standby allows higher RTO and RPO with minimal running cost.
Choose Cloud Spanner when the workload needs horizontal scaling of both reads and writes across regions, and choose Cloud SQL when the need is vertical growth of one primary plus scaling of reads. Cloud Spanner uses built-in synchronous replication across zones and regions in an active-active topology, while Cloud SQL uses high availability (HA) with primary and standby plus cross-region and cascading read replicas that require promotion on failover.
A global load balancer automatically diverts traffic to another region if a region is unreachable while keeping the same external IP address, while a regional load balancer survives zone failure inside one region and needs Cloud DNS routing to point clients to the load balancer in the failover region for cross-region recovery.
Choose Spot VMs for interruptible, fault-tolerant work such as batch jobs that tolerate preemption, and choose committed use discounts (CUDs) for stable, long-running usage that will consume a one-year or three-year commitment. Spot VMs provide unused capacity at more than 80 percent lower price than regular VMs with no commitment, while committed use discounts reward one-year or three-year commitments.
Last updated