edge-computing

Edge Computing

Comprehensive guide to edge computing architecture - running compute closer to users for lower latency and better performance.

When to Use This Skill

• Designing edge function architectures
• Deciding where to place compute (edge vs origin)
• Implementing serverless at edge
• Understanding edge platform capabilities
• Optimizing latency-sensitive applications
• Building globally distributed applications

Edge Computing Fundamentals

What is Edge Computing?

Compute Placement Spectrum:

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  User Device    Edge     Regional    Central    Origin     │
│  (Client)       (CDN)    (Cloud)     (Cloud)    (Cloud)    │
│                                                             │
│     ◄──────────────────────────────────────────────────►   │
│                                                             │
│  Lowest         ┌─────────────────────────────┐  Highest   │
│  Latency        │      EDGE COMPUTING         │  Latency   │
│                 │  (This skill's focus)       │            │
│                 └─────────────────────────────┘            │
│                                                             │
│  Limited        ◄─────────────────────────────►  Full      │
│  Resources                                       Resources  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Edge = Running code on CDN/network edge servers (100s of locations)
vs Regional = Running in a few cloud regions (10-20 locations)
vs Origin = Running in one primary location (1-3 locations)

Edge vs Serverless vs Traditional

Comparison:

                    Edge Functions    Cloud Functions    Containers/VMs
────────────────────────────────────────────────────────────────────────
Locations           100-300+          10-20             1-10
Cold Start          <50ms             100ms-seconds     N/A (always warm)
Execution Limit     10-30 seconds     15 minutes        Unlimited
Memory              128MB-1GB         256MB-10GB        Unlimited
CPU                 Limited           Standard          Full control
State               Stateless         Stateless         Stateful OK
Cost Model          Per request       Per request       Per instance
Best For            Low-latency,      General compute   Complex apps,
                    simple logic                        long-running

Use Cases by Type:
Edge: Auth, routing, personalization, A/B tests, redirects
Cloud Functions: APIs, webhooks, background processing
Containers: Full applications, databases, ML inference

Edge Platform Architecture

Edge Platform Components:

┌─────────────────────────────────────────────────────────────┐
│                    Control Plane                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ Deploy   │  │  Config  │  │ Secrets  │  │ Metrics  │   │
│  │ API      │  │  Store   │  │  Mgmt    │  │ & Logs   │   │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘   │
└───────┼─────────────┼─────────────┼─────────────┼──────────┘
        │             │             │             │
        └─────────────┼─────────────┼─────────────┘
                      │             │
        ╔═════════════╧═════════════╧═════════════╗
        ║           Global Distribution            ║
        ╚═════════════════════════════════════════╝
                      │
    ┌─────────────────┼─────────────────┐
    │                 │                 │
┌───▼───┐        ┌───▼───┐        ┌───▼───┐
│ Edge  │        │ Edge  │        │ Edge  │
│ POP 1 │        │ POP 2 │        │ POP N │
│┌─────┐│        │┌─────┐│        │┌─────┐│
││ V8  ││        ││ V8  ││        ││ V8  ││
││Isol.││        ││Isol.││        ││Isol.││
│└─────┘│        │└─────┘│        │└─────┘│
└───────┘        └───────┘        └───────┘

Execution Model:
- V8 Isolates: Lightweight isolation (not containers)
- Instant cold start (sub-50ms)
- Per-request execution
- Auto-scaled per POP

Edge Function Patterns

Request Interception

Request/Response Lifecycle:

User Request ──► Edge Function ──► Origin (optional)
                      │
              ┌───────┴───────┐
              │               │
         Modify Request   Short-circuit
         (continue to    (return response
          origin)         from edge)

Use Cases:

1. URL Rewriting
   /old-page → /new-page
   /api/v1/* → /api/v2/*

2. Header Manipulation
   Add security headers
   Add request ID
   Normalize Accept-Language

3. Authentication
   Validate JWT at edge
   Check API key
   Redirect to login

4. A/B Testing
   Assign cohort
   Rewrite to variant URL

5. Bot Protection
   Challenge bots
   Block known bad actors

6. Geolocation Routing
   Route to regional origin
   Apply regional rules

Response Transformation

Response Transformation Patterns:

1. HTML Injection
   ┌─────────────────────────────────────────┐
   │ Inject analytics, A/B test scripts     │
   │ Add personalized content               │
   │ Insert GDPR banners by region          │
   └─────────────────────────────────────────┘

2. Content Optimization
   ┌─────────────────────────────────────────┐
   │ Compress responses                      │
   │ Image optimization/resizing            │
   │ Minification                           │
   └─────────────────────────────────────────┘

3. Response Caching
   ┌─────────────────────────────────────────┐
   │ Cache API responses at edge            │
   │ Assemble from cache fragments          │
   │ Serve stale while revalidating         │
   └─────────────────────────────────────────┘

4. Error Handling
   ┌─────────────────────────────────────────┐
   │ Fallback pages on origin error         │
   │ Custom error pages per region          │
   │ Retry logic with backoff               │
   └─────────────────────────────────────────┘

Edge Storage Patterns

Edge Storage Options:

1. Key-Value Store (KV)
   ├── Read-heavy workloads
   ├── Eventually consistent
   ├── Low latency reads
   └── Limited write throughput

   Use: Feature flags, configuration, user sessions

2. Durable Objects (Cloudflare)
   ├── Strong consistency
   ├── Stateful edge compute
   ├── Single-instance per ID
   └── WebSocket support

   Use: Real-time collaboration, chat, gaming state

3. Edge Databases
   ├── Distributed SQL (PlanetScale, Turso)
   ├── Read replicas at edge
   ├── Low latency reads
   └── Write to primary region

   Use: User data, product catalogs, CMS

4. R2/S3-Compatible Storage
   ├── Object storage at edge
   ├── No egress fees (some providers)
   └── Large file storage

   Use: Static assets, user uploads, backups

Compute Placement Decisions

Decision Framework

Where Should This Run?

Question 1: Latency Requirements
├── <50ms required? → Edge
├── <200ms acceptable? → Regional cloud
└── Latency not critical? → Central origin

Question 2: Compute Complexity
├── Simple transformations? → Edge
├── Moderate logic? → Edge or Regional
└── Complex processing? → Regional or Central

Question 3: Data Dependencies
├── No data needed? → Edge
├── Read-heavy, cacheable? → Edge with cache
├── Strong consistency needed? → Regional
└── Write-heavy? → Central

Question 4: State Requirements
├── Stateless? → Edge
├── Session state? → Edge with KV/Durable Objects
└── Complex state? → Regional or Central

Question 5: Cost Sensitivity
├── High request volume, simple? → Edge (efficient)
├── CPU-intensive? → Regional (cheaper)
└── Long-running? → Central

Hybrid Architecture

Hybrid Edge + Origin Architecture:

┌─────────────────────────────────────────────────────────────┐
│                        Edge Layer                            │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  • Authentication/Authorization                     │    │
│  │  • Rate limiting                                    │    │
│  │  • Request routing                                  │    │
│  │  • Static content                                   │    │
│  │  • Simple personalization                           │    │
│  │  • Caching logic                                    │    │
│  └─────────────────────────────────────────────────────┘    │
└────────────────────────────┬────────────────────────────────┘
                             │
                  Only complex requests pass through
                             │
┌────────────────────────────▼────────────────────────────────┐
│                       Origin Layer                           │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  • Business logic                                   │    │
│  │  • Database operations                              │    │
│  │  • Third-party integrations                         │    │
│  │  • ML inference                                     │    │
│  │  • Complex computations                             │    │
│  └─────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────┘

Benefits:
- Offload work from origin
- Faster responses for simple requests
- Origin protected from attack traffic
- Scale each layer independently

Edge Platforms

Cloudflare Workers

Cloudflare Workers:

Execution:
- V8 isolates (not containers)
- <5ms cold start
- 200+ edge locations
- 10ms CPU time (free) / 30s (paid)

Features:
├── Workers KV (key-value store)
├── Durable Objects (stateful)
├── R2 (object storage)
├── D1 (SQLite at edge)
├── Queues (async processing)
└── Hyperdrive (database connection pooling)

Example:
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);

    // Simple routing
    if (url.pathname.startsWith('/api/')) {
      return handleAPI(request, env);
    }

    // Serve static
    return env.ASSETS.fetch(request);
  }
}

AWS Lambda@Edge / CloudFront Functions

AWS Edge Options:

CloudFront Functions:
├── JavaScript only
├── Sub-millisecond start
├── 2MB memory
├── Request/response manipulation only
├── Cannot make network calls
└── Very cheap at scale

Lambda@Edge:
├── Node.js, Python
├── 128-3008MB memory
├── Up to 30s execution (origin response)
├── Can make network calls
├── Access to AWS services
└── Higher latency than CF Functions

Use Case Mapping:
CloudFront Functions: Headers, redirects, URL rewrites
Lambda@Edge: Auth, A/B testing, dynamic responses
Lambda (Regional): Full API logic, database access

Fastly Compute@Edge

Fastly Compute@Edge:

Execution:
- WebAssembly-based (Wasm)
- Multi-language (Rust, JS, Go, etc.)
- No cold start (pre-compiled)
- 50ms-120s execution time

Features:
├── Geolocation data
├── Device detection
├── Real-time logging
├── Edge dictionaries
└── Origin fetch with caching

Strengths:
- Best for dynamic content
- Real-time purging
- Advanced caching control
- Strong VCL migration path

Example (Rust):
use fastly::{Request, Response};

#[fastly::main]
fn main(req: Request) -> Result<Response, Error> {
    match req.get_path() {
        "/api" => handle_api(req),
        _ => Ok(req.send("origin")?)
    }
}

Best Practices

Edge Computing Best Practices:

1. Keep It Simple
   □ Edge = simple, fast operations
   □ Complex logic → origin
   □ Minimize dependencies
   □ Fail fast and gracefully

2. Optimize Cold Start
   □ Minimize code size
   □ Lazy load where possible
   □ Use global scope for init
   □ Avoid heavy dependencies

3. Handle Failures
   □ Origin unavailable handling
   □ Timeout handling
   □ Fallback responses
   □ Error tracking

4. Monitor Everything
   □ Latency percentiles
   □ Error rates
   □ Cold start frequency
   □ Origin fallthrough rate

5. Security
   □ Validate input at edge
   □ Rate limit early
   □ Sanitize data
   □ Use secrets management

6. Cost Optimization
   □ Cache aggressively
   □ Right-size execution time
   □ Use appropriate tier
   □ Monitor usage patterns

Anti-Patterns

Edge Computing Anti-Patterns:

1. "Everything at Edge"
   ❌ Moving all logic to edge
   ✓ Strategic placement based on requirements

2. "Database at Edge"
   ❌ Complex database operations at edge
   ✓ Read replicas or cached data at edge

3. "Ignoring Cold Starts"
   ❌ Large bundles, heavy initialization
   ✓ Optimize bundle size, lazy loading

4. "Origin Coupling"
   ❌ Edge functions tightly coupled to origin
   ✓ Edge functions should work independently when possible

5. "No Fallbacks"
   ❌ Edge function fails = user sees error
   ✓ Graceful degradation, cached responses

6. "Synchronous Everything"
   ❌ Waiting for slow operations at edge
   ✓ Async processing, fire-and-forget logging

Related Skills

• cdn-architecture - CDN and caching patterns
• serverless-patterns - Serverless architecture
• latency-optimization - End-to-end latency reduction
• multi-region-deployment - Global infrastructure