Prepare and test your skills

Prepare and test your skills

Google Cloud compute options differ in how much infrastructure Google manages and how much control you keep. The three core choices are Compute Engine (opens in a new tab) for virtual machines, Google Kubernetes Engine (GKE) (opens in a new tab) for containers, and Cloud Run for serverless containers. The right choice depends on application design, scaling needs, and how much operational work you want to handle.
Compute Engine is Google Cloud's Infrastructure as a Service (IaaS) product for creating and running virtual machine (VM) and bare metal instances. Compute Engine gives you full control over the operating system, kernel settings, CPU, memory, storage types, and guest operating system. Compute Engine supports NVIDIA GPUs and Google tensor processing units (TPUs) attached to instances and offers a minimum uptime service level objective (SLO) of 99.5%, which varies by region, Network Service Tier, and deployment setup.
Compute Engine offers flexible machine and storage choices for different workloads:
Compute Engine can run single VMs or managed instance groups (MIGs) that are managed as one entity. A regional MIG automatically spreads VMs across multiple zones in a region, and autoscaling adds or removes VMs based on demand. Choose Compute Engine for custom architectures, lift-and-shift migrations, commercial software, or any workload that needs administrative control over virtual servers.
Google Kubernetes Engine (GKE) is a managed Kubernetes platform for deploying, scaling, and orchestrating containerized applications. GKE is built on Kubernetes, the open-source container-orchestration system, where nodes are Compute Engine VMs grouped into a cluster and workloads run as containers in Pods on those nodes. Google manages the Kubernetes control plane for security and availability and manages the operating system in both modes.
GKE has two management modes and layered scaling. In Autopilot mode, Google manages nodes and adjusts capacity without manual action, while in Standard mode you manage node pools. Horizontal Pod Autoscalers add or remove container replicas, Vertical Pod Autoscalers adjust pod requests and limits, the cluster autoscaler adds or removes nodes, and Kueue orchestrates batch jobs. Cloud Service Mesh controls traffic into and between clusters, Config Sync applies configuration from a single source, and Backup for GKE backs up persistent data. Choose GKE for distributed applications, microservices, and APIs that need robust orchestration.
Cloud Run is a serverless platform for running containerized applications without managing servers or clusters. Cloud Run handles the operating system, kernel, network setup, and capacity management. You package work as containers that run as web services, asynchronous tasks, or batch jobs. Cloud Run services are regional resources replicated across multiple zones in their region for availability.
Traffic flows from incoming requests to Cloud Run container instances, and Cloud Run adds instances when requests or CPU use rises and removes instances when traffic falls. Cloud Run supports NVIDIA RTX PRO 6000 Blackwell and L4 GPUs but does not support other GPU models or Google TPUs. Choose Cloud Run when you want to focus on code and data rather than infrastructure operations.
Compute service models describe where the management boundary sits between you and Google. IaaS gives the most control, Platform as a Service (PaaS) balances control with a managed platform, and serverless moves all infrastructure management to Google.
Three side-by-side stacks compare IaaS, PaaS and Serverless. IaaS with Compute Engine leaves OS and apps to you, PaaS with GKE leaves only workloads to you, and Serverless with Cloud Run leaves only code to you while Google manages the rest.
| Model | What you manage | What Google manages | Example services |
|---|---|---|---|
| IaaS | Operating system, middleware, applications | Virtualization, servers, storage, networking | Compute Engine, Google Cloud VMware Engine |
| PaaS | Workloads and some platform choices | Infrastructure, operating system, runtime | Batch, GKE, Cluster Director |
| Serverless | Application code or container | All infrastructure management | Cloud Run, Cloud Run functions |
Cloud compute brings three main advantages over owning servers. Reduced overhead means Google manages hardware, power, cooling, and virtualization so teams spend less time on upkeep. Elastic scaling means MIGs, GKE autoscalers, and Cloud Run add capacity during peaks and remove it when quiet, which avoids paying for idle servers. Consumption pricing means you pay for actual use plus discounts such as committed use discounts (CUDs) for steady use, sustained use discounts for consistent Compute Engine use, and Spot VMs for fault-tolerant work on unused capacity.
Exam tip: Choose Cloud Run when Google should manage all infrastructure, GKE when you need Kubernetes orchestration for containers, and Compute Engine when you need VM or bare metal control.
Core cloud compute terms describe different levels of abstraction, from full control of virtual servers to fully managed execution of code. Compute Engine (opens in a new tab) provides virtual machines with the most control, Google Kubernetes Engine (GKE) (opens in a new tab) provides managed orchestration for containers, and Cloud Run provides serverless execution with minimal management. Choosing a model trades configuration flexibility for reduced management effort.
Virtual machines, containers, and serverless form a spectrum from maximum control to minimum management. Virtual machines in Compute Engine are individual virtual servers where you choose the machine type, image, zone, network, and operating system. You remain responsible for patching, scaling, and operating those machines, which fits lifting existing applications, running commercial software that needs operating system access, and using specific machine types.
Containers are lightweight packages that hold an application and everything it needs to run, so the same container runs consistently in different environments. GKE automates deploying, scaling, and managing those containers in clusters, but you still package workloads and define orchestration. Microservices split a large application into small, independent services, such as separate APIs for users, orders, and payments, that are typically deployed as containers and can be updated and scaled independently. Serverless computing with Cloud Run lets you run containerized web apps, tasks, or batch jobs while Google handles servers, operating system, network, and scaling.
| Model | Google Cloud example | Management | Choose when |
|---|---|---|---|
| Virtual machines | Compute Engine | You manage VMs, operating system, and scaling | You need full control, custom images, or operating system access |
| Containers | GKE | You package containers; Google provides managed orchestration | You run microservices or APIs that need orchestration |
| Serverless | Cloud Run | Google manages servers, operating system, network, and scaling | You want to deploy without server or cluster administration |
Containerization bundles an application with its dependencies into a standard image, such as a Docker image, so the workload runs the same way on different platforms. Containerization supports componentization, portability, and rapid deployment in three related ways. Componentization puts separate parts, such as a web server and a database, in separate containers so one can be updated without affecting the other. Portability means the same container runs on many platforms without worrying about system details. Rapid deployment means systems are built from definitions and images so parts deploy quickly and automatically.
Kubernetes is the open-source orchestration system, and GKE is the managed Google Cloud service that runs Kubernetes clusters. A GKE environment consists of nodes grouped into a cluster, workloads packaged as Pods placed on nodes, and a control plane that runs system components such as the API server. In GKE, Google manages the control plane while you deploy container workloads through the Kubernetes API.
A Pod is an app-specific logical host for one or more containers that runs on a node, and containers in the same Pod can share storage volumes. On-disk files inside a container are ephemeral and are lost when the container restarts, which is different from a Compute Engine instance where the attached disk stays with the instance. Kubernetes solves this with volume and Storage Class abstractions, including the GCE PD storage class that lets containers use Compute Engine persistent disks so data survives restarts and can be shared in the Pod. Artifact Registry provides private storage for Docker images through an HTTPS endpoint, with images hosted in Cloud Storage and accessible by default only to principals with project access.
Load balancing in GKE distributes incoming traffic across containers, nodes, and Pods so large architectures can share demand. Traffic flows from internet clients to the load balancer, and the load balancer forwards traffic to available GKE endpoints. GKE supports two main approaches that differ in simplicity and routing intelligence.
| Option | How it is enabled | What it routes on |
|---|---|---|
| Network load balancing | Add type: LoadBalancer to the service file, which uses Compute Engine network load balancing with forwarding rules to target pools | Address, port, and protocol type, including TCP/UDP such as SMTP, while the app can inspect packets directly |
| HTTP(S) load balancing | Create a Kubernetes Ingress resource, which provisions the Compute Engine HTTP/HTTPS load balancer | HTTPS, content-based routing, and cross-region routing |
The Cluster Autoscaler automatically resizes clusters to match demand. The autoscaler first checks for Pods waiting for a node with free resources, then grows the node pool if resizing would allow those Pods to be scheduled. The autoscaler also monitors node usage and deletes a node when it has been unneeded for an extended period and all its Pods can be scheduled elsewhere. Together, growing for unscheduled Pods and removing long-idle nodes keeps applications responsive without keeping unneeded capacity.
Exam tip: type: LoadBalancer creates network load balancing for TCP/UDP traffic, while an Ingress resource provisions HTTP(S) load balancing for content-based and cross-region routing.
Resource efficiency means matching capacity to actual demand so applications stay responsive without paying for idle resources. Managed autoscaling covers each compute style: Compute Engine MIGs scale a group of VMs as one entity using minimum and maximum counts and thresholds such as CPU use, GKE autoscaling adjusts nodes and Pods using Cluster Autoscaler, Horizontal and Vertical Pod Autoscalers, and Node Auto-Provisioning, and Cloud Run adds or removes serverless instances as request traffic rises and falls.
Discounted capacity lowers the price of the capacity you use. Committed use discounts provide savings for committing to a level of use over time, sustained use discounts give automatic Compute Engine savings for consistent use, and Spot VMs give access to unused VM capacity at a lower cost than regular VMs. Right-sizing keeps allocation aligned over time: Cloud Monitoring shows real-time use, Recommender suggests changes such as different machine types, and tags and labels group spending by project or department. Cloud Billing budgets, alerts, dashboards, and reports track trends and forecast costs.
Scalability, agility, and flexible spending are the main business reasons to run compute in the cloud. Compute Engine managed instance groups (MIGs) (opens in a new tab) scale VMs as a group, Google Kubernetes Engine (GKE) (opens in a new tab) scales containers and nodes, and Cloud Run scales serverless instances with traffic. Together they keep performance steady during peaks without wasting resources when demand is low.
Elasticity is the ability of cloud resources to grow and shrink as demand changes. Autoscaling adds capacity when demand rises and removes capacity when demand falls, using signals such as CPU use, memory use, and queue depth. Right-sizing is different: right-sizing changes how much CPU or memory each workload receives to match actual use, while autoscaling changes how many resources run. Over-provisioning wastes money on idle capacity, while under-provisioning creates bottlenecks and slow performance.
| Option | What scales | How it responds |
|---|---|---|
| Compute Engine MIGs | Group of VMs as one entity | Adds VMs at high use and removes VMs at low use, within minimum and maximum |
| GKE | Cluster nodes and Pods | Cluster Autoscaler changes nodes, Horizontal Pod Autoscaler changes replicas, Vertical Pod Autoscaler tunes requests and limits |
| Cloud Run | Serverless instances | Scales up with traffic, scales down when traffic falls, scales to zero when idle |
Global infrastructure places workloads in regions around the world so users get responsive access. Region choice should balance latency for users, compliance rules for data location, and cost goals, with help from tools such as the Region Picker. Availability planning also requires that both a primary system and its disaster recovery system have enough capacity to absorb surges and support graceful failover. Capacity planning uses historical use, growth projections, and business needs to forecast compute, storage, and API demand, while Cloud Monitoring and BigQuery reveal high-demand periods and bottlenecks.
Operational agility means shipping applications faster while managing less infrastructure. Managed services handle patching, scaling, security hardening, and disaster recovery by default, which lowers long-term operational cost and speeds time-to-market. Teams then spend more time building features instead of maintaining servers.
Managed VMs with MIGs keep VM control with automated group management. You define an autoscaling policy with minimum and maximum VM counts, metrics such as CPU use flow into the policy, and the policy adds VMs at high use and removes VMs at low use. Automated container management with GKE removes manual sizing of container placement: the control plane places containers across nodes, Horizontal Pod Autoscaler adds Pods first during a spike, then Cluster Autoscaler adds nodes if needed, and the process reverses when demand falls. Serverless agility with Cloud Run removes server management entirely: traffic flows directly to Cloud Run, instances scale with traffic, and scale-to-zero powers resources only while they process requests, which fits intermittent or event-driven work.
| Option | Management level | Scaling behavior |
|---|---|---|
| Compute Engine MIGs | Customer manages VMs as a group | Adds or removes VMs between minimum and maximum |
| GKE | Platform manages nodes and placement | Adjusts Pods, node size, and node count with four autoscalers |
| Cloud Run | No infrastructure to manage | Scales with traffic and scales to zero when idle |
Exam tip: Cloud Run scales to zero when idle with built-in autoscaling, while MIGs scale between a configured minimum and maximum number of VMs.
Capital expenditure (CapEx) is upfront spending to own servers, storage, networking, and data center space. Total cost of ownership for CapEx includes hardware and software plus power, cooling, maintenance, and support, and teams often overprovision extra servers for peaks and failover that sit idle most of the time. Operational expenditure (OpEx) is ongoing spending to use cloud resources without owning hardware: you provision a VM, cluster, or serverless instance when needed and release it when demand drops.
Flexible pricing makes OpEx controllable by matching price to workload pattern:
Visibility keeps OpEx efficient. Tags and labels attach project, team, or department metadata to resources so spending flows to its owner in billing reports. Cloud Billing budgets and alerts track actual spending against limits and notify stakeholders when budgets are exceeded, but budgets and alerts do not automatically stop resources.
Choosing compute in Google Cloud means matching architecture, deployment frequency, and scaling behavior to the most aligned service. Cloud Run (opens in a new tab) fits serverless containers, Google Kubernetes Engine (GKE) (opens in a new tab) fits orchestrated containers, and Compute Engine fits self-managed VMs. More control gives more flexibility but increases maintenance, while more automation reduces maintenance but limits customization.
The control-versus-management trade-off is the starting point for the decision. The decision flow moves in order from fully managed options to self-managed infrastructure:
A decision tree starting with five questions that route a workload to Cloud Run, Compute Engine, Batch, GKE, Cluster Director, or Cluster Toolkit based on how much infrastructure management and orchestration the learner wants.
Cloud Run is a serverless platform where Google manages the operating system, kernel, network, and capacity, and adds or removes instances based on requests or CPU. Google Kubernetes Engine (GKE) is a managed Kubernetes platform where Google manages the control plane and operating system; Autopilot also manages nodes, while Standard leaves node pools to you, with Horizontal and Vertical Pod Autoscalers for containers and cluster autoscaler for nodes. Compute Engine is the core IaaS platform where you control CPU, memory, storage, guest operating system, kernel, and network, with manual scaling or MIGs you configure.
| Service | Infrastructure control | Scaling behavior |
|---|---|---|
| Cloud Run | Google manages OS, kernel, network, capacity | Adds or removes instances by requests or CPU |
| GKE | Google manages control plane and OS; Standard adds node-pool control | Adds or removes containers with HPA and VPA, nodes with cluster autoscaler |
| Compute Engine | You control OS, kernel, machine type, storage, network | Manual scaling or MIGs that you configure |
Serverless, container-based, and virtual machine models differ in provisioning, scaling, and daily maintenance. Serverless minimizes administration, containers add orchestration control, and virtual machines give full infrastructure control.
Batch is a serverless option for scheduling, queuing, and executing batch jobs. You submit scripts or containers to a queue, Google manages the operating system and execution environment, Batch provisions VMs based on queued jobs and stops them when jobs complete, and the queue retries tasks on error. Batch supports NVIDIA GPUs up to RTX PRO 6000 but does not support Google TPUs, and fits data analysis, video conversion, and simulations. Specialized clusters extend the choice: Cluster Director automates AI, machine learning (ML), and high performance computing (HPC) cluster lifecycle with login nodes and compute nodesets, while Cluster Toolkit is an open-source tool that provisions clusters from Infrastructure as Code blueprints and leaves operating system and lifecycle control to you.
VMware Engine runs VMware VMs on Google hardware without application changes and without GPU or TPU support, which fits migration with minimal operational change. Compute Engine deployment planning assesses application state, where stateful apps store client or session data and stateless apps do not, plus provisioning needs such as zones, virtual private cloud (VPC) networks, and low-latency placement, plus resilience needs such as zonal protection and fixed IP addresses.
Exam tip: Choose Cloud Run when Google should manage all infrastructure; choose Compute Engine when you want to manage VMs or bare metal instances yourself.
Cost constraints come from machine size, provisioning model, licenses, and quotas. Custom machine types size CPU and memory independently to avoid paying for unused capacity, stateless MIGs support autoscaling to cut idle cost while stateful MIGs cannot be autoscaled, and machine-type recommendations match resources to needs.
Pricing choices trade discount for stability:
Performance and location constraints determine whether machine types, accelerators, and storage speed are available where users and data reside. Region choice affects latency, service availability, cost, data-transfer cost, regulatory needs, and sustainability, so the cheapest region may not have the lowest latency or carbon footprint. Google Cloud Hyperdisk allows more tuning than Persistent Disk: Hyperdisk Balanced provisions input/output operations per second (IOPS) and throughput separately, and Hyperdisk Extreme offers higher maximum IOPS and throughput than solid-state drive (SSD) Persistent Disk. Zonal Persistent Disk stays in one zone, regional Persistent Disk synchronously replicates across two zones, Filestore regional instances replicate across three zones, and Cloud Storage dual-region buckets with turbo replication provide a 15-minute recovery point objective (RPO).
Compute Engine (opens in a new tab) is Google Cloud's Infrastructure as a Service product for self-managed virtual machines and bare metal instances. Compute Engine runs Linux and Windows VMs on Google's worldwide infrastructure with no up-front costs and control through the console, CLI, or API. Business value comes from paying only for needed capacity, keeping workloads running through failure, and shaping each VM to fit its workload.
Pay-as-you-go billing in Compute Engine means charges follow actual instance, storage, and network use. VMs are billed per second with a 1-minute minimum, storage cost is based on data stored, and network cost is based on data transferred between VMs and to the internet. A business can add instances during a spike and remove them when demand falls, which replaces capital spending on physical servers with operational spending that rises and falls with use.
Committed use discounts lower rates for steady work committed for one year or three years:
| Discount type | What is committed | Where discount applies |
|---|---|---|
| Enterprise discounts | Minimum total Google Cloud spend at negotiated rate | Organization Cloud Billing commitment |
| Resource-based CUDs | Minimum Compute Engine resources for 1 or 3 years | Specific region, shared across projects |
| Spend-based CUDs | Minimum spend on a product for 1 or 3 years | Billing account, regionally or globally |
Spot VMs use spare Google Cloud capacity at more than 80% less than regular VMs. Spot VMs suit fault-tolerant work that can stop and restart, such as batch processing, while committed or on-demand VMs suit work that needs continuous availability. Resource tools control quantity and rate together: autoscaling changes VM count with demand, custom machine types fit CPU and memory to the workload, and Spot VMs shift flexible work to low-cost spare capacity.
Exam tip: Use Spot VMs for fault-tolerant work that can be interrupted, and use CUDs for steady work that runs for one or three years in a known region.
Google's global infrastructure is a network of regions, where each region contains multiple isolated zones for deploying Compute Engine resources. Region choice affects latency, available machine types, cost, and regulatory rules. A virtual private cloud (VPC) is global, but each subnet is bound to one region, so moving workloads to a new region needs new subnets and updated connections such as Cloud Interconnect or Cloud VPN.
Reliability means VMs stay available through maintenance, spikes, and zone problems. Compute Engine offers a minimum uptime SLO of 99.5%, varying by regions, Network Service Tiers, and deployment configuration. Traffic flows from users to a load balancer and then to healthy VM instances, and cross-region load balancing can spread traffic across regions. A MIG depends on an instance template to create identical VMs, a regional MIG automatically provisions VMs across zones so remaining zones serve requests if one zone fails, and the autoscaler depends on the MIG to add VMs when load rises and remove VMs when load falls.
Keeping data running through failure depends on replication scope:
| Storage option | Replication scope | Continuity benefit |
|---|---|---|
| Zonal Persistent Disk | Stored in one zone | Preserved if instance stops, but not replicated |
| Regional Persistent Disk | Synchronously replicated across two zones | Survives a zonal failure |
| Filestore regional instance | Synchronously replicated across three zones | Shared data stays available and mounts on multiple VMs |
Compute Engine also supports autohealing, which recreates a VM if it stops or stops responding, and rolling updates that update all VMs in a MIG as one group. For objects, Cloud Storage regional buckets replicate across zones in a region, while dual-region or multi-region buckets store data in at least two locations for stronger regional protection.
Resource customization shapes each VM to fit a workload, while scalable infrastructure changes how many VMs run as demand changes. Custom machine types (opens in a new tab) let you choose CPU and memory instead of accepting only predefined sizes. Compute Engine provides general-purpose, compute-optimized, network-optimized, storage-optimized, memory-optimized, and accelerator-optimized families, each with series and predefined types, plus machine-type recommendations to match requirements.
Autoscaling adds or removes VM instances as demand varies, but only for managed instance groups. A MIG is a pool of homogeneous VMs created from a common instance template, and an autoscaler adds or removes those VMs. Autoscaling works for stateless MIGs that do not store client, transaction, or session data; stateful MIGs that preserve client or session IDs cannot be autoscaled. Autoscaling handles traffic gracefully and cuts cost when need is low, but zone capacity limits can delay scale-out until capacity returns.
| Capability | What it changes | Key limitation |
|---|---|---|
| Custom machine types | CPU and memory of each VM | Available only for some machine series |
| Autoscaling | Number of VMs in a MIG | Only managed groups; stateful MIGs cannot autoscale |
| Spot VMs | Provisioning model and cost | Can be preemptively stopped; not for high availability |
Custom types create value when needs are predictable by avoiding overprovisioning and limiting licensing cost to needed cores, including bringing your own licenses and disabling SMT to reduce vCPUs per core from 2 to 1.
Rehosting, also called lift and shift, moves a specialized legacy application to cloud infrastructure with little or no change to code or architecture. Google Cloud VMware Engine (opens in a new tab) preserves VMware environments, while Compute Engine (opens in a new tab) hosts standard VMs. Business drivers are speed, reduced operational burden, cost control, compliance preservation, and avoiding a risky rewrite.
Rehosting is most viable when an application is tightly coupled to its current platform, must meet strict compliance constraints, or needs immediate cloud scalability without redesign. Rehosting preserves the operating system, dependencies, and structure, so critical workloads keep running with minimal disruption. Other paths fit different conditions: refactor when dependencies must be untangled or systems cannot run as-is, and rebuild when a workload no longer meets needs, can be replaced, uses end-of-life technology, or carries uneconomical license fees.
The modernization path moves in three ordered phases:
Rehosting optimizes from an infrastructure perspective first, and after applications run in Google Cloud it becomes easier to integrate cloud services. Rehosted applications can still communicate with remaining on-premises systems over a hybrid connection using VPN or Interconnect, which matters when legacy hardware or regulations keep some workloads on-premises.
Rehosting reduces data-center overhead by shifting physical responsibilities to the provider. In an on-premises environment you own cooling, physical security, hardware maintenance, power, cabling, and the virtualization platform. In a public cloud environment the provider manages physical security, power and cabling, hardware maintenance, and virtualization, while you manage application resources with the option to use fully managed services.
Google Cloud compute services simplify management of existing workloads. A Windows-based .NET move typically starts by moving Windows Server and SQL Server instances to Compute Engine VMs, manually with Windows Server images, SQL Server images, or Marketplace solutions, or with tools such as Migrate to Virtual Machines. After configuration, teams can create custom VM images to recreate instances, deploy fault-tolerant Active Directory with a VPC or use Managed Service for Microsoft Active Directory, and use SQL Server images or move to Cloud SQL for SQL Server. Initial gains include custom machine types that pay for what is used, VMs and disaster recovery environments that run only when needed, persistent disks with snapshots for backup and restore, live migration that avoids maintenance windows, and rightsizing recommendations before migration.
Reliability around rehosted workloads comes from cloud services added without changing code. Load balancing routes traffic to available resources and prevents overload, health checks ensure traffic goes only to responsive backends, and autohealing in MIGs deletes unavailable VMs and creates new ones. Rate limiting protects against sudden spikes such as distributed denial-of-service (DDoS) attacks and can limit billing through quotas. Network Service Tiers optimize connectivity: Premium Tier serves global users with backends in more than one region by routing through Google's network from the closest point of presence (PoP).
Exam tip: Rehost (lift and shift) changes where the workload runs, not how it is built; refactor (move and improve) changes the workload to use cloud capabilities.
Rehosting shifts spending from owning data-center assets to paying for cloud resources as they are used. A complete total cost of ownership (TCO) comparison includes hardware and software plus power, cooling, maintenance, and support, plus cloud network use that is often overlooked because on-premises cabling is a one-time cost. After the move, custom machine types fit CPU, memory, and storage to need, start-and-stop billing pays only while VMs run, and autoscaling and sizing recommendations match capacity to demand. The price calculator estimates Google Cloud costs before deployment.
Rehosting lowers initial risk by avoiding rewrites, dependency untangling, and new toolchains, which reduces chances to introduce bugs, shortens migration time, and lets teams learn cloud operations. Programs such as the Rapid Migration Program provide best practices to lower risk and control costs. Rehosting also enables later modernization as the first step before replatforming or rearchitecting.
| Target | What it preserves | Choose when |
|---|---|---|
| Google Cloud VMware Engine | VMware environment, vSphere, vCenter, HCX, NSX-T, vSAN policies | Application is tightly coupled to VMware and needs minimal change |
| Google Compute Engine | Individual VMs with multi-tenant or sole-tenant tenancy | Application can run on standard VMs without VMware features |
VMware Engine planning uses migration waves with VMware HCX, bulk migration preferred, plus checks for version compatibility and non-migratable content such as mounted ISOs and passthrough devices. Compute Engine tenancy affects isolation: multi-tenant is the default with only pay-as-you-go Windows Server licenses, while sole-tenant gives exclusive physical servers, supports bring-your-own-license and pay-as-you-go, and allows SMT configuration for performance and licensing balance.
Choose Cloud Run when Google should manage all infrastructure including the operating system, kernel, network, and capacity, choose Google Kubernetes Engine (GKE) when you need Kubernetes orchestration for containers such as microservices and APIs, and choose Compute Engine when you need self-managed virtual machines or bare metal instances with control over the operating system and machine configuration. Cloud Run adds or removes instances based on requests or CPU use, GKE scales containers and nodes with pod and cluster autoscalers, and Compute Engine scales manually or with managed instance groups that you configure.
Autoscaling changes how many resources run by adding capacity when demand rises and removing it when demand falls, while right-sizing changes how much CPU or memory each workload receives to match actual use. Over-provisioning wastes money on idle capacity, while under-provisioning creates bottlenecks and slow performance.
Spot VMs use spare Google Cloud capacity at more than 80% less than regular VMs for fault-tolerant work that can stop and restart, such as batch processing, but they can be preemptively stopped or deleted. Committed use discounts lower rates for steady work committed for one year or three years, with resource-based commitments for a specific region and spend-based commitments for a billing account.
Last updated