Deployment Strategies

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  strategy:
    type: Recreate    # ← Kill all old pods, then create new ones
  template:
    spec:
      containers:
        - name: myapp
          image: myapp:v2

deploy-recreate:
  name: Recreate Deployment
  runs-on: ubuntu-latest
  steps:
    - name: Deploy new version
      run: |
        echo "⚠️ WARNING: This will cause downtime!"
 
        # Scale down to 0
        kubectl scale deployment/myapp --replicas=0 -n production
        kubectl rollout status deployment/myapp -n production
 
        # Update image
        kubectl set image deployment/myapp \
          myapp=myregistry.io/myapp:${{ github.sha }} \
          -n production
 
        # Scale back up
        kubectl scale deployment/myapp --replicas=3 -n production
        kubectl rollout status deployment/myapp -n production

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 4
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1          # Create 1 extra pod during rollout
      maxUnavailable: 0    # Never have fewer than 4 pods available
  template:
    spec:
      containers:
        - name: myapp
          image: myapp:v2
          readinessProbe:   # ← Critical: K8s only sends traffic to ready pods
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 10
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 30
            periodSeconds: 10

deploy-rolling:
  name: Rolling Update
  runs-on: ubuntu-latest
  steps:
    - name: Deploy with rolling update
      run: |
        kubectl set image deployment/myapp \
          myapp=myregistry.io/myapp:${{ github.sha }} \
          -n production
 
    - name: Monitor rollout
      run: |
        kubectl rollout status deployment/myapp \
          -n production \
          --timeout=10m
 
    - name: Verify all pods healthy
      run: |
        READY=$(kubectl get deployment myapp -n production \
          -o jsonpath='{.status.readyReplicas}')
        DESIRED=$(kubectl get deployment myapp -n production \
          -o jsonpath='{.spec.replicas}')
 
        if [ "$READY" != "$DESIRED" ]; then
          echo "❌ Not all pods are ready: $READY/$DESIRED"
          kubectl rollout undo deployment/myapp -n production
          exit 1
        fi
        echo "✅ All $READY/$DESIRED pods ready"
 
    - name: Rollback on failure
      if: failure()
      run: |
        echo "❌ Rolling back to previous version..."
        kubectl rollout undo deployment/myapp -n production
        kubectl rollout status deployment/myapp -n production

# blue-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-blue
  labels:
    app: myapp
    version: blue
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
      version: blue
  template:
    metadata:
      labels:
        app: myapp
        version: blue
    spec:
      containers:
        - name: myapp
          image: myapp:v1.0.0
 
---
# green-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-green
  labels:
    app: myapp
    version: green
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
      version: green
  template:
    metadata:
      labels:
        app: myapp
        version: green
    spec:
      containers:
        - name: myapp
          image: myapp:v2.0.0
 
---
# service.yaml — Switch by changing selector
apiVersion: v1
kind: Service
metadata:
  name: myapp
spec:
  selector:
    app: myapp
    version: blue    # ← Change to "green" to switch
  ports:
    - port: 80
      targetPort: 3000

deploy-blue-green:
  name: Blue-Green Deployment
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
 
    - name: Determine current and target color
      id: colors
      run: |
        CURRENT=$(kubectl get service myapp -n production \
          -o jsonpath='{.spec.selector.version}')
        TARGET=$([ "$CURRENT" = "blue" ] && echo "green" || echo "blue")
        echo "current=$CURRENT" >> $GITHUB_OUTPUT
        echo "target=$TARGET" >> $GITHUB_OUTPUT
        echo "Current: $CURRENT → Target: $TARGET"
 
    - name: Deploy to target environment
      run: |
        TARGET=${{ steps.colors.outputs.target }}
 
        kubectl set image deployment/myapp-$TARGET \
          myapp=myregistry.io/myapp:${{ github.sha }} \
          -n production
 
        kubectl rollout status deployment/myapp-$TARGET \
          -n production --timeout=5m
 
    - name: Test target environment
      run: |
        TARGET=${{ steps.colors.outputs.target }}
 
        # Get internal service URL for testing
        kubectl run smoke-test --rm -i --restart=Never \
          --image=curlimages/curl:latest \
          -n production \
          -- curl -f http://myapp-$TARGET:3000/health
 
        echo "✅ Health check passed on $TARGET"
 
    - name: Switch traffic to target
      run: |
        TARGET=${{ steps.colors.outputs.target }}
 
        kubectl patch service myapp -n production \
          -p "{\"spec\":{\"selector\":{\"version\":\"$TARGET\"}}}"
 
        echo "✅ Traffic switched to $TARGET"
 
    - name: Verify switch
      run: |
        sleep 10
        curl -f https://myapp.com/health
        echo "✅ Production is healthy"
 
    - name: Rollback on failure
      if: failure()
      run: |
        CURRENT=${{ steps.colors.outputs.current }}
        echo "❌ Rolling back to $CURRENT..."
 
        kubectl patch service myapp -n production \
          -p "{\"spec\":{\"selector\":{\"version\":\"$CURRENT\"}}}"
 
        echo "✅ Rolled back to $CURRENT"

# Stable deployment (90% traffic)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-stable
spec:
  replicas: 9    # 9 out of 10 pods = 90%
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: myapp:v1.0.0
 
---
# Canary deployment (10% traffic)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-canary
spec:
  replicas: 1    # 1 out of 10 pods = 10%
  selector:
    matchLabels:
      app: myapp    # Same label = same service
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: myapp:v2.0.0
 
---
# Service routes to both (by label)
apiVersion: v1
kind: Service
metadata:
  name: myapp
spec:
  selector:
    app: myapp    # Matches BOTH deployments
  ports:
    - port: 80
      targetPort: 3000

# Istio VirtualService for precise traffic splitting
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: myapp
spec:
  hosts:
    - myapp.production.svc.cluster.local
  http:
    - route:
        - destination:
            host: myapp
            subset: stable
          weight: 95          # 95% to stable
        - destination:
            host: myapp
            subset: canary
          weight: 5           # 5% to canary
 
---
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: myapp
spec:
  host: myapp
  subsets:
    - name: stable
      labels:
        version: v1
    - name: canary
      labels:
        version: v2

deploy-canary:
  name: Canary Deployment
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
 
    # Step 1: Deploy canary (5%)
    - name: Deploy canary (5%)
      run: |
        kubectl set image deployment/myapp-canary \
          myapp=myregistry.io/myapp:${{ github.sha }} \
          -n production
        kubectl rollout status deployment/myapp-canary -n production
 
    # Step 2: Monitor canary for 5 minutes
    - name: Monitor canary (5 min)
      run: |
        echo "Monitoring canary for 5 minutes..."
        for i in $(seq 1 10); do
          sleep 30
 
          # Check error rate
          ERROR_RATE=$(curl -s "http://prometheus:9090/api/v1/query" \
            --data-urlencode 'query=rate(http_requests_total{status=~"5..",version="canary"}[1m]) / rate(http_requests_total{version="canary"}[1m]) * 100' \
            | jq -r '.data.result[0].value[1] // "0"')
 
          # Check latency
          LATENCY=$(curl -s "http://prometheus:9090/api/v1/query" \
            --data-urlencode 'query=histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{version="canary"}[1m]))' \
            | jq -r '.data.result[0].value[1] // "0"')
 
          echo "Check $i/10: Error rate: ${ERROR_RATE}%, P99 latency: ${LATENCY}s"
 
          # Abort if error rate > 5% or latency > 2s
          if (( $(echo "$ERROR_RATE > 5" | bc -l) )); then
            echo "❌ Error rate too high! Aborting canary."
            kubectl rollout undo deployment/myapp-canary -n production
            exit 1
          fi
 
          if (( $(echo "$LATENCY > 2.0" | bc -l) )); then
            echo "❌ Latency too high! Aborting canary."
            kubectl rollout undo deployment/myapp-canary -n production
            exit 1
          fi
        done
        echo "✅ Canary monitoring passed"
 
    # Step 3: Promote canary to stable
    - name: Promote to 100%
      run: |
        kubectl set image deployment/myapp-stable \
          myapp=myregistry.io/myapp:${{ github.sha }} \
          -n production
        kubectl rollout status deployment/myapp-stable -n production
 
        # Scale down canary
        kubectl scale deployment/myapp-canary --replicas=0 -n production
 
        echo "✅ Canary promoted to stable!"
 
    - name: Rollback on failure
      if: failure()
      run: |
        kubectl rollout undo deployment/myapp-canary -n production
        echo "✅ Canary rolled back"

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: myapp
spec:
  hosts:
    - myapp.com
  http:
    # Route beta users to v2
    - match:
        - headers:
            x-beta-user:
              exact: "true"
      route:
        - destination:
            host: myapp
            subset: v2
 
    # Route users with test cookie to v2
    - match:
        - headers:
            cookie:
              regex: ".*ab_group=B.*"
      route:
        - destination:
            host: myapp
            subset: v2
 
    # Everyone else gets v1
    - route:
        - destination:
            host: myapp
            subset: v1

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: myapp
spec:
  hosts:
    - myapp
  http:
    - route:
        - destination:
            host: myapp
            subset: v1
      mirror:
        host: myapp
        subset: v2
      mirrorPercentage:
        value: 100.0  # Mirror 100% of traffic

// Code deployed to production — but feature hidden
if (featureFlags.isEnabled('new-checkout')) {
  renderNewCheckout();  // Only for enabled users
} else {
  renderOldCheckout();  // Everyone else
}