--- id: backend-edge-runtime-deep title: Edge Runtime — Workers / Deno Deploy / Vercel Edge category: Coding status: draft source_trust_level: B verification_status: conceptual created_at: 2026-05-09 updated_at: 2026-05-09 tags: [backend, edge, vibe-coding] tech_stack: { language: "TS", applicable_to: ["Backend"] } applied_in: [] aliases: [Cloudflare Workers, Deno Deploy, Vercel Edge, edge function, V8 isolates, low latency global] --- # Edge Runtime Deep > Lambda 보다 빠른, region 가 가까운. **Cloudflare Workers (V8), Deno Deploy, Vercel Edge, AWS Lambda@Edge**. ## 📖 핵심 개념 - V8 isolate: Lambda 보다 작은 (5ms cold start). - 200+ city deploy. - Web standard API (Fetch, Crypto). - Stateless (state 가 KV / D1). ## 💻 코드 패턴 ### Cloudflare Workers ```ts export default { async fetch(req: Request, env: Env, ctx: ExecutionContext) { return new Response('Hello from edge'); }, }; ``` ```bash npx wrangler deploy ``` ### Hono on Workers ```ts import { Hono } from 'hono'; const app = new Hono(); app.get('/', (c) => c.text('Hello')); app.get('/users/:id', (c) => c.json({ id: c.req.param('id') })); export default app; ``` → Express 비슷. 작은 (10 KB). ### KV (Workers) ```ts const value = await env.MY_KV.get('key'); await env.MY_KV.put('key', JSON.stringify(data), { expirationTtl: 3600 }); ``` → Eventually consistent. Edge 친화 (1 sec global propagation). ### D1 (SQLite at edge) ```ts const r = await env.DB.prepare('SELECT * FROM users WHERE id = ?').bind(id).first(); ``` → SQLite. 최신 read 만 region (write 가 1 region). ### R2 (S3-compatible) ```ts await env.MY_BUCKET.put('file.jpg', buffer); const obj = await env.MY_BUCKET.get('file.jpg'); ``` → Egress 무료. ### Durable Objects (stateful) ```ts export class Counter { state: DurableObjectState; constructor(state: DurableObjectState) { this.state = state; } async fetch(req: Request) { let count = await this.state.storage.get('count') ?? 0; count++; await this.state.storage.put('count', count); return new Response(String(count)); } } // Worker const id = env.COUNTER.idFromName('global'); const obj = env.COUNTER.get(id); const r = await obj.fetch(req); ``` → Stateful + globally addressable. Chat / game. ### Hyperdrive (DB pool) ```toml [[hyperdrive]] binding = 'HYPERDRIVE' id = '...' ``` ```ts import postgres from 'postgres'; const sql = postgres(env.HYPERDRIVE.connectionString); const users = await sql`SELECT * FROM users`; ``` → Edge 가 Postgres 직접. Pool / cache 자동. ### Deno Deploy ```ts Deno.serve((req) => new Response('Hello')); ``` ```bash deno deploy --project=my-app main.ts ``` ### Vercel Edge ```ts // app/api/hello/route.ts export const runtime = 'edge'; export async function GET(req: Request) { return new Response('Hello'); } ``` ### Bun ```ts Bun.serve({ port: 3000, fetch(req) { return new Response('Hello'); }, }); ``` → Self-host. Edge 가 아님 (single region). ### Limits ``` Cloudflare Workers: - 1 MB code (50 MB free plan). - 10 ms CPU (free), 30 sec (paid). - 128 MB memory. - No Node API (npm 일부). Lambda@Edge: - 1 MB code. - 5 sec timeout. - 128 MB. Deno Deploy: - 다른 limits. ``` → Lambda 보다 strict. ### Web standards ```ts // fetch, crypto, URL, Headers, Response const r = await fetch(url); const hash = await crypto.subtle.digest('SHA-256', data); const u = new URL('https://example.com/path?x=1'); ``` → Browser-compatible. Node 만 안 됨. ### Node compat (CF) ```toml compatibility_flags = ['nodejs_compat'] ``` ```ts import { readFile } from 'node:fs/promises'; // → 일부 Node API. ``` → 점진적 추가. ### Cold start ``` Workers: 5 ms (V8 isolate). Lambda: 200-1000 ms (container). Deno Deploy: ~10 ms. → Edge 가 훨씬 빠름. ``` ### Deploy ```bash # Workers wrangler deploy # Vercel vercel --prod # Deno deno deploy ``` → Atomic, global, secs. ### Routing ``` Cloudflare: my-app.example.com/* → worker. Vercel: /api/* → edge function. ``` ### Observability ```ts console.log('processed'); // → Wrangler tail / Workers Analytics. ``` → Production 의 Datadog / Sentry 통합. ### Rate limit ```ts // Cloudflare Rate Limiting Rule (Dashboard). // 또는 Worker: const ip = req.headers.get('cf-connecting-ip'); const key = `rl:${ip}`; const count = await env.KV.get(key); if (Number(count) > 100) return new Response('Rate limit', { status: 429 }); await env.KV.put(key, String(Number(count ?? 0) + 1), { expirationTtl: 60 }); ``` ### Cron (Workers) ```toml [triggers] crons = ['0 9 * * *'] ``` ```ts export default { async scheduled(event, env, ctx) { await dailyJob(); }, }; ``` ### Queue (Workers) ```ts // Producer await env.MY_QUEUE.send({ taskId: '...' }); // Consumer export default { async queue(batch, env) { for (const msg of batch.messages) { await process(msg.body); } }, }; ``` → Edge 의 message queue. ### WebSocket (Workers + DO) ```ts class ChatRoom extends DurableObject { async fetch(req: Request) { if (req.headers.get('upgrade') === 'websocket') { const pair = new WebSocketPair(); this.handleSession(pair[1]); return new Response(null, { status: 101, webSocket: pair[0] }); } } handleSession(ws: WebSocket) { ws.accept(); ws.addEventListener('message', (e) => { // ... }); } } ``` → Real-time chat at edge. ### Cost ``` Cloudflare Workers Free: - 100k req / day. - $5 / month for 10M. Vercel Edge: - 1M / month free. - $20 / month after. Deno Deploy: - 1M / month free. → Edge 가 traditional Lambda 보다 cheap (volume). ``` ### Use case ``` - API gateway / proxy. - Auth (verify JWT, OIDC). - Rate limit / WAF. - Image transform (CF Image, Vercel Image). - A/B test routing. - Static site (Pages). - Realtime (DO + WS). - AI inference (Cloudflare Workers AI). ``` ### Cloudflare Workers AI ```ts const r = await env.AI.run('@cf/meta/llama-3-8b-instruct', { prompt: 'Hello', }); ``` → Edge 의 LLM. 작은 model. ### vs Lambda ``` Lambda: 더 mature, 큰 ecosystem, 모든 language. Edge: 빠름, 작은, 가벼운. → Heavy compute = Lambda. HTTP / 작은 = Edge. ``` ### Limits 의 함정 ``` - Long task (>30 sec) = timeout. - Big bundle = limit. - Native module = 안 됨. - 큰 file (100 MB+) = R2. - Persistent connection = DO. ``` ### When? ``` ✓ Global low-latency. ✓ 작은 / simple logic. ✓ Auth proxy. ✓ A/B routing. ✗ Heavy compute (ML training). ✗ Long-running (>5 min). ✗ Complex Node app. ``` ## 🤔 의사결정 기준 | 작업 | 추천 | |---|---| | Auth gateway | Cloudflare Workers | | Vercel + Next | Edge function | | Deno-native | Deno Deploy | | Stateful | DO | | DB pool at edge | Hyperdrive / Neon HTTP | | Local dev | wrangler dev / bun | | Heavy compute | Lambda / VM | ## ❌ 안티패턴 - **Big bundle**: limit. - **Long task**: timeout. - **Persistent connection (no DO)**: 깨짐. - **State in worker memory**: lost. - **Heavy compute**: timeout. - **Node-only API**: 안 됨. - **Per-request DB connection**: pool 폭발. ## 🤖 LLM 활용 힌트 - Cloudflare Workers + Hono = 가장 modern. - DO 가 stateful. - Hyperdrive 가 DB pool. - Web standards (fetch, crypto) only. ## 🔗 관련 문서 - [[Backend_Edge_Functions]] - [[Backend_Hono_Modern]] - [[DB_Serverless_Edge]]