Deno 2 실전 가이드 — Node.js 호환 모드·내장 KV·Queues로 외부 인프라 없이 서버리스 백엔드 구축하기

// npm: 접두어 — node_modules 없이 즉시 사용
import express from "npm:express@4";
import { Hono } from "npm:hono@4";
 
// node: 접두어 — Node.js 내장 모듈 그대로
import { createServer } from "node:http";
import { join } from "node:path";

const kv = await Deno.openKv();
 
// 계층적 키 구조로 데이터 구성
await kv.set(["users", "alice"], { name: "Alice", email: "alice@example.com" });
await kv.set(["users", "bob"], { name: "Bob", email: "bob@example.com" });
 
// 단일 키 조회
const user = await kv.get(["users", "alice"]);
console.log(user.value); // { name: "Alice", email: "alice@example.com" }
 
// 접두어 기반 목록 조회
const iter = kv.list({ prefix: ["users"] });
for await (const entry of iter) {
  console.log(entry.key, entry.value);
}

async function transferBalance(fromId: string, toId: string, amount: number) {
  const kv = await Deno.openKv();
 
  while (true) {
    const [fromEntry, toEntry] = await kv.getMany([
      ["balances", fromId],
      ["balances", toId],
    ]);
 
    if (fromEntry.value === null || toEntry.value === null) {
      throw new Error("계좌를 찾을 수 없습니다");
    }
 
    const fromBalance = fromEntry.value as number;
    const toBalance = toEntry.value as number;
 
    if (fromBalance < amount) throw new Error("잔액 부족");
 
    const res = await kv.atomic()
      .check(fromEntry)  // versionstamp 변화 감지
      .check(toEntry)
      .set(["balances", fromId], fromBalance - amount)
      .set(["balances", toId], toBalance + amount)
      .commit();
 
    if (res.ok) break;  // 성공 시 종료, 충돌 시 재시도
  }
}

const kv = await Deno.openKv();
 
// 메시지 발행 — 즉시 실행
await kv.enqueue({
  type: "welcome-email",
  jobId: crypto.randomUUID(),
  userId: "alice",
  to: "alice@example.com",
});
 
// 지연 실행 — 30분 후 처리
await kv.enqueue(
  { type: "trial-reminder", jobId: crypto.randomUUID(), userId: "alice" },
  { delay: 30 * 60 * 1000 }
);

# 기존 package.json의 의존성 설치
deno install
 
# package.json의 scripts.start를 deno task로 실행
deno task start
 
# 또는 직접 실행 (필요한 퍼미션 명시)
deno run --allow-net --allow-env --allow-read src/index.ts

import express from "npm:express@4";
import cors from "npm:cors@2";
 
const app = express();
app.use(cors());
 
app.get("/health", (_req, res) => {
  res.json({ status: "ok", runtime: "deno" });
});
 
app.listen(3000, () => console.log("서버 시작: http://localhost:3000"));

// main.ts
import { Hono } from "npm:hono@4";
 
type EmailQueueMessage =
  | { type: "verify-email"; jobId: string; userId: string; email: string }
  | { type: "welcome-email"; jobId: string; userId: string; email: string };
 
const app = new Hono();
const kv = await Deno.openKv();
 
// 사용자 생성
app.post("/users", async (c) => {
  const body = await c.req.json();
  const id = crypto.randomUUID();
  const user = { id, ...body, createdAt: new Date().toISOString() };
 
  await kv.set(["users", id], user);
 
  const msg: EmailQueueMessage = {
    type: "verify-email",
    jobId: crypto.randomUUID(),
    userId: id,
    email: body.email,
  };
  await kv.enqueue(msg);
 
  return c.json(user, 201);
});
 
// 사용자 조회
app.get("/users/:id", async (c) => {
  const entry = await kv.get(["users", c.req.param("id")]);
  if (!entry.value) return c.json({ error: "Not found" }, 404);
  return c.json(entry.value);
});
 
// 이메일 처리 워커
kv.listenQueue(async (msg: EmailQueueMessage) => {
  switch (msg.type) {
    case "verify-email":
      console.log(`이메일 인증 발송: ${msg.email}`);
      // 실제 메일 발송 로직
      break;
    case "welcome-email":
      console.log(`환영 이메일 발송: ${msg.email}`);
      break;
  }
});
 
Deno.serve({ port: 3000 }, app.fetch);

deno run --allow-net --allow-env main.ts

// chat.ts
const kv = await Deno.openKv();
 
Deno.serve({ port: 8080 }, async (req) => {
  if (req.headers.get("upgrade") !== "websocket") {
    return new Response("WebSocket만 허용됩니다", { status: 400 });
  }
 
  const url = new URL(req.url);
  const roomId = url.searchParams.get("room") ?? "general";
  const { socket, response } = Deno.upgradeWebSocket(req);
 
  socket.onopen = async () => {
    // 최근 50개 메시지 전송
    const messages = [];
    for await (const entry of kv.list(
      { prefix: ["messages", roomId] },
      { limit: 50, reverse: true }
    )) {
      messages.unshift(entry.value);
    }
    socket.send(JSON.stringify({ type: "history", messages }));
 
    // 새 메시지 감시 시작
    const watcher = kv.watch([["last_message_id", roomId]]);
 
    // WebSocket 종료 시 watcher 정리 — 누락 시 스트림 리소스 누수
    socket.onclose = () => watcher.cancel();
 
    (async () => {
      for await (const [entry] of watcher) {
        if (socket.readyState !== WebSocket.OPEN) break;
        const latest = await kv.get(["messages", roomId, entry.value as string]);
        if (latest.value) {
          socket.send(JSON.stringify({ type: "message", data: latest.value }));
        }
      }
    })();
  };
 
  socket.onmessage = async (e) => {
    const { text, userId } = JSON.parse(e.data);
    const msgId = crypto.randomUUID();
    const message = { id: msgId, text, userId, timestamp: Date.now() };
 
    await kv.atomic()
      .set(["messages", roomId, msgId], message)
      .set(["last_message_id", roomId], msgId)
      .commit();
  };
 
  return response;
});

Deno.cron("daily-report", "0 9 * * *", async () => {
  const kv = await Deno.openKv();
  const stats = await collectDailyStats(kv);
  await sendSlackReport(stats);
});
 
Deno.cron("cleanup-sessions", "*/30 * * * *", async () => {
  const kv = await Deno.openKv();
  const now = Date.now();
  for await (const entry of kv.list({ prefix: ["sessions"] })) {
    const session = entry.value as { expiresAt: number };
    if (session.expiresAt < now) {
      await kv.delete(entry.key);
    }
  }
});

# 개발 중 — 편의를 위해 전체 허용
deno run --allow-all main.ts
 
# 프로덕션 — 최소 퍼미션 명시
deno run \
  --allow-net=0.0.0.0:3000 \
  --allow-env=DATABASE_URL,SMTP_HOST \
  --allow-read=/app/static \
  main.ts

type QueueMessage =
  | { type: "send-email"; jobId: string; to: string }
  | { type: "process-payment"; jobId: string; orderId: string };
 
kv.listenQueue(async (msg: QueueMessage) => {
  const markerKey = ["processing_jobs", msg.jobId];
 
  // 원자적으로 처리 마커 선점 — 이미 존재하면 commit 실패
  const claim = await kv.atomic()
    .check({ key: markerKey, versionstamp: null })
    .set(markerKey, true, { expireIn: 24 * 60 * 60 * 1000 })
    .commit();
 
  if (!claim.ok) return;  // 이미 처리됐거나 처리 중
 
  switch (msg.type) {
    case "send-email":
      await sendEmail(msg.to);
      break;
    case "process-payment":
      await processPayment(msg.orderId);
      break;
  }
});

# macOS/Linux
curl -fsSL https://deno.land/install.sh | sh
 
# 기존 Node.js 프로젝트 폴더에서
deno install
deno task start