Prepare and test your skills
Prepare and test your skills
Modernization of application lifecycle and architecture is the shift from large, slow-changing systems to smaller services that can be built, deployed, and scaled independently. Code flows from developers to independent microservices, then to automated deployment pipelines, then to monitored production systems. On Google Cloud, this evolution uses Skaffold modules for independent development, Cloud Code (opens in a new tab) for rapid Kubernetes development, and Cloud Monitoring (opens in a new tab) with Active Assist to sustain performance as business needs grow.
Breaking legacy systems into microservices modules means splitting one large application into named groups of services that can be developed and debugged separately. Skaffold modules are defined inside a skaffold.yaml file, where each module declares its own build artifacts, Kubernetes manifests, and deploy settings. The Bank of Anthos sample shows this pattern, with ten microservices grouped into five Skaffold modules that can be changed without rebuilding the whole system.
The five Bank of Anthos modules separate the application by ownership and lifecycle:
This separation means a change to the frontend does not require rebuilding the databases, so each area can evolve at its own pace and deployment velocity increases while old-code maintenance costs fall.
Configuration dependencies in Skaffold control the order in which modules deploy. A module becomes a named configuration by setting metadata.name in its skaffold.yaml entry, such as db or setup. A dependent module lists that name under requires with a configs list, and data and startup flow from the dependency to the dependent, so the db module deploys only after the setup module is deployed.
Defining modules and dependencies follows an ordered workflow:
skaffold.yaml file live.metadata.name such as db to each Skaffold configuration.requires with - configs: DEPENDENCY_NAME when one configuration must deploy first.kubectl.Exam tip: A Skaffold configuration listed under requires must be deployed before the current configuration can be deployed.
Continuous development with Cloud Code is a rapid edit, build, and deploy loop that runs Kubernetes resources directly from the development environment. A developer makes a code change, such as adding a /greeting endpoint to the FrontendController class in src/main/java/cloudcode/guestbook/frontend, saves the project with Ctrl/Cmd+S or builds it, and watches progress and deployment logs in the console window. After the change is deployed, the developer confirms the update in the running application and repeats the loop for the next change.
The development session has a clear lifecycle. The session starts when code flows from the IDE to the build system and then to Kubernetes deployment targets, and it stays active through repeated edits. The session ends when the developer clicks the Stop icon, at which point Cloud Code deletes all Kubernetes resources used for the development session. Teams can also select specific Skaffold modules and their dependencies in the Build / Deploy tab under Run > Edit configurations, so only the needed services and their dependencies are rebuilt during fast iteration.
Sustaining performance as needs evolve means combining load testing, trend analysis, and resource recommendations to keep the application aligned with growth. Load testing finds potential breakpoints and shows how the application can scale under higher traffic, which helps architects plan capacity before growth causes failures. Cloud Monitoring then tracks the running application over time to validate changes and catch regressions.
Cloud Monitoring supports continuous improvement in four related ways:
Active Assist complements monitoring by providing insights and recommendations that help optimize resource utilization. Recommendations from Active Assist flow back to the operations team, which adjusts resource allocation to improve performance and control cost as demand shifts.
Transformation of data strategy and operational intelligence is the progression from keeping data only for archiving to using data continuously for real-time analytics and machine learning. Early stages focus on durable, low-cost storage for backups and compliance, while mature stages add processing pipelines, data warehouses, and models that guide proactive decisions. This evolution moves a business from looking backward at historic reports to acting in the moment to improve operations and customer experiences.
An evolving storage strategy matches each dataset to its access frequency and required retention period. Cloud Storage (opens in a new tab) is the central object store that holds everything from frequently read analytics data to regulatory archives, with buckets accessible from inside and outside Google Cloud. Architects first define workload characteristics, security constraints, resilience needs, and performance goals, then select a storage class and transfer method, and they reassess those choices as the business expands to new regions or adds new use cases.
Cloud Storage classes trade access cost and performance against minimum retention time:
| Storage class | Access pattern | Minimum retention and typical use |
|---|---|---|
| Standard with Autoclass | Varying or unpredictable access | No fixed minimum; Autoclass moves each object automatically to the right class |
| Standard | Frequent access | No fixed minimum; high-throughput analytics, data lakes, websites, streaming video, and mobile apps |
| Nearline | Infrequent access | At least 30 days; backups and long-tail multimedia content |
| Coldline | Rare access | At least 90 days; disaster recovery copies |
| Archive | Very rare access | At least 365 days; regulatory archives |
Frequently accessed analytics data can be served faster by placing Cloud CDN in front of a bucket to cache content near clients, or by using Rapid Cache for read-heavy workloads with infrequent changes such as machine learning (ML) training, inference, and analytics. Data reaches Google Cloud through Storage Transfer Service for large online transfers between object and file systems, Transfer Appliance for large offline transfers when bandwidth is limited or expensive, and direct upload with the console, gcloud CLI, APIs, or client libraries. Choosing among them depends on data size, time limits, bandwidth, cost, and compliance requirements.
A modern analytics platform combines four related components that move data from raw events to business-ready insight. A data lake is a scalable and secure platform for ingesting and storing data from multiple systems, with Cloud Storage commonly used as the central repository. A processing pipeline is an end-to-end process that takes data or events from one or more systems, transforms the data, and loads it into another system, usually a data warehouse. A data warehouse is an enterprise system for analysis and reporting of data that usually comes from an operational database, with BigQuery commonly used as the warehouse on Google Cloud.
The components connect in a clear flow where data flows from source systems to the data lake and then through the pipeline to the data warehouse:
Because the warehouse depends on the pipeline and the pipeline depends on the lake, reliability and locality choices must cover all three layers together. Governance, encryption with customer-managed keys, and consistent tooling across environments help the platform grow without rebuilding each new use case from scratch.
Batch analytics is periodic processing of collected files to produce business metrics and historic insight. In a retail example, stores send point-of-sale (POS) files to a Cloud Storage bucket, and the files wait there until the scheduled job runs. This pattern fits reporting, sales summaries, and exploratory analysis where a delay of minutes or hours is acceptable.
Data flows through the batch pipeline in order:
Columnar formats also allow interoperability with open-source engines such as Hive and Presto that may run on premises. Because batch jobs can be recreated and restarted after an outage, disaster recovery focuses first on protecting the ingested files, the processed lake data, and the metastore metadata.
Streaming analytics processes events continuously so the business can react while events are still happening. Change data capture (CDC) tracks inserts and updates from source systems over time, and the pipeline applies those changes to the warehouse in near real time. This low-delay design supports operational intelligence such as live dashboards, immediate alerts, and transaction scoring.
In the streaming pattern, data flows from producers to Pub/Sub, then through Dataflow, then into BigQuery for analysis. Pub/Sub queues receive events from transactional systems and hold them as a durable handover point between environments. Dataflow runs Apache Beam pipelines for both batch and streaming patterns, reading from sources, applying transforms, and writing to sinks. BigQuery then stores historic and newly appended data for analytics and decision-making, with datasets created in a regional location such as us-central1 or a multi-region location such as US or EU.
A four-step process flow showing continuous events moving from transactional producers to Pub/Sub, then through Dataflow to BigQuery for live dashboards, alerts, and scoring.
Locality and availability shape where each step can run. A Dataflow job can be restricted with a regional endpoint, worker region, and worker zone so workers and job metadata stay in an approved location, or workers can run in other Google Cloud regions when rules allow processing elsewhere. When encryption can mitigate data-at-rest rules, customer-managed encryption keys allow use of broader regions for Dataflow state, sources, and sinks and for BigQuery datasets. For append-only warehouses partitioned by date, recovery can restore only recent partitions, but the export must include any partitions that can still change, such as the last 7 days of an orders table when returns are allowed within 7 days.
Exam tip: Extract, transform, and load (ETL) transforms data before loading it into the warehouse, while extract, load, and transform (ELT) loads data first and then transforms it inside BigQuery.
Machine learning integration turns curated analytics data into predictions that drive action. Data scientists follow common Machine Learning Operations (MLOps) principles to build and serve models that consume data products made available by data product teams. Once deployed, models provide real-time inference for transactional use cases such as fraud detection, where each transaction flows to the model and returns a risk score before the transaction completes.
The same platform also supports exploratory data analysis that enriches source data for better targeting and service. Analysis of sales and marketing campaign data can reveal demographic customer segments where sales are expected to be highest, so future campaigns run where they are most likely to succeed. Hybrid designs extend this reach by using Pub/Sub queues or Cloud Storage buckets as handover points from on-premises systems, Dataflow or Cloud Data Fusion for pipelines, Sensitive Data Protection for masking personally identifiable information, and BigQuery Omni to query data stored in Amazon S3 or Azure Blob Storage without first moving every dataset.
Adaptation to global scale and elasticity (opens in a new tab) is the shift from fixed-capacity on-premises hardware to cloud-native design that adds or removes resources as demand changes and distributes work across the globe. A well-designed app scales up and down as demand increases and decreases, and it remains available during zone failures, region disruptions, and seasonal traffic spikes. This approach lets a business expand to new markets and handle fluctuating user demand while consuming only the resources necessary to meet demand.
Elastic design replaces fixed servers with resources that adjust dynamically based on workload requirements. Elasticity allows different components of a system to scale independently, so capacity can be added precisely where it is needed without over-provisioning the whole system or under-provisioning a busy tier. With proper design, removing under-utilized resources reduces costs without compromising performance, while adding resources during high traffic maintains user experience.
Scalability is the measure of a system's ability to handle varying amounts of work by adding or removing resources. A scalable web app works well with one user or many users and gracefully handles peaks and dips in traffic. Three themes support this behavior across the app lifecycle: automation of provisioning and deployment, loose coupling of independent components, and data-driven design where metrics and logs guide scaling and health decisions.
Designing for global scale and high availability means distributing compute, traffic management, and data replication across Google Cloud regions and zones to maximize availability. Availability is the fraction of time a service is usable, and highly available architectures increase it by redundantly deploying components across multiple zones or multiple regions. How an app is placed across regions and zones affects its availability, latency, and ability to withstand a zone or region disruption.
Google Cloud provides several capabilities that connect global placement to high availability:
Because traffic flows from the global load balancer to healthy capacity, the failure of components in one zone or region does not have to stop the app when redundant capacity exists elsewhere.
Elastic capacity changes in two directions, and performance requirements determine when and how a system uses each one. The team first evaluates baseline capacity and expected load, then defines the circumstances in which the system scales up when load increases and scales down when load decreases. Scaling down can be horizontal, vertical, or both, so costs fall when demand falls.
| Scaling type | How capacity changes | What happens to components |
|---|---|---|
| Horizontal scaling | Adds replica nodes to increase overall capacity | More instances share the increased demand, then are removed when no longer needed |
| Vertical scaling | Replaces existing components with larger components | The same component gains more capacity, memory, and storage |
Choose horizontal scaling when demand should be spread across more replicas, and choose vertical scaling when an individual component needs more power. For known periods of high traffic, plan to scale manually ahead of time; for load changes, use autoscaling that responds to increases or decreases in demand.
Responding to fluctuating and peak demand combines advance preparation for known peaks with automatic reaction to unexpected surges. For a known event such as seasonal retail sales, manually scaling up or scaling out before the event ensures the system can immediately handle the load, because reactive scaling can take several minutes to add resources and users could experience delays. For unknown surges, autoscaling triggers elastic scaling based on metrics such as CPU utilization, load balancer serving capacity, latency, and custom metrics defined in Cloud Monitoring.
Data flows from apps and infrastructure to Cloud Monitoring, and the autoscaler depends on those metrics to decide when to add or remove capacity. For example, an application on a Compute Engine managed instance group (MIG) may perform best until average CPU utilization reaches 75%. An autoscaling policy creates more instances when utilization reaches that threshold, which absorbs load and keeps average utilization near the target until the configured maximum number of instances is reached, then removes instances when demand decreases. Resource planning also extends to data services, such as planning slot reservations in BigQuery or adjusting autoscaling limits in Spanner with the managed autoscaler.
Predictive autoscaling for Compute Engine improves reaction time by combining real-time data with historical trends. The autoscaler forecasts future load, such as CPU utilization, and recomputes the forecast every few minutes so it adapts rapidly to very recent changes. Without predictive autoscaling, an autoscaler can only scale reactively based on observed real-time changes. Inherently elastic serverless services reduce this operational work further:
These serverless compute, database, and messaging services scale quickly from zero to high request volumes, and the customer pays only for what is used, while database products like BigQuery, Spanner, and Bigtable deliver consistent performance across massive data sizes.
Exam tip: Scale manually ahead of a known peak because reactive autoscaling can take several minutes; use metric-based autoscaling for unexpected surges.
Planning for critical periods means identifying when an application is most business-critical, planning adequate capacity, and testing against peak-load conditions. Critical periods are often peak-load periods, and freezing production code during those windows reduces outage risk. Common seasonal patterns include:
Business needs also evolve, so reliability and scaling requirements must be reassessed periodically as the organization grows and priorities change. An app deployed in two zones behind a regional load balancer may later need multi-region distribution as users expand globally. Tradeoffs constrain those choices: cost-optimization quotas can limit compute cores, stored data, or cross-region network traffic, and data-residency rules can require data to be stored and processed in specific countries even when users are global, which directly affects which regions and zones can host the app.
requires must be deployed before the dependent module can deploy.Horizontal scaling adds replica nodes to increase overall capacity so more instances share the increased demand and are removed when no longer needed, while vertical scaling replaces existing components with larger components with more capacity, memory, and storage. Choose horizontal scaling when demand should be spread across more replicas and vertical scaling when an individual component needs more power.
Cloud Storage Nearline requires at least 30 days for infrequent access such as backups, Coldline requires at least 90 days for rare access such as disaster recovery copies, and Archive requires at least 365 days for very rare access such as regulatory archives. Standard has no fixed minimum for frequent access and Standard with Autoclass moves each object automatically to the right class.
Data flows from producers to Pub/Sub, then through Dataflow, then into BigQuery for analysis. Pub/Sub queues receive events from transactional systems as a durable handover point, Dataflow runs Apache Beam pipelines that read from sources, apply transforms, and write to sinks, and BigQuery stores historic and newly appended data for analytics and decision-making.
Clicking Stop ends the Cloud Code development session and deletes all Kubernetes resources used for the development session. The session stays active through repeated edits after code flows from the IDE to the build system and then to Kubernetes deployment targets.
An online retail enterprise currently hosts a monolithic backend application on a fleet of Compute Engine virtual machines. As business demand increases, the engineering team encounters several challenges:
You need to modernize the architecture to support independent CI/CD release cycles, eliminate infrastructure management overhead, and achieve rapid elasticity with zero idle cost.
Which modernization strategy should you recommend?
Last updated