Prepare and test your skills

Prepare and test your skills

Infrastructure modernization benefits are the scalability, reliability, and cost gains from moving from owned on-premises servers to managed compute, storage, and networking on Google Cloud. On-premises teams pay for hardware, power, cooling, and maintenance whether capacity is used or not, while Google Cloud uses a consumption-based model where teams pay for what they use and scale up or down with demand. This shift moves work like patching, backup, and hardware repair to Google and lets teams focus on applications.
Infrastructure modernization moves an application stack from self-managed servers to Google Cloud managed services. A typical legacy .NET application is a monolith built on .NET Framework, hosted on Windows Server, and connected to SQL Server, which brings Windows licensing costs, limited deployment choices, hard upgrades, and fixed capacity that is difficult to budget and scale. A modernized architecture reduces management overhead with managed services, runs .NET and containers without Windows dependencies, uses microservices for faster upgrades, and uses serverless computing for agile scaling and budgeting.
Responsibility also shifts between the customer and the provider:
| Resource | On-premises environment | Google Cloud public cloud |
|---|---|---|
| Physical security and safety | You | Service provider |
| Power and network cabling | You | Service provider |
| Hardware, including maintenance | You | Service provider |
| Virtualization platform | You | Service provider |
| App resources | You | You, eventually leveraging fully managed services |
The modernization path is a gradual journey with three phases, and each phase removes limits that make the next phase possible. Before modernizing, teams assess applications and dependencies to decide what can move and what must stay because of legacy technology or regulatory rules. Different parts of the same system can be in different phases and still work together over a secure hybrid connection.
A three-phase process flow showing the modernization path: Rehost moves VMs as-is to Compute Engine, Replatform optimizes components like Cloud SQL and MIGs without changing architecture, and Re-architect rebuilds with GKE, Cloud Run, and managed services.
The three phases differ in what changes and what they improve:
| Phase | What changes | Main benefits |
|---|---|---|
| Rehost in the cloud (lift and shift) | Move VMs as-is to Compute Engine | Cost savings from custom machine types, starting and stopping VMs only when needed, and rightsizing recommendations; efficiency from persistent disks and snapshots; reliability from live migration without maintenance windows |
| Replatform | Add instance templates, managed instance groups (MIGs), and managed replacements while staying in VMs | Better management, resilience, scalability, and elasticity; Windows containers can run on Google Kubernetes Engine (GKE), and Migrate to Containers can extract apps from VMs without rewriting them |
| Re-architect and rebuild | Redesign around Kubernetes, Linux containers, and serverless | Lower cost from Linux and serverless, stronger availability and service level agreements (SLAs), faster delivery with Cloud Build and Cloud Deploy, and new capabilities from BigQuery, Spanner, and multiregional storage |
Exam tip: Rehost (lift and shift) moves workloads with minimal change, while replatform optimizes components without changing the application architecture; re-architect and rebuild changes the architecture to use managed or serverless services.
Managed services shift platform management from the application team to Google Cloud. Common replacements require extra integration code but remove patching, scaling, security hardening, and disaster recovery work:
Managed services also improve daily operations. Application logs flow from applications to Cloud Logging, and application metrics flow to Cloud Monitoring, where dashboards combine server and application metrics for troubleshooting and planning.
Scalability is the ability to add or remove capacity to match demand, and reliability is the ability to stay available and recover from failures. Google Cloud provides autoscaling at the VM, container, and serverless layers so capacity follows traffic instead of sitting idle.
Reliability improves because managed services offer multiregional availability, stronger SLAs, and better security than self-managed VMs. Other reliability features include live migration, persistent disks and snapshots for backup and restore, and MIG features such as regional deployments, autohealing of failed VMs, and auto-updating.
Cost efficiency on Google Cloud comes from using only needed capacity and paying the lowest sustainable rate for it. Right-sizing means watching utilization and adjusting allocation to actual demand, because over-provisioning wastes money and under-provisioning causes slow performance. Cloud Monitoring gives real-time visibility into use, Recommender suggests better allocations, and custom metrics and alerts can trigger automated resizing. Autoscaling then adds capacity when workloads rise and removes it when they fall, so teams do not pay for idle servers.
Discounts and pricing options lower the rate paid for used capacity:
| Option | Commitment | Scope and use |
|---|---|---|
| Enterprise discounts | Minimum total spend on Google Cloud | Negotiated at organization level |
| Resource-based CUDs | Minimum Compute Engine resources for 1 or 3 years | Region-specific; shared across projects for most billing accounts |
| Spend-based CUDs | Minimum spend on a product for 1 or 3 years | Billing account level; regional or global depending on product |
| Spot VMs | No commitment; uses unused VM capacity | For fault-tolerant and flexible workloads; more than 80% cheaper than regular VMs |
Product tools add more savings, including Compute Engine custom machine types and Spot VMs, GKE cluster autoscaler, Cloud Storage Object Lifecycle Management and Autoclass, and BigQuery capacity-based pricing. A total cost of ownership (TCO) model should include hardware and software plus power, cooling, maintenance, and support, plus network costs such as ingress, egress, and cross-regional or cross-zonal traffic that affect disaster recovery design.
Networking modernization connects on-premises and cloud resources securely and manages the network as software. When workloads must stay on-premises because of legacy hardware, compliance, or local regulations, a VPN or Interconnect (opens in a new tab) securely connects on-premises networks to Google Cloud resources. In Google Cloud, the physical network is virtualized with software-defined networking (SDN), and infrastructure-as-code tools such as Terraform deploy and tear down environments consistently. Network billing includes ingress, egress, and regional or zonal traffic, and egress charges apply to services such as Compute Engine, Cloud Storage, Cloud SQL, and Cloud Interconnect, so placement across zones and regions affects both cost and high-availability design.
Business and operational outcomes of modernization are faster innovation, stronger security and reliability, lower waste, and more time for strategic work instead of server maintenance. Modernization replaces an on-premises monolith with a cloud-based architecture that is more cost-effective, efficient, and resilient. The change is gradual, with each phase removing one limitation and enabling the next.
| Characteristic | Legacy application | Modern cloud-based application |
|---|---|---|
| Management | Team manages on-premises Windows and SQL Server servers | Minimal overhead by integrating with managed services |
| Portability and cost | Limited deployment options with Windows dependency and licensing costs | Full mobility with .NET and containers and no Windows licensing costs |
| Updates | Difficult to upgrade a monolithic architecture | High-velocity upgrades with independently deployable microservices |
| Scaling and budgeting | Little agility to plan, budget, and scale with fixed resources | Full agility to scale and budget with serverless architecture |
The ordered path that produces these outcomes is:
Accelerated innovation means teams release new features faster and adapt quickly to market and regulatory change. Modernized applications use independently deployable microservices, so one service can be updated, tested, and deployed without redeploying the whole monolith. Continuous integration tools such as Cloud Build (opens in a new tab) and Cloud Deploy automate builds, run unit, integration, and end-to-end tests, provision environments, and scan artifacts for vulnerabilities within minutes.
Agility also comes from automated scaling and global performance. Traffic flows from users to Cloud Load Balancing, which distributes load across regions, while autoscaling adds or removes capacity as demand changes and Cloud CDN caches content close to users. Frontend applications benefit most because they are often stateless and change frequently, so they fit serverless platforms such as Cloud Run and App Engine. For data-driven work, petabyte-scale BigQuery with Looker supports analytics, Spanner provides globally scalable databases, and Cloud Storage provides multiregional and highly available storage.
Strengthened security and reliability means replacing self-managed infrastructure with Google-managed controls and highly available platforms. Managed services provide multiregional availability, stronger service level agreements (SLAs), and better security than self-managed virtual machines (VMs). Kubernetes platforms such as Google Kubernetes Engine (GKE) (opens in a new tab) add health checks, automatic recreation of failed Pods, automated rollouts and rollbacks, cluster autoscaling, regional clusters, and highly available control planes.
Security improves because identity, secrets, and encryption move from application code to managed services. Application requests flow to Identity-Aware Proxy (IAP) for authentication instead of a custom-coded login layer, while secrets and encryption keys flow from local application files to Secret Manager and Cloud Key Management Service (Cloud KMS). Messaging moves from self-hosted MSMQ, RabbitMQ, or Kafka to Pub/Sub, and file storage moves from network attached storage (NAS) to Cloud Storage. Application logs flow to Cloud Logging and metrics flow to Cloud Monitoring, where teams build dashboards and route data to BigQuery for analysis and extended retention.
Resource optimization means using only needed capacity and paying the lowest sustainable rate for it. Automated scaling adjusts allocation without manual work, including Compute Engine autoscaling and GKE cluster autoscaler with node auto-provisioning. Packing multiple Kubernetes Pods onto the same VMs fully uses those VMs and can reduce VM count and Windows licensing costs. Moving from Windows containers to Linux containers and from VMs to serverless computing further increases cost optimization.
Google Cloud also provides product-specific tools and pricing options to remove waste:
Exam tip: Choose automated scaling and managed services for efficiency gains, and choose commitment discounts such as one-year or three-year CUDs for lower billing rates — scaling reduces what you use, discounts reduce what you pay.
Focusing on strategic work means shifting undifferentiated platform management to Google Cloud so teams spend time on products, not maintenance. Self-hosted databases and queues require dedicated work for patching, scaling, security hardening, and disaster recovery. Managed services shift that burden to Google Cloud, which provides built-in reliability and compliance capabilities that offset infrastructure costs.
This shift changes daily operations from manual upkeep to automation and continuous improvement. Infrastructure is defined with Infrastructure as Code (IaC) tools such as Terraform, so environments deploy consistently and changes can be tested and rolled back. Teams hold retrospectives after milestones, incidents, or testing cycles, foster a blameless culture of learning, and adopt new Google Cloud features for AI, analytics, and security. The result is less time managing servers and more capacity for new services, better customer experiences, and faster adaptation to change.
Application modernization approaches are the different levels of change used to move applications from on-premises virtual machines (VMs) to cloud-native designs on Google Cloud. Google Kubernetes Engine (GKE) (opens in a new tab), Cloud Run, and App Engine are managed destinations that support faster releases, portability across environments, and better performance through autoscaling and managed infrastructure. Starting with rehosting optimizes infrastructure first, and once applications run in the cloud it is easier to integrate cloud services and adopt cloud-first architectures.
The phased path that connects the approaches is:
Different parts of the same stack can use different approaches at the same time and still communicate over a hybrid network connection.
Replatforming is the approach that optimizes parts of an application, such as its database, caching layer, or storage, without changing its architecture and with minimal code changes. The goal of replatforming is better management, resilience, scalability, and elasticity while the application still runs largely in the VM environment. Traffic still flows from users to the application frontend, and the frontend still calls the backend, but backend dependencies are replaced with managed services that Google Cloud operates.
Common in-place replacements need no code changes and only minimal configuration changes:
These replacements provide minimal management, enhanced security, and built-in scalability. Compute Engine features such as instance templates, managed instance groups with autoscaling, autohealing, regional deployments, and auto-updating further increase resiliency and availability without restructuring the application.
Refactoring, also called move and improve, is the approach that untangles dependencies and restructures a large monolithic VM-based application into several independent microservices. The refactored microservices run as containers on managed container services like GKE or Cloud Run, where the platform handles scaling, rollout, and health management. This shift enables independent development, testing, and deployment of each service, which supports faster development cycles and continuous integration and continuous deployment (CI/CD).
Consider refactoring when workloads meet any of these conditions:
A practical mix-and-match example is to replatform an on-premises MySQL backend to Cloud SQL, refactor frontend VMs to containers on GKE Autopilot where Google manages nodes, scaling, and security, and replace hardware load balancing and firewall appliances with Cloud Load Balancing and Google Cloud Armor. Frontend components are often refactored first because backends do not depend on frontends, frontends are often stateless, and stateless frontends benefit most from load balancing, multiregional deployment, Cloud CDN caching, serverless execution, and autoscaling.
Containerization is the practice of packaging an application and all its dependencies into a lightweight container that runs consistently across environments. A container is much lighter than a VM because it does not include a full operating system, so multiple containers can be packed onto the same host for greater density and lower infrastructure cost. Migrate to Containers (opens in a new tab) can extract a container image from an existing VM workload and build Docker artifacts for GKE, GKE Autopilot, GKE Enterprise, or Cloud Run without requiring source code or a full rewrite.
Containerization on GKE and GKE Enterprise provides several operational benefits:
Kubernetes detects when a container Pod is down and recreates it, autoscales Pods, and performs automated rollouts, rollbacks, and health checks. Packing multiple Pods onto the same VMs helps fully use VMs and can reduce the number of VMs and Windows licensing costs.
Choosing a runtime means matching the control, application type, and pricing model of GKE and Cloud Run to the workload, with App Engine as an additional managed option for web frontends. GKE is the container-optimized Kubernetes environment for running many containers with different requirements and fine-grained control over deployment. Cloud Run is the serverless container environment that follows the Knative API but runs on Google infrastructure, so no Kubernetes cluster is created or managed. App Engine, like Cloud Run, supports frequently changing frontend applications that benefit from simplified CI/CD, load balancing, and autoscaling.
A 4-row comparison matrix of GKE versus Cloud Run across deployment, control, application types, and pricing, showing full Kubernetes control for stateful apps versus serverless pay-per-use for stateless services.
| Feature | GKE | Cloud Run |
|---|---|---|
| Deployment and management | Customer manages Kubernetes clusters, including node configuration, networking, scaling, and upgrades, while Google Cloud manages underlying infrastructure | Customer provides source code or container image and Cloud Run builds and runs it with no cluster to provision or manage |
| Control and flexibility | Full control with custom node configurations, network policies, security settings, and add-ons | Limited infrastructure control with settings for environment variables, concurrency, and network connections, optimized for simplicity and speed |
| Application types | Supports stateless and stateful applications and complex applications with specific resource needs | Best suited for stateless, request-driven or event-driven services, web services, and functions |
| Pricing model | Pay per cluster per hour, regardless of Standard or Autopilot mode, size, or topology | Pay per use, rounded up to the nearest 100 milliseconds, billed for request duration |
Cloud Run autoscales containers by default, deploys in seconds, and provides revisions and traffic splitting for safe releases. Cloud Run integrates with Pub/Sub, Cloud Scheduler, Cloud Tasks, and backends such as Cloud SQL, so the same service can serve autoscaled web frontends or internal microservices triggered by events. GKE supports both Windows and Linux containers, cluster autoscaling, auto-repairing, auto-upgrading, container isolation, and preemptible VMs, and GKE Autopilot manages cluster configuration including nodes, scaling, and security.
Exam tip: Choose Cloud Run for stateless web frontends and event-driven jobs with pay-per-use scaling, and choose GKE for stateful services and complex microservices that need persistent volumes and fine-grained control.
Rehost moves workloads as-is to Compute Engine, replatform optimizes selected components without changing the application architecture, and re-architect rebuilds the architecture around containers, microservices, and serverless services. Rehost moves Windows Server and SQL Server instances as-is to Compute Engine virtual machine (VM) instances, replatform replaces database, caching, or storage with managed services with minimal code changes, and re-architect uses Kubernetes, Linux containers, and serverless platforms for faster delivery and stronger availability.
Use Cloud Run for stateless, request-driven or event-driven services such as frequently changing web frontends because it scales automatically and bills pay-per-use rounded up to the nearest 100 milliseconds with no cluster to manage. Use Google Kubernetes Engine (GKE) for stateful and complex applications with specific resource needs because it provides full Kubernetes control over node configuration, networking, scaling, and upgrades and charges per cluster per hour.
Google Cloud replaces fixed on-premises capacity with a consumption-based model where teams pay for what they use and scale up or down with demand using Compute Engine managed instance groups (MIGs), Google Kubernetes Engine (GKE) autoscaling, and Cloud Run serverless autoscaling. Reliability improves through multiregional availability, stronger service level agreements (SLAs), live migration, persistent disks and snapshots, and autohealing, while costs are lowered with right-sizing, custom machine types, Spot VMs that are more than 80% cheaper than regular VMs, and one-year or three-year committed use discounts (CUDs).
An organization runs a legacy monolithic application on on-premises virtual machines and plans to modernize it on Google Cloud. The leadership team has established the following modernization goals:
Which application modernization approach should the organization implement?
Replatform the application by keeping the monolithic codebase on Compute Engine virtual machines and migrating the database to Cloud SQL
Package the monolithic application into custom virtual machine boot disk images and deploy them across Compute Engine instance templates
Extract the entire monolithic application into a single container using Migrate to Containers and deploy it exclusively on Cloud Run
Refactor the monolith into containerized microservices, deploying stateless web services on Cloud Run and stateful backend services on Google Kubernetes Engine (GKE)
Last updated