Prepare and test your skills
Prepare and test your skills
Software development lifecycle (SDLC) on Google Cloud is the automated path that moves code from commit to production with security checks at every stage. Cloud Build compiles and tests code, Artifact Registry stores versioned container images, and Cloud Deploy promotes the same immutable image through development, staging, and production. This chain removes manual errors and ensures only verified artifacts reach users.
Automated build and promotion is the ordered workflow that turns a source commit into a running deployment without rebuilding between environments. Traffic flows from the source repository to Cloud Build, then from Cloud Build to Artifact Registry and Cloud Storage, then from Cloud Build to Cloud Deploy for staging deployment. The enterprise sequence runs in order: first commit triggers the build, then Cloud Build creates the image and pushes it to Artifact Registry, then Cloud Build runs tests, then Cloud Build runs Container Structure Tests and vulnerability scanning, then Cloud Build approves the image, and only after approval Binary Authorization signs the image with an attestation. The same image digest moves across environments and is never modified, while configuration and secrets are injected at deploy time.
Artifact Registry validates artifacts before promotion. Artifact Analysis scans new images on upload, extracts system package information, and continuously updates metadata when new vulnerability data arrives. Release images use semantic versioning tags, while pre-release images use the Git commit hash that ties the image to the exact source change. Only verified artifacts move forward, so vulnerable or untested images are blocked before they reach a runtime environment.
Deployment strategy evaluation is the choice of how a new version replaces the old version to limit disruption and keep a clear rollback path. Google Kubernetes Engine (GKE) natively supports recreate and rolling strategies, while blue-green on GKE requires additional tooling such as Spinnaker. Cloud Deploy adds gated approvals so promotion to a target only proceeds after required approval.
| Strategy | Traffic shift | Resource and compatibility requirement |
|---|---|---|
| Blue-green | Traffic flows from the old server set to the new server set in one switch after verification | Temporarily requires up to twice the production servers; database schemas must stay backward compatible to at least the previous version |
| Rolling | Traffic flows gradually from old servers to new servers as each server is updated | Updates servers in place without a full duplicate fleet; requires load balancer behavior that avoids bouncing users between versions |
Choose blue-green when avoiding interruption during cutover outweighs the cost of duplicate capacity. Choose rolling when the goal is early detection of issues with a smaller capacity footprint.
Shift-left security means moving security checks early into the pipeline so developers get fast feedback on every change. Cloud Build runs builds in isolated and ephemeral environments with granular Identity and Access Management permissions, secrets flow from Secret Manager into the build instead of living in code, and Cloud Build supports Supply-chain Levels for Software Artifacts (SLSA) Level 3 builds with signed provenance that includes image digests, source locations, toolchain, steps, and duration. The chain of trust flows from version-controlled source to Cloud Build with provenance, to Artifact Registry with continuous scanning, to a Binary Authorization gate that permits deployment only when policy is satisfied.
Exam tip: Artifact Analysis finds and tracks vulnerabilities in images, while Binary Authorization blocks deployment unless the required attestations prove the checks passed.
Continue with this study guide: Software development lifecycle (SDLC)
Continuous integration and continuous deployment on Google Cloud is the automation that builds every change, stores one immutable artifact, and promotes that artifact safely through multiple targets. Cloud Deploy (opens in a new tab) defines the ordered progression of targets, a release represents a version to deploy, and a rollout executes that release into a specific target. Cloud Build (opens in a new tab) executes the build and test workflow that feeds the pipeline.
Release orchestration in Cloud Deploy controls how a release moves through targets such as dev, staging, and prod without manual steps. An Automation is a child resource of one delivery pipeline that stores the target selector and the rules for what to do, while an AutomationRun is created each time the automation triggers and stores the parent Automation plus rollout identity and metadata. Each automation belongs to one delivery pipeline and cannot be shared, and you can automate up to 250 automation rules per delivery pipeline.
Cloud Deploy supports four automated actions:
The automation workflow runs in order: first configure the Automation, then register it with gcloud deploy apply, then create a release that starts rollouts in order, then Cloud Deploy triggers promote or advance logic on success or repair logic on failure. For canary, the advanceRolloutRule waits for a source phase to become IN_PROGRESS, waits an additional configured time, then advances to the next phase until the stable phase serves 100 percent.
DevSecOps and supply chain security is the practice of building verification into every stage so each code change is checked before production. A software supply chain includes all code, dependencies, people, processes, and trusted systems used to develop, build, store, and run software. The secure release moves in order from build in Cloud Build with authenticated provenance, to store and scan in Artifact Registry with Artifact Analysis, to attest and enforce with Binary Authorization, to deliver with Cloud Deploy through development, test, and production with approvals and audit.
A five-step left-to-right process flow from source commit through Cloud Build, Artifact Registry with Artifact Analysis scanning, Binary Authorization attestation gate, to Cloud Deploy promoting the same image through dev, staging, and prod.
Artifact Analysis automatically scans container images on upload to Artifact Registry and continuously monitors stored metadata against new vulnerability sources. When new information arrives, Artifact Analysis updates image metadata, creates new vulnerability occurrences, and deletes occurrences that are no longer valid. Binary Authorization enforces policy at deploy time to GKE and Cloud Run by checking attestations that prove a specific build system created the image, that the image complies with vulnerability policy, and that the image passed promotion criteria such as development to QA.
Automated build and artifact management is the practice of producing, testing, versioning, and storing container images on every source change. The container pipeline flows in order from trigger to fetch of source code, to fetch of dependencies from Artifact Registry, to build and validation with static analysis and unit testing, to storage of the image in Artifact Registry only after tests pass, to deployment by Cloud Deploy pulling the image to GKE. Shared configuration with Skaffold lets the same build definition render manifests for different environments without rebuilding the image.
| Image type | Identifier | Use when |
|---|---|---|
| Release image | Semantic versioning tag | Producing a formal release to promote across environments |
| Pre-release image | Git commit hash | Building from a main-branch commit that still needs work before release |
Base images stay tightly controlled to avoid unsupported runtimes, and workload images build from those bases. Validation covers both application code with unit, functional, integration, and load tests and image structure with Container Structure Tests for commands, files, and metadata. Because configuration and secrets are injected at deploy time, the exact tested artifact moves unchanged and rollbacks return to a known image.
Exam tip: Use promote rules to move a release between targets, but use advance rules only inside a target that uses a canary strategy to move between phases.
Continue with this study guide: Continuous integration/continuous deployment
Troubleshooting and root cause analysis on Google Cloud is the systematic practice of separating network failures from permission failures and application failures from platform incidents. The method first checks whether traffic can travel from source to destination, then checks whether the identity is allowed to perform the action. Network checks use Connectivity Tests and flow logs, while permission checks use Policy Troubleshooter.
Network connectivity troubleshooting proves where traffic stops by comparing intended configuration with actual traffic. Connectivity Tests is a static configuration analyzer in Network Intelligence Center that analyzes the configured path from a source endpoint to a destination endpoint without sending live traffic. Traffic flows from the source, such as a virtual machine (VM) or subnet, across Virtual Private Cloud (VPC) routes, peering connections, and virtual private network (VPN) tunnels to the destination, and if a firewall rule blocks the path, Connectivity Tests identifies that rule.
VPC Flow Logs records actual sampled traffic entering and leaving VMs per subnet, and entries flow from the subnet to Cloud Logging. Firewall Rules Logging audits individual allow or deny rules to verify they work as intended. VPC Flow Logs shows whether traffic left or entered through the expected port, while Firewall Rules Logging shows which rule allowed or denied it. Cloud Audit Logs records who did what, where, and when, with Admin Activity logs always enabled, Data Access logs disabled by default except for BigQuery, and System Event logs for Compute Engine events such as live migration.
Systematic diagnosis uses reliability goals and observability tools to detect, isolate, and resolve failures. Reliability starts with service level objectives (SLOs) such as 99.9% API success, 95th percentile latency below 300 ms, time to first token below 500 ms for 99% of requests, and harmful output below 0.1%. Cloud Monitoring (opens in a new tab) analyzes performance data that flows from infrastructure and applications into dashboards and alerting rules, including AI serving metrics through Google Cloud Managed Service for Prometheus.
Cloud Monitoring tracks the four golden signals: latency, traffic, error rate, and saturation of CPU, memory, GPU, or TPU. Cloud Logging stores log data that links a failed request to its timestamp, service, stack trace, and recent configuration change. Cloud Trace follows a single request from frontend through each downstream microservice to pinpoint which span adds latency. Error Reporting groups repeated crashes by signature to show which error is spiking, while Cloud Profiler reveals which function blocks consume time or memory. The Google Cloud Service Health Dashboard shows global platform status, while Personalized Service Health shows incidents for a specific project with API, alerts, and RSS support.
Structured incident response ensures evidence is collected quickly, in order, and by the right owners. The runbook moves in order: first communication notifies stakeholders and activates escalation, then triage determines scope and whether the cause is infrastructure, application, or configuration, then investigation uses dashboards, logs, traces, and history to separate symptoms from cause, then resolution applies the fix and records what changed. Business-critical recovery must depend only on data plane components that continuously process operations, not on management plane operations such as VM-creation APIs.
A blameless post-mortem is a written record that explains what happened, why it happened, and what will change without attributing fault to individuals. Findings flow from SLO breaches, golden-signal charts, log and trace excerpts, change records, and Service Health history. Prevention uses progressive deployment where changes first apply to a few VMs in one zone, then effects are monitored, then issues trigger quick revert, then verified changes expand gradually. Changes to global resources such as VPC networks and global load balancers receive high-risk review because one misconfigured forwarding rule can stop the frontend while backends remain intact.
Exam tip: Policy Troubleshooter requires the underlying permission, not the role name, so enter values like compute.instances.create with principal and resource.
Continue with this study guide: Troubleshooting/root cause analysis best practices
Testing and validation is the process of checking code, templates, performance, and recovery before and after deployment so reliability, performance, and security hold in production. Validation happens before provisioning to block misconfigurations, during CI/CD to block untested artifacts, and after deployment to detect drift. Together these layers prevent expensive production fixes.
Infrastructure as Code (IaC) validation checks version-controlled templates for errors and policy violations before resources are created. The template flows from the developer to automated validation and then to the cloud control plane, and only validated code is allowed to create or change infrastructure. This order creates a trust boundary where nothing crosses into production without proof it meets standards.
| Method | What it checks | When it runs |
|---|---|---|
| Linting | Syntax, formatting, and basic configuration errors | First, as soon as the template is written or committed |
| Policy-as-code enforcement | Allowed regions, encryption, identity controls, and other security rules | Second, by evaluating the template against codified policies |
| Pre-deployment simulation | Which resources would be created, modified, or deleted | Third, by previewing the plan before provisioning |
Policy-as-code tools such as Sentinel or Forseti block provisioning when a template violates policy and return it to the developer. After deployment, the lifecycle moves from proposed to validated to deployed to monitored. Post-deployment controls include Cloud Asset Inventory (opens in a new tab) for what actually exists, centralized Security Information and Event Management logging for audit, regular vulnerability scans, and centralized remediation tracking until issues resolve.
Performance, load, and resiliency testing proves applications can handle expected demand, peak stress, and failures without losing reliability. Load testing simulates normal and peak traffic to check behavior, while stress testing pushes the system to its limits to find bottlenecks. Cloud Load Balancing distributes simulated traffic to test targets while external services generate realistic patterns, and results inform resource allocation, tuning, and capacity planning.
Capacity planning translates forecast user count, request rate, seasonal variation, and growth into concrete resources such as Compute Engine managed instance group size, machine type, and persistent disk count. Teams maintain N+1 redundancy, manage zonal, regional, and global quotas and rate quotas, reserve compute capacity in specific zones, and monitor utilization with Cloud Monitoring. Resiliency testing deliberately causes faults with chaos engineering and fault injection, including zonal and regional failure scenarios. Google validates large-scale resilience by disconnecting a production-equivalent internal region to confirm that local services go offline while other zones and regions remain unaffected.
Automated testing in CI/CD validates every code change before promotion. Cloud Build imports source from Cloud Storage, GitHub, or Bitbucket, pulls dependencies, and runs static analysis, unit, integration, and end-to-end tests. Cloud Deploy then promotes verified container images through targets such as GKE. The image lifecycle is fixed: first build the image, then run the test suite, and only after success store the image in Artifact Registry.
Disaster recovery validation proves backup and failover meet recovery time objective (RTO) and recovery point objective (RPO). RTO answers how long until service resumes, while RPO answers how much data in writes can be lost.
| Approach | Scope | Replication | Recovery expectation |
|---|---|---|---|
| High availability (HA) | Regional deployment across zones | Synchronous replication between zones | Zero or near-zero RTO and RPO with active-active topology |
| Disaster recovery (DR) | Multi-region deployment | Typically asynchronous replication | Assessed RTO and RPO with manual or semi-automated failover |
Teams align backup frequency with RPO, use Cloud Storage, Cloud SQL automated backups, Spanner backups, and point-in-time recovery, and test full restores in non-production with the complete application stack.
Exam tip: Linting checks whether the template is written correctly, while policy-as-code checks whether the template is allowed by security rules.
Continue with this study guide: Testing and validation of software and infrastructure
Service catalog and provisioning is the governed self-service model that lets teams deploy quickly from approved choices without bypassing controls. A cloud admin publishes curated solutions, shares them with selected folders or projects, and automation provisions them with consistent identity, networking, and billing. Governance travels with the code through infrastructure as code.
Governance through private catalogs publishes only approved cloud solutions for discovery and launch. Service Catalog provides this control under a Google Cloud organization, where the organization holds the catalog, the catalog holds the solutions, and sharing grants visibility to users in specific folders and projects. Because Service Catalog respects organization policies and Deployment Manager constraints, those broader controls continue to apply to every launch.
| Solution type | What it contains | Governance use |
|---|---|---|
| Deployment Manager template | Reusable infrastructure template plus schema that can limit region and machine type | Enforce where a solution can deploy and control cost and compliance at launch |
| Reference link | Verified web link such as help documentation | Distribute only admin-reviewed links instead of unvetted sources |
Catalog creation requires Service Catalog enabled for the organization and the Catalog Admin role on that organization. The console workflow runs in order: open the Service Catalog Admin page, select the project with Service Catalog enabled, click CREATE CATALOG, enter a name that cannot be changed later, enter a description visible only to admins, then click Create. After creation, the admin assigns solutions and shares the catalog with specific folders or projects.
Secure self-service provisioning combines resource hierarchy, Identity and Access Management (IAM), and a defined lifecycle. The Organization resource (opens in a new tab) sits at the apex for central visibility, folders group related projects, and projects hold resources such as Compute Engine VMs, Pub/Sub topics, Cloud Storage buckets, and Cloud VPN endpoints. An IAM allow policy attached at the organization or folder flows down to children, so placement decides which guardrails apply.
The lifecycle moves through ordered states: first request with owner, cost center, and environment, then placement and approval to folder, billing account, and network with quota checks, then provisioning with standard APIs, IAM bindings, and labels, then active use within Shared VPC, VPC Service Controls, and budget alerts, then decommissioning when the unattended project recommender shows the project is no longer needed. Access is managed by placing users in groups synced with Cloud Identity, granting IAM roles to groups under least privilege, and using Workforce Identity Federation for third-party identity providers such as Okta or Microsoft Entra ID without service account keys.
Automated provisioning defines desired state in version-controlled files and lets automation make infrastructure match that state. HashiCorp Terraform uses the Google Cloud Terraform Provider to interact with Google Cloud APIs. The workflow runs in order: first describe desired state in configuration files, then run terraform plan to preview changes, then run terraform apply to create or update infrastructure and write a JSON state file that maps configuration to real resources.
Governance prevents automation from creating privilege sprawl. The google_*_iam_member resource adds individual members without claiming the full policy, while google_*_iam_policy and google_*_iam_binding are authoritative and overwrite all permissions on the next apply. Consistent labels and folder structure support cost, compliance, and inventory, while Compute Engine managed instance groups with autoscaling, Cloud Monitoring, Recommender, and Active Assist keep active resources right-sized and secure.
Exam tip: Use google_*_iam_member for additive IAM changes; google_*_iam_policy and google_*_iam_binding overwrite the full policy.
Continue with this study guide: Service catalog and provisioning
Disaster recovery on Google Cloud is the design that turns business limits for downtime and data loss into replication, backup, and traffic failover across regions. Recovery time objective (RTO) sets how long an application can stay offline, while recovery point objective (RPO) sets how much data the business can afford to lose. Smaller RTO and RPO require more replication, automation, and standby capacity, so cost and complexity rise as objectives approach zero.
Data resiliency keeps data durable and available when an entire region fails through synchronous replication, asynchronous storage, and point-in-time recovery. Cloud Storage (opens in a new tab) dual-region and multi-region buckets store objects in at least two geographically separate areas regardless of storage class, with asynchronous synchronization between locations. Turbo replication replicates to both regions of a dual-region with a 15-minute RPO, while cross-bucket replication asynchronously copies from a source bucket to a destination bucket in a different location.
| Bucket location | Where data is stored | Choose when |
|---|---|---|
| Single-region | One Google Cloud region | Data must stay in one region or lowest latency to that region is required |
| Dual-region | Two specific regions you select, with optional Turbo replication | You need survival of total regional failure plus control over the second region |
| Multi-region | At least two areas selected by Google within the multi-region | You want maximum availability without managing the region pair |
Firestore regional databases synchronously replicate across at least three zones for 99.99% availability, while multi-region databases replicate across five zones in three regions for 99.999% availability. Backup and DR Service backs up Persistent Disk snapshots to Cloud Storage with monitoring and audit, scheduled database backups allow daily or weekly backups with 14-week retention, and point-in-time recovery allows reading data from up to seven days in the past at 1-minute granularity with RTO of 0 and RPO of 1 minute. Object holds, soft delete, Object Versioning, Bucket lock, and Object Retention Lock create a safety window against accidental or malicious deletion.
Traffic management shifts client traffic automatically from a failed primary to healthy backups in other regions. The primary is the global external Application Load Balancer that handles traffic normally, while backups are two or more regional external Application Load Balancers in failover regions. Cloud DNS (opens in a new tab) controls the switch: failover routes traffic from primary to backups when health checks fail, and failback reverses routing after health checks pass.
| Strategy attribute | Active-passive | Active-active |
|---|---|---|
| Steady-state traffic flow | Client to global external Application Load Balancer to backend | Client to global external Application Load Balancer to regional external Application Load Balancer to backend |
| Failure-state traffic flow | Client to regional external Application Load Balancer to backend | Client to regional external Application Load Balancer to backend, bypassing global layer |
| Reliability verification | Regional layer is idle, so periodic testing or DNS trickle traffic is needed | Steady-state traffic continuously tests the regional layer |
Select active-active bypass unless the application needs global capacity-aware spillover across regions, in which case use active-passive failover. Capacity must be reserved in failover regions or emergency autoscaling accepted, health checks must send traffic only to responsive backends, and managed instance groups can autoheal by replacing unavailable VMs. Recovery environments can be hot standby or rebuilt with Terraform, and quotas in the recovery region must be checked periodically.
Recovery objectives group applications into tiers that dictate standby design. Tier 1, about 5% of apps such as real-time payments, requires RTO Zero and RPO Zero for zone and region outages. Tier 2, about 35% of apps such as CRM, requires RTO 15 minutes and RPO 15 minutes for zone outage and RTO 1 hour and RPO 1 hour for region outage. Tier 3, about 60% of apps such as HR tools, requires RTO 1 hour and RPO 1 hour for zone outage and RTO 12 hours and RPO 12 hours for region outage. Business-critical operations must depend only on data plane components, not on management plane operations such as VM-creation APIs.
| Pattern | Recovery readiness | RTO and RPO | Cost and use |
|---|---|---|---|
| Cold standby | No running servers; images and backups wait for failover | Largest RTO and RPO | Lowest cost; fits batch jobs and Tier 3 apps |
| Warm standby | Minimal suite runs, such as small database replica with async replication | Smaller RTO and RPO | Medium cost; fits Tier 2 apps |
| Hot standby | Both environments serve production with replication | Lowest RTO and RPO | Highest cost; fits Tier 1 payments and storefronts |
Exam tip: Smaller RTO and RPO means higher cost, so cold costs least with largest RTO and RPO, warm sits in the middle, and hot costs most with smallest RTO and RPO.
Continue with this study guide: Disaster recovery
Technical processes connect development speed with operational safety by using the same principles across pipelines, testing, troubleshooting, provisioning, and recovery. Automation builds and promotes one immutable artifact with attestations, validation blocks bad templates and images before production, observability separates network, permission, and application causes after deployment, and catalogs and disaster recovery designs ensure self-service stays governed and restorable. Cost, risk, and recovery time trade against each other in every choice, from blue-green versus rolling to cold versus hot standby.
On Google Kubernetes Engine (GKE), blue-green switches traffic from the old server set to the new server set in one switch after verification, while rolling shifts traffic gradually from old servers to new servers as each server is updated. Blue-green temporarily requires up to twice the production servers and requires database schemas to stay backward compatible to at least the previous version, while rolling updates servers in place without a full duplicate fleet and requires load balancer behavior that avoids bouncing users between versions. Choose blue-green when avoiding interruption during cutover outweighs the cost of duplicate capacity, and choose rolling when the goal is early detection of issues with a smaller capacity footprint.
Artifact Analysis scans container images on upload to Artifact Registry and continuously updates vulnerability metadata, while Binary Authorization enforces policy at deploy time by blocking deployment unless required attestations prove the checks passed. Artifact Analysis extracts system package information, creates new vulnerability occurrences when new vulnerability data arrives and deletes occurrences that are no longer valid, while Binary Authorization checks attestations proving that a specific build system created the image, that the image complies with vulnerability policy, and that the image passed promotion criteria such as development to QA.
Cold standby has the lowest cost with the largest recovery time objective (RTO) and recovery point objective (RPO), warm standby has medium cost with smaller RTO and RPO, and hot standby has the highest cost with the lowest RTO and RPO. Recovery time objective (RTO) sets how long an application can stay offline while recovery point objective (RPO) sets how much data the business can afford to lose, so smaller objectives require more replication, automation, and standby capacity. Cold standby keeps no running servers with images and backups waiting for failover, warm standby runs a minimal suite such as a small database replica with asynchronous replication, and hot standby keeps both environments serving production with replication.
dev, staging, and prod. A delivery pipeline defines the o…Last updated