Prepare and test your skills
Prepare and test your skills
Designing for business requirements means linking business goals, market rules, and financial limits to specific architecture choices. Functional requirements define what the system must do, including organization setup, product readiness, hosting location, and data movement, while non-functional requirements define how well it must behave, including availability, scalability, performance, security, residency, and cost. A governed design maps regulations and product goals to preventive controls that harden compute and networks, detective controls that log and monitor activity, and corrective controls that remediate findings after scans or major changes. Product-aligned patterns turn enterprise data and elastic capacity into value, such as retrieval-augmented generation (RAG) that grounds answers in enterprise facts and cloud bursting that keeps steady load on premises while bursting to Google Cloud for peaks.
Quality goals become measurable through reliability requirements (opens in a new tab) for availability, scalability, and performance. A service level indicator (SLI) measures behavior from the user perspective, such as percentile latency or successful-response ratio, while a Service Level Objective (SLO) sets the target with a bound and time window, such as 95th percentile latency below 300 ms over 30 days. Recovery is judged by Recovery Time Objective (RTO) for allowed downtime and Recovery Point Objective (RPO) for allowed data loss, where smaller values need more ready infrastructure and more frequent replication. Google Cloud supports these goals with redundancy, geographically distributed data centers, automatic shifting of control planes from a failed facility to a healthy facility, and automatic mirroring of data.
Business continuity planning translates tolerance for downtime and data loss into disaster recovery architectures. High availability typically uses synchronous replication across zones in one region for near-zero RTO and RPO, while disaster recovery typically uses asynchronous replication across regions with defined failover and replication lag. Business-critical operations must depend only on data plane components that continuously process operations, not on management plane operations such as VM-creation APIs that may be unavailable during an outage. Tier 1 systems such as payment storefronts may require zero RTO and zero RPO, while Tier 2 and Tier 3 systems allow minutes to hours.
| Pattern | What runs before failover | Recovery and cost tradeoff |
|---|---|---|
| Cold standby | Backups in Cloud Storage (opens in a new tab) , images, and templates; no running servers | Largest RTO and RPO, lowest cost |
| Warm standby | Minimal database runs and receives replication; app servers restored from snapshots | Small RTO and RPO, medium cost |
| Hot standby | Full secondary environment runs and serves traffic with continuous replication | Near-zero RTO and RPO, highest cost |
Traffic flows from clients into Cloud Load Balancing, which steers to healthy backends based on health checks, while Cloud DNS redirects requests between environments because DNS zones are global resources resilient to zone and region outages. A typical cold failover runs in order: first create the recovery deployment from the template, then restore the latest backup and transaction logs, then validate with simulated user scenarios, then switch Cloud DNS to the recovery servers. Data resilience adds dual-region Cloud Storage buckets, Firestore in Datastore mode with synchronous replication across zones, Bigtable with at least two clusters, and protections such as soft delete, Object Versioning, Bucket Lock, and Backup and DR Service.
Exam tip: High availability means synchronous replication across zones in one region, while disaster recovery means asynchronous replication across regions where failover steps and replication lag affect RTO and RPO.
Cost optimization matches capacity and pricing to real demand so spending follows business value. New ingestion data often starts in Standard storage for frequent reads, then moves to Nearline or Coldline when rarely read, then to Archive for long-term retention. Object Lifecycle Management pairs a condition such as object age with an action, so data flows from Standard to a cheaper class and finally to deletion only after the condition is met, while Autoclass moves each object automatically based on observed access. Commitment discounts lower rates through one-year or three-year commitments, and Spot VMs use unused capacity at more than 80% discount but can be preempted, so they suit fault-tolerant batch jobs. Utilization data flows from Cloud Monitoring to Recommender, which suggests rightsizing, while billing data flows from Cloud Billing to reports and BigQuery export with budgets and labels such as team=banking_appdev for ownership.
Supporting the application design uses managed integration and decoupled patterns to stay scalable and safe to change. Traffic flows from clients through Apigee to backend systems, where Apigee applies access controls and inspection before requests reach protected data, while Cloud Service Mesh controls routing, retries, and failover between services. A queue sits between a producing service and a consuming service so the producer writes a message and continues while the consumer processes it later, with circuit breakers, exponential backoff, and graceful degradation for protection. Synchronous integration with Apigee waits for an immediate response, while asynchronous integration with Pub/Sub decouples sender and receiver so work survives spikes, and synchronous dependencies between environments should be minimized because they couple availability to both sides at once.
Design trade-offs balance control against simplicity, cost against resilience, and consistency against latency. Requests flow to a Google-managed control plane in serverless options such as Cloud Run, App Engine, and Cloud Run functions, which scale automatically with no servers to patch, while Bare Metal Solution provides sole-tenancy servers where the customer owns patching, licensing, and availability design. Workload disposition decides whether to build custom solutions on Compute Engine or Google Kubernetes Engine (GKE), buy managed services such as Cloud SQL, Spanner, BigQuery, and Dataflow, or archive and deprecate legacy systems to Cloud Storage with ordered teardown from edge inward. Placement for bursting, recovery, and sovereignty decides where application and database copies run, including keeping EU data in EU regions and using another cloud in the same country when one cloud has only one region there.
Success is tracked with business key performance indicators (KPIs) such as revenue and satisfaction, technical KPIs such as latency and error rate, and reliability objectives where the error budget starts at 1 minus the SLO. Security follows least privilege, where Cloud Identity authenticates users, Identity and Access Management (IAM) authorizes actions with default deny, and VPC Service Controls creates a service perimeter that allows free communication inside but blocks communication across the perimeter by default. Observability combines logs in Cloud Logging, metrics in Cloud Monitoring, traces in Cloud Trace, and profiles in Cloud Profiler, with the four golden signals of latency, traffic, error rate, and saturation showing health and triggering alerts before failures cascade.
The Google Cloud Well-Architected Framework 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 six pillars: operational excellence, security and privacy and compliance, reliability, cost optimization, performance optimization, and sustainability.
Operational excellence deploys and manages workloads through automation and continuous monitoring instead of repeated manual steps, with small frequent changes and documented architecture for collaboration. Reliability plans for failure from natural disasters, fiber cuts, and complex outages, using RTO and RPO to choose infrastructure and disaster recovery mechanisms, plus simplified, decoupled, and stateless designs to limit blast radius. Security follows a shared responsibility model where Google secures physical infrastructure and foundational services while the customer secures data, applications, identities, and access, enforced with least privilege and zero trust where every request is authenticated and verified.
High availability and failover design keeps applications reachable through hardware, software, zone, and region failures without manual action. Traffic flows from clients to a forwarding rule with one external IP, then from Cloud Load Balancing to backend virtual machines (VMs) that pass health checks and away from VMs that fail them. Compute Engine managed instance groups (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.
| Option | Traffic scope | Failover behavior |
|---|---|---|
| Regional load balancer | Spreads traffic across VMs in multiple zones within one region | Survives zone failure; cross-region recovery uses Cloud DNS routing to the failover region |
| Global load balancer | Receives traffic at the edge nearest the client and distributes across regions | Automatically diverts traffic to another region while keeping the same external IP |
Resource scope defines which outage a resource can survive based on where its copies run. Compute Engine VMs are zonal resources in one zone, regional resources such as regional buckets, regional Persistent Disk, regional MIGs, and Cloud Run services span zones in one region, and multi-regional or global resources such as multi-region Cloud Storage buckets, Spanner instances, Firestore, BigQuery, VPC networks, and Pub/Sub topics survive regional loss. Data persistence uses synchronous replication for low RPO within a region and asynchronous replication across regions, with Firestore multi-region synchronously replicating across five zones in three regions, Cloud Storage confirming writes redundantly then asynchronously replicating data, and Cloud SQL and Spanner combining automated backups with point-in-time recovery (PITR).
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.
Flexibility of cloud resources is the ability to match capacity to demand and run workloads where they fit best without rewriting them. Containers decouple applications from hosts, while Kubernetes handles orchestration with the same services and APIs in cloud and private environments, and Google Kubernetes Engine (GKE) provides managed Kubernetes with Autopilot managing nodes and scaling. Right-sizing continuously monitors utilization and adjusts allocation, where data flows from Cloud Monitoring to Recommender for suggestions, while autoscaling adds capacity when demand rises and removes it when demand falls. Provisioning models trade commitment for discount, including resource-based committed use discounts (CUDs) for a region, spend-based CUDs at the billing account level, and Spot VMs for fault-tolerant work.
Scalability handles more users and data without redesign by growing the data tier, compute tier, and traffic management together. Cloud Spanner scales throughput and storage horizontally across many replicas that all serve traffic in an active-active topology, while Cloud SQL scales vertically to a larger primary and scales reads with replicas that require promotion on failover. Compute autoscaling uses MIG policies, predictive forecasting, scheduled pre-provisioning, and serverless elasticity where Cloud Run scales stateless containers to zero when idle. A request through the programmable front end moves in fixed order: first Google Cloud Armor edge policies evaluate traffic at Google Front Ends (GFEs), then Cloud CDN serves cache hits, then backend policies evaluate cache misses, then the request flows to the selected backend so malicious traffic and repeatable content do not consume application capacity.
Performance optimization proves where requests wait and then cuts that wait through monitoring, network path choice, and right-sized storage. Metrics flow from Pods into Managed Service for Prometheus and then to Cloud Monitoring, where queries such as vllm:gpu_cache_usage_perc reveal KV cache exhaustion and queue growth that trigger Horizontal Pod Autoscaler scaling. Network Service Tiers control entry path, where Premium Tier enters the Google network at the point of presence (PoP) closest to the sender for lower latency and Standard Tier travels over the internet with more hops. High-performance configuration matches machine type and disk size to input/output operations per second (IOPS) and throughput, such as C4A machine series scaling to 160,000 IOPS and Hyperdisk Balanced allowing separate provisioning of IOPS and throughput with synchronous replication options across zones.
Gemini Cloud Assist (opens in a new tab) is an AI collaborator that turns natural language requirements into deployable architectures and helps operate them. You describe what you want in plain language in the Cloud Assist panel, review the suggested architecture, choose Edit App Design to load it onto the Application Design Center canvas, iterate with follow-up prompts, and create an application instance that carries Terraform infrastructure as code into deployment. Because generated output can be plausible but incorrect, every recommendation, Terraform snippet, and CLI command must be validated before use.
Operational monitoring uses chat for quick explanations with page context and Investigations for in-depth analysis where data flows from logs, metrics, and configurations to the investigation engine for ranked hypotheses. Backup and recovery protects stateful data within RTO and RPO limits using cold, warm, and hot standby patterns, Persistent Disk snapshots that capture only changed blocks, and database backups with PITR. Recovery follows an ordered sequence of schedule trigger, incremental storage, retention expiration, and restore to a new disk or table, with Cloud Storage lifecycle moving backups from Standard to Nearline to Coldline to Archive and protections such as Soft Delete and Bucket Lock preventing premature loss.
Integration with on-premises and multicloud environments designs secure links, portable workloads, and shared identity between data centers, Google Cloud, and other clouds. Traffic between environments depends on bandwidth, latency, packet loss, and jitter, so the architect matches volume, privacy, encryption, and reliability to the right connection. Cloud VPN, Cloud Interconnect, and Cross-Cloud Interconnect provide transport, with Cloud Router providing dynamic routing across them.
| Option | Transport | Choose when |
|---|---|---|
| HA VPN | Encrypted IPsec over internet, or over Interconnect | Transfers need encryption and high availability |
| Dedicated Interconnect | Direct physical connection in a colocation facility | Sustained transfers are typically 10 Gbps or more with deterministic performance |
| Partner Interconnect | Private connection through a service provider | Dedicated capacity below about 10 Gbps without direct cross-connects |
| Cross-Cloud Interconnect | Managed private connection between clouds | Multicloud traffic needs line-rate private connectivity |
Cloud Router uses Border Gateway Protocol (BGP) to exchange routes with the external router so both the Virtual Private Cloud (VPC) network and the on-premises network learn reachable prefixes automatically. For Dedicated Interconnect you manage the on-premises router and establish BGP sessions to Cloud Router, while Partner Interconnect responsibility follows Layer 2 or Layer 3 type. When a link or tunnel fails, BGP withdraws unreachable routes and Cloud Router directs traffic to remaining healthy paths, which enables failover and active/active designs. Dedicated circuits require 10-Gbps, 100-Gbps, or 400-Gbps single-mode fiber up to 10 km with Link Aggregation Control Protocol (LACP) and 802.1Q VLANs.
Exam tip: An HA VPN gateway configured with only one active interface and one external IP address does not provide an availability SLA.
Cloud-native networking organizes VPC networks, private endpoints, container addresses, and traffic controls for availability with clear boundaries. Shared VPC is a VPC owned by a host project and shared with service projects, so the host controls subnets and central firewall rules while service projects deploy workloads. VPC Network Peering is a bilateral connection that lets two VPCs exchange private traffic while each keeps its own firewall rules, but peering is non-transitive, so traffic from spoke A to hub H cannot continue to spoke B without a separate peering or transitive path. Hub-and-spoke designs share Interconnect in the hub, with appliances in the hub for Layer 7 inspection when required.
Container networking gives every Pod its own IP so Pods communicate without Network Address Translation, while a Service groups Pods behind a stable virtual IP and DNS name. VPC-native GKE networking makes Pod IPs directly routable using alias IP ranges from subnet secondary ranges, with modern Dataplane V2 using eBPF for performance. Private Service Connect lets a consumer VPC use a private IP to reach a producer service without exposing entire networks, allowing overlapping ranges through producer-side source NAT at Layer 4. A user request flows in order: first Cloud Armor edge policies evaluate at the front end, then Cloud CDN serves cache hits, then backend policies evaluate misses, then the request flows to backends such as MIGs, GKE, or Cloud Run, with health checks routing only to responsive backends.
Choosing data processing solutions decides where cleaning and shaping happens with the least management effort. Extract, transform, and load (ETL) extracts data, transforms it in an intermediate service, then loads cleaned data into BigQuery, while extract, load, and transform (ELT) loads raw data into BigQuery first and transforms it inside with SQL. BigQuery separates storage in the Colossus file system in compressed columnar Capacitor format from compute supplied as slots, operating directly on compressed data over a petabit network. Cloud Dataflow runs Apache Beam jobs for batch and streaming without cluster management, allocating workers, autoscaling, rebalancing slow work, and providing exactly-once processing by default.
| Model | Operational model | Choose when |
|---|---|---|
| Cloud Dataproc | Managed ephemeral Spark clusters created and deleted per job | Workload already runs on Hadoop or Spark and rewriting is impractical |
| Cloud Dataflow | Serverless workers allocated, autoscaled, and deleted automatically | One pipeline must handle batch plus low-latency streaming |
Real-time ingestion flows from publishers to a Pub/Sub topic, then to Dataflow workers, then to sinks such as BigQuery or Cloud Storage, with Pub/Sub buffering unacknowledged messages for up to 7 days. Storage selection matches access to service: Cloud Storage holds objects with regional synchronous replication and dual-region asynchronous data replication with 15-minute turbo replication RPO, Filestore mounts shared files across VMs with synchronous replication across three zones, and Persistent Disk and Hyperdisk attach block volumes with regional synchronous replication across two zones. Operational databases include Cloud SQL for standard relational online transaction processing (OLTP), Spanner for globally distributed relational transactions, Firestore in Datastore mode for schemaless entities, and Cloud Bigtable for high-throughput non-transactional data, while BigQuery serves analytics with partitioning, clustering, and slot pricing.
Mapping compute needs matches how work is triggered, scaled, and operated to the right platform. Google Kubernetes Engine (GKE) keeps Kubernetes-level control where Google manages the control plane and the team manages nodes and scaling, with Autopilot managing nodes automatically and Standard managing node pools directly. Cloud Run hides servers so the team provides code or an image and Google operates the rest, with services for web requests, jobs for background tasks, and Cloud Run functions for event-driven code that scales to zero. Traffic flows from a request or event to Cloud Run, which starts instances, routes work, and scales on requests or CPU.
| Feature | GKE | Cloud Run |
|---|---|---|
| Management | Team manages clusters, nodes, and upgrades | Team provides source or image; no clusters |
| Control | Full control over nodes and network policies | Limited to concurrency and environment settings |
| Pricing | Pay-per-cluster per hour plus nodes | Pay-per-use rounded to nearest 100 ms |
Compute Engine provides self-managed VMs where selection balances family, accelerators, threading, region, and licensing. A custom machine type provisions only needed CPU and memory to reduce waste, while Spot VMs offer discounts up to 91% but can be reclaimed at any time with stop as the default termination action and no service-level agreement (SLA). AI Hypercomputer (opens in a new tab) integrates GPUs, TPUs, high-bandwidth networking, and high-throughput storage such as Managed Lustre to maximize goodput, with Clustered GPUs using synchronized maintenance for training and General GPUs using independent maintenance for serving. Agent design combines grounding through RAG, memory in Memorystore and Firestore, tools via Model Context Protocol (MCP) on Cloud Run, and models from Model Garden with lifecycle stages of select, customize, evaluate, canary release, and monitor.
Continue with this study guide: Designing network, storage, and compute resources
Integrating solutions with existing systems connects new Google Cloud applications to on-premises and other-cloud systems without disrupting operations. Gated ingress requires all inbound API calls to pass through Apigee as the central gateway for authentication, policy enforcement, rate limiting, and analytics. Traffic flows from the remote network over Cloud VPN or Cloud Interconnect to a Private Service Connect endpoint in the application VPC linked to the Apigee VPC, then to an internal load balancer, then to application APIs. Firewall rules filter traffic in the application VPC, and hiding the backend subnet prevents bypassing the endpoint.
When inspection outside the application VPC is required, a transit VPC sits between hybrid connectivity and the application VPC, where traffic flows through deep packet inspection before continuing to the internal load balancer. Apigee Adapter for Envoy runs close to remote backends with a management plane on Google Cloud and a data plane of Envoy proxy plus Apigee Remote Service, moving in order: client access to Envoy, policy check to Remote Service, forwarding to backend if allowed, and asynchronous configuration sync from the management plane. Bidirectional integration uses an endpoint to expose a producer service to a consumer VPC and an interface to let a producer VM reach into a consumer VPC and on-premises sources, with the two paths serving independent purposes and keeping overlapping addresses private.
Assessing and migrating systems moves servers, databases, and datasets with correct sizing and validation. Google Cloud Migration Center collects asset data through automated collectors and imports, recommends target sizes, and generates a Total Cost of Ownership (TCO) report. Complete discovery prevents wrong assumptions about scope and performance, recording engine versions, topology, pipelines, and datasets that pipelines read.
| Transfer option | Source to destination | Choose when |
|---|---|---|
| Storage Transfer Service | Online sources to Cloud Storage | Data is reachable online and target is object storage |
| Transfer Appliance | On-premises via shipped hardware to Google Cloud | Data exceeds 20 TB up to 1 petabyte and network transfer would disrupt operations |
| BigQuery Data Transfer Service | SaaS apps, Teradata, or Redshift to BigQuery | Analytics data needs scheduled loading |
Database migration with built-in backups moves relational data to Cloud SQL or AlloyDB through an export file in Cloud Storage that is restored to the target instance for one-time moves with acceptable downtime. PostgreSQL moves use pg_dump for databases of 500 GB or less and pg_dumpall for users and roles, with Cloud Storage single-object limit of 5 terabytes requiring segmentation and compression to reduce cost. Data Validation Tool (opens in a new tab) compares source and destination tables for row counts, schemas, and values before cutover while fallback is still possible, complemented by HarbourBridge for Spanner and Hive-to-BigQuery frameworks.
Exam tip: Choose Storage Transfer Service for online transfers and Transfer Appliance when offline shipment is needed for data over 20 TB up to 1 petabyte.
Change-based strategies differ in what changes and how much time they need. Mission-critical workloads use zero or near-zero downtime approaches, while secondary workloads can accept a cutover window. Migration Center supports discovery, while managed services encapsulate move logic, with tool choice depending on strategy, source and target, data size, change frequency, and managed service availability.
| Strategy | What changes | Tradeoff |
|---|---|---|
| Refactor | Modify workloads to use cloud scalability | Takes longer than rehost and needs new skills |
| Re-architect | Change how code functions, such as splitting a monolith | More complex and can introduce bugs needing retesting |
| Rebuild | Decommission and rewrite as cloud-optimized | Takes longest and removes debt |
| Repurchase | Move to SaaS equivalent | Easier on resources but less control |
A proof of concept (POC) validates feasibility at low cost by defining scope and success criteria for compatibility, downtime, and performance, then iterating until criteria are met and capturing findings in migration documentation. Validation is continuous: before migration test cases are refactored for the target, during migration integration tests check migrated and not-yet-migrated parts at each milestone, and after migration baseline, functional, and load tests compare time, errors, and scalability. VPC planning establishes the global network with regional subnets, where a VPC is global and each subnet is bound to one region, while hybrid connectivity over Interconnect or VPN links source and target first. Hybrid Subnets lets a VPC share a CIDR with on-premises during migration when VPN or Interconnect provides connectivity, routing is enabled with overlap allowed, and migration tooling moves workloads into the overlapping subnet.
Dependency mapping records which application calls which database or service, scored on criticality and difficulty, to form waves where dependent apps, databases, and queues move together. Sequencing moves foundational pieces first in order: first group workloads into batches, then order batches with low-risk batches first, then order inside each batch with dependencies before callers. Good first-movers are non-mission-critical, representative, owned by motivated teams, and tolerant of cutover, with stateless microservices preferred early to avoid split data.
Determining license implications compares reusing existing licenses against paying for software as part of usage. Bring Your Own License (BYOL) reuses licenses on Compute Engine with no extra Google charge for the image itself, but the customer still pays the vendor and pays Google for infrastructure. Sole-tenant nodes are physical servers dedicated to one project, required for physical-core licenses with dedicated hardware requirements, with node templates minimizing licensed servers and cores. License-included images bundle software cost into hourly usage on multi-tenant hosts, so cost grows and shrinks with running instances, as with Oracle Database@Google Cloud.
| License scenario | Requires sole-tenant nodes | Portability path |
|---|---|---|
| Physical-core license with dedicated hardware | Yes | Bring media and run on sole-tenant nodes |
| Linux subscription for RHEL or SLES | No | Bring subscription without sole-tenant nodes |
| Microsoft app with Software Assurance and License Mobility | No, when OS allows it | Run on multi-tenant instances after verification |
Rightsizing matches capacity to measured utilization through machine type recommendations and observability data, including decommissioning idle resources, using custom machine types, and running fault-tolerant work on Spot VMs. Autoscaling adds and removes capacity by policy, with MIGs for VMs, Cluster Autoscaler and Pod autoscalers for GKE, and traffic-based scaling for Cloud Run. Continuous auditing tracks spend through Cloud Billing reports, BigQuery export, budgets, labels, Cloud Asset Inventory drift detection, Organization Policy constraints, quotas, and least-privilege IAM, while SAP software runs only under BYOL with assessment data sizing cores, memory, and storage.
Modernization of compute moves large VM-based monoliths to independent microservices on managed platforms. A monolith is refactored or rearchitected so tightly coupled parts become separate services that scale, deploy, and fail independently, commonly on GKE or Cloud Run with Cloud Service Mesh, Logging, and Monitoring. Containers and Kubernetes provide a common runtime, including GKE clusters outside Google Cloud with Google Distributed Cloud connected. A practical path is phased migration, where teams start with lift-and-shift or replatforming and then refactor after running in the cloud, such as replatforming MySQL to Cloud SQL while refactoring frontends to GKE Autopilot and replacing hardware balancing with Cloud Load Balancing.
Decoupling places a managed API layer between clients and microservices, where Apigee acts as a unifying facade that centralizes control, adds security, shields clients from backend changes, and supports audit trails. Operating modern architectures treats clusters as automated and fungible, where an upgrade provisions a new cluster, deploys workloads automatically, and decommissions the old cluster. Automated pipelines build, test, and promote changes, with Cloud Build creating images and Cloud Deploy promoting artifacts to GKE, Cloud Run, or Compute Engine through unit, integration, and end-to-end testing including load and stress tests.
Exam tip: Choose rehost when the workload can move as-is with few dependencies, and choose refactor when dependencies, unsupported operating systems, inefficient resource use, or manual deployments must be fixed.
Transformation of data strategy moves from storing data only for archiving to using data continuously for analytics and machine learning. Cloud Storage holds everything from frequently read analytics to regulatory archives, with frequently read data accelerated by Cloud CDN caching or Rapid Cache for ML training. Data reaches Google Cloud by Storage Transfer Service for large online transfers, Transfer Appliance for large offline transfers, or direct upload with console, gcloud CLI, or APIs.
| Storage class | Access pattern | Minimum retention and typical use |
|---|---|---|
| Standard with Autoclass | Varying or unpredictable | No fixed minimum; moves each object automatically |
| Standard | Frequent | Analytics, lakes, and websites |
| Nearline | Infrequent | At least 30 days; backups and long-tail media |
| Coldline | Rare | At least 90 days; disaster recovery copies |
| Archive | Very rare | At least 365 days; regulatory archives |
A modern analytics platform moves data from source systems to a data lake in Cloud Storage, then through a processing pipeline to a warehouse in BigQuery. Batch analytics stages files for scheduled processing, where point-of-sale files flow to a bucket, Managed Service for Apache Airflow orchestrates, Apache Spark ETL cleans and computes metrics, and processed data lands in Parquet and ORC with metadata in Dataproc Metastore. Streaming analytics processes events continuously, where data flows from producers to Pub/Sub, then through Dataflow running Beam pipelines, then into BigQuery for analysis, with change data capture applying inserts and updates in near real time. Data Engineering Agent (opens in a new tab) patterns extend this with ETL before the warehouse load versus ELT with transformation inside BigQuery.
Cloud-first design builds applications as independent microservices instead of one tightly connected system. Each service handles its own requests and evolves independently, with traffic flowing through asynchronous messaging and network calls for global scalability. A stateless service handles each request independent of previous requests so instances can be created and destroyed without losing in-flight data, while stateful services need careful recovery planning. As dependencies grow, one overloaded service can cause cascading failure, relieved by circuit breakers that stop traffic to failing services, exponential backoff that spaces retries, and graceful degradation that reduces function instead of failing completely.
Refactoring for portability needs observability where metrics, logs, and traces flow into Cloud Monitoring and Cloud Logging for analysis and alerting. Metrics capture numerical measurements such as request rate, logs capture time-stamped events such as failures, and traces capture one transaction journey across components to show bottlenecks. Monitoring flows from platform signals to application-specific needs, with exclusion filters skipping low-value logs to control cost and Active Assist recommending allocation changes. Prioritization of managed and serverless services chooses Cloud Run, Cloud Run functions, BigQuery, Spanner, Pub/Sub, Eventarc, and Workflows before self-managed VMs to automate capacity and scaling. Horizontal scaling adds replica nodes to share demand and is preferred for resilience, while vertical scaling replaces components with larger ones, with reactive, proactive, and predictive autoscaling matching capacity to demand and session state kept in Memorystore for Redis so any instance can handle any request.
Continue with this study guide: Envisioning future solution improvements
A comparison matrix contrasting cold, warm, and hot standby disaster recovery patterns across what runs before failover, RTO and RPO, and cost, showing the tradeoff from lowest cost with largest recovery targets to highest cost with near-zero recovery targets.
A service level indicator (SLI) measures behavior from the user perspective such as percentile latency or successful-response ratio, while a Service Level Objective (SLO) sets the target with a bound and time window. For example, an SLO can require 95th percentile latency below 300 ms over 30 days.
High availability typically uses synchronous replication across zones in one region for near-zero Recovery Time Objective (RTO) and Recovery Point Objective (RPO), while disaster recovery typically uses asynchronous replication across regions with defined failover and replication lag. Failover steps and replication lag therefore affect RTO and RPO for disaster recovery.
Cold standby keeps only backups in Cloud Storage, images, and templates with no running servers, so it has the largest Recovery Time Objective (RTO) and Recovery Point Objective (RPO) and the lowest cost. Warm standby keeps a minimal database running with replication and restores app servers from snapshots for small RTO and RPO at medium cost, while hot standby runs a full secondary environment serving traffic with continuous replication for near-zero RTO and RPO at the highest cost.
Choose Storage Transfer Service when data is reachable online and the target is object storage in Cloud Storage. Choose Transfer Appliance when on-premises data exceeds 20 TB up to 1 petabyte and network transfer would disrupt operations, since it uses shipped hardware to move data to Google Cloud.
Last updated