Edge Functions Deployment

Cloudflare Workers execute JavaScript at over 300 edge locations with zero cold starts. We set up your Workers project with Wrangler, KV namespaces, Durable Objects, and R2 storage bindings.

# wrangler.toml
name = "api-router"
main = "src/index.ts"
compatibility_date = "2024-12-01"

[env.production]
vars = { ENVIRONMENT = "production" }
kv_namespaces = [
  { binding = "CACHE", id = "abc123", preview_id = "def456" }
]
r2_buckets = [
  { binding = "ASSETS", bucket_name = "prod-assets" }
]

[[env.production.routes]]
pattern = "api.yourdomain.com/*"
zone_name = "yourdomain.com"

[observability]
enabled = true

// src/index.ts — Edge API router
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
    
    // Check KV cache first
    const cached = await env.CACHE.get(url.pathname, 'json');
    if (cached) {
      return Response.json(cached, {
        headers: { 'X-Cache': 'HIT', 'Cache-Control': 's-maxage=60' }
      });
    }

    // Route to origin
    const origin = await fetch(`https://origin.internal${url.pathname}`, {
      headers: request.headers,
    });
    
    // Cache successful responses
    if (origin.ok) {
      const data = await origin.json();
      await env.CACHE.put(url.pathname, JSON.stringify(data), {
        expirationTtl: 300
      });
      return Response.json(data, { headers: { 'X-Cache': 'MISS' } });
    }
    return origin;
  }
};

We configure custom domains, rate limiting rules, and Cloudflare Access policies for authenticated endpoints. Workers Analytics provides request volume and error rate dashboards out of the box.

For AWS-native stacks, we deploy Lambda@Edge functions that run at CloudFront edge locations. Common use cases include A/B testing, authentication, URL rewriting, and dynamic content generation.

resource "aws_lambda_function" "edge_auth" {
  function_name = "edge-auth"
  runtime       = "nodejs20.x"
  handler       = "index.handler"
  role          = aws_iam_role.edge_lambda.arn
  publish       = true  # Required for Lambda@Edge
  provider      = aws.us-east-1  # Must be us-east-1

  filename         = data.archive_file.edge_auth.output_path
  source_code_hash = data.archive_file.edge_auth.output_base64sha256
}

resource "aws_cloudfront_distribution" "main" {
  default_cache_behavior {
    lambda_function_association {
      event_type   = "viewer-request"
      lambda_arn   = aws_lambda_function.edge_auth.qualified_arn
      include_body = false
    }
  }
}

Lambda@Edge has specific constraints: maximum 5-second timeout for viewer events, no environment variables (use SSM Parameter Store with region-aware lookups), and deployment in us-east-1 only. We handle all of these nuances in the Terraform configuration.

If your frontend is on Vercel, we configure Edge Functions for middleware, API routes, and dynamic rendering. Edge middleware runs before every request and executes in under 5ms for tasks like geolocation-based routing, bot detection, and feature flags.

// middleware.ts — Vercel Edge Middleware
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export const config = { matcher: ['/api/:path*', '/app/:path*'] };

export function middleware(request: NextRequest) {
  const country = request.geo?.country || 'US';
  const response = NextResponse.next();
  
  // Add geo headers for downstream handlers
  response.headers.set('X-User-Country', country);
  
  // EU users → EU origin
  if (['DE','FR','NL','SE','FI','IT','ES'].includes(country)) {
    const euUrl = new URL(request.url);
    euUrl.hostname = 'eu-origin.yourdomain.com';
    return NextResponse.rewrite(euUrl);
  }
  
  // Rate limiting via Edge Config
  const ip = request.ip || 'unknown';
  response.headers.set('X-Client-IP', ip);
  
  return response;
}

We also configure Edge Config for feature flags and A/B tests that update instantly across all edge locations without redeployment.

Edge functions are difficult to debug in production because they run across hundreds of locations simultaneously. We set up comprehensive observability:

• Structured logging — JSON logs with request ID, edge location, latency, and cache status
• Error tracking — Sentry or Logflare integration for real-time alerting
• Canary deployments — Cloudflare Workers gradual rollout or Lambda@Edge version-based traffic splitting
• Tail workers — Cloudflare tail workers for real-time log streaming during incidents

# Cloudflare Workers gradual rollout via Wrangler
wrangler versions upload
wrangler versions deploy \
  --version-id abc123:90% \
  --version-id def456:10%   # Canary at 10%

# Monitor error rate, then promote
wrangler versions deploy \
  --version-id def456:100%  # Full rollout

Rollbacks are instant — under 30 seconds for Cloudflare Workers, under 5 minutes for Lambda@Edge (due to CloudFront propagation). We document the rollback procedure in your runbook so any team member can execute it during an incident.