Prepare and test your skills
Prepare and test your skills
Integration with on-premises and multicloud environments is the design of secure links, portable workloads, and shared data and identity between a private data center, Google Cloud, and other clouds. Traffic between environments depends on bandwidth, latency, packet loss, and jitter, so the architect matches transfer volume, privacy, encryption, and reliability targets to the right connection. Google Cloud provides Cloud VPN (opens in a new tab), Cloud Interconnect, and Cross-Cloud Interconnect for transport, with Cloud Router providing dynamic routing across them.
Hybrid connectivity options are the four managed paths that carry traffic between on-premises, Google Cloud, and other clouds. HA VPN connects an on-premises network to a Virtual Private Cloud (VPC) network through encrypted IPsec tunnels over the public internet and can provide a 99.99% or 99.9% availability service-level agreement (SLA) depending on topology. Dedicated Interconnect provides direct physical connections between customer routing equipment and Google equipment in a common colocation facility without traversing the public internet, which gives deterministic performance for large sustained transfers. Partner Interconnect extends an on-premises network to VPC networks through a supported service provider, while Cross-Cloud Interconnect (opens in a new tab) provides private line-rate connectivity between Google Cloud and supported cloud providers without managing remote cross-connects.
The choice follows volume, privacy, and operations. Use HA VPN for smaller or occasional transfers that need IPsec encryption and private IP addresses, including HA VPN over Cloud Interconnect when traffic must not traverse the public internet. Use Dedicated Interconnect for sustained transfers typically at 10 Gbps or more when the team can meet Google in a supported facility and manage routing equipment. Use Partner Interconnect for dedicated capacity normally below 10 Gbps per connection without building direct cross-connects, and use Cross-Cloud Interconnect for multicloud traffic that needs 99.9% or 99.99% availability with Media Access Control security (MACsec) when encryption is required.
A decision tree branching on multicloud need, private transport, bandwidth, and encryption to select HA VPN, Dedicated, Partner, or Cross-Cloud Interconnect.
| Option | Transport | Choose when |
|---|---|---|
| HA VPN | Encrypted IPsec over internet, or over Interconnect | Transfers need encryption and high availability, or IPsec is required over Partner Interconnect |
| Dedicated Interconnect | Direct physical connection in a colocation facility | Sustained transfers are typically 10 Gbps or more and deterministic performance with an SLA is required |
| Partner Interconnect | Private connection through a service provider | Larger-than-VPN transfers need 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 without managing remote routing equipment |
Dedicated Interconnect has strict physical rules. Circuits must use 10-Gbps, 100-Gbps, or 400-Gbps single-mode fiber with 10GBASE-LR, 100GBASE-LR4, or 400GBASE-LR4 optics, with a maximum fiber length of 10 km. Network devices must support IPv4 link-local addressing, Link Aggregation Control Protocol (LACP), External Border Gateway Protocol version 4 with multi-hop, and 802.1Q VLANs. Each colocation facility supports VLAN attachments in only a subset of Google Cloud regions, and 100-Gbps circuits are not available in every location.
Exam tip: An HA VPN gateway configured with only one active interface and one external IP address does not provide an availability SLA.
Cloud Router is the Google Cloud service that uses Border Gateway Protocol (BGP) to provide dynamic routing for hybrid connectivity. Cloud Router is used together with Cloud Interconnect and Cloud VPN gateways, including HA VPN. Instead of maintaining static routes on each side, Cloud Router exchanges routes with the external router over BGP sessions so both the VPC network and the on-premises or other-cloud network learn reachable prefixes automatically.
The external router is the device that provides access to the peered network, either an on-premises router or a virtual router hosted by a remote cloud provider. For Dedicated Interconnect, you manage the on-premises router and establish BGP sessions between that router and Cloud Router. For Partner Interconnect, responsibility follows the connection type, with Layer 2 leaving BGP to the customer router and Layer 3 leaving BGP to the provider. When a link, tunnel, or path fails, BGP withdraws unreachable routes and Cloud Router directs traffic to remaining healthy paths, which enables failover and active/active HA VPN designs.
Workload portability is the ability to move an application between computing environments without significantly modifying the application or its operational model. Containers decouple applications from host infrastructure, while Kubernetes handles orchestration, deployment, scaling, and management with the same services and APIs in cloud and private environments. Google Kubernetes Engine (GKE) (opens in a new tab) provides managed Kubernetes so operations staff shift focus from maintaining infrastructure to maintaining applications, with Autopilot mode managing nodes, scaling, and security settings.
Fleet management in GKE is the method for operating multiple clusters as logical groupings of similar environments across on-premises, edge, and other clouds. A fleet groups clusters so security, configuration, and service management stay consistent instead of configuring each cluster separately. A service mesh adds container-level security control with end-to-end mutual TLS (mTLS), so a service in one environment communicates directly with a service in another environment using identity-based authentication rather than network location alone. Even with this common runtime, performance can differ because compute, networking, security capabilities, and proximity to dependent services vary by environment, and load balancer behavior can also differ.
Cross-cloud data and identity integration connects storage, analytics, and identities across Google Cloud, AWS, Azure, and on-premises into one architecture. BigQuery Omni runs BigQuery compute locally in an AWS or Azure region to query data stored in Amazon S3 or Azure Blob Storage, so query results return to BigQuery without first copying entire datasets. Storage Transfer Service (STS) copies data into a Cloud Storage bucket from Cloud Storage, Amazon S3, Azure storage, on-premises network file system (NFS) storage, or public HTTP URLs, with full and incremental copies, automatic retry, scheduled recurring transfers, and monitoring.
The handover networking pattern moves data from on-premises transactional systems to Pub/Sub queues or Cloud Storage buckets that then feed processing pipelines built with Cloud Data Fusion and Dataflow. Storage Transfer Service for on-premises data uses fault-tolerant agents that crawl NFS directories in parallel, which requires identical mounts at the same paths, many agents for bandwidth, a bandwidth cap to protect other workloads, and Cloud Monitoring alerts for agent health. Identity federation lets identities managed by an external identity provider access Google Cloud without separate Google accounts, with patterns for Cloud Identity or Google Workspace federation, Workforce Identity Federation with or without System for Cross-domain Identity Management (SCIM), and hybrid identity.
Continue with this study guide: Integration with on-premises/multicloud environments
Google Cloud AI and machine learning solutions combine high-performance infrastructure, agent frameworks, and a model catalog to build scalable enterprise applications. AI Hypercomputer (opens in a new tab) vertically integrates hardware, open software, and flexible consumption to maximize goodput, the measure of actual machine learning productivity. Vertex AI Agent Builder and Gemini Enterprise Agent Platform combine Gemini models with enterprise data, memory, and tools, while Model Garden connects model selection to tuning, deployment, and monitoring.
AI Hypercomputer infrastructure for training and serving is an integrated supercomputing system that keeps accelerators doing productive work from prototyping to massive-scale training and real-time serving. The system supports all available NVIDIA GPUs and Google Cloud TPUs connected over high-bandwidth networking so distributed training and large-model inference scale across thousands of instances. Data flows from high-throughput storage such as Google Cloud Managed Lustre and Cloud Storage Rapid to GPU and TPU nodes so checkpoint loading, dataset reads, and token delivery keep pace with computation.
GPU capacity is divided by maintenance and reliability behavior. General GPUs are managed as independent compute units with asynchronous maintenance and standard node auto-repair for serving fleets. Clustered GPUs are managed as a single tightly coupled system with synchronized maintenance plus automated health monitoring and proactive node replacement for long-running distributed training. Google Cloud TPUs use hardware designed for large matrix operations with on-chip high-bandwidth memory for larger models and batch sizes, and TPUs connect in groups called slices that scale with little to no code change.
| Compute option | Accelerator support | Control and orchestration |
|---|---|---|
| Cluster Director | NVIDIA GB300 Ultra, GB200, B200, H200, and H100, no TPUs | Google-managed custom Ubuntu with Slurm and automatic scaling based on CPU consumption |
| Google Kubernetes Engine (GKE) | All available NVIDIA GPUs and all available Google Cloud TPUs | Google-managed Autopilot or semi-managed Standard with Kubernetes orchestration and pod and node autoscaling |
| Cluster Toolkit | All available NVIDIA GPUs and all available Google Cloud TPUs | Self-managed with customizable infrastructure-as-code and scaling with MIGs or GKE tools |
| Compute Engine | All available NVIDIA GPUs and all available Google Cloud TPUs | Self-managed with manual orchestration and manual or automatic scaling with MIGs |
Consumption matches provisioning style to predictability. Flex-start VMs, Spot VMs, and Reservations cover different needs, while Dynamic Workload Scheduler provides atomic provisioning for entire blocks of interconnected nodes so a large training job obtains its full set of connected nodes together. Spot VMs lower cost for fault-tolerant experimentation but can be preempted, while committed capacity and calendar or flex-start reservations improve obtainability for high-demand accelerators.
Exam tip: Choose Clustered GPUs when you need synchronized maintenance and proactive node replacement for tightly coupled training, and choose General GPUs when you need independent units with asynchronous maintenance and node auto-repair for serving fleets.
Agent design with grounding, memory, and tools is the practice of combining a foundation model with enterprise data, conversational state, and actions so outputs are accurate and actionable. A conversational agent holds multi-turn dialogue, remembers context, calls tools or APIs, and completes tasks such as customer service and scheduling. A search application focuses on finding and summarizing trusted information, where a document-retrieval agent fetches passages from curated documents and returns factual answers with citations. Choose a conversational agent when the user needs back-and-forth help and actions, and choose a search application when the user needs a cited answer from validated documentation.
Grounding connects model output to verifiable data through Retrieval-Augmented Generation (RAG), which first retrieves relevant chunks or entities and then passes those results into the model prompt for generation. Vertex AI Search can serve as the retrieval backend through RAG Engine, and answer quality depends on input data quality because inaccurate source data produces false outputs. Memory retains context within a session and preferences across sessions, with Memorystore for Redis for short-term conversational state, Firestore for long-term history based on raw data, and Vertex AI Agent Engine Memory Bank for long-term personalized memory that automatically extracts and updates preferences. A vector database stores embeddings and returns the most similar vectors for a query, supported with the pgvector extension on Cloud SQL for PostgreSQL and AlloyDB for PostgreSQL.
Tools let the orchestrator act on external services, APIs, and websites by reasoning about the goal, selecting a tool, sending input, and using the output in the next step. Documented tool types include Model Context Protocol (MCP) through an MCP server on Cloud Run, basic utilities for math and time, API calling, image or chart generation, browser and operating system automation, code execution on Cloud Run, and Vertex AI Agent Engine Code Execution in managed sandboxes. Gemini 2.5 Flash is designed for agentic workloads with higher speed, built-in tool use, multimodal generation, and a 1M token context window.
Model Garden is the catalog for discovering and comparing foundation models from Google, open-source projects, and third-party partners. A foundation model is a large model trained on multi-terabyte datasets that can perform many tasks from a simple prompt, such as translation, summarization, and code generation. Google models are accessed through a managed API that reduces operational overhead, while open models can be self-hosted within your own network when deep fine-tuning control or strict security and data residency is required.
Model selection starts with the most affordable model that still meets quality and latency, flowing from use case to modality to size to cost validation. Modality is the data types a model handles, such as text, images, video, and audio. Size is the number of parameters, where larger models can learn more complex patterns but often cost more and respond more slowly. Gemini Pro is recommended as the primary task orchestrator for agentic applications needing strong reasoning, and model routing sends simple tasks to a small language model while keeping complex reasoning on a larger model. The thinking budget controls how many thinking tokens the model uses before answering, where a higher budget can improve quality but increase latency and cost.
| Model runtime | Serves | Choose when |
|---|---|---|
| Agent Platform | Gemini, partner, open, or custom models through a fully managed API | You need enterprise security, scaling, and generative AI tools without managing servers |
| Cloud Run | Open or custom containerized models as serverless containers | You prioritize serverless simplicity for variable traffic that can scale to zero |
| Google Kubernetes Engine (GKE) | Open or custom containerized models on Kubernetes | You need maximum control over infrastructure, specialized hardware, or complex networking |
The model lifecycle keeps a deployed model current through an ordered sequence. First, select the latest suitable base model from Model Garden. Then customize and retrain with new data through automated pipelines. Then evaluate quality, factual accuracy, toxicity, coherence, and safety and compare candidates with Experiments. Then release in stages with Cloud Deploy using canary releases to a subset of users. Finally, monitor output quality, harmful content, latency, token throughput, and queries per second, with artifacts stored in Cloud Storage or Model Registry to enable rollback to the most recent stable version.
Cloud-native networking in Google Cloud organizes VPC networks, private service endpoints, container addresses, and traffic controls so distributed applications stay available with low latency and clear boundaries. Cloud Load Balancing (opens in a new tab) distributes traffic across healthy backends globally or regionally, while Cloud Next Generation Firewall and Google Cloud Armor enforce boundaries around workloads and hybrid connections. Private Service Connect and VPC-native GKE networking expose individual services and Pods without exposing entire networks.
Enterprise VPC designs balance central control with team autonomy through Shared VPC, peering, and isolated consumer-producer access. Shared VPC (opens in a new tab) is a VPC network owned by a host project and shared with attached service projects, so the host controls subnets and central firewall rules while service projects deploy workloads under least-privilege permissions. A common pattern uses transit or hub VPC networks that land Cloud Interconnect or Cloud VPN connections and then share that connectivity with application VPC networks that host workloads.
VPC Network Peering is a bilateral connection that lets two independent VPC networks exchange private traffic over Google's backbone while each team keeps its own firewall rules and routing. Peering is non-transitive, which means traffic from spoke A to hub H cannot continue from hub H to spoke B without a separate peering or transitive mechanism. Scale is bounded by peering limits, and Cloud VPN with custom advertised routes can add transitivity and more spokes but adds per-tunnel bandwidth limits, cost, and complexity.
| Design | How sharing works | Choose when |
|---|---|---|
| Shared VPC per environment | Host project owns network; service projects share subnets | Central firewall, routing, and IP management are required |
| Hub-and-spoke with appliances | Hub hosts inspection appliances; spokes host workloads | Layer 7 inspection between workloads is required |
| Hub-and-spoke without appliances | Hub hosts Interconnect; spokes host workloads | Team autonomy with shared hybrid access and no inter-workload inspection is required |
| Consumer-producer with PSC | Each team owns its VPC and publishes services | Teams must manage their own IP space and communicate only through defined endpoints |
Hub-and-spoke without appliances gives shared hybrid access without inspection between workloads, with traffic flowing from a spoke to the hub over peering and then to on-premises over Cloud Interconnect. Hub-and-spoke with appliances routes traffic through inspection virtual machines in the hub using an internal passthrough Network Load Balancer as the next hop with symmetric hashing, and appliances must sit in the same region as inspected workloads. Avoid directly peering large separated environments such as development to production, and use controlled channels such as Cloud Storage or Pub/Sub when isolated environments must exchange data.
Exam tip: VPC Network Peering is non-transitive, so peered spokes stay isolated unless you add direct spoke-to-spoke peering or a transitive path such as Cloud VPN with custom advertised routes or Network Connectivity Center.
Container networking and private service connectivity connect Kubernetes Pods and shared services through stable endpoints rather than broad network merges. Every Pod receives its own unique IP address and all Pods communicate directly without Network Address Translation, while a Service groups Pods behind a stable virtual IP and DNS name such as my-service.my-namespace.svc.cluster.local. Traffic flows from the client to the Service virtual IP, then the node data plane forwards the packet to one selected backend Pod, with modern GKE Dataplane V2 using eBPF instead of kube-proxy iptables for performance and observability.
VPC-native GKE networking makes Pod IPs directly routable in the VPC by using alias IP ranges drawn from VPC subnet secondary ranges, so packets travel through normal VPC routing without NAT between nodes. The Container Network Interface plugin allocates Pod IPs, while the GKE control plane configures VPC routes, firewall rules, and load balancers from Kubernetes objects. Private Service Connect creates service abstractions where a consumer VPC uses a private IP to reach a producer service, with traffic flowing from the consumer endpoint to the producer service without exposing the entire producer network. At Layer 4 the producer uses NAT subnets for source NAT, which allows overlapping consumer and producer IP ranges, while at Layer 7 the producer uses an internal Application Load Balancer with a URL map.
| Option | Connectivity model | IP address requirement |
|---|---|---|
| Private Service Connect | Consumer endpoint connects to a producer service | Allows overlapping ranges because of producer-side source NAT |
| Private services access | Private connection established with peering | Requires producer and consumer networks to be peered |
| VPC Network Peering | Direct internal communication between two VPCs | Requires non-overlapping IP addresses |
Load balancing strategies divide by traffic scope, with global load balancers for multi-region distribution and regional and internal load balancers for contained traffic. A global external Application Load Balancer is a proxy-based Layer 7 load balancer that distributes HTTP and HTTPS traffic to backends in multiple regions such as Managed Instance Groups in two regions and supports traffic splitting. A regional load balancer keeps backends in one region but remains resilient to zone outages, while an internal load balancer provides private tier-to-tier communication such as web tier to app tier. Health checks route traffic only to responsive backends even when virtual machines report RUNNING but the application has crashed, and autohealing recreates failed VMs in Managed Instance Groups.
Security perimeters separate workload security close to workloads from perimeter security at every boundary between organizations, VPCs, hybrid connections, and the internet. Hierarchical firewall policies assigned at the organization or folder level enforce a consistent posture that lower-level rules cannot override, with goto_next delegating evaluation to lower policies. Cloud Next Generation Firewall provides stateful per-VM filtering with geolocation objects, fully qualified domain name filtering, intrusion detection and prevention, TLS intercept, and Google Threat Intelligence. A programmable global front end combines the global external Application Load Balancer with Cloud CDN caching at edge points of presence and Cloud Armor Layer 7 filtering, with volumetric DDoS protection enabled by default.
A user request flows through an ordered sequence. First, the request arrives at the front end and is evaluated by Cloud Armor edge policies. Then Cloud CDN serves the content from cache if allowed and cacheable. Then on a cache miss the request is evaluated by backend security policies. Finally, if allowed, the request flows to the backend server such as Compute Engine MIGs, GKE, Cloud Run, or hybrid endpoints.
Choosing data processing solutions means deciding where cleaning and shaping work happens and which Google Cloud service does that work with the least management effort. BigQuery (opens in a new tab) provides high-performance SQL-based processing for extract, load, and transform flows, while Cloud Dataprep, Dataflow, Data Fusion, and Dataproc support extract, transform, and load flows. Cloud Pub/Sub provides asynchronous ingestion, while Dataflow and Cloud Functions provide processing for low-latency transformation and immediate insight.
Extract, transform, and load (ETL) is the pattern where data is extracted from the source, transformed in an intermediate processing service, and only then loaded into BigQuery as cleaned production data. A file-based ETL flow moves data from the source to staging, then to a Cloud Storage bucket, then into a transformation service that writes to BigQuery. A JDBC-based ETL flow reads directly from the source database through a JDBC driver into the transformation service. Choose ETL when data must be trimmed, cleansed, or enriched before loading, or when an existing transformation process must be preserved.
Extract, load, and transform (ELT) is the pattern where raw data is loaded into BigQuery first and transformed inside BigQuery afterward. Data flows from the source to a BigQuery staging table, then SQL queries read from the staging table and write output into the final production table. A typical marketing workflow extracts new customer data with BigQuery Data Transfer Service, loads raw data into tables, and runs scheduled SQL transformations with Dataform. Choose ELT when raw data can land unchanged and the warehouse can supply compute for cleaning, joining, and aggregation.
| Pattern | Where transformation runs | Primary tools |
|---|---|---|
| ETL | Before the BigQuery load in a processing service | Dataflow with Beam, Data Fusion with graphical pipelines, Managed Service for Apache Spark, Dataprep with visual recipes |
| ELT | After the BigQuery load as SQL from staging to production | BigQuery Data Transfer Service for loads, BigQuery SQL for transformation, Dataform for versioned pipelines |
BigQuery as a transformation engine separates storage from compute so ELT scales without cluster resizing. Storage lives in the Colossus distributed file system in compressed columnar Capacitor format, and BigQuery operates directly on compressed data. Compute is supplied as slots managed by Google and allocated by a fair scheduler, with memory over a petabit network. Cloud Dataprep by Trifacta lets business users visually explore and prepare JSON or CSV data, with Dataflow executing those visual recipes toward BigQuery.
Exam tip: ETL transforms data before it is loaded into BigQuery with Dataflow, Data Fusion, Dataproc, or Dataprep, while ELT loads data into a BigQuery staging table first and then transforms it with SQL that writes to the production table.
Managed cluster-based processing with Cloud Dataproc provisions ephemeral clusters that run existing open source engines such as Apache Spark, Flink, and Presto. Each Managed Service for Apache Spark cluster exists only as long as the processing stage runs and is deleted when the job ends. This model fits teams with existing Hadoop or Spark code because pipelines can be ported unmodified instead of being rewritten. Recovery focuses on data in Cloud Storage, processed Parquet and ORC files, and table metadata in Dataproc Metastore.
Serverless unified processing with Cloud Dataflow (opens in a new tab) runs Apache Beam jobs for both batch and streaming without cluster management. Data flows from sources through Beam transforms to destinations, and the same pipeline code can run on Dataflow or other Beam runners such as Flink or Spark. When a job runs, Dataflow allocates worker virtual machines, distributes work in parallel, autoscales with load, dynamically rebalances slow work, and deletes workers when the job completes. Dataflow provides exactly-once processing by default, with an at-least-once mode for streaming pipelines that can tolerate duplicates to reduce cost and improve latency.
| 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 would be impractical |
| Cloud Dataflow | Serverless workers allocated, autoscaled, rebalanced, and deleted automatically | One pipeline must handle batch plus low-latency streaming without managing clusters |
An ephemeral Spark workflow orchestrated by Managed Airflow follows an ordered sequence. First, validate input by confirming new files arrived in the Cloud Storage bucket. Then create the ephemeral cluster. Then run the Spark job to perform ETL and produce metrics. Finally, delete the cluster so capacity is not left idle.
Real-time and event-driven architecture lets producers and consumers communicate asynchronously through a messaging layer instead of waiting on direct calls. Cloud Pub/Sub is an asynchronous messaging service where publishers send events to a named topic and the service delivers copies to subscribers without publishers waiting as with synchronous remote procedure calls. Pub/Sub uses per-message parallelism by leasing individual messages and tracking success, which maximizes parallelism compared with partition-based systems such as Kafka that limit concurrency to partition count. Latencies are typically on the order of 100 milliseconds.
The combined real-time pipeline moves data through an ordered sequence. First, event sources publish messages to a predefined topic from many clients at once. Then the Pub/Sub service holds messages and leases each message to subscriber clients, buffering unacknowledged messages for up to 7 days when downstream processing pauses. Then data flows to Cloud Dataflow for streaming enrichment, windowing, and joins, or to Cloud Functions for single-event automation. Finally, processing writes results to BigQuery, Bigtable, or Cloud Storage or republishes events for other applications. Cloud Functions fits discrete reactions where a full streaming pipeline would be excess overhead, with push delivery as HTTP POST requests to webhooks.
| Option | Primary unit | Choose when |
|---|---|---|
| Cloud Dataflow | Apache Beam pipeline | Work needs continuous streaming transforms, windowing, or delivery at scale |
| Cloud Functions | Event-triggered function | Work is a short single-event reaction or workflow automation step |
| Cloud Pub/Sub with storage sink | Topic and subscription | Work is durable distribution or buffering without complex transformation |
Continue with this study guide: Choosing data processing solutions
Choosing appropriate storage types means matching how an application accesses data to the right Google Cloud service for objects, shared files, block volumes, operational databases, and analytics. Cloud Storage (opens in a new tab) holds unstructured objects in buckets, Filestore provides shared file systems, and Persistent Disk and Hyperdisk provide block volumes for virtual machines. Cloud SQL, Spanner, Firestore in Datastore mode, and Bigtable cover relational and non-relational operational needs, while BigQuery and Cloud Storage classes cover analytics and lifecycle cost.
Object, file, and block storage differ by access protocol, sharing model, and replication scope. Cloud Storage holds data as objects inside regional, dual-region, or multi-region buckets. Data in regional buckets is replicated synchronously across zones in the region, while dual-region and multi-region buckets store data redundantly in at least two geographic locations with synchronous metadata writes and asynchronous data replication. For dual-region buckets, turbo replication ensures newly written objects are replicated between the region pair with a recovery point objective of 15 minutes.
Filestore is fully managed network file storage that multiple virtual machines in a region can mount and share for files needed by a whole tier, such as configuration files, tools, and centralized logs. A Filestore regional instance replicates synchronously across three zones, with optional replication to a different region for protection against regional outage. Persistent Disk and Hyperdisk are high-performance block volumes attached to Compute Engine virtual machines, where zonal volumes live in one zone and regional volumes replicate synchronously across two zones but not across regions. Hyperdisk Balanced lets you provision input/output operations per second and throughput separately and dynamically.
| Service | Access model | Replication and consistency |
|---|---|---|
| Cloud Storage | Objects in buckets for unstructured data | Regional replicates synchronously across zones; dual-region and multi-region write metadata synchronously and replicate data asynchronously |
| Filestore | Shared file system mounted on multiple virtual machines | Regional replicates synchronously across three zones; optional replication to another region |
| Persistent Disk and Hyperdisk | Block volume attached to a virtual machine | Regional replicates synchronously across two zones; data is not replicated across regions |
Exam tip: Regional Persistent Disk replicates synchronously across two zones but not across regions; use Cloud Storage dual-region or multi-region buckets when data must be redundantly stored in two geographic locations.
Operational database selection balances transactional guarantees, scale, schema control, and read and write performance. Cloud SQL is a fully managed relational service delivering MySQL, PostgreSQL, and SQL Server for standard online transaction processing with related data in row-based tables. Google handles setup, maintenance, and administration, while automated backups plus binary logging enable point-in-time recovery to a fresh instance. High availability protects against zonal failure and cross-region replicas protect against regional failure, with Enterprise Plus providing a 99.99% availability SLA, near-zero downtime maintenance, intelligent caching, and 35 days of log retention.
Cloud Spanner is a mission-critical global-scale relational service that combines relational structure with global distribution using GoogleSQL, an ANSI-compliant dialect. Applications send query, definition, manipulation, access-control, and transaction-control statements, with access control at table and column level. Firestore in Datastore mode (opens in a new tab), often called Datastore, is a schemaless NoSQL document database where entities of the same kind can have different properties. Datastore provides atomic transactions, strong consistency, automatic scaling, and managed encryption, but queries are served by indexes so joins, inequality filtering on multiple properties, and subquery filtering are not supported. Cloud Bigtable is a NoSQL database for large operational datasets that do not require ACID transactions or highly structured data and need high-throughput reads and writes.
| Service | Data model | Scaling and fit |
|---|---|---|
| Cloud SQL | Relational tables with MySQL, PostgreSQL, or SQL Server | Best for standard relational OLTP with point-in-time recovery and cross-region replicas |
| Cloud Spanner | Relational tables with GoogleSQL | Best when relational transactions and SQL must span regions |
| Firestore in Datastore mode | Schemaless NoSQL entities with kinds, properties, and keys | Best for catalogs and profiles where query cost follows result size |
| Cloud Bigtable | NoSQL for large, less-structured data | Best when structure is loose and strict transactions are unnecessary |
Analytics storage and lifecycle controls match data volume, access frequency, and retention to cost-effective placement. BigQuery is a fully managed analytic warehouse that separates storage from compute so each scales independently, with storage billed separately and no provisioning or reservations required. When a query runs, the engine distributes work in parallel across workers over a petabit network and executes in memory. BigQuery storage provides 99.999999999% annual durability through replication across availability zones, with encryption before writing to disk and columnar format optimized for analytics. BigQuery is not designed for online transaction processing, which belongs in Cloud SQL, Spanner, or Firestore.
A BigQuery query follows an ordered flow from distribution to return. First, the engine distributes work in parallel across multiple workers. Then workers scan relevant tables and process the query. Finally, workers gather results for return. Data enters through batch loads in Avro, Parquet, ORC, CSV, JSON, Datastore, and Firestore formats, through streaming with the Storage Write API, or automatically through BigQuery Data Transfer Service. When data should not move, federated queries and external tables query data where it lives, including Cloud Storage, Bigtable, Spanner, Cloud SQL, AWS S3, Azure Blob Storage, and Google Drive.
Partitioning, clustering, and pricing control analytic cost by scanning less data per query. Ingestion-time partitioned tables divide by ingestion time, column-partitioned tables divide by TIMESTAMP or DATE column, and integer-range partitioned tables divide by integer column. Clustering organizes data within partitions by commonly filtered columns, which helps for string columns or multiple columns accessed together. On-demand pricing pays for bytes processed per query for variable workloads, while capacity-based pricing purchases slot reservations with a minimum of 100 slots and a default maximum of 2,000 slots for predictable concurrent workloads. Cloud Storage classes and regional, dual-region, and multi-region locations align retention and residency, with unmodified BigQuery data over 90 days dropping to half-price storage.
Mapping compute needs to platform products means matching how work is triggered, scaled, and operated to the right container platform. Google Kubernetes Engine (GKE) (opens in a new tab) keeps Kubernetes-level control with the team in exchange for more administration, while Cloud Run (opens in a new tab) hides servers and clusters to reduce daily operations. Cloud Run functions (opens in a new tab) extends that serverless model to small event-driven code that runs inside Cloud Run.
Operational control and infrastructure ownership divide differently on GKE and Cloud Run. GKE is a managed Kubernetes platform where Google manages the Kubernetes control plane for security and availability, while the team manages node configuration, networking, scaling, and upgrades. In Autopilot mode Google provisions nodes, adjusts capacity, enforces a default security posture, and the team pays only for resources requested by workloads. In Standard mode the team manages node pools directly and keeps control over the virtual machines that serve as Kubernetes nodes.
Cloud Run serverless abstraction means the team provides code or a container image and Google operates everything underneath, including operating system, kernel, network setup, and capacity. Cloud Run services run code that responds to web requests, Cloud Run jobs run code that performs background tasks and then exits, and Cloud Run functions run single lightweight functions for event-driven work. Traffic flows from an incoming request or event to Cloud Run, which starts container instances, routes work to them, and scales instances up or down based on requests or CPU use. Operational work therefore shifts from server care to service settings such as environment variables, concurrency, and network connections.
| Feature | GKE | Cloud Run |
|---|---|---|
| Deployment and management | Team manages clusters, including nodes, networking, scaling, and upgrades | Team provides source or image; no cluster provisioning |
| Control and flexibility | Full control over nodes, network policies, security, and add-ons | Limited control to environment variables, concurrency, and network connections |
| Application types | Stateless and stateful apps, including complex microservices | Stateless request-driven or event-driven services, jobs, and functions |
| Pricing model | Pay-per-cluster per hour, irrespective of mode, size, or topology | Pay-per-use, rounded up to the nearest 100 milliseconds |
Exam tip: Choose Cloud Run when no explicit Kubernetes requirement exists, and choose GKE when the workload needs stateful storage, custom node or network configuration, or Kubernetes APIs.
Workload archetypes link trigger type, state, and control needs to the right platform. Cloud Run functions are lightweight single-purpose code units that respond to events such as a storage change, message, or schedule, often initiating a larger workflow such as starting a batch job on Cloud Run. Choose Cloud Run functions when work should start only when something happens, run briefly, and then stop. Cloud Run for containerized request-based scaling fits stateless web applications, mobile backends, APIs, and periodic batch jobs with variable traffic, scaling instances automatically as load rises and removing them as load falls.
GKE for complex orchestration runs containerized applications across a cluster of nodes with control at two dependent levels. At the pod level the Horizontal and Vertical Pod Autoscalers add or remove containers and adjust resources, with Kueue orchestrating batch jobs through queues. At the node level the cluster autoscaler adds or removes nodes to fit pods that need placement. GKE supports stateless and stateful applications with persistent attached volumes, fine-grained allocation, network policies, all available NVIDIA GPUs, and all available Google TPUs, while Cloud Run supports only NVIDIA RTX PRO 6000 Blackwell and L4 GPUs and does not support TPUs.
Portability and economic trade-offs determine how easily workloads move and when each pricing model costs less. Container portability between GKE and Cloud Run is high because both use standard container images, so the same image stored in Artifact Registry can run on either platform without modification. Both use a declarative API model, with the Cloud Run Admin API v1 designed to be compatible with the Kubernetes API, and both integrate with Cloud Deploy, Cloud Logging, Cloud Monitoring, and Binary Authorization. Traffic can shift gradually because load balancers can sit in front of both platforms, with requests flowing to GKE endpoints, Cloud Run endpoints, or split across both for testing and rollback.
Cost follows utilization pattern. Cloud Run uses pay-per-use billing rounded up to the nearest 100 milliseconds, so charges accrue while users browse or jobs execute and stop when traffic stops and instances scale down. GKE uses pay-per-cluster per hour plus underlying node capacity, so nodes remain available for steady traffic and persistent state. If utilization is constant and autoscaling is rarely needed, fixed GKE capacity can be more attractive than per-request billing. Choose Cloud Run when demand is spiky or idle periods are long and cost should stop when requests stop, and choose GKE when demand is steady and persistent capacity with Kubernetes control costs less.
Choosing Compute Engine resources means matching virtual machines to performance, isolation, and licensing needs instead of using a default size. Compute Engine (opens in a new tab) is an infrastructure as a service product that provides self-managed virtual machines with a KVM hypervisor for Linux and Windows, configured through the console, CLI, or REST API. Selection balances cost, performance, and workload rules by choosing the machine family, accelerators, CPU threading, region, and license model, with workload parallelism, latency, state, and regulatory limits narrowing valid types before cost tuning begins.
Accelerator-optimized machines are the Compute Engine family for workloads that need hardware accelerators in addition to CPUs, such as GPUs for parallel processing. Compute Engine provides families for balanced general-purpose needs, CPU-intensive compute-optimized work, memory-intensive work, storage-intensive work, network-intensive work, and accelerator-backed specialized work. An accelerator-optimized virtual machine depends on the attached accelerator, and the application depends on that combined CPU-plus-accelerator capacity to complete parallel work. Choose an accelerator-optimized type when the bottleneck is parallel throughput that general-purpose CPUs alone cannot meet efficiently.
Custom sizing fits virtual CPUs and memory to exact needs when a predefined general-purpose size does not fit. A custom machine type lets an architect provision only the CPU and memory required for predictable workloads and bills only for provisioned resources with no up-front cost. Machine type recommendations analyze utilization and suggest a size that matches compute requirements, which is useful when memory is fully used while CPUs sit idle or the reverse. Each virtual CPU is implemented as a single hardware multithread, with two virtual CPUs sharing one physical core by default. For highly parallel or floating-point work such as genetic analysis and financial modeling, reducing threads per core can improve performance, while disabling simultaneous multithreading reduces virtual CPUs per core from 2 to 1 to lower bring-your-own-license costs for software licensed per core.
| Option | What is provisioned | Choose when |
|---|---|---|
| Predefined machine type | Fixed CPU and memory set by Compute Engine | Needs are standard or still changing and simplicity matters |
| Custom machine type | Custom CPU and memory chosen for the workload | Needs are predictable and a predefined size would leave CPU or memory idle |
Exam tip: Use a custom machine type for predictable workloads where a predefined size wastes CPU or memory; use machine type recommendations first to identify the right CPU and memory combination.
Spot VMs are the latest version of preemptible virtual machines sold through the spot provisioning model using excess Compute Engine capacity at much lower prices. Discounts reach up to 91% for many machine types, GPUs, TPUs, and Local SSDs, but Compute Engine can reclaim capacity at any time by preempting the VMs. Spot VMs provide the same machine types, options, and performance as regular VMs while running, with no minimum or maximum runtime unless a limit is configured. They trade guaranteed availability for major cost savings.
Suitability depends on graceful failure. Spot VMs fit fault-tolerant stateless workloads such as batch jobs and fault-tolerant web tiers without high availability requirements, where preemption only delays completion. A batch job across many Spot VMs slows but does not stop if some VMs are reclaimed. Spot VMs do not fit stateful services, critical request paths, or workloads needing guaranteed capacity or uptime commitments. Operational limits include no support for the A4X series or bare metal, no Free Tier credits, no live migration to standard VMs, no automatic restart, no SLA coverage, and possible inability for Managed Instance Groups to scale to target size when zonal capacity is limited. The configured termination action is either stop, which is the default, or delete.
| Mode | Cost and availability | Choose when |
|---|---|---|
| On-demand VMs | Standard price, subject to zonal stock-outs | Workload needs standard VMs without reservation or queue |
| Spot VMs | Much lower price, no capacity assurance, can be stopped or deleted | Workload is fault-tolerant, stateless, and batch-oriented |
| Reservations | Reserved capacity held as a pool of VMs | Workload needs capacity assurance and higher scheduling goodput |
| Dynamic Workload Scheduler | Queued requests for GPU-powered VMs in a dedicated pool | Workload needs GPUs while avoiding stock-outs and preemption risk |
Compliance-driven placement and license decisions determine where virtual machines run and who carries software cost to meet regulatory, security, and contractual rules. Region choice is constrained by machine type availability, end-user and application latency, resource and cross-regional transfer cost, regulatory and region-specific restrictions, and sustainability such as low-carbon regions. The most cost-efficient region might not have the lowest carbon footprint or required machine types, so the compliant region and machine type must be selected first. Data placement follows the same boundary logic, with zonal volumes staying in one zone, regional volumes replicating synchronously across two zones, and no cross-region replication unless a multi-region storage service is used.
License ownership depends on managed versus self-managed databases. When you use Cloud SQL for SQL Server, license costs are included in service charges with limited operating system control. When you run SQL Server on Compute Engine virtual machines, you retain full operating system access but must carry third-party license costs separately, including failover cluster instances when needed. Specify exact software versions in startup scripts and templates so recreated VMs stay consistent and license-compliant. Choose Cloud SQL when the managed configuration meets needs and simplified licensing is preferred, and choose Compute Engine only when Cloud SQL does not support the required configuration or operating system access is needed.
Use HA VPN for smaller or occasional transfers that need IPsec encryption and private IP addresses, including HA VPN over Cloud Interconnect when traffic must not traverse the public internet. Use Dedicated Interconnect for sustained transfers typically at 10 Gbps or more when the team can meet Google in a supported facility and manage routing equipment, and use Partner Interconnect for dedicated capacity normally below 10 Gbps per connection without building direct cross-connects.
Shared VPC is a VPC network owned by a host project and shared with attached 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 independent VPC networks exchange private traffic over Google's backbone while each team keeps its own firewall rules and routing, and peering is non-transitive and requires non-overlapping IP addresses.
Choose Google Kubernetes Engine when the workload needs stateful storage, custom node or network configuration, or Kubernetes APIs. Choose Cloud Run when no explicit Kubernetes requirement exists, especially for stateless request-driven or event-driven services with spiky traffic or long idle periods where cost should stop when requests stop.
Cloud Router uses Border Gateway Protocol sessions to exchange routes between a VPC network and an on-premises or other-cloud router so both sides learn reachable prefixes automatically. It is used together with Cloud Interconnect and Cloud VPN gateways including HA VPN, and when a link, tunnel, or path fails, Border Gateway Protocol withdraws unreachable routes and Cloud Router directs traffic to remaining healthy paths.
Last updated