How Progressive Delivery In Kubernetes Environments Can Be Enhanced Using Argo Rollouts In Combination With Datadog Metrics

|

Progressive delivery has become an essential deployment strategy for modern Kubernetes environments. It enables engineering teams to incrementally release new application versions, monitor their performance, and roll back quickly if something goes wrong. This approach reduces risk, enhances control, and supports continuous delivery pipelines.

In this article, we’ll explore how Argo Rollouts, a Kubernetes controller for progressive delivery, can be effectively combined with Datadog, a leading observability platform, to enhance deployment safety and visibility. We’ll cover core concepts, integration steps, and practical code examples to demonstrate how to achieve seamless canary or blue-green deployments.

What Is Progressive Delivery?

Progressive delivery is a software release strategy that allows changes to be gradually rolled out to users. It includes techniques like:

  • Canary deployments: A small percentage of users receive the update first.

  • Blue-green deployments: Two environments run in parallel; traffic is switched from old to new.

  • Feature flags: Dynamically toggle features at runtime.

In Kubernetes, native support for progressive delivery is limited. Enter Argo Rollouts.

What Is Argo Rollouts?

Argo Rollouts is an open-source Kubernetes controller that enables progressive delivery strategies such as:

  • Canary deployments with automated metrics analysis

  • Blue-green deployments with preview environments

  • Traffic shifting using service mesh or ingress controllers

Key features include:

  • Automated rollback

  • Pause and resume capabilities

  • Integration with metric providers like Datadog, Prometheus, and Kayenta

  • Detailed deployment history

Why Integrate With Datadog?

While Argo Rollouts can make decisions based on metrics, it requires integration with a monitoring provider to fetch those metrics. Datadog is ideal for this because it offers:

  • Powerful metric dashboards

  • Custom alerts and monitors

  • Rich tagging support for Kubernetes objects

  • Native integrations with Kubernetes and Argo Rollouts

Combining both tools allows you to define conditions like:

“If the error rate exceeds 5% within the first 10 minutes of deployment, trigger a rollback automatically.”

Setting Up Argo Rollouts In Your Kubernetes Cluster

Let’s walk through how to install and configure Argo Rollouts.

Step 1: Install Argo Rollouts
bash
kubectl create namespace argo-rollouts
kubectl apply -n argo-rollouts -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml

Verify the controller is running:

bash
kubectl get pods -n argo-rollouts
Step 2: Install the Argo Rollouts CLI
bash
brew install argo-rollouts
# or
curl -LO https://github.com/argoproj/argo-rollouts/releases/latest/download/argo-rollouts-linux-amd64
chmod +x argo-rollouts-linux-amd64
mv argo-rollouts-linux-amd64 /usr/local/bin/argo-rollouts

Enabling Datadog Metrics for Rollouts

To enable Argo Rollouts to use Datadog for automated promotion or rollback, you’ll need to use the AnalysisTemplate feature.

Configure Kubernetes for Datadog

If not already installed:

bash
helm repo add datadog https://helm.datadoghq.com
helm install datadog-agent datadog/datadog \
--set datadog.apiKey=<YOUR_DATADOG_API_KEY> \
--set datadog.site='datadoghq.eu' \
--set agents.enabled=true \
--set clusterAgent.enabled=true \
--set clusterChecks.enabled=true

Ensure your Datadog monitors and metrics are set up correctly for:

  • http_requests_total

  • http_error_rate

  • latency (p95 or p99)

Example: Canary Rollout With Datadog Metrics

Let’s assume you want to deploy a new version of a service and validate it with Datadog metrics.

Create the Analysis Template

yaml
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
name: datadog-success-rate
spec:
metrics:
- name: error-rate-check
provider:
datadog:
interval: 1m
query: "sum:myapp.errors{env:prod}.as_count() / sum:myapp.requests{env:prod}.as_count()"
failureLimit: 1
successCondition: result < 0.05

This analysis template checks that the error rate is below 5%.

Define the Rollout

yaml
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
name: myapp-rollout
spec:
replicas: 4
selector:
matchLabels:
app: myapp
template:
metadata:
labels:
app: myapp
spec:
containers:
- name: myapp
image: myorg/myapp:v2
ports:
- containerPort: 80
strategy:
canary:
steps:
- setWeight: 25
- pause: {duration: 2m}
- analysis:
templates:
- templateName: datadog-success-rate
args: []
- setWeight: 50
- pause: {duration: 2m}
- setWeight: 100

Each step in the canary strategy increases traffic gradually. After the 25% shift, the rollout pauses and runs the Datadog metric check.

Monitor Rollout

Use the Argo Rollouts dashboard:

bash
argo-rollouts dashboard

Or check rollout status via CLI:

bash
argo-rollouts get rollout myapp-rollout

If the Datadog metric indicates the error rate is too high, the rollout is paused or rolled back.

Adding Advanced Features

You can customize this integration further:

Multi-Metric Analysis

yaml
metrics:
- name: high-error-rate
provider:
datadog:
query: "sum:myapp.errors{env:prod} / sum:myapp.requests{env:prod}"
failureLimit: 1
successCondition: result < 0.05– name: latency-check
provider:
datadog:
query: “avg:myapp.latency.p95{env:prod}”
failureLimit: 1
successCondition: result < 300

Using Datadog Monitors Instead of Raw Metrics

You can create a Datadog monitor and trigger actions based on its status:

yaml
provider:
datadog:
query: "alerts(\"myapp-error-monitor\").status"
successCondition: result == 0

Benefits Of This Integration

Combining Argo Rollouts with Datadog unlocks several benefits:

Benefit Description
Safe Deployments Automate rollback if Datadog detects spikes in errors or latency.
Observability-Aware Delivery Define success/failure using business metrics.
Granular Control Use canary steps and pause logic with live metric evaluations.
Improved Developer Confidence Teams can ship with reduced risk and instant feedback.

  • Tag all Datadog metrics with Kubernetes metadata (env, pod, service) for traceability.

  • Use separate monitors per rollout stage to avoid false positives.

  • Add notification hooks (e.g., Slack, email) for failed rollouts.

  • Enable version-specific dashboards in Datadog to visually compare old vs. new performance.

  • Use successCondition and failureLimit wisely to avoid premature rollbacks.

Conclusion

Progressive delivery is crucial for modern, resilient Kubernetes environments. By combining Argo Rollouts with Datadog metrics, you can automate intelligent deployment workflows that respond to real-time service behavior. Whether you’re releasing a critical backend service or a customer-facing feature, this integration offers the visibility, control, and safety net needed to deploy with confidence.

Argo Rollouts acts as the smart controller, orchestrating canary steps and managing traffic shifts, while Datadog ensures those transitions are monitored with deep, real-time insights. This synergy empowers teams to deliver high-quality software faster, avoid outages, and embrace a data-driven DevOps culture.

By adopting this approach, you’re not just deploying code—you’re evolving how your organization handles change. The risk is lower, the feedback is immediate, and the results are measurable. And in a world of continuous delivery, that’s the competitive edge every engineering team needs.