Zero-Downtime Blue-Green Deployments on Edge Infrastructure

Modern Deployment Constraints: The DNS Propagation Bottleneck

Traditional zero-downtime deployment strategies rely on shifting traffic at the load balancer or modifying DNS records to point to a new release. However, DNS changes are slow to propagate due to client-side caching and varying Time-To-Live (TTL) settings.

If a new deployment fails, rolling back via DNS can take hours, exposing users to bugs or broken services. Edge-native routing resolves this limitation by intercepting incoming requests at the network edge and routing them dynamically based on configurations stored in local, fast-replicating key-value databases.

Edge-Native Routing Architecture for Blue-Green Switches

By routing traffic through edge workers, developers can split traffic between two active application stacks (Blue and Green) instantly. The edge worker inspects a configuration variable (e.g., active target weights) stored in a global KV store.

Requests are then routed to the corresponding destination URL. Since the worker runs within the request path, changing the KV configuration updates routing globally in seconds, bypassing DNS caching completely.

• Dynamic Traffic Routing: Diverts incoming requests to specific backends based on real-time configuration values.
• Session Affinity: Tracks user assignments using secure cookies to prevent users from bouncing between versions during a session.
• Canary Rollouts: Increments traffic allocations (e.g., 5% green, 95% blue) to monitor new code before deploying to all users.

Implementing a Dynamic Traffic Router Worker

The following TypeScript code illustrates a Cloudflare Worker that dynamically splits traffic between Blue and Green environments using a configuration stored in Workers KV. The worker also implements session affinity using a cookie, ensuring users remain on the same version throughout their session:

export interface Env {
  DEPLOYMENT_KV: KVNamespace;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // Retrieve the active deployment configuration from the KV store
    const configStr = await env.DEPLOYMENT_KV.get("routing_config");
    const config = configStr
      ? JSON.parse(configStr)
      : {
          blueWeight: 100,
          blueUrl: "https://blue.example.com",
          greenUrl: "https://green.example.com",
        };

    const cookies = request.headers.get("Cookie") || "";
    let deployment = "";

    // Verify if the client has a session affinity cookie
    if (cookies.includes("deploy-env=blue")) {
      deployment = "blue";
    } else if (cookies.includes("deploy-env=green")) {
      deployment = "green";
    } else {
      // Determine routing based on weights
      const random = Math.random() * 100;
      deployment = random < config.blueWeight ? "blue" : "green";
    }

    const targetUrl = deployment === "blue" ? config.blueUrl : config.greenUrl;
    const url = new URL(request.url);
    const destination = `${targetUrl}${url.pathname}${url.search}`;

    // Reconstruct request with the target destination URL
    const modifiedRequest = new Request(destination, {
      method: request.method,
      headers: request.headers,
      body: request.body,
    });

    const response = await fetch(modifiedRequest);

    // Set cookie to maintain session affinity
    const newResponse = new Response(response.body, response);
    newResponse.headers.append(
      "Set-Cookie",
      `deploy-env=${deployment}; Path=/; Max-Age=3600; SameSite=Lax`
    );
    newResponse.headers.set("X-Deployment-Environment", deployment);

    return newResponse;
  }
};

Automated Health-Checking and Instant Rollback Triggers

To automate the deployment pipeline, developers can configure telemetry endpoints and health checkers. When a new release (Green) is deployed, automated test suites and error tracking scripts monitor performance. If error rates or response latencies on the Green stack exceed acceptable thresholds, a monitoring service triggers a webhook that updates the KV routing_config file, reverting the Blue weight back to 100% instantly.

Custom Edge Routing Pipelines with Bramsley

Building resilient, instant-rollback deployment pipelines at the edge demands tight integration across global key-value stores and performant worker runtimes. Bramsley designs tailored routing architectures to eliminate release friction.