Rolling Deployment

Rolling Deployment is a progressive deployment strategy that gradually replaces application instances with new versions, wave by wave. Unlike a "big bang" deployment, this approach maintains service availability while reducing risks associated with new releases. It's the preferred method for critical applications requiring continuous availability.

Fundamentals of Rolling Deployment

• Incremental deployment in batches of instances, typically 10-25% at a time
• Progressive validation with health checks between each wave
• Temporary coexistence of multiple application versions during deployment
• Ability to pause or cancel at any time if issues are detected

Strategic Benefits

• Zero downtime: application remains available throughout the entire deployment
• Reduced blast radius: issues only affect a subset of users
• Simplified rollback: quick reversion capability if anomalies occur
• Progressive validation: early problem detection before full deployment
• Existing infrastructure: no additional resources needed unlike Blue-Green
• Real-world monitoring: behavior observation on production traffic

Practical Example with Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-backend
spec:
  replicas: 10
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 2        # Max 2 extra pods during update
      maxUnavailable: 1  # Max 1 unavailable pod during update
  minReadySeconds: 30    # Wait 30s before considering pod ready
  template:
    metadata:
      labels:
        app: api-backend
        version: v2.5.0
    spec:
      containers:
      - name: api
        image: company/api:v2.5.0
        readinessProbe:    # Mandatory health validation
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5
        livenessProbe:
          httpGet:
            path: /alive
            port: 8080
          initialDelaySeconds: 15
          periodSeconds: 10

In this example, Kubernetes progressively deploys version v2.5.0: it updates 1-3 pods at a time (maxUnavailable=1, maxSurge=2), waits for them to pass health checks, then continues with the next batch. Complete deployment takes approximately 5-10 minutes for 10 replicas.

Effective Implementation

1. Define optimal batch size (10-25% of total) based on criticality and volume
2. Configure robust health checks (readiness + liveness probes) for automatic validation
3. Establish clear success metrics (latency, error rate, resources) with alert thresholds
4. Implement real-time monitoring system to detect anomalies quickly
5. Plan observation delay (soak time) between waves for metric validation
6. Prepare automatic rollback procedure based on health metrics
7. Document version compatibility strategy (backward/forward compatibility)
8. Test rolling deployment in staging environment with realistic load

Associated Tools and Platforms

• Kubernetes: native management via RollingUpdate strategy with fine-grained parameter control
• AWS ECS/EKS: integrated support with AWS CodeDeploy for advanced orchestration
• Spinnaker: multi-cloud deployment pipeline with configurable rolling strategies
• ArgoCD: GitOps deployment with progressive synchronization and auto-healing
• Flagger: progressive delivery automation with automatic metrics analysis
• Terraform: infrastructure-as-code definition with rolling lifecycle management

Critical Considerations

Rolling Deployment represents an optimal balance between safety and efficiency for most modern applications. By enabling frequent deployments without service interruption, it fosters an agile DevOps culture while maintaining operational stability. Its thoughtful implementation significantly reduces time-to-market and change-associated risk, generating measurable business value through faster and more reliable release cycles.