# Project structure
.
├── docker-compose.blue.yml
├── docker-compose.green.yml
├── nginx/
│   ├── nginx.conf
│   └── sites/
│       ├── blue-upstream.conf
│       └── green-upstream.conf
└── services/
    ├── payment-api/
    ├── notification-worker/
    └── analytics-api/

#!/bin/bash
# deploy-blue-green.sh - Blue-green deployment automation

set -e

ENVIRONMENT=${1:-green}
CURRENT_ENV=$(cat .current_deployment 2>/dev/null || echo "blue")
NEW_ENV="green"

if [ "$CURRENT_ENV" = "green" ]; then
    NEW_ENV="blue"
fi

echo "Current deployment: $CURRENT_ENV"
echo "Deploying to: $NEW_ENV"

# Step 1: Build new environment
echo "Building $NEW_ENV environment..."
docker compose -f docker-compose.${NEW_ENV}.yml build --no-cache

# Step 2: Start new environment
echo "Starting $NEW_ENV environment..."
docker compose -f docker-compose.${NEW_ENV}.yml up -d

# Step 3: Wait for services to be ready
echo "Waiting for services to be healthy..."
sleep 30

# Step 4: Health checks
echo "Running health checks on $NEW_ENV..."
HEALTH_CHECKS=(
    "http://localhost:8101/health"  # payment-api-green
    "http://localhost:8103/health"  # analytics-api-green
)

for url in "${HEALTH_CHECKS[@]}"; do
    for i in {1..30}; do
        if curl -f -s "$url" > /dev/null; then
            echo "✓ $url healthy"
            break
        fi
        if [ $i -eq 30 ]; then
            echo "✗ $url failed health check"
            echo "Deployment aborted"
            docker compose -f docker-compose.${NEW_ENV}.yml down
            exit 1
        fi
        echo "Waiting for $url... ($i/30)"
        sleep 2
    done
done

# Step 5: Run smoke tests
echo "Running smoke tests on $NEW_ENV..."
./src/scripts/smoke-tests.sh "$NEW_ENV" || {
    echo "Smoke tests failed. Rolling back."
    docker compose -f docker-compose.${NEW_ENV}.yml down
    exit 1
}

# Step 6: Switch traffic
echo "Switching traffic to $NEW_ENV..."
cat > nginx/sites/active-deployment.conf <<EOF
# Active deployment: $NEW_ENV
upstream payment_api_active {
    server payment-api-${NEW_ENV}:8001;
}

upstream analytics_api_active {
    server analytics-api-${NEW_ENV}:8003;
}
EOF

# Reload nginx
docker exec myapp_nginx nginx -s reload

echo "Traffic switched to $NEW_ENV"

# Step 7: Monitor new environment
echo "Monitoring $NEW_ENV for 60 seconds..."
sleep 60

# Step 8: Verify no errors
ERROR_COUNT=$(docker logs myapp_payment_api_${NEW_ENV} --since 60s 2>&1 | grep -i error | wc -l || true)
if [ "$ERROR_COUNT" -gt 10 ]; then
    echo "⚠ High error count detected: $ERROR_COUNT"
    echo "Consider rolling back with: ./deploy-blue-green.sh rollback"
    exit 1
fi

# Step 9: Stop old environment
echo "Stopping old $CURRENT_ENV environment..."
docker compose -f docker-compose.${CURRENT_ENV}.yml down

# Step 10: Update current deployment
echo "$NEW_ENV" > .current_deployment

echo "✓ Deployment complete!"
echo "  Active: $NEW_ENV"
echo "  Previous: $CURRENT_ENV (stopped)"

#!/bin/bash
# rollback-blue-green.sh - Instant rollback

set -e

CURRENT_ENV=$(cat .current_deployment)
PREVIOUS_ENV="blue"

if [ "$CURRENT_ENV" = "blue" ]; then
    PREVIOUS_ENV="green"
fi

echo "Rolling back from $CURRENT_ENV to $PREVIOUS_ENV"

# Start previous environment (if not running)
docker compose -f docker-compose.${PREVIOUS_ENV}.yml up -d

# Wait for services
echo "Waiting for services..."
sleep 20

# Switch traffic
cat > nginx/sites/active-deployment.conf <<EOF
# Active deployment: $PREVIOUS_ENV (rollback)
upstream payment_api_active {
    server payment-api-${PREVIOUS_ENV}:8001;
}

upstream analytics_api_active {
    server analytics-api-${PREVIOUS_ENV}:8003;
}
EOF

docker exec myapp_nginx nginx -s reload

echo "$PREVIOUS_ENV" > .current_deployment
echo "✓ Rollback complete to $PREVIOUS_ENV"

#!/bin/bash
# switch-k8s.sh - Switch traffic between blue/green in Kubernetes

CURRENT=$(kubectl get service payment-api -n myapp -o jsonpath='{.spec.selector.version}')
NEW="green"

if [ "$CURRENT" = "green" ]; then
    NEW="blue"
fi

echo "Switching from $CURRENT to $NEW"

# Update service selector
kubectl patch service payment-api -n myapp -p "{\"spec\":{\"selector\":{\"version\":\"$NEW\"}}}"

echo "✓ Traffic switched to $NEW"

# Verify
sleep 10
kubectl get endpoints payment-api -n myapp

# 1. Deploy to green environment
./deploy-blue-green.sh green

# What it does:
# - Builds new Docker images
# - Starts green containers
# - Waits for health checks (30s)
# - Runs smoke tests
# - Switches nginx to green
# - Monitors for 60s
# - Stops blue containers

# 2. If issues detected, rollback instantly
./rollback-blue-green.sh

# Rollback is instant because:
# - Blue environment still exists
# - Just switch nginx upstream
# - No rebuild needed

#!/bin/bash
# migrate-blue-green.sh

# Phase 1: Backward-compatible migration (before deployment)
echo "Running backward-compatible migrations..."
docker exec myapp_postgres psql -U postgres -d myapp_db <<EOF
-- Add new column (nullable)
ALTER TABLE payments ADD COLUMN new_field VARCHAR(255);

-- Add index in background
CREATE INDEX CONCURRENTLY idx_payments_new ON payments(new_field);
EOF

# Phase 2: Deploy green environment
./deploy-blue-green.sh green

# Green is live, blue still works with nullable column

# Phase 3: After verification, make column required (optional)
docker exec myapp_postgres psql -U postgres -d myapp_db <<EOF
-- Only after green is stable
ALTER TABLE payments ALTER COLUMN new_field SET NOT NULL;
EOF

# Phase 4: Remove blue environment
docker compose -f docker-compose.blue.yml down

# For breaking changes, use maintenance mode:

# 1. Enable maintenance mode
cat > nginx/sites/maintenance.conf <<EOF
server {
    listen 443 ssl http2;
    server_name payment-api.example.com;
    return 503 "Maintenance in progress";
}
EOF

docker exec myapp_nginx nginx -s reload

# 2. Run breaking migration
docker exec myapp_postgres psql -U postgres -d myapp_db < breaking-migration.sql

# 3. Deploy new version
./deploy-blue-green.sh green

# 4. Disable maintenance mode
# (switching to green automatically restores service)

# Monitor key metrics during blue-green switch
watch -n 1 '
echo "=== Container Status ==="
docker ps --filter "label=service=payment-api" --format "table {{.Names}}\t{{.Status}}"

echo ""
echo "=== Health Checks ==="
curl -s http://localhost:8001/health | jq .status
curl -s http://localhost:8101/health | jq .status

echo ""
echo "=== Active Nginx Upstream ==="
docker exec myapp_nginx cat /etc/nginx/sites/active-deployment.conf | grep "server payment"

echo ""
echo "=== Error Rates ==="
docker logs myapp_payment_api_blue --since 60s 2>&1 | grep -c ERROR || echo 0
docker logs myapp_payment_api_green --since 60s 2>&1 | grep -c ERROR || echo 0
'