Prepare and test your skills

Prepare and test your skills

Evaluate Scalability and Resource Efficiency is about growing capacity on demand while using fewer compute and memory resources. Modern cloud development improves both by packaging apps in containers (opens in a new tab), splitting them into microservices, and running them with automated orchestration on Google Kubernetes Engine (GKE) (opens in a new tab).
Containers are lightweight, standalone, executable packages that include application code, runtime, system tools, system libraries, and settings. Unlike virtual machines (VMs), containers do not include an operating system, so they need considerably fewer compute and memory resources. This allows a cluster to run more workloads at higher density, supports fine-grained resource allocation, lowers infrastructure costs, and starts quickly for scalable and resilient apps.
Migrate to Containers containerizes existing VM-based apps so they can run on GKE, GKE Autopilot, GKE Enterprise, or Cloud Run without access to source code, rewriting, or rearchitecting. The tool extracts an image from the VM workload and builds a Docker image and related artifacts. That image-based management enables rolling updates, dynamic scaling, self-healing, and integration with a continuous integration/continuous deployment (CI/CD) pipeline using tools such as Cloud Build. In contrast, lift-and-shift migration to Compute Engine preserves the same operational model used on-premises and modernizes only the underlying infrastructure.
A microservices architecture breaks an application into loosely coupled, independent services that can be released, deployed, managed, and scaled separately. This independence is the core scalability advantage: if one component has a different availability requirement or scaling profile, it can become a standalone service and receive resources only when it needs them. Teams can also use different technology stacks for different services.
Independent scaling improves operational efficiency because a traffic spike in one part of the app does not force the whole app to scale as one unit. Modular design can also improve resiliency by removing single points of failure. However, distributed microservices create service interdependencies, and failure of one service can cause cascading failure in others. Techniques such as the circuit breaker pattern, exponential backoffs, and graceful degradation reduce traffic to an overloaded or failing service and limit the spread of failure.
A stateless application or service does not keep local persistent data or state, so each request is handled independently of previous requests. Statelessness helps scalability and recoverability because the service can grow, shrink, or restart without losing data needed for in-flight requests. This matters when an autoscaler is used, because the instances, nodes, or Pods hosting the service can be created and destroyed unexpectedly. Not every service can be stateless, so stateless and stateful services should be separated clearly.
Automated container orchestration makes this scaling practical. GKE provides a managed Kubernetes environment to host and orchestrate containerized apps. Kubernetes detects when a container Pod is down and recreates it, autoscales Pods, performs automated rollouts and rollbacks, and runs health checks. GKE adds cluster autoscaling, regional clusters, highly available control planes, automatic operating system upgrades, declarative desired-state management, and hybrid and multi-cloud support with GKE Enterprise. Packing multiple Pods onto the same VMs can use VMs more fully, potentially reducing the number of VMs and Windows licensing costs.
Exam tip: Stateless services scale and recover more easily because an autoscaler can create and destroy their instances, nodes, or pods without losing local state.
Google Cloud platforms for running containers differ in control, orchestration, and serverless management. The choice depends on how much Kubernetes flexibility the team needs versus fully managed autoscaling. The table compares the main options.
| Platform | Management model | Scaling and billing behavior | Choose when |
|---|---|---|---|
| Cloud Run (opens in a new tab) | Serverless, managed compute platform for stateless containers | Autoscaled by default and billed for duration of request; deployment in seconds; supports revisions and traffic splitting | You want serverless stateless containers, event-driven microservices, or autoscaled web frontends |
| GKE | Managed Kubernetes environment | Orchestrates containerized apps with Pod autoscaling, cluster autoscaling, self-healing, and automated rollouts or rollbacks | You need Kubernetes orchestration and operational flexibility |
| App Engine Flexible | Managed platform as a service (PaaS) | Hosts containers in a managed platform | You want managed PaaS container hosting |
| Compute Engine | Infrastructure as a service (IaaS) VMs | Runs containers on VMs | You need complete control over the container environment |
Cloud Run integrates with Pub/Sub, Cloud Scheduler, Cloud Tasks, and backends such as Cloud SQL, so traffic flows from events or web requests to autoscaled containers and then to managed backends. GKE and GKE Enterprise can add Cloud Service Mesh or Istio on GKE to automate network and security policies without changing application code, and Cloud Logging and Cloud Monitoring can be added through configuration.
Managed services improve operational efficiency by shifting platform management from the application team to Google Cloud. Instead of self-hosting infrastructure, teams use managed replacements that can offer multiregional availability, stronger service level agreements (SLAs), and better security. These services may need extra integration code, but they reduce management work:
For operations, Cloud Logging stores application and system logs, Cloud Monitoring provides performance monitoring and dashboards, and Cloud Trace supports application performance management. Cloud Build can automate the build-test-deploy cycle and work with Container Registry's Vulnerability Scanner and Binary Authorization to prevent images built from unknown source code or insecure repositories from running.
Testing scalability and resilience validates that efficiency holds under real load and failure. Performance or load tests should verify that key metrics stay within expected levels for varying loads, such as average request latency for spiky user requests or average task-processing time when task volume suddenly increases. Tests should also verify that the number of resources created stays in range, such as the number of VMs created for backend tasks. Edge cases include reaching maximum scaling limits and handling a sudden load increase while scaling down.
Resilience testing introduces failure in a structured, escalating order to confirm the app responds as expected and generates correct alerts and metrics:
If a service mesh such as Istio is used, faults can be injected at the application layer instead of killing Pods or machines, corrupting packets can be injected at the TCP layer, delays can simulate latency or an overloaded upstream system, and aborts can mimic upstream failures.
Analyze Agility and Speed of Innovation is about turning a new idea into a working production feature faster. Containerization accelerates this cycle because containers (opens in a new tab) package an app and its dependencies into a portable image that runs the same way in development, testing, and production. Combined with CI/CD, that portability automates building, testing, and deploying, so features release faster with shorter time-to-market.
Continuous integration (CI) is the automated work applied before deployment, including building, packaging, and testing an application. Continuous delivery (CD) operates on the artifact produced by CI and uses highly automated deployment processes applied with high frequency. Together, CI/CD creates a repeatable pipeline where every code change flows from source control through automated checks to a deployable container image.
Cloud Build (opens in a new tab) handles the CI part by watching the source repository with a trigger. When a change is committed to the main branch, Cloud Build rebuilds the application container, stores build artifacts, runs tests, and calls the delivery system. Cloud Deploy (opens in a new tab) handles the CD part by managing delivery to a series of target environments in a defined promotion sequence. This separation lets development move fast while releases stay controlled and traceable.
Containers running on Google Kubernetes Engine (GKE) (opens in a new tab) accelerate releases because GKE provides consistent infrastructure and orchestration for deploying and operating container-based apps. Kubernetes and containers alone do not guarantee speed, so a modern approach also streamlines onboarding, CI/CD practices, and operations. With uniform methods and built-in best practices, organizations gain speed in three related ways:
Image-based management further speeds operations because the same container image moves through the pipeline and supports rolling updates, dynamic scaling, and self-healing. Because containers are lighter than VMs and share the node kernel, teams also get greater workload density and fine-grained resource allocation.
The Google Cloud pipeline for containerized apps connects development, CI, and CD into one flow that reuses the same configuration across environments. Cloud Code provides the development workspace, running with a local minikube cluster in Cloud Shell so developers validate changes early. Shared configuration is carried across development, staging, and production through Skaffold, an open-source tool for Kubernetes-native development, which increases parity and helps catch issues before production.
A five-step left-to-right flow from Cloud Code development through Cloud Build, Cloud Deploy staging, manual approval, and production GKE, showing the same tested image promoted without rebuilding.
Code flows from source to production in an ordered sequence:
Exam tip: Build the container image once in CI and promote that same tested image through staging to production; do not rebuild the image for each environment, because rebuilding can introduce untested differences.
Examine Portability and Environmental Consistency is about moving an app between computing environments without major changes and behaving predictably across development, testing, production, hybrid, and multicloud. Migrate to Containers (opens in a new tab) supports this by containerizing existing VM-based apps to run on Google Kubernetes Engine (GKE) (opens in a new tab), GKE Autopilot clusters, GKE Enterprise, or Cloud Run without source code access, rewriting, or rearchitecting.
Containers are lightweight packages that contain an application and all its dependencies. Because containers do not contain an operating system, they are much lighter than VMs and need fewer compute and memory resources. This gives greater workload density, fine-grained resource allocation, and lower infrastructure costs. Running multiple containers on the same host also makes apps more consistent, predictable, and efficient than running them directly on a VM.
Migrate to Containers extracts an image from a VM workload and constructs a Docker image and related artifacts. This image-based management modernizes lifecycle and operations, including CI/CD integration with Cloud Build, plus rolling updates, dynamic scaling, and self-healing. GKE and GKE Enterprise add automatic operating system upgrades, which reduces node maintenance. Containerizing on GKE reinforces consistency and portability in several ways:
Portability means moving an application from one computing environment to another without significantly modifying the application and its operational model. For portability to work, deployment and management must be consistent across environments, and visibility, configuration, and security must also be consistent. The ability to make a workload portable should not conflict with the workload being cloud-first.
Containers and Kubernetes provide an abstraction layer that hides differences between environments. GKE can run modern apps anywhere at scale and includes managed open source components to secure workloads, enforce compliance policies, and provide network observability and troubleshooting. GKE Multi-Cloud provides consistent governance, operations, and security posture across clouds. GKE also lets teams operate multi-cluster apps as fleets. For hybrid designs, GKE helps create cloud-like experiences on-premises and unified paths to a GKE hybrid environment. In a zero trust distributed architecture, services on-premises or in another cloud communicate across environments through end-to-end mutual TLS (mTLS) secure service-to-service communications.
Infrastructure automation is essential for portability in hybrid and multicloud architectures. One common approach is infrastructure as code (IaC), which manages infrastructure in files instead of manually configuring a VM, security group, or load balancer in a user interface. Terraform (opens in a new tab) is a popular IaC tool that defines infrastructure resources in a file and automates their creation in heterogeneous environments.
Configuration management tools such as Ansible, Puppet, or Chef can establish a common deployment and configuration process. An image-baking tool like Packer can create VM images for different platforms; using a single shared configuration file, Packer and Cloud Build can create a VM image for Compute Engine. Prometheus and Grafana help ensure consistent monitoring across environments. A common toolchain abstracts differences between environments and unifies provisioning, deployment, management, and monitoring. Cloud Build modernizes the build-test-deploy cycle and integrates with Container Registry's Vulnerability Scanner and Binary Authorization to block images from unknown or insecure sources. Google Cloud Observability provides Cloud Logging for logs, Cloud Monitoring for performance, and Cloud Trace for performance management.
The choice between lift-and-shift and containerization determines how much the operational model changes. The table compares the two paths.
| Approach | What it does | Operational model | Choose when |
|---|---|---|---|
| Migrate to VMs (lift-and-shift) | Migrates VM workloads into VM instances in Compute Engine | Preserves the same operational model used on-premises; modernizes only underlying infrastructure | The simplest migration path is needed and minimal change is preferred |
| Migrate to Containers | Containerizes VM-based apps to run on GKE, GKE Autopilot, GKE Enterprise, or Cloud Run | Modernizes orchestration and management without source access, rewriting, or rearchitecting | The goal is to use cloud-specific tools, methods, and managed services |
After containerizing, teams choose a runtime based on control, flexibility, and management overhead.
| Runtime option | What it is | Scaling and management | Choose when |
|---|---|---|---|
| GKE | Managed Kubernetes to run modern apps anywhere at scale, with components to secure workloads, enforce policies, and troubleshoot networks | Supports multi-cluster fleets; GKE Multi-Cloud gives consistent governance and security | Kubernetes flexibility and hybrid or multicloud control are needed |
| Cloud Run | Serverless option for containers; follows the Knative API but runs on Google infrastructure without Kubernetes clusters | Containers are autoscaled and billed for request duration; deployment in seconds; supports revisions and traffic splitting | Serverless containers are wanted without managing clusters |
| Knative serving | More flexible version of Cloud Run with Knative simplicity plus Kubernetes flexibility | Cloud Run on GKE Enterprise can add GPUs to underlying instances or scale to many containers | Kubernetes flexibility is needed with a simpler Knative API |
Portability with minimal changes does not guarantee equal performance in every environment. Differences in underlying compute, infrastructure security capabilities, networking infrastructure, and proximity to dependent services can lead to substantially different performance. Moving a workload may also require moving data, because environments can have different storage and management services. Load balancer behavior provisioned with Kubernetes or GKE may also differ between environments.
Data movement at scale can be complex, and data classification for regulated industries can identify storage locations and cross-region movement restrictions. Hybrid and multicloud architectures can increase the attack surface depending on how systems and data are distributed, raising risk of unauthorized access and data loss. Extending on-premises security approaches to the cloud is not always technically feasible. For Windows containers, not all of the Windows stack is supported, and the target operating system must be chosen based on the .NET Framework version.
Exam tip: Lift-and-shift with Migrate to VMs preserves the on-premises operational model and modernizes only infrastructure; Migrate to Containers converts VM workloads to containers for GKE or Cloud Run, enabling modern orchestration without source code changes.
Migrate to Containers converts virtual machine (VM) workloads to containers for Google Kubernetes Engine (GKE) or Cloud Run without source code changes, rewriting, or rearchitecting, enabling modern orchestration such as rolling updates, dynamic scaling, and self-healing. Lift-and-shift with Migrate to VMs migrates VM workloads into VM instances in Compute Engine, preserving the same operational model used on-premises and modernizing only the underlying infrastructure.
Stateless services do not keep local persistent data or state, so each request is handled independently of previous requests. This lets an autoscaler create and destroy instances, nodes, or Pods hosting the service without losing data needed for in-flight requests, so the service can grow, shrink, or restart more easily.
Use Cloud Run when you want serverless stateless containers, event-driven microservices, or autoscaled web frontends because it is autoscaled by default and billed for duration of request with deployment in seconds and support for revisions and traffic splitting. Use Google Kubernetes Engine (GKE) when you need Kubernetes orchestration and operational flexibility with Pod autoscaling, cluster autoscaling, self-healing, and automated rollouts or rollbacks.
A microservices architecture breaks an application into loosely coupled, independent services that can be released, deployed, managed, and scaled separately. Because of that independence, a traffic spike in one part of the app does not force the whole app to scale as one unit, so resources go only to the service that needs them.
An organization wants to modernize its software development lifecycle to accelerate feature releases and reduce the time-to-market for new business capabilities. The engineering team needs a strategy that ensures applications run consistently across development, staging, and production while automating the build, testing, and deployment stages.
How does adopting containerization alongside continuous integration and continuous delivery (CI/CD) pipelines achieve these business goals?
By packaging application code and dependencies into consistent images that automated pipelines build, test, and deploy seamlessly across target environments
By bypassing automated testing stages in deployment pipelines to allow developers to publish unverified code directly to production
By requiring developers to manually recompile binaries and reconfigure runtime dependencies individually on every destination server
By converting microservices into static monolithic virtual machine images that require manual configuration updates at each deployment stage
Last updated