8장: 서버리스와 엣지 배포

- 전 세계 35+ 리전에 자동 분산 배포
- V8 Isolate 기반 실행 (가상 머신이 아님)
- 콜드 스타트 없음에 가까운 시작 시간
- 웹 표준 API 완벽 지원
- Deno KV 전역 분산 데이터베이스 내장
- GitHub 연동 자동 배포 (프리뷰 배포 포함)
- 무료 티어 포함

# deployctl 설치
deno install -gArf jsr:@deno/deployctl
 
# 프로젝트 배포
deployctl deploy --project=my-app src/main.ts
 
# 프로덕션 배포 (고정 URL)
deployctl deploy --project=my-app --prod src/main.ts

// main.ts - Deno Deploy에서 실행되는 코드
Deno.serve(async (req: Request) => {
  const url = new URL(req.url);
 
  // 라우팅
  if (url.pathname === "/") {
    return new Response("Deno Deploy에서 실행 중입니다", {
      headers: { "Content-Type": "text/plain; charset=utf-8" },
    });
  }
 
  if (url.pathname === "/api/time") {
    return new Response(
      JSON.stringify({
        timestamp: new Date().toISOString(),
        region: Deno.env.get("DENO_REGION") ?? "unknown",
      }),
      {
        headers: { "Content-Type": "application/json" },
      },
    );
  }
 
  return new Response("Not Found", { status: 404 });
});

1. Deno Deploy 대시보드에서 GitHub 저장소 연결
2. 엔트리포인트 파일 지정 (예: src/main.ts)
3. main 브랜치에 push하면 자동 프로덕션 배포
4. PR을 열면 프리뷰 URL 자동 생성
5. 프리뷰 URL로 변경사항 검증 후 머지

Deno Deploy (V8 Isolate)
  - 콜드 스타트: ~10ms
  - 웜 스타트: ~0ms
 
AWS Lambda (Node.js, 컨테이너)
  - 콜드 스타트: ~200-500ms
  - 웜 스타트: ~1-5ms
 
AWS Lambda (Node.js, SnapStart)
  - 콜드 스타트: ~100-200ms
  - 웜 스타트: ~1-5ms
 
Cloudflare Workers (V8 Isolate)
  - 콜드 스타트: ~5ms
  - 웜 스타트: ~0ms

실행 시간 제한
  - 요청당 최대 실행 시간: 50초 (기본), 150초 (유료)
  - 장기 실행 작업에는 적합하지 않음
 
메모리 제한
  - Isolate당 메모리 제한 (약 512MB)
  - 대용량 데이터 처리에 제약
 
파일 시스템
  - 읽기 전용 파일 시스템 (정적 파일만 접근)
  - 동적 파일 생성/수정 불가
 
네이티브 모듈
  - C/C++ 네이티브 모듈 사용 불가
  - Wasm(WebAssembly)으로 대체 가능

const kv = await Deno.openKv();
 
interface Session {
  userId: string;
  email: string;
  createdAt: string;
  expiresAt: string;
}
 
async function createSession(userId: string, email: string): Promise<string> {
  const sessionId = crypto.randomUUID();
  const now = new Date();
  const expires = new Date(now.getTime() + 24 * 60 * 60 * 1000); // 24시간
 
  const session: Session = {
    userId,
    email,
    createdAt: now.toISOString(),
    expiresAt: expires.toISOString(),
  };
 
  await kv.set(["sessions", sessionId], session, {
    expireIn: 24 * 60 * 60 * 1000, // 자동 만료
  });
 
  return sessionId;
}
 
async function getSession(sessionId: string): Promise<Session | null> {
  const result = await kv.get<Session>(["sessions", sessionId]);
  return result.value;
}
 
async function deleteSession(sessionId: string): Promise<void> {
  await kv.delete(["sessions", sessionId]);
}
 
// HTTP 서버에서 활용
Deno.serve(async (req) => {
  const url = new URL(req.url);
 
  if (url.pathname === "/api/login" && req.method === "POST") {
    const { userId, email } = await req.json();
    const sessionId = await createSession(userId, email);
 
    return new Response(JSON.stringify({ ok: true }), {
      headers: {
        "Content-Type": "application/json",
        "Set-Cookie": `session=${sessionId}; HttpOnly; Secure; SameSite=Strict; Path=/`,
      },
    });
  }
 
  if (url.pathname === "/api/me") {
    const cookie = req.headers.get("Cookie") ?? "";
    const sessionId = cookie.match(/session=([^;]+)/)?.[1];
 
    if (!sessionId) {
      return new Response("인증 필요", { status: 401 });
    }
 
    const session = await getSession(sessionId);
    if (!session) {
      return new Response("세션 만료", { status: 401 });
    }
 
    return new Response(JSON.stringify(session), {
      headers: { "Content-Type": "application/json" },
    });
  }
 
  return new Response("Not Found", { status: 404 });
});

const kv = await Deno.openKv();
 
async function incrementPageView(path: string): Promise<number> {
  // 원자적 증가 연산
  let retries = 0;
  while (retries < 5) {
    const current = await kv.get<number>(["pageviews", path]);
    const newCount = (current.value ?? 0) + 1;
 
    const result = await kv.atomic()
      .check(current) // 낙관적 잠금
      .set(["pageviews", path], newCount)
      .commit();
 
    if (result.ok) {
      return newCount;
    }
 
    retries++;
  }
 
  throw new Error("카운터 업데이트 실패 (동시성 충돌)");
}
 
Deno.serve(async (req) => {
  const url = new URL(req.url);
 
  // 페이지 방문 시 카운터 증가
  const views = await incrementPageView(url.pathname);
 
  return new Response(
    JSON.stringify({
      path: url.pathname,
      views,
      region: Deno.env.get("DENO_REGION"),
    }),
    {
      headers: { "Content-Type": "application/json" },
    },
  );
});

// 이 코드는 Deno Deploy와 Cloudflare Workers 모두에서 동작합니다
async function handleRequest(request: Request): Promise<Response> {
  const url = new URL(request.url);
 
  switch (url.pathname) {
    case "/": {
      return new Response("환영합니다", {
        headers: { "Content-Type": "text/plain; charset=utf-8" },
      });
    }
 
    case "/api/data": {
      const data = { timestamp: Date.now(), message: "엣지에서 응답" };
      return new Response(JSON.stringify(data), {
        headers: { "Content-Type": "application/json" },
      });
    }
 
    case "/api/hash": {
      const body = await request.text();
      const encoder = new TextEncoder();
      const hash = await crypto.subtle.digest("SHA-256", encoder.encode(body));
      const hex = Array.from(new Uint8Array(hash))
        .map((b) => b.toString(16).padStart(2, "0"))
        .join("");
 
      return new Response(JSON.stringify({ hash: hex }), {
        headers: { "Content-Type": "application/json" },
      });
    }
 
    default:
      return new Response("Not Found", { status: 404 });
  }
}
 
// Deno Deploy용 엔트리포인트
Deno.serve(handleRequest);

// Cloudflare Workers에서 동일한 handleRequest 사용
export default {
  async fetch(request: Request): Promise<Response> {
    return handleRequest(request);
  },
};

Deno Deploy 전용
  - Deno.openKv() - 내장 KV 저장소
  - Deno.cron() - 내장 크론 스케줄러
  - Deno.env.get("DENO_REGION") - 리전 정보
 
Cloudflare Workers 전용
  - KV (Cloudflare KV)
  - R2 (오브젝트 스토리지)
  - D1 (SQLite 기반 DB)
  - Durable Objects (상태 관리)
 
공통 (WinterCG 호환)
  - fetch, Request, Response
  - URL, URLSearchParams
  - crypto.subtle
  - TextEncoder, TextDecoder
  - Headers, AbortController
  - ReadableStream, WritableStream

사용자 요청
  |
  v
엣지 노드 (CDN)
  |-- 정적 파일 (HTML, CSS, JS, 이미지) --> 즉시 응답
  |-- API 요청 (/api/*) --> Deno Deploy 엣지 함수
                              |
                              v
                          Deno KV / 외부 DB

// fresh.config.ts
import { defineConfig } from "fresh";
 
export default defineConfig({
  // Deno Deploy에서 자동으로 최적화됨
});
 
// routes/index.tsx - SSR이 엣지에서 수행
import { page } from "fresh";
 
export default page(function Home() {
  return (
    <div>
      <h1>엣지에서 렌더링된 페이지</h1>
      <p>
        이 페이지는 사용자와 가장 가까운 엣지 노드에서 서버 사이드 렌더링됩니다.
      </p>
    </div>
  );
});

// 매 시간 실행되는 크론 작업
Deno.cron("hourly-cleanup", "0 * * * *", async () => {
  const kv = await Deno.openKv();
 
  // 만료된 세션 정리
  const iter = kv.list({ prefix: ["sessions"] });
  const now = Date.now();
 
  for await (const entry of iter) {
    const session = entry.value as { expiresAt: string };
    if (new Date(session.expiresAt).getTime() < now) {
      await kv.delete(entry.key);
    }
  }
 
  console.log("만료 세션 정리 완료");
});
 
// 매일 자정에 실행
Deno.cron("daily-stats", "0 0 * * *", async () => {
  const kv = await Deno.openKv();
 
  // 일일 통계 집계
  const stats = { date: new Date().toISOString().split("T")[0], views: 0 };
 
  const iter = kv.list<number>({ prefix: ["pageviews"] });
  for await (const entry of iter) {
    stats.views += entry.value;
  }
 
  await kv.set(["daily-stats", stats.date], stats);
  console.log(`일일 통계 저장: ${stats.views} views`);
});

성능 최적화
  [ ] 응답에 적절한 Cache-Control 헤더 설정
  [ ] 정적 자산은 CDN에서 서빙
  [ ] KV 조회 결과를 메모리에 캐싱 (짧은 TTL)
  [ ] 불필요한 외부 API 호출 최소화
 
보안
  [ ] 환경 변수로 시크릿 관리 (하드코딩 금지)
  [ ] CORS 헤더 적절히 설정
  [ ] Rate limiting 구현
  [ ] 입력 값 검증 철저히
 
모니터링
  [ ] 에러 로깅 설정
  [ ] 응답 시간 모니터링
  [ ] KV 사용량 추적
  [ ] 리전별 트래픽 분석