Study guide
11.4 Progressive Delivery Automation: Argo Rollouts, Flagger & Feature Flags
Kubernetes and Cloud Native Associate KCNA
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Introduction & Exam Overview
1.1 About the KCNA Exam & Certification Path 1.2 How to Use This Study Guide
2 Chapter 2: Kubernetes Fundamentals - Cluster Architecture & the API
2.1 Kubernetes Architecture & Control Plane Components 2.2 Worker Node Architecture & Node Components 2.3 Kubernetes API, Declarative Management & kubectl 2.4 Kubernetes Releases, API Versioning & Deprecation Policy
3 Chapter 3: Kubernetes Fundamentals - Workloads & Configuration
3.1 Core Workload Objects (Pods, Deployments & ReplicaSets) 3.2 Advanced Controllers (StatefulSets, DaemonSets, Jobs & CronJobs) 3.3 Namespaces, Labels, Selectors & Annotations 3.4 ConfigMaps, Secrets & Application Configuration 3.5 Pod & Container Lifecycle, Restart Policies & Graceful Termination
4 Chapter 4: Kubernetes Fundamentals - Scheduling & Autoscaling
4.1 Scheduling, Resource Management & Node Selection 4.2 Advanced Scheduling: Affinity, Topology Spread, Priority & Disruption Budgets 4.3 Autoscaling Workloads & Clusters (HPA, VPA, Cluster Autoscaler, KEDA)
5 Chapter 5: Kubernetes Fundamentals - Cluster Administration & Extensibility
5.1 Kubernetes Distributions, Installation Tools & Managed Services 5.2 Cluster Administration: Node Maintenance, Upgrades & etcd Backup 5.3 Extending Kubernetes: CRDs, Operators & the Controller Pattern
6 Chapter 6: Kubernetes Fundamentals - Containerization
6.1 Container Fundamentals, Runtimes & Registries 6.2 Container Image Anatomy: Layers, Tags, Digests & Pull Policy
7 Chapter 7: Container Orchestration - Networking & Service Discovery
7.1 Kubernetes Networking, Services & Ingress 7.2 Cluster DNS & Service Discovery with CoreDNS 7.3 NetworkPolicies, Zero-Trust Segmentation & the Gateway API
8 Chapter 8: Container Orchestration - Storage
8.1 Storage Concepts (PVs, PVCs, StorageClasses & CSI) 8.2 Volume Types, Snapshots & Stateful Storage Operations
9 Chapter 9: Container Orchestration - Security
9.1 Kubernetes Security & Access Control (RBAC & ServiceAccounts) 9.2 The 4C's of Cloud Native Security & Supply-Chain Trust 9.3 Service Mesh, mTLS & Zero-Trust Service Identity
10 Chapter 10: Container Orchestration - Troubleshooting
10.1 Container Troubleshooting & Health Probes 10.2 Cluster & Node-Level Troubleshooting
11 Chapter 11: Cloud Native Application Delivery
11.1 Cloud Native CI/CD Pipelines & Build Tooling 11.2 GitOps & Package Management (Helm, Kustomize, Argo CD & Flux) 11.3 Deployment Strategies & Release Management 11.4 Progressive Delivery Automation: Argo Rollouts, Flagger & Feature Flags 11.5 Application Debugging & Developer Workflows in Kubernetes 11.6 Platform Engineering & Developer Self-Service
12 Chapter 12: Cloud Native Architecture - Observability & Principles
12.1 Cloud Native Observability (Logging, Metrics & Tracing) 12.2 Cloud Native Principles & Architecture Patterns 12.3 Serverless, FaaS & Event-Driven Architecture
13 Chapter 13: Cloud Native Architecture - CNCF Ecosystem & Community
13.1 The CNCF Landscape, Governance & Project Lifecycle 13.2 Cloud Native Community, Collaboration & Contribution
11.4 Progressive Delivery Automation: Argo Rollouts, Flagger & Feature Flags
Key Takeaways Explain This Topic AI
Progressive delivery is the automation of a release strategy — a controller shifts traffic in steps, evaluates metrics, and promotes or rolls back without human intervention.
Argo Rollouts replaces the Deployment object with a Rollout custom resource that owns the canary or blue/green steps natively.
Flagger drives an existing Deployment by manipulating a service mesh or ingress controller's traffic weights instead of replacing the workload object.
Automated analysis queries a metrics provider such as Prometheus against a success threshold, and a failed analysis aborts the rollout and restores full traffic to the stable version.
Feature flags separate deployment from release, so code can ship dark and be switched on for a user segment without another rollout.
Last updated: October 2026
11.4 Progressive Delivery Automation: Argo Rollouts, Flagger & Feature Flags
Quick Answer: Section 11.3 described what canary and blue/green releases are. Progressive delivery is the automation that actually runs them: a controller shifts traffic in defined steps, queries metrics after each step , and promotes or aborts on its own . Argo Rollouts replaces the Deployment object with a Rollout CRD; Flagger leaves the Deployment in place and drives a service mesh or ingress controller. Feature flags go further still, decoupling deployment from release entirely.
A canary that nobody watches is not a canary — it is a slow outage. The automation is the point.
1. Why Native Deployments Are Not Enough
A Kubernetes Deployment gives you exactly one automated strategy, RollingUpdate , and its only health signal is the readiness probe . That probe answers "is the process accepting connections?" — not "is the new version returning correct answers at an acceptable error rate and latency?"
So a build that passes readiness but returns HTTP 500 on 20% of requests will roll out to 100% of your fleet, cheerfully, in about ninety seconds.
- Capability Deployment Progressive delivery controller
- Incremental pod replacement Yes Yes
- Precise traffic weights (5%, 25%, 50%) No Yes
- Automated metric analysis between steps No Yes
- Automatic abort on a bad metric No Yes
- Manual promotion gate mid-rollout No Yes
- Blue/green with a pre-promotion test hook No Yes
- 2. Argo Rollouts
Argo Rollouts introduces a Rollout custom resource that is a drop-in replacement for a Deployment — same Pod template, plus a strategy block that describes the release as a sequence of steps. apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
name: api
spec:
replicas: 10
strategy:
canary:
- canaryService: api-canary
- stableService: api-stable
trafficRouting:
istio:
virtualService: { name: api-vs }
steps:
- setWeight: 5
- pause: { duration: 5m } # observe
- analysis: # automated gate
templates:
- templateName: success-rate
- setWeight: 25
- pause: { duration: 10m }
- setWeight: 50
- pause: {} # indefinite: wait for manual promotion
- setWeight: 100
template:
# ... identical to a Deployment pod template ...
Three kinds of step, and knowing the difference is the exam-relevant part:
setWeight — move a percentage of traffic to the canary.
pause: { duration } — wait a fixed period so metrics accumulate.
pause: {} with no duration — wait indefinitely for a human to run kubectl argo rollouts promote .
analysis — run an AnalysisTemplate and continue only if it succeeds.
Argo Rollouts also implements blue/green with previewService , prePromotionAnalysis , and postPromotionAnalysis hooks, plus a configurable scaleDownDelaySeconds that keeps the old version warm for an instant rollback.
3. Flagger
Flagger takes the opposite design decision: it leaves your Deployment untouched and adds a Canary resource that drives it, manipulating the traffic weights of an underlying mesh or ingress (Istio, Linkerd, NGINX, Traefik, Gateway API). apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
name: api
spec:
- targetRef: { apiVersion: apps/v1, kind: Deployment, name: api }
- service: { port: 80 }
analysis:
- interval: 1m
- threshold: 5 # abort after 5 failed checks
- maxWeight: 50
- stepWeight: 10
metrics:
- name: request-success-rate
- thresholdRange: { min: 99 }
- interval: 1m
- name: request-duration
- thresholdRange: { max: 500 }
- interval: 1m
webhooks:
- name: load-test
- url: http://flagger-loadtester/
- Argo Rollouts Flagger
- Workload object Replaces Deployment with Rollout Keeps the Deployment , adds a Canary
- Traffic control Mesh, ingress, or replica ratio Requires a mesh or supported ingress
- Migration cost Change kind: on existing manifests Add one object, change nothing else
- Home Argo project (CNCF graduated) Flux project (CNCF graduated)
- 4. Automated Analysis Is the Real Feature
Both controllers reduce to the same loop: shift a little traffic, ask a metrics provider whether things are still healthy, then continue or abort. apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
name: success-rate
spec:
metrics:
- name: success-rate
- interval: 1m
- count: 5
- successCondition: result[0] >= 0.99
- failureLimit: 2
provider:
prometheus:
- address: http://prometheus.monitoring:9090
- query: |
- sum(rate(http_requests_total{job="api",code!~"5.."}[2m]))
- /
- sum(rate(http_requests_total{job="api"}[2m]))
Providers include Prometheus, Datadog, New Relic, CloudWatch, and Kubernetes Jobs for arbitrary checks. On failure the controller immediately returns 100% of traffic to the stable version and scales the canary to zero — mean time to recovery measured in seconds rather than in however long it takes to page someone.
This is also where sections 12.1 and 11.4 interlock: you cannot automate a promotion decision without the metrics from your observability stack. Progressive delivery is observability with a control loop attached.
5. Feature Flags: Decoupling Deployment from Release
Even a perfect canary still ties a user-visible change to a deployment. Feature flags break that link: DEPLOY ── ship the code to production, flag OFF ──► nobody sees it
- RELEASE ── flip the flag for 1% of users ─────────► gradual exposure
- ROLLBACK ─ flip the flag back ────────────────────► instant, no redeploy
Benefits that a rollout controller alone cannot give you:
Rollback in milliseconds — a configuration change, not a rollout.
Targeting by attribute — internal staff, a beta cohort, a single region.
Trunk-based development — merge incomplete work behind a flag instead of maintaining long-lived branches.
Experimentation — the A/B testing pattern from section 11.3, controlled per user rather than per Pod.
OpenFeature is the CNCF project standardising the flag-evaluation API across vendors, so application code is written once against a vendor-neutral SDK.
The cost is real and should be stated: every flag is a branch in production, and un-retired flags accumulate into combinatorial complexity nobody can reason about. Mature teams treat flag removal as part of the definition of done.
6. Choosing
- Situation Approach
- Small internal service, low blast radius Plain Deployment with a good readiness probe
- User-facing service, mesh already installed Flagger — least disruption to existing manifests
- Complex multi-step release with manual gates and blue/green hooks Argo Rollouts
- Change must be reversible in seconds, or targeted at a user segment Feature flags
Regulated environment requiring an explicit human approval Rollout controller with an indefinite pause: {} step