Blue-Green Deployment Strategy

Implement blue-green deployment: $ARGUMENTS

Current Infrastructure State

• Load balancer config: @nginx.conf or @haproxy.cfg or cloud LB configuration
• Current deployment: !curl -s https://api.example.com/version 2>/dev/null || echo "Version endpoint needed"
• Container orchestration: !kubectl get deployments 2>/dev/null || docker service ls 2>/dev/null || echo "Container platform detection needed"
• Health endpoints: !curl -s https://api.example.com/health 2>/dev/null | jq -r '.status // "Unknown"' || echo "Health check setup needed"
• DNS configuration: Check for DNS management capabilities

Task

Implement production-grade blue-green deployment with comprehensive validation and monitoring.

Blue-Green Architecture Components

1. Infrastructure Setup

Load Balancer Configuration (NGINX)

upstream blue {
    server blue-app-1:3000;
    server blue-app-2:3000;
    server blue-app-3:3000;
}

upstream green {
    server green-app-1:3000;
    server green-app-2:3000;
    server green-app-3:3000;
}

# Current active environment
upstream active {
    server blue-app-1:3000;
    server blue-app-2:3000;
    server blue-app-3:3000;
}

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://active;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Environment $environment;
        
        # Health check configuration
        proxy_connect_timeout 5s;
        proxy_send_timeout 5s;
        proxy_read_timeout 5s;
        
        # Retry configuration
        proxy_next_upstream error timeout invalid_header http_500 http_502 http_503;
        proxy_next_upstream_tries 2;
    }

    # Health check endpoint
    location /health {
        access_log off;
        proxy_pass http://active/health;
        proxy_connect_timeout 1s;
        proxy_send_timeout 1s;
        proxy_read_timeout 1s;
    }

    # Environment indicator
    location /environment {
        access_log off;
        return 200 $environment;
        add_header Content-Type text/plain;
    }
}

HAProxy Configuration

global
    daemon
    log 127.0.0.1:514 local0
    stats socket /var/run/haproxy.sock mode 600 level admin

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms
    option httplog
    option dontlognull

# Blue environment
backend blue_backend
    balance roundrobin
    option httpchk GET /health
    http-check expect status 200
    server blue1 blue-app-1:3000 check
    server blue2 blue-app-2:3000 check
    server blue3 blue-app-3:3000 check

# Green environment
backend green_backend
    balance roundrobin
    option httpchk GET /health
    http-check expect status 200
    server green1 green-app-1:3000 check
    server green2 green-app-2:3000 check
    server green3 green-app-3:3000 check

# Frontend with switching logic
frontend main_frontend
    bind *:80
    # Environment switching via ACL
    use_backend blue_backend if { var(txn.environment) -m str blue }
    use_backend green_backend if { var(txn.environment) -m str green }
    default_backend blue_backend  # Default to blue

# Stats interface
frontend stats
    bind *:8404
    stats enable
    stats uri /stats
    stats refresh 5s

2. Kubernetes Blue-Green Implementation

Blue-Green Service Management

# blue-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: app-service-blue
  labels:
    app: myapp
    environment: blue
spec:
  selector:
    app: myapp
    environment: blue
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

---
# green-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: app-service-green
  labels:
    app: myapp
    environment: green
spec:
  selector:
    app: myapp
    environment: green
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

---
# active-service.yaml (points to current active environment)
apiVersion: v1
kind: Service
metadata:
  name: app-service-active
  labels:
    app: myapp
    environment: active
spec:
  selector:
    app: myapp
    environment: blue  # Switch this to 'green' during deployment
  ports:
    - port: 80
      targetPort: 3000
  type: LoadBalancer

Blue-Green Deployments

# blue-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-blue
  labels:
    app: myapp
    environment: blue
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
      environment: blue
  template:
    metadata:
      labels:
        app: myapp
        environment: blue
    spec:
      containers:
      - name: app
        image: myapp:v1.0.0
        ports:
        - containerPort: 3000
        env:
        - name: ENVIRONMENT
          value: "blue"
        - name: VERSION
          value: "v1.0.0"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"

---
# green-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-green
  labels:
    app: myapp
    environment: green
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
      environment: green
  template:
    metadata:
      labels:
        app: myapp
        environment: green
    spec:
      containers:
      - name: app
        image: myapp:v1.1.0  # New version
        ports:
        - containerPort: 3000
        env:
        - name: ENVIRONMENT
          value: "green"
        - name: VERSION
          value: "v1.1.0"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"

3. Deployment Automation Scripts

Blue-Green Deployment Script

```bash

#!/bin/bash

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

source "$SCRIPT_DIR/config.sh"

Configuration

BLUE_ENV="blue"

GREEN_ENV="green"

HEALTH_CHECK_URL="${APP_URL}/health"

READY_CHECK_URL="${APP_URL}/ready"

VERSION_URL="${APP_URL}/version"

Colors for output

RED='\033[0;31m'

GREEN='\033[0;32m'

BLUE='\033[0;34m'

YELLOW='\033[1;33m'

NC='\033[0m' # No Color

log() {

echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}"

}

warn() {

echo -e "${YELLOW}[WARNING] $1${NC}"

}

error() {

echo -e "${RED}[ERROR] $1${NC}"

exit 1

}

Get current active environment

get_current_env() {

if kubectl get service app-service-active &>/dev/null; then

kubectl get service app-service-active -o jsonpath='{.spec.selector.environment}'

else

echo "blue" # Default to blue if service doesn't exist

fi

}

Get inactive environment (opposite of current)

get_inactive_env() {

local current_env=$1

if [ "$current_env" = "blue" ]; then

echo "green"

else

echo "blue"

fi

}

Deploy to inactive environment

deploy_to_inactive() {

local version=$1

local current_env=$(get_current_env)

local inactive_env=$(get_inactive_env "$current_env")

log "Current active environment: $current_env"

log "Deploying version $version to $inactive_env environment"

# Update deployment with new image

kubectl set image deployment/app-$inactive_env app=myapp:$version

# Wait for rollout to complete

log "Waiting for deployment rollout to complete..."

kubectl rollout status deployment/app-$inactive_env --timeout=600s

# Verify pods are running

log "Verifying pods are running..."

kubectl wait --for=condition=ready pod -l app=myapp,environment=$inactive_env --timeout=300s

log "Deployment to $inactive_env environment completed successfully"

}

Health check function

health_check() {

local env=$1

local service_url="http://app-service-$env.$NAMESPACE.svc.cluster.local"

log "Performing health check for $env environment..."

# Use kubectl port-forward for internal testing

kubectl port-forward service/app-service-$env 8080:80 &

local port_forward_pid=$!

sleep 5 # Wait for port-forward to establish

local health_status=1

local attempts=0

local max_attempts=10

while [ $attempts -lt $max_attempts ]; do

if curl -f -s http://localhost:8080/health > /dev/null; then

health_status=0

break

fi

attempts=$((attempts + 1))

log "Health check attempt $attempts/$max_attempts failed, retrying..."

sleep 10

done

# Clean up port-forward

kill $port_forward_pid 2>/dev/null || true

if [ $health_status -eq 0 ]; then

log "Health check passed for $env environment"

return 0

else

error "Health check failed for $env environment after $max_attempts attempts"

fi

}

Smoke tests

run_smoke_tests() {

local env=$1

log "Running smoke tests for $env environment..."

# Port-forward for testing

kubectl port-forward service/app-service-$env 8080:80 &

local port_forward_pid=$!

sleep 5

local test_results=()

# Test 1: Health endpoint

if curl -f -s http://localhost:8080/health | jq -e '.status == "healthy"' > /dev/null; then

test_results+=("✅ Health endpoint")

else

test_results+=("❌ Health endpoint")

fi

# Test 2: Version endpoint

if curl -f -s http://localhost:8080/version > /dev/null; then

test_results+=("✅ Version endpoint")

else

test_results+=("❌ Version endpoint")

fi

# Test 3: Main application endpoint

if curl -f -s http://localhost:8080/ > /dev/null; then

test_results+=("✅ Main endpoint")

else

test_results+=("❌ Main endpoint")

fi

# Test 4: Database connectivity (if applicable)

if curl -f -s http://localhost:8080/db-health 2>/dev/null | jq -e '.connected == true' > /dev/null; then

test_results+=("✅ Database connectivity")

else

test_results+=("⚠️ Database connectivity (not tested)")

fi

# Clean up port-forward

kill $port_forward_pid 2>/dev/null || true

# Display results

log "Smoke test results for $env:"

printf '%s\n' "${test_results[@]}"

# Check if all critical tests passed

local failed_tests=$(printf '%s\n' "${test_results[@]}" | grep -c "❌" || true)

if [ "$failed_tests" -gt 0 ]; then

error "Smoke tests failed with $failed_tests failures"

fi

log "All smoke tests passed for $env environment"

}

Switch traffic to new environment

switch_traffic() {

local target_env=$1

local current_env=$(get_current_env)

if [ "$target_env" = "$current_env" ]; then

warn "Target environment ($target_env) is already active"

return 0

fi

log "Switching traffic from $current_env to $target_env"

# Create backup of current service configuration

kubectl get service app-service-active -o yaml > "/tmp/service-backup-$(date +%Y%m%d-%H%M%S).yaml"

# Update service selector to point to new environment

kubectl patch service app-service-active -p '{"spec":{"selector":{"environment":"'$target_env'"}}}'

# Verify the switch

sleep 10

local new_active_env=$(get_current_env)

if