Blue-Green-Deployments: Releases ohne Ausfallzeit

# ❌ Single environment — downtime during deployment
upstream api {
  server api-v1:3000;
  # During deployment: stop v1, start v2, hope for the best
}
 
# ✅ Blue-green with nginx — traffic switch via config reload
# blue is currently live
upstream api_blue {
  server api-blue-1:3000;
  server api-blue-2:3000;
  server api-blue-3:3000;
}
 
upstream api_green {
  server api-green-1:3000;
  server api-green-2:3000;
  server api-green-3:3000;
}
 
# Point to the active environment
upstream api_active {
  server api-blue-1:3000;
  server api-blue-2:3000;
  server api-blue-3:3000;
}
 
server {
  listen 80;
  location / {
    proxy_pass http://api_active;
  }
}

import {
  ElasticLoadBalancingV2Client,
  ModifyListenerCommand,
  DescribeTargetHealthCommand,
} from "@aws-sdk/client-elastic-load-balancing-v2";
 
const elbClient = new ElasticLoadBalancingV2Client({});
 
async function switchTraffic(
  listenerArn: string,
  targetGroupArn: string
): Promise<void> {
  // Verify all targets in the new group are healthy
  const healthResponse = await elbClient.send(
    new DescribeTargetHealthCommand({ TargetGroupArn: targetGroupArn })
  );
 
  const unhealthy = healthResponse.TargetHealthDescriptions?.filter(
    (t) => t.TargetHealth?.State !== "healthy"
  );
 
  if (unhealthy && unhealthy.length > 0) {
    throw new Error(
      `Cannot switch: ${unhealthy.length} unhealthy targets in new group`
    );
  }
 
  // Switch the listener to the new target group
  await elbClient.send(
    new ModifyListenerCommand({
      ListenerArn: listenerArn,
      DefaultActions: [
        {
          Type: "forward",
          TargetGroupArn: targetGroupArn,
        },
      ],
    })
  );
 
  console.log(`Traffic switched to ${targetGroupArn}`);
}

// ❌ Deploy and switch immediately
async function deploy() {
  await deployToGreen(newVersion);
  await switchTraffic(greenTargetGroup); // No verification!
}
 
// ✅ Deploy, verify, then switch
async function deploy() {
  await deployToGreen(newVersion);
 
  // Run smoke tests against the green environment directly
  const smokeTestResults = await runSmokeTests({
    baseUrl: "http://green-internal.example.com",
    tests: [
      { name: "health", method: "GET", path: "/health", expectedStatus: 200 },
      { name: "auth", method: "POST", path: "/api/auth/verify", expectedStatus: 200 },
      { name: "list-items", method: "GET", path: "/api/items?limit=1", expectedStatus: 200 },
    ],
    timeoutMs: 5000,
  });
 
  if (smokeTestResults.failures.length > 0) {
    console.error("Smoke tests failed:", smokeTestResults.failures);
    throw new Error("Aborting deployment: smoke tests failed on green environment");
  }
 
  // Verify response schema matches expectations
  const schemaValid = await validateResponseSchema({
    baseUrl: "http://green-internal.example.com",
    endpoints: ["/api/items", "/api/users/me"],
  });
 
  if (!schemaValid) {
    throw new Error("Aborting deployment: API schema validation failed");
  }
 
  await switchTraffic(greenTargetGroup);
  console.log("Deployment complete — traffic now on green");
}

// ❌ Breaking migration — blue can't work with green's schema
// Migration: RENAME COLUMN users.name TO users.full_name
// Blue environment immediately breaks because it still queries "name"
 
// ✅ Two-phase migration — compatible with both versions
// Phase 1: Add new column (deploy with green)
// Migration: ALTER TABLE users ADD COLUMN full_name VARCHAR(255);
// Backfill: UPDATE users SET full_name = name WHERE full_name IS NULL;
// Green reads from full_name, Blue continues reading from name
 
// Phase 2: Remove old column (only after blue is decommissioned)
// Migration: ALTER TABLE users DROP COLUMN name;
// This runs only after confirming no environment reads "name"
 
interface MigrationPhase {
  step: number;
  migration: string;
  compatible_versions: string[];
  safe_to_rollback: boolean;
}
 
const migrationPlan: MigrationPhase[] = [
  {
    step: 1,
    migration: "ALTER TABLE users ADD COLUMN full_name VARCHAR(255)",
    compatible_versions: ["v1.2.0", "v1.3.0"],
    safe_to_rollback: true,
  },
  {
    step: 2,
    migration: "UPDATE users SET full_name = name WHERE full_name IS NULL",
    compatible_versions: ["v1.2.0", "v1.3.0"],
    safe_to_rollback: true,
  },
  {
    step: 3,
    migration: "ALTER TABLE users DROP COLUMN name",
    compatible_versions: ["v1.3.0"],  // Only after v1.2.0 is gone
    safe_to_rollback: false,
  },
];

# Current state: green is live (v1.3.0), blue still has v1.2.0
# Problem detected in v1.3.0
 
# Instant rollback — switch back to blue
aws elbv2 modify-listener \
  --listener-arn "$LISTENER_ARN" \
  --default-actions "Type=forward,TargetGroupArn=$BLUE_TARGET_GROUP"
 
# Rollback complete in seconds — no redeployment needed
# Blue is still running v1.2.0 exactly as it was
 
# Investigate, fix, and redeploy to green when ready