Edge Computing + Backend: Edge Functions and Global Deployment

Goal

Edge computing is moving from concept to practice. By pushing computation to edge nodes closer to users, you can significantly reduce latency and improve user experience. This article explores edge computing in backend architecture and how to build globally deployed edge applications.

Background

Traditional Architecture vs Edge Architecture

Traditional Architecture:
User -> CDN -> Origin Server -> Database -> Response

Edge Architecture:
User -> Edge Node (Compute + Cache) -> Database -> Response

Edge Computing Advantages

| Dimension | Traditional | Edge | |-----------|-------------|------| | Latency | 100-500ms | 10-50ms | | Availability | Depends on origin | Distributed HA | | Cost | High origin cost | Pay-per-use | | Scalability | Vertical | Horizontal |

Major Edge Platforms

| Platform | Feature | Use Case | |----------|---------|----------| | Cloudflare Workers | Cost-effective, rich ecosystem | API, full-stack apps | | Vercel Edge Functions | Deep Next.js integration | Frontend apps | | Deno Deploy | Native TypeScript support | Modern web apps | | AWS Lambda@Edge | AWS ecosystem integration | Enterprise apps |

Edge Function Implementation

Cloudflare Workers

interface Env {
  DB: D1Database;
  KV: KVNamespace;
  AI: Ai;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
    
    if (url.pathname === '/api/users') return handleUsers(request, env);
    if (url.pathname === '/api/products') return handleProducts(request, env);
    
    return new Response('Not Found', { status: 404 });
  },
};

async function handleUsers(request: Request, env: Env): Promise<Response> {
  const cacheKey = new Request(request.url, request);
  const cache = caches.default;
  
  let response = await cache.match(cacheKey);
  if (response) return response;
  
  const users = await env.DB.prepare('SELECT * FROM users LIMIT 10').all();
  
  response = new Response(JSON.stringify(users.results), {
    headers: { 'Content-Type': 'application/json', 'Cache-Control': 'public, max-age=60' },
  });
  
  await cache.put(cacheKey, response.clone());
  return response;
}

async function handleProducts(request: Request, env: Env): Promise<Response> {
  const url = new URL(request.url);
  const query = url.searchParams.get('q');
  
  if (query) {
    const embedding = await env.AI.run('@cf/baai/bge-base-en-v1.5', { text: query });
    const results = await env.DB.prepare(
      `SELECT * FROM products ORDER BY vector_distance(embedding, ?) LIMIT 5`
    ).bind(JSON.stringify(embedding.data)).all();
    return new Response(JSON.stringify(results.results));
  }
  
  const products = await env.DB.prepare('SELECT * FROM products LIMIT 20').all();
  return new Response(JSON.stringify(products.results));
}

Deno Deploy

import { serve } from "https://deno.land/std@0.208.0/http/server.ts";

const DB_URL = Deno.env.get("DATABASE_URL")!;

serve(async (req: Request): Promise<Response> => {
  const url = new URL(req.url);
  
  if (url.pathname.startsWith("/api/image")) return handleImage(req);
  if (url.pathname.startsWith("/api/proxy")) return handleProxy(req);
  
  return new Response("Not Found", { status: 404 });
});

async function handleImage(req: Request): Promise<Response> {
  const url = new URL(req.url);
  const imageUrl = url.searchParams.get("url");
  const width = parseInt(url.searchParams.get("w") || "800");
  const quality = parseInt(url.searchParams.get("q") || "80");
  
  if (!imageUrl) return new Response("Missing url parameter", { status: 400 });
  
  const response = await fetch(imageUrl);
  const imageBlob = await response.blob();
  const processedImage = await processImage(imageBlob, width, quality);
  
  return new Response(processedImage, {
    headers: { "Content-Type": "image/webp", "Cache-Control": "public, max-age=31536000" },
  });
}

async function handleProxy(req: Request): Promise<Response> {
  const url = new URL(req.url);
  const targetUrl = url.searchParams.get("target");
  
  if (!targetUrl) return new Response("Missing target parameter", { status: 400 });
  
  return fetch(new Request(targetUrl, { method: req.method, headers: req.headers, body: req.body }));
}

Global Deployment Strategy

Database Design

CREATE TABLE users (
    id TEXT PRIMARY KEY,
    email TEXT UNIQUE NOT NULL,
    name TEXT,
    region TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_users_region ON users(region);

CREATE TABLE products (
    id TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    description TEXT,
    price DECIMAL(10, 2),
    stock INTEGER DEFAULT 0,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE cache_metadata (
    key TEXT PRIMARY KEY,
    region TEXT NOT NULL,
    value_hash TEXT NOT NULL,
    expires_at DATETIME NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Caching Strategy

class EdgeCache {
  private kv: KVNamespace;

  constructor(kv: KVNamespace) { this.kv = kv; }

  async get<T>(key: string): Promise<T | null> {
    const value = await this.kv.get(key, 'json');
    return value as T | null;
  }

  async set<T>(key: string, value: T, ttl: number = 3600): Promise<void> {
    await this.kv.put(key, JSON.stringify(value), { expirationTtl: ttl });
  }

  async getOrSet<T>(key: string, fetcher: () => Promise<T>, ttl: number = 3600): Promise<T> {
    const cached = await this.get<T>(key);
    if (cached) return cached;
    const value = await fetcher();
    await this.set(key, value, ttl);
    return value;
  }

  async multiLevelGet<T>(
    key: string,
    levels: Array<{ get: (k: string) => Promise<T | null>; set: (k: string, v: T) => Promise<void> }>
  ): Promise<T | null> {
    for (let i = 0; i < levels.length; i++) {
      const value = await levels[i].get(key);
      if (value) {
        for (let j = 0; j < i; j++) await levels[j].set(key, value);
        return value;
      }
    }
    return null;
  }
}

Data Synchronization

class EdgeSync {
  private regions: string[];
  private primaryRegion: string;

  constructor(regions: string[], primaryRegion: string) {
    this.regions = regions;
    this.primaryRegion = primaryRegion;
  }

  async write(key: string, value: any): Promise<void> {
    await this.writeToRegion(this.primaryRegion, key, value);
    
    const syncPromises = this.regions
      .filter(r => r !== this.primaryRegion)
      .map(region => this.syncToRegion(region, key, value));
    
    Promise.allSettled(syncPromises).then(results => {
      results.forEach((result, index) => {
        if (result.status === 'rejected') console.error(`Sync to region ${index} failed:`, result.reason);
      });
    });
  }

  async read(key: string, region: string): Promise<any> {
    const value = await this.readFromRegion(region, key);
    this.checkConsistency(key, region, value);
    return value;
  }

  private async writeToRegion(region: string, key: string, value: any): Promise<void> {
    await fetch(`https://${region}.api.example.com/sync`, {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key, value }),
    });
  }

  private async readFromRegion(region: string, key: string): Promise<any> {
    const response = await fetch(`https://${region}.api.example.com/data?key=${key}`);
    return response.json();
  }

  private async syncToRegion(region: string, key: string, value: any): Promise<void> {
    await this.writeToRegion(region, key, value);
  }

  private async checkConsistency(key: string, region: string, localValue: any): Promise<void> {
    const primaryValue = await this.readFromRegion(this.primaryRegion, key);
    if (JSON.stringify(localValue) !== JSON.stringify(primaryValue)) await this.syncToRegion(region, key, primaryValue);
  }
}

Advanced Scenarios

Edge AI Inference

async function handleAIRequest(request: Request, env: Env): Promise<Response> {
  const { text } = await request.json();
  const result = await env.AI.run('@cf/meta/llama-2-7b-chat-int8', {
    messages: [{ role: 'system', content: 'You are an assistant' }, { role: 'user', content: text }],
    max_tokens: 512,
  });
  return new Response(JSON.stringify(result));
}

async function getEmbedding(text: string, env: Env): Promise<number[]> {
  const result = await env.AI.run('@cf/baai/bge-base-en-v1.5', { text });
  return result.data[0];
}

async function classifyImage(image: ArrayBuffer, env: Env): Promise<any> {
  const result = await env.AI.run('@cf/microsoft/resnet-50', { image: [...new Uint8Array(image)] });
  return result;
}

Real-Time Collaboration

class EdgeWebSocket {
  private state: DurableObjectState;
  private sessions: Map<string, WebSocket> = new Map();

  constructor(state: DurableObjectState) { this.state = state; }

  async fetch(request: Request): Promise<Response> {
    if (request.headers.get('Upgrade') === 'websocket') return this.handleWebSocket(request);
    return new Response('Expected WebSocket', { status: 426 });
  }

  private handleWebSocket(request: Request): Response {
    const pair = new WebSocketPair();
    const [client, server] = [pair[0], pair[1]];
    this.handleSession(server);
    return new Response(null, { status: 101, webSocket: client });
  }

  private handleSession(ws: WebSocket): void {
    const sessionId = crypto.randomUUID();
    this.sessions.set(sessionId, ws);
    ws.accept();

    ws.addEventListener('message', (event) => { this.handleMessage(sessionId, event.data as string); });
    ws.addEventListener('close', () => {
      this.sessions.delete(sessionId);
      this.broadcast(JSON.stringify({ type: 'user_left', userId: sessionId }));
    });

    ws.send(JSON.stringify({ type: 'welcome', sessionId, users: Array.from(this.sessions.keys()) }));
  }

  private handleMessage(senderId: string, message: string): void {
    const data = JSON.parse(message);
    this.sessions.forEach((ws, sessionId) => {
      if (sessionId !== senderId) ws.send(JSON.stringify({ ...data, userId: senderId }));
    });
  }

  private broadcast(message: string): void {
    this.sessions.forEach((ws) => { ws.send(message); });
  }
}

Summary

Core value of edge computing in backend architecture:

1. Low Latency: Computation executes near users.
2. High Availability: Distributed architecture, no single point of failure.
3. Cost Optimization: Pay-per-use, no server maintenance.
4. Global Coverage: Easy global deployment.
5. AI Ready: Edge AI inference becomes possible.

Edge computing best practices:

• Choose the right edge platform
• Design good data synchronization strategies
• Implement multi-level caching
• Consider cold start optimization
• Monitoring and alerting

Edge computing is redefining backend architecture. As a backend engineer, understanding edge computing principles and practices will help you build faster, more reliable, and more scalable applications.