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