Prepare and test your skills

Prepare and test your skills

Cloud modernization and migration is the move from owning on-premises servers to running workloads on Google Cloud (opens in a new tab) as a public cloud. A workload is an application, service, database, virtual machine, or container that provides business value. Each workload is assessed and given its own path, so parts of the same system can move in different ways and still work together.
The shift to cloud is a shift from fixed capacity to elastic capacity and from capital expenditure (CapEx) to operational expenditure (OpEx). CapEx means buying servers with large upfront spending, while OpEx means paying on demand for what is used. A typical legacy system is a monolithic .NET Framework app on Windows Server with on-premises SQL Server, which brings licensing costs, hard upgrades, and fixed hardware that is difficult to scale.
Business drivers for the move include lower total cost of ownership, stronger availability and resilience, faster development and testing, and innovation with analytics and artificial intelligence (AI). Technical drivers include multi-regional performance, automated rollouts, high-level application programming interfaces (APIs), serverless services, and provisioning of compute and storage in minutes. In public cloud, Google manages physical facilities, hardware, and virtualization, so the customer focuses on applications and can shut down short-term capacity when finished.
Exam tip: CapEx means buying servers you own with large upfront spending, while OpEx means paying on demand for what you use; the cloud driver is lowest possible CapEx with fast provisioning.
Migration strategies describe how much an application changes during the move to Google Cloud. Choosing a strategy depends on dependencies, cost, skills, and whether the technology can run in the cloud.
Lift-and-shift is fastest because code and architecture stay the same. Re-architecting takes more time and testing and needs new skills, but it unlocks independent scaling and faster releases. A common cycle is to first rehost or replatform to get into the cloud, then refactor or rearchitect once the workload runs stably over a hybrid connection.
Different paths for different applications means each workload follows the approach that fits its requirements. For example, a backend MySQL database can be replatformed to Cloud SQL while frontend VMs are refactored to containers on Google Kubernetes Engine (GKE) (opens in a new tab), where Google manages nodes, scaling, and security. Hardware load balancing can be replaced with Cloud Load Balancing and firewall functions with Google Cloud Armor. Other replacements include Cloud Storage for network attached storage, Pub/Sub for self-hosted messaging, Identity-Aware Proxy (IAP) for custom login, and Secret Manager with Cloud Key Management Service (Cloud KMS) for local secrets.
Decisions about scope use three options. Retire means decommissioning a workload that is not worth moving. Retain means keeping a workload in place for technical, compliance, or privacy reasons. Migrate means moving the workload to Google Cloud in waves. The ordered migration process moves through Assess, Plan, Deploy, and Optimize:
Continue with this study guide: Cloud modernization and migration
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) for containers, and Cloud Run for serverless containers. More control gives more flexibility but more maintenance, while more automation reduces maintenance but limits customization.
A decision tree branching on infrastructure control and orchestration needs to select Cloud Run, GKE, Compute Engine, or Batch.
Compute Engine is Google Cloud's Infrastructure as a Service (IaaS) product for creating and running virtual machine and bare metal instances. Compute Engine gives full control over the operating system, kernel, CPU, memory, storage, and network. It supports NVIDIA GPUs and Google tensor processing units (TPUs) (opens in a new tab) and offers machine choices across general-purpose, compute-optimized, memory-optimized, storage-optimized, network-optimized, and accelerator-optimized families, plus custom machine types and CPU platforms (opens in a new tab).
Storage choices trade performance for durability. Local SSD offers the best performance but loses data when the instance stops. Hyperdisk is fast, durable, configurable block storage, while Persistent Disk is durable block storage for machine series that do not support Hyperdisk. Compute Engine can run single VMs or managed instance groups (MIGs) that manage many VMs as one entity, spread them across zones, and autoscale them with demand. Choose Compute Engine for lift-and-shift migrations, commercial software, and any workload that needs operating system control.
Google Kubernetes Engine (GKE) is a managed Kubernetes platform for deploying, scaling, and orchestrating containerized applications. 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. In Autopilot mode Google also manages nodes and adjusts capacity automatically, while in Standard mode you manage node pools.
Cloud Run is a serverless platform for running containerized applications without managing servers or clusters. You provide code or a container image, and Cloud Run handles the operating system, networking, and capacity. Traffic flows from incoming requests to Cloud Run container instances, and Cloud Run adds instances when requests rise and removes them when traffic falls. Cloud Run services are regional resources replicated across zones. Choose GKE for distributed microservices and APIs that need orchestration, and choose Cloud Run when you want to focus on code rather than infrastructure.
Compute service models describe where the management boundary sits between you and Google.
| 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 reduced overhead, elastic scaling, and consumption pricing. Google manages hardware, power, cooling, and virtualization. MIGs, GKE autoscalers, and Cloud Run add capacity during peaks and remove it when quiet, which avoids paying for idle servers. Pricing follows use, with committed use discounts (CUDs) for steady one-year or three-year use, sustained use discounts for consistent Compute Engine use, and Spot VMs that use spare capacity at more than 80% less for fault-tolerant work.
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.
Continue with this study guide: Computing in the cloud
Serverless computing on Google Cloud means running code without provisioning or managing servers. The main platforms are Cloud Run (opens in a new tab) for containerized applications and Cloud Run functions for single-purpose, event-driven functions. Teams focus on business logic while Google handles provisioning, scaling, load balancing, and runtime maintenance.
Automatic provisioning in serverless means capacity follows traffic instantly without tuning rules. Cloud Run routes incoming requests to backend containers and scales each revision to the number of container instances needed for current requests. When a revision receives no traffic, it scales to zero instances by default, so no compute charges occur while idle. The minimum instances setting can keep an instance warm for faster response, which trades higher cost for lower cold-start delay.
This behavior differs from Compute Engine autoscaling, which requires manually tuned rules for MIGs and does not scale to zero. Other services share the same elastic model, including Cloud Run functions, Pub/Sub, Eventarc, Workflows, BigQuery, and Spanner. For enterprise traffic, serverless network endpoint groups let Cloud Run use HTTP(S) load balancing with Application Load Balancer (opens in a new tab) features such as Cloud CDN caching and multi-region serving.
A serverless event flow moves in a fixed order from source to storage. First, an event source emits a change, such as a file upload, database update, HTTP request, Cloud Scheduler schedule, or Cloud Tasks task. Second, data flows from the source to Pub/Sub or Eventarc, which delivers the message to its target. Third, the message invokes a container on Cloud Run or a function on Cloud Run functions, which runs only for the duration of the work. Fourth, Workflows passes output to the next service, and persistent data flows from the compute step to Cloud Storage, Firestore, Cloud SQL, BigQuery, or Spanner.
Containers on Cloud Run are ephemeral, so temporary files live only during processing and persistent data must flow to managed storage. Deployment is streamlined with revisions and traffic splitting, so a new version can run alongside the old version. Code flows from source control through Cloud Build to Cloud Run, and Cloud Run sends request logs and container logs automatically to Cloud Logging while metrics flow automatically to Cloud Monitoring with no agent setup.
Cloud Run, App Engine, and Cloud Run functions all scale automatically and charge on a pay-per-use basis, but they fit different needs.
| Service | What you deploy | Best use case | Scaling and runtime notes |
|---|---|---|---|
| Cloud Run | Container, code, or function | Scalable web apps, APIs, and portable containers | Automatic scaling; scales to zero by default; request timeout up to 60 minutes |
| App Engine | App with services and versions | Scalable web platforms across multiple runtimes | Standard scales to zero with warm-up; flexible does not scale to zero |
| Cloud Run functions | Single-purpose function | Event-driven automation and connecting services | Stays idle until an event invokes it; uses resources only during execution |
App Engine is a serverless platform for apps across multiple runtimes. The standard environment supports automatic scaling, scale-to-zero, and configurable warm-up requests, while the flexible environment does not scale to zero and supports custom runtimes. Cloud Run functions remains idle until an event triggers it, then compute flows to the function and results flow to connected services. Google Cloud recommends Cloud Run over App Engine for new projects because Cloud Run handles the same web workloads with more flexibility and improved integrations.
Exam tip: Serverless autoscaling is instant and can scale down to zero resources, while autoscaling in services such as Compute Engine requires fine-tuning rules.
Continue with this study guide: Serverless computing
Containers in the cloud are lightweight packages that hold an application and its dependencies without a full operating system. A container shares the host operating system kernel, while a virtual machine carries its own complete operating system. When containers run on managed platforms like Google Kubernetes Engine (GKE), teams pack more work onto fewer machines and let Google Cloud handle scaling, patching, and infrastructure.
Resource efficiency describes how fully each host machine is used. Because containers omit a full operating system and allow fine-grained allocations, many containers or Pods can run on the same host, start quickly, and leave hardware idle less often. Traditional VMs on Compute Engine have a heavier footprint and costs continue even when idle, while containers on managed platforms have a lighter footprint and support fast startup that enables scaling with demand.
Environmental consistency means an application behaves the same in development, testing, and production because it carries its runtime with it. A container image is the immutable built artifact that holds code, runtime, libraries, and settings, while configuration and secrets are injected at deploy time. Teams build the image once, store it in Artifact Registry, and promote that same tested artifact from development to quality assurance to production. Rebuilding at each stage can introduce untested differences, so Cloud Build builds once and Cloud Deploy promotes the same artifact forward with access control (opens in a new tab) limiting who can promote it.
Agility through microservices is the ability to break a large monolith into smaller services that update and scale on their own. A legacy monolith must be redeployed as a whole, while a containerized microservice is commonly a Deployment with load-balanced Pods behind a Service. Each microservice grows or shrinks based on its own traffic, so a busy checkout service can add Pods while an idle reporting service stays small. Kubernetes recreates failed Pods, performs rollouts and rollbacks, and runs health checks, while GKE adds cluster autoscaling, auto-repair, and regional clusters.
Modern development combines containers, microservices, and automated pipelines. Continuous integration builds, packages, and tests the app, while continuous delivery deploys the artifact frequently. Code flows from source to production in order: develop and validate, build and test with Cloud Build, release to staging with Cloud Deploy, promote the same container to production with approval, and operate consistently. This image-based flow supports rolling updates, canary releases, and blue/green deployments, and Migrate to Containers can extract an image from a VM workload without source access.
Choosing a managed container option means trading direct VM control for less operational work and automatic elasticity.
| Solution | Best for | Cost and management tradeoff |
|---|---|---|
| VMs with startup scripts | Single VM, testing, privileged mode | Team owns setup and pays even when idle |
| Cloud Run | Stateless apps and small to medium jobs | Platform handles elasticity and scales to zero |
| Batch | Batch jobs with a definite end state | Platform manages execution for finite jobs |
| GKE | Many containers and advanced control | Cluster orchestration with auto-repair and scaling |
GKE groups Compute Engine VMs as nodes into a cluster managed through the Kubernetes API. In Autopilot mode Google manages control plane and worker nodes and bills only for Pod requests, while in Standard mode the team manages nodes and pays for full node capacity. Cloud Run removes clusters entirely, routes each request to backend instances with built-in load balancing, and bills only for time code runs rounded to the nearest 100 milliseconds. The same standard image can often run on either runtime, with Cloud Run carrying variable stateless services and GKE carrying stateful or complex services.
Exam tip: Stay on Compute Engine with startup scripts to keep VM control, choose Cloud Run for stateless services, Batch for jobs with a definite end state, and GKE for advanced control across many containers.
Continue with this study guide: Containers in the cloud
The business value of application programming interfaces (APIs) is that they let organizations reuse capabilities, integrate systems quickly, and grow securely at scale. An API defines stable entry points, data formats, and response codes so one application can use logic built by another without knowing how the backend works. On Google Cloud, API Gateway provides definition and deployment, Apigee provides full management and governance, and Google Enterprise APIs provide long-term stability.
An API contract is the agreement between a provider and a consumer about how the API will behave. The provider exposes a URL, request format, response format, and authentication method, and consumers build against that stable interface. For example, a book API can accept a GET request with an isbn parameter and return JSON with title, author, and publish date plus a 200 code. New parameters or fields can be added later without breaking the existing isbn behavior.
A reusable service on API Gateway moves through an ordered lifecycle. First, define the API as an OpenAPI 2.0 spec with backend URL, formats, and authentication. Second, upload the spec with gcloud to create an API config. Third, deploy the config on API Gateway. Fourth, allow clients to make REST calls through the gateway to the backend. Fifth, update by changing the spec and redeploying. After deployment, traffic flows from client apps through API Gateway to the backend service and back, while the gateway handles concurrency, authorization, monitoring, and logging.
Public-facing APIs turn internal services and data into digital products that outside developers can use. External developers build mobile, web, and partner integrations on pricing, ordering, tracking, or legacy database functions exposed as secure HTTP endpoints that return XML or JSON. Direct monetization charges for use through Apigee rate plans, which define currency, setup fees, recurring fees, and consumption fees. Usage is tracked by developer API key for billing.
| Billing account | When developers pay | How charges work |
|---|---|---|
| Postpaid | After using API products | Billed after usage with no upfront payment |
| Prepaid | Before using API products | Upfront payment goes to a wallet and fees are deducted |
Indirect monetization earns value through brand expansion and partner growth rather than per-call fees. The Apigee developer ecosystem supports onboarding, a portal with documentation and samples, and interactive SmartDocs where users can send a live request and view a live response. Publishing moves in order: create API products that bundle proxies with limits, register developers, register apps and issue API keys, and provide documentation. A request is granted only if the key is valid, and deleting a developer invalidates all associated keys.
Apigee API Management is Google Cloud's native platform for building, managing, and securing APIs. An API proxy maps one public HTTP endpoint to a backend service on Cloud Run functions, Cloud Run, App Engine, app servers, or legacy systems. Traffic flows from the client app to the managed endpoint and then to the backend, with responses returning along the same path. Policies on the proxy add security, rate limiting, quotas, caching, and fault handling without changing the backend. An API product bundles proxies with a service plan and is the central mechanism for authorization and access control (opens in a new tab).
Layered protection adds network controls in front of API checks. Requests flow from client to external Application Load Balancer to Cloud Armor for web application firewall and distributed denial-of-service protection to reCAPTCHA to Apigee policy execution to backend forwarding. Apigee forwards valid requests over internal IPs to GKE, through Cloud Interconnect to private data centers, or through NAT to third parties. Visibility comes from Apigee API Analytics (opens in a new tab), which collects URL, IP address, user ID, latency, and error data asynchronously so measurement has no effect on performance.
Exam tip: Reusing an API does not require knowing how the backend service is built — integration only requires the defined URL, request and response formats, and authentication method.
Continue with this study guide: The value of APIs
Hybrid and multi-cloud strategies describe where workloads run. A hybrid architecture combines on-premises infrastructure with public cloud, while a multi-cloud architecture uses services from more than one cloud service provider (CSP). Organizations choose these models for flexibility, compliance, and resilience, at the cost of added complexity.
Strategic motivations include reducing vendor lock-in, choosing best-of-breed services, improving resilience, meeting compliance, and optimizing costs. Avoiding lock-in means not depending on one provider for every workload, but feasibility depends on dependencies, rebuilding cost, skills, and consistent security. Meeting data sovereignty means storing and processing sensitive data such as personally identifiable information (PII) in a required country, often by using another CSP that has a local region where the current CSP does not.
Resilience uses a second environment as standby so work continues if the primary fails. In a hybrid design, an on-premises app backs up to Google Cloud and activates a replica there if on-premises fails. In a multicloud design, Google Cloud can be primary and another cloud can hold a passive replica. Backup frequency and active versus passive replicas depend on recovery time and recovery point objectives. Best-of-breed use often sends data from on-premises or other clouds into Google Cloud for low-cost archive, AI and machine learning, and BigQuery analytics, which improves reliability (opens in a new tab) through geographic distribution.
Exam tip: Hybrid connects Google Cloud with on-premises, while multicloud connects Google Cloud with other cloud providers.
GKE Enterprise is a single control panel for hybrid and multicloud infrastructure that enables consistent deployment and portable applications. Google Kubernetes Engine (GKE) provides the uniform runtime: apps are packaged into containers, deployed as Pods to nodes, and managed through the Kubernetes API. Kubernetes hides differences between edge and cloud so teams develop and operate the same way. A fleet is a logical grouping of clusters that share security, configuration, and service management across Google Cloud, on-premises, edge, and other clouds.
Consistent security means the same controls apply everywhere, including Policy Controller, Config Sync from a source of truth, Binary Authorization for images, VPC Service Controls perimeters, and encryption in transit with VPN or TLS. Service communication uses zero trust with end-to-end mutual TLS, and the mirrored network pattern prevents direct communication unless explicitly required. Centralized logging gives one view of metrics, and Cloud Deploy with Cloud Build and Artifact Registry delivers consistently to GKE, Cloud Run, or both.
Compliance and data residency constrain where data may live and how sensitive systems connect. Hybrid designs keep highly secure data on-premises and expose only needed capabilities, often modernizing legacy services with API interfaces managed by Apigee. Tiered topologies place the frontend in Google Cloud with the backend on-premises, while cloud bursting sends overflow traffic to Google Cloud at peak and shrinks it when demand falls. Development can stay on-premises while CI/CD pushes updates to Google Cloud production.
GKE and Cloud Run differ in control and billing:
| Feature | GKE | Cloud Run |
|---|---|---|
| Deployment | Manage clusters, nodes, networking, scaling | Run containers without managing clusters |
| Control | Full control and customization | Limited control over environment and concurrency |
| Application types | Stateless and stateful, complex apps | Stateless, request-driven web services |
| Pricing | Pay per cluster per hour | Pay per use to nearest 100 milliseconds |
Autopilot mode means Google manages control plane and worker nodes and charges only for Pod requests, while Standard mode means the team manages nodes and pays for full node capacity. Using two providers in the same region can meet residency and improve availability, but only when both offer the needed services with regional service endpoints (opens in a new tab) in that region.
Continue with this study guide: Hybrid and multi-cloud
Rehost moves a workload as-is with minimal change such as Windows and SQL Server to Compute Engine virtual machines, Replatform keeps the core app but replaces selected parts such as self-hosted MySQL to Cloud SQL, Refactor modifies the workload to improve performance, cost, features, or user experience, Rearchitect changes how code functions such as breaking a monolith into microservices, Rebuild decommissions the old app and rewrites it as fully cloud-optimized, and Repurchase moves to software-as-a-service such as Google Workspace. Lift-and-shift is fastest because code and architecture stay the same, while re-architecting takes more time and testing and needs new skills but unlocks independent scaling and faster releases.
Choose Compute Engine when you need virtual machine or bare metal control with full control over the operating system, choose Google Kubernetes Engine (GKE) when you need Kubernetes orchestration for distributed microservices and APIs, and choose Cloud Run when you want Google to manage all infrastructure so you can focus on code. Cloud Run scales to zero by default when a revision receives no traffic, while Google Kubernetes Engine (GKE) provides cluster orchestration with Autopilot mode where Google manages nodes and Standard mode where you manage node pools.
A hybrid architecture combines on-premises infrastructure with public cloud, while a multi-cloud architecture uses services from more than one cloud service provider (CSP). In a hybrid design an on-premises app can back up to Google Cloud and activate a replica there if on-premises fails, while in a multicloud design Google Cloud can be primary and another cloud can hold a passive replica.
Last updated