Study guide
9.1 Progressive Delivery: Blue-Green, Canary & Ring Deployments
Microsoft Certified: Azure DevOps Engineer Expert AZ-400
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Flow of Work, Traceability & Work Tracking
1.1 Flow of Work, GitHub Flow & Feedback Cycles 1.2 Work Tracking with Azure Boards & GitHub Projects 1.3 End-to-End DevOps Traceability & Quality Tracking
2 Chapter 2: DevOps Metrics, Dashboards & Team Collaboration
2.1 DORA Metrics, Flow Metrics & Dashboard Design 2.2 Lifecycle Metrics Across the Six DevOps Phases 2.3 Work Item Queries, WIQL Charts & Analytics 2.4 Project Documentation: Wikis, Mermaid Diagrams & Release Notes 2.5 Webhooks, Service Hooks & Microsoft Teams ChatOps
3 Chapter 3: Git Branching Strategies & Pull Request Workflows
3.1 Git Branching Models & Strategy Design 3.2 Pull Request Workflows & Merge Strategies 3.3 Branch Policies, Quality Gates & Compliance Restrictions
4 Chapter 4: Repository Management, Optimization & Git Data Operations
4.1 Git LFS Architecture & .gitattributes Tracking 4.2 LFS History Migration, git-fat & File Locking 4.3 Git Repository Scaling, Scalar & Monorepo Governance 4.4 Repository Permissions & Git Tag Governance 4.5 Git Data Recovery & Sensitive-Data Scrubbing
5 Chapter 5: Package Management & Dependency Versioning
5.1 Selecting Package Tools: Azure Artifacts vs. GitHub Packages 5.2 Feed Scoping, Upstream Sources & Pipeline Authentication 5.3 Package Views, Immutability & Quality Promotion 5.4 Dependency Versioning: SemVer, CalVer & Automated Versioning 5.5 Pipeline Artifact Versioning & Artifact Storage Strategy
6 Chapter 6: Pipeline Infrastructure, Agents & Integration
6.1 Selecting a CI/CD Solution: Azure Pipelines vs. GitHub Actions 6.2 GitHub-Azure Pipelines Integration & Hybrid Migration 6.3 Hosted vs. Self-Hosted Agents & Runners 6.4 VMSS Elastic Pools, Container Jobs & Agent Governance 6.5 Pipeline Triggers, Filters & Concurrency Management
7 Chapter 7: YAML Pipeline Architecture & Reusable Elements
7.1 YAML Pipeline Anatomy: Stages, Jobs, Steps & Workspaces 7.2 Job Execution Order: DAG Dependencies, Parallelism & Conditions 7.3 Reusable Elements: Templates, Parameters & Variables 7.4 Variable Groups, Secret Variables & Key Vault Linking 7.5 YAML Environments, Checks & Deployment Approvals
8 Chapter 8: Testing Strategy, Quality Gates & Code Coverage
8.1 Test Strategy Design: Local, Unit & Integration Testing 8.2 Load, Stress & Performance Testing in Pipelines 8.3 Test Execution Tasks, Agents & Results Integration 8.4 Code Coverage Analysis & SonarQube Integration 8.5 Quality Gates, Release Gates & Governance Checks
9 Chapter 9: Modern Deployment Strategies & Zero-Downtime Delivery
9.1 Progressive Delivery: Blue-Green, Canary & Ring Deployments 9.2 Minimizing Downtime: Deployment Slots & Rolling Updates 9.3 Feature Flags with Azure App Configuration & Feature Manager 9.4 Designing the High-Priority Hotfix Path 9.5 Ordered Dependency Deployments, Resiliency & Rollback
10 Chapter 10: Artifact Deployment & Database DevOps
10.1 Containerized Application Delivery: ACR, AKS & Container Apps 10.2 Binary, Web App, Function & Scripted Deployments 10.3 Database DevOps: State-Based & Migration-Based Strategies
11 Chapter 11: Infrastructure as Code (IaC) & Azure Deployment Environments
11.1 Infrastructure as Code Strategy: Bicep, ARM & Terraform 11.2 Desired State Configuration & Azure Machine Configuration 11.3 Azure Deployment Environments (ADE) & Developer Self-Service
12 Chapter 12: Pipeline Maintenance, Health & Modernization
12.1 Pipeline Health, Flaky Tests & Reliability Engineering 12.2 Pipeline Optimization: Caching, Slicing & Concurrency 12.3 Artifact & Build Retention Governance 12.4 Modernizing CI/CD: Classic to YAML Migration
13 Chapter 13: Authentication, Authorization & Identity Governance
13.1 Microsoft Entra Service Principals & Managed Identities 13.2 Service Connections, Workload Identity & Personal Access Tokens 13.3 Azure DevOps Projects, Teams & Permission Evaluation 13.4 Access Levels, GitHub Roles & Outside Collaborators
14 Chapter 14: Secrets Management, Sensitive Data & DevSecOps Scanning
14.1 Azure Key Vault, Secret Variables & Secretless CI/CD 14.2 Security Scanning Strategy, GHAS & Secret Scanning 14.3 CodeQL SAST in Pipelines and Containers 14.4 Software Supply Chain, Container Scanning & Cloud Defender
15 Chapter 15: Telemetry Collection, Azure Monitor & Alerting
15.1 Azure Monitor Architecture, AMA & Data Collection Rules 15.2 Application Insights & Specialized Azure Monitor Insights 15.3 Alerting Rules, Action Groups & GitHub Repository Insights
16 Chapter 16: Telemetry Analysis, Distributed Tracing & SRE Practices
16.1 Distributed Tracing, Application Map & Exception Triage 16.2 KQL Log Analytics, SRE Observability & Error Budgets
9.1 Progressive Delivery: Blue-Green, Canary & Ring Deployments
Key Takeaways Explain This Topic AI
Progressive delivery expands continuous delivery by decoupling deployment from release and introducing blast-radius control through incremental user exposure.
Blue-Green deployment maintains two identical production environments (Blue active, Green idle/staging), routing 100% of user traffic via a load balancer switch, enabling near-instant rollback at the cost of double infrastructure footprint.
Canary deployments route a small fraction of real production traffic (e.g., 5% -> 25% -> 100%) to an updated baseline to validate operational telemetry (latency, errors, exceptions) before committing to a wide rollout.
Ring-based deployment organizes user exposure into concentric cohorts (Ring 0 internal canary -> Ring 1 early adopters -> Ring 2 broader users -> Ring 3 general availability) separated by mandatory baking periods.
Canary deployment evaluates system operational health and technical reliability, whereas A/B testing measures user behavior, engagement, and business conversion rates.
Last updated: September 2026
9.1 Progressive Delivery: Blue-Green, Canary & Ring Deployments
Traditional "big-bang" software releases require scheduled maintenance windows, service offline notifications, and high-stress cutovers. If an undetected defect slips into production during a big-bang release, 100% of the user base is impacted simultaneously, and rolling back often requires a lengthy, high-risk redeployment. Modern DevOps engineering eliminates this operational vulnerability through progressive delivery —an advanced operational model that decouples code deployment from feature release and systematically controls the blast radius of new versions.
On the AZ-400 exam, candidates must demonstrate mastery over zero-downtime deployment patterns, evaluate the infrastructure and financial tradeoffs between Blue-Green and Canary releases, configure progressive Ring-based exposure pipelines, and distinguish operational canary health verification from business-driven A/B testing.
1. Core Concepts: Decoupling Deployment from Release
To understand modern progressive delivery, engineers must distinguish two foundational terms often conflated in traditional IT operations:
Deployment : The technical process of provisioning infrastructure, installing compiled application binaries, copying container images, and running database schema migrations. Deployment makes software present in an environment, but it does not necessarily expose that code to end users.
Release : The business and operational process of routing real user traffic to the newly deployed software.
By separating deployment from release, DevOps teams can thoroughly test and warm up applications in production environments under real conditions without subjecting external users to cold starts, startup latency, or latent configuration defects.
2. Blue-Green Deployment Architecture
Blue-Green deployment is a zero-downtime delivery pattern that relies on two identical, isolated production environments called Blue and Green . [Azure Front Door / Application Gateway]
- │
- 100% Live Traffic │ (Instant VIP Cutover)
- ┌──────────────────────┴──────────────────────┐
- ▼ ▼
- [Blue Environment (Active)] [Green Environment (Staging)]
- Running Version 1.0 • Running Version 2.0
- Serving 100% of Users • Undergoing Final Smoke Tests
- Monitored by Production Alerts • Fully Warmed and Verified
- │ │
- └──────────────────────┬──────────────────────┘
- ▼
- [Shared Production Database]
- (Backward-Compatible Schema)
- Architectural Mechanics
State at Rest : At any given time, only one environment is active (e.g., Blue is actively serving 100% of live production traffic running Version 1.0). The alternate environment ( Green ) sits idle or serves as a staging target.
Deployment Phase : The CI/CD pipeline deploys the new release (Version 2.0) exclusively to the idle Green environment. Automated integration tests, security scans, and smoke tests run against Green without affecting live users on Blue.
Switchover Phase : Once Green is certified healthy, the edge traffic routing layer—such as Azure Front Door , Azure Application Gateway , or Azure Traffic Manager —swaps its routing target. Within milliseconds, 100% of inbound client requests route to Green (making Green active). Blue immediately transitions to the idle staging environment.
Instant Rollback : If unexpected anomalies, memory spikes, or critical errors occur post-cutover, the routing layer simply switches traffic back to Blue. Recovery Time Objective (RTO) is measured in seconds rather than hours because the previous known-good version was never torn down.
Infrastructure and Architectural Tradeoffs
Cost Multiplier : Blue-Green deployment requires running duplicate compute capacity. For massive enterprise clusters (e.g., hundreds of Azure Kubernetes Service nodes or large Azure App Service Plans), maintaining two identical parallel environments effectively doubles baseline infrastructure costs during deployment cycles.
Database Schema Evolution (The Expand/Contract Pattern) : Because Blue and Green often operate against the same back-end data store during the cutover window, database schemas must maintain backward and forward compatibility. Schema migrations must follow the Expand/Contract (Parallel Change) pattern:
Expand : Add new columns, tables, or nullable fields without modifying or dropping existing columns so Version 1.0 (Blue) and Version 2.0 (Green) function simultaneously.
Contract : Once Green is stable and Blue is retired, a follow-up migration removes deprecated columns or enforces non-null constraints.
State and Session Persistence : Stateful applications requiring in-memory session state will drop user sessions upon cutover unless user sessions are externalized into a distributed cache, such as Azure Cache for Redis , or handled via sticky cookie affinity.
3. Canary Deployment Strategy & Operational Health Gating
Where Blue-Green cuts over 100% of traffic in an all-or-nothing switch, Canary deployment introduces incremental traffic shifting to minimize the blast radius of software defects. [Traffic Routing Layer]
- │
- ┌───────────────────────┴───────────────────────┐
- │ 90% Production Traffic │ 10% Canary Traffic
- ▼ ▼
- [Baseline Fleet (v1.0)] [Canary Fleet (v2.0)]
- 90% of Users • 10% of Users (Random/Targeted)
- Emits Baseline Telemetry • Monitored against Error Gates
- │ │
- └───────────────────────┬───────────────────────┘
- ▼
- [Application Insights / Azure Monitor]
- Compare: HTTP 5xx, Exception Rate, Latency
- If Metric Breached -> Automated Immediate Rollback
- If Metric Healthy -> Advance Traffic (25% -> 50% -> 100%)
- Traffic Shifting Mechanics
The deployment pipeline updates a small subset of instances (e.g., 10% of pods or a dedicated canary host) with the new version (v2.0).
The load balancing fabric (e.g., Azure Front Door, Azure Application Gateway, or Kubernetes Ingress/Service Mesh) routes a calibrated percentage of live user requests to the canary instances (e.g., 5% or 10%), while the remaining 90%–95% continues to hit the stable baseline (v1.0).
Real users generate real production workload against the canary code, exposing subtle defects, concurrency locks, or integration edge cases that synthetic test suites fail to uncover.
Operational Health Gating & Automated Rollback
Canary deployments rely fundamentally on telemetry comparison. Application Insights and Azure Monitor collect real-time Service Level Indicators (SLIs) comparing the canary cohort directly against the baseline fleet:
- HTTP 5xx Server Error Rates
- Unhandled Exception Frequency
- p95 and p99 Request Latency
- CPU and Memory Saturation
If the canary telemetry breaches predefined Service Level Objectives (SLOs)—for example, if the canary generates an HTTP 500 error rate exceeding 0.5% over a 5-minute evaluation window—the automated release pipeline trips a circuit breaker. Inbound traffic routing instantly reverts to 100% baseline, and the canary instances are quarantined or deprovisioned automatically without human intervention.
4. Ring-Based Deployments (Progressive Exposure)
Ring-based deployment (also known as progressive exposure or phased rollout) is an enterprise evolution of canary deployment championed by Microsoft in Azure DevOps and Windows engineering. Instead of shifting arbitrary percentages of anonymous traffic, ring deployments release changes to increasingly wider, structured user cohorts known as Rings . ┌─────────────────────────────────────────────────────────────┐
- │ Ring 3: General Availability (Broad Global Production) │
- │ ┌─────────────────────────────────────────────────────────┤
- │ │ Ring 2: Broader Enterprise Cohort (Low-Risk Tenants) │
- │ │ ┌─────────────────────────────────────────────────────┤
- │ │ │ Ring 1: Early Adopter Customers (Pilot / Beta) │
- │ │ │ ┌─────────────────────────────────────────────────┤
- │ │ │ │ Ring 0: Internal Canary (Engineering Team) │
- └───┴───┴───┴─────────────────────────────────────────────────┘
- Cohort Ring Taxonomy
Ring 0 (Canary / Internal Engineering) : Deployed exclusively to the development and operations team that built the feature. The team "dogfoods" their own code in production against real internal accounts. If catastrophic bugs exist, only the authors experience them.
Ring 1 (Early Adopters / Pilot Users) : Deployed to external beta users or pilot customers who have opted in to receive early features in exchange for early access. These users tolerate occasional minor glitches and provide rich telemetry.
Ring 2 (Broader Production Cohort) : Deployed to a broader customer segment, such as non-critical commercial tenants or low-traffic geographic regions. This validates scalability and performance under realistic diurnal load curves.
Ring 3 (General Availability / Mission-Critical) : The final rollout ring covering all remaining enterprise customers, regulated industries, and mission-critical workloads.
Baking Periods (Soak Times)
A mandatory element of ring deployments is the baking period (also called soak time or wait timer). Pipelines do not advance from Ring 0 to Ring 1 immediately upon successful deployment. Instead, the pipeline pauses execution for a configured duration (e.g., 2 hours, 12 hours, or 24 hours). This observation window allows:
Telemetry to accumulate across diverse user interactions.
Identification of slow memory leaks, resource exhaustion, or unclosed database connection pools.
Evaluation of background scheduled jobs and asynchronous message consumers that execute at periodic intervals.
5. Canary Deployments vs. A/B Testing: The Crucial Exam Distinction
A frequent trap on the AZ-400 exam is confusing Canary deployments with A/B testing . While both split traffic between two versions of an application, their purpose, audience, telemetry, and decision-makers are fundamentally distinct.
Architectural Dimension Canary Deployment A/B Testing
Primary Purpose Operational Safety & Resilience : Validate system stability and detect technical regressions Business Experimentation : Measure user behavior, engagement, and conversion rates
Primary Stakeholder DevOps Engineers, Site Reliability Engineers (SREs), Infrastructure Architects Product Managers, UX Researchers, Growth/Marketing Teams
Key Metrics Monitored HTTP 5xx errors, unhandled exceptions, p95/p99 latency, CPU/memory saturation Click-through rates, checkout conversion, bounce rates, revenue per session
Traffic Routing Basis Anonymous percentage split (e.g., 5% of all requests) or infrastructure topology User attributes, session cookies, demographic cohorts, or feature flag targeting rules
Rollout Criteria Automated health gates and telemetry alert rules pass without threshold breach Statistical significance reached demonstrating Variant B outperforms Variant A
Failure Response Instant automated rollback to restore system availability Experiment concludes Variant B failed business hypothesis; feature flag disabled
6. Comprehensive Strategy Comparison Matrix
Deployment Pattern Infrastructure Cost Cutover Speed Rollback Speed Blast Radius Primary Validation Mechanism
Big Bang (All-at-Once) 1x (Lowest) Slow (Maintenance window) Very Slow (Full redeploy) 100% of users (Highest) Post-deployment smoke testing
Blue-Green 2x (Highest) Instant (Routing cutover) Instant (Seconds) 100% once switched Staging pre-validation on Green
Canary ~1.1x (Low/Moderate) Gradual (Percentage steps) Fast (Revert routing) Small (5%–10% of users) Automated operational telemetry gates
Ring-Based ~1.1x–1.2x (Moderate) Phased over days/weeks Fast per ring Contained by cohort Baking periods & SLI/SLO gates
A/B Testing 1x (Built into app) Continuous experiment Instant via feature flag Targeted user segment Business telemetry & conversion math
- 7. Realistic Exam Scenario & Common Traps
- Scenario: Global FinTech Payment Engine Release
Organization : Contoso Payments processes over $500 million in credit card transactions daily across 40 countries. A major update to their fraud detection scoring engine is scheduled for deployment.
Constraint 1 : Operating budget strictly prohibits maintaining duplicate production compute clusters year-round (ruling out permanent 2x Blue-Green infrastructure).
Constraint 2 : Management demands that any failure during deployment must impact fewer than 5% of transactions and must automatically abort within 60 seconds if error rates rise.
Constraint 3 : Changes must bake for at least 6 hours during live European business hours before expanding globally.
DevOps Architect Solution :
Implement a Canary deployment integrated into a Ring-based pipeline .
Stage 1 (Ring 0): Route 5% of live transactions to the canary instances via weighted routing on Azure Front Door.
Stage 2: Enforce an automated Azure Monitor Alerts gate evaluating HTTP 500 status codes and processing latency. If errors breach 0.1%, the pipeline trips and Azure Front Door immediately zeroes out the canary weight.
Stage 3: Configure a Wait Timer check (baking period) of 360 minutes (6 hours) to monitor transaction settlement queues before the pipeline triggers Ring 1 (100% global deployment).
Common Exam Traps to Avoid
Trap: Selecting Blue-Green when budget constraints explicitly forbid duplicate infrastructure. Blue-Green requires 2x identical environments. If an exam question mentions cost limitations or container density caps, Canary or Rolling updates are the correct choice.
Trap: Confusing Canary deployments with A/B testing. If a question asks how to test whether a "new green checkout button yields higher sales," the answer is A/B testing , never Canary.
Trap: Neglecting database backward compatibility during Blue-Green cuts. Switching web traffic from Blue to Green instantaneously will crash production if the database schema was modified with breaking changes. Always specify the Expand/Contract database migration pattern.