프로덕션에서의 Bun: 무엇이 되고, 안 되고, 놀라웠는지

# Bun 버전 확인
bun --version
 
# TypeScript 파일을 직접 실행 — tsconfig도, 컴파일 단계도 필요 없음
bun run server.ts
 
# 패키지 설치
bun install
 
# 테스트 실행
bun test
 
# 프로덕션용 번들
bun build ./src/index.ts --outdir ./dist

# 시작 시간 측정 — 각각 100번 실행
hyperfine --warmup 5 'node -e "console.log(1)"' 'bun -e "console.log(1)"'
 
# 일반적인 결과:
# node:  ~40ms
# bun:   ~6ms

# 클린 설치 벤치마크 — 먼저 node_modules와 lockfile 삭제
rm -rf node_modules bun.lockb package-lock.json
 
# npm 시간 측정
time npm install
# Real: ~18.4s (일반적인 중간 규모 프로젝트)
 
# bun 시간 측정
time bun install
# Real: ~2.1s

# bombardier로 빠른 벤치마크
# 간단한 "Hello World" 응답 테스트
 
# Bun 서버
bombardier -c 100 -d 10s http://localhost:3000
# 요청/초: ~105,000
 
# Node.js (네이티브 http 모듈)
bombardier -c 100 -d 10s http://localhost:3001
# 요청/초: ~48,000
 
# Node.js (Express)
bombardier -c 100 -d 10s http://localhost:3002
# 요청/초: ~15,000

// fibonacci.ts — 이것은 엔진 바운드이지 런타임 바운드가 아닙니다
function fib(n: number): number {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}
 
const start = performance.now();
console.log(fib(42));
console.log(`${(performance.now() - start).toFixed(0)}ms`);

bun run fibonacci.ts   # ~1650ms
node fibonacci.ts      # ~1580ms

# 적절한 벤치마킹을 위해 hyperfine 설치
brew install hyperfine  # macOS
# 또는: cargo install hyperfine
 
# 실제 앱의 시작 + 실행 벤치마크
hyperfine --warmup 3 \
  'node dist/server.js' \
  'bun src/server.ts' \
  --prepare 'sleep 0.1'
 
# HTTP 서버의 경우, bombardier 또는 wrk 사용
# 중요: "Hello World"가 아닌 현실적인 페이로드로 테스트하세요
bombardier -c 50 -d 30s -l http://localhost:3000/api/users
 
# 메모리 비교
/usr/bin/time -v node server.js  # Linux
/usr/bin/time -l bun server.ts   # macOS

# package.json에서 모든 의존성 설치
bun install
 
# 의존성 추가
bun add express
 
# 개발 의존성 추가
bun add -d vitest
 
# 의존성 제거
bun remove express
 
# 의존성 업데이트
bun update express
 
# 특정 버전 설치
bun add express@4.18.2

# lockfile을 사람이 읽을 수 있는 형식으로 덤프
bun bun.lockb > lockfile-dump.txt
 
# 또는 내장 텍스트 출력 사용
bun install --yarn
# 이것은 bun.lockb와 함께 yarn.lock을 생성합니다

{
  "name": "my-monorepo",
  "workspaces": ["packages/*", "apps/*"]
}

# 모든 워크스페이스의 의존성 설치
bun install
 
# 특정 워크스페이스에서 스크립트 실행
bun run --filter packages/shared build
 
# 특정 워크스페이스에 의존성 추가
bun add react --filter apps/web

# 1단계: 기존 lockfile과 node_modules 삭제
rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
 
# 2단계: Bun으로 설치
bun install
 
# 3단계: 앱이 여전히 작동하는지 확인
bun run dev
# 또는: node dist/server.js  (Bun 패키지 매니저, Node 런타임)

// 이것들은 모두 Bun에서 예상대로 작동합니다
import fs from "node:fs";
import path from "node:path";
import crypto from "node:crypto";
import { Buffer } from "node:buffer";
import { EventEmitter } from "node:events";
import { Readable, Writable } from "node:stream";
import http from "node:http";
import https from "node:https";
import { URL, URLSearchParams } from "node:url";
import os from "node:os";
import child_process from "node:child_process";

# 패키지가 네이티브 애드온을 사용하는지 확인
ls node_modules/your-package/binding.gyp  # 이것이 존재하면 네이티브입니다

// 이것은 Bun에서 작동하지 않습니다 — V8 전용
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// 이것은 작동합니다 — Bun의 동등한 것 또는 크로스 런타임 접근 사용
const encoded = new TextEncoder().encode(JSON.stringify({ data: "test" }));

# 프로젝트에서 Bun의 내장 호환성 검사 실행
bun --bun node_modules/.bin/your-tool
 
# --bun 플래그는 node_modules 스크립트에도 Bun의 런타임을 강제합니다

# 빠른 호환성 검사 — Bun에서 전체 테스트 스위트 실행
bun test  # bun 테스트 러너 사용 시
# 또는
bun run vitest  # vitest 사용 시

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);
 
    if (url.pathname === "/") {
      return new Response("Hello from Bun!", {
        headers: { "Content-Type": "text/plain" },
      });
    }
 
    if (url.pathname === "/api/users") {
      const users = [
        { id: 1, name: "Alice" },
        { id: 2, name: "Bob" },
      ];
      return Response.json(users);
    }
 
    return new Response("Not Found", { status: 404 });
  },
});
 
console.log(`Server running at http://localhost:${server.port}`);

import { Database } from "bun:sqlite";
 
const db = new Database("app.db");
db.run(`
  CREATE TABLE IF NOT EXISTS todos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    completed INTEGER DEFAULT 0,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);
 
const server = Bun.serve({
  port: process.env.PORT || 3000,
 
  async fetch(req) {
    const url = new URL(req.url);
    const method = req.method;
 
    try {
      // GET /api/todos
      if (url.pathname === "/api/todos" && method === "GET") {
        const todos = db.query("SELECT * FROM todos ORDER BY created_at DESC").all();
        return Response.json(todos);
      }
 
      // POST /api/todos
      if (url.pathname === "/api/todos" && method === "POST") {
        const body = await req.json();
 
        if (!body.title || typeof body.title !== "string") {
          return Response.json({ error: "Title is required" }, { status: 400 });
        }
 
        const stmt = db.prepare("INSERT INTO todos (title) VALUES (?) RETURNING *");
        const todo = stmt.get(body.title);
        return Response.json(todo, { status: 201 });
      }
 
      // DELETE /api/todos/:id
      const deleteMatch = url.pathname.match(/^\/api\/todos\/(\d+)$/);
      if (deleteMatch && method === "DELETE") {
        const id = parseInt(deleteMatch[1], 10);
        db.run("DELETE FROM todos WHERE id = ?", [id]);
        return new Response(null, { status: 204 });
      }
 
      return Response.json({ error: "Not found" }, { status: 404 });
    } catch (error) {
      console.error("Request error:", error);
      return Response.json({ error: "Internal server error" }, { status: 500 });
    }
  },
});
 
console.log(`Server running on port ${server.port}`);

// 파일 읽기
const file = Bun.file("./config.json");
const text = await file.text(); // 문자열로 읽기
const json = await file.json(); // JSON으로 직접 파싱
const bytes = await file.arrayBuffer(); // ArrayBuffer로 읽기
const stream = file.stream(); // ReadableStream으로 읽기
 
// 파일 메타데이터
console.log(file.size); // 바이트 단위 크기
console.log(file.type); // MIME 타입 (예: "application/json")
 
// 파일 쓰기
await Bun.write("./output.txt", "Hello, World!");
await Bun.write("./data.json", JSON.stringify({ key: "value" }));
await Bun.write("./copy.png", Bun.file("./original.png"));
 
// Response body를 파일에 쓰기
const response = await fetch("https://example.com/data.json");
await Bun.write("./downloaded.json", response);

const server = Bun.serve({
  port: 3000,
 
  fetch(req, server) {
    const url = new URL(req.url);
 
    if (url.pathname === "/ws") {
      const upgraded = server.upgrade(req, {
        data: {
          userId: url.searchParams.get("userId"),
          joinedAt: Date.now(),
        },
      });
 
      if (!upgraded) {
        return new Response("WebSocket upgrade failed", { status: 400 });
      }
      return undefined;
    }
 
    return new Response("Use /ws for WebSocket connections");
  },
 
  websocket: {
    open(ws) {
      console.log(`Client connected: ${ws.data.userId}`);
      ws.subscribe("chat");
    },
 
    message(ws, message) {
      // 모든 구독자에게 브로드캐스트
      server.publish("chat", `${ws.data.userId}: ${message}`);
    },
 
    close(ws) {
      console.log(`Client disconnected: ${ws.data.userId}`);
      ws.unsubscribe("chat");
    },
  },
});

import { Database } from "bun:sqlite";
 
// 데이터베이스 열기 또는 생성
const db = new Database("myapp.db");
 
// 더 나은 동시 읽기 성능을 위한 WAL 모드
db.exec("PRAGMA journal_mode = WAL");
 
// 테이블 생성
db.run(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    email TEXT UNIQUE NOT NULL,
    name TEXT NOT NULL,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);
 
// 준비된 문 (재사용 가능, 반복 쿼리에 더 빠름)
const insertUser = db.prepare("INSERT INTO users (email, name) VALUES ($email, $name) RETURNING *");
 
const findByEmail = db.prepare("SELECT * FROM users WHERE email = $email");
 
// 사용법
const user = insertUser.get({
  $email: "alice@example.com",
  $name: "Alice",
});
console.log(user); // { id: 1, email: "alice@example.com", name: "Alice", ... }
 
// 트랜잭션
const insertMany = db.transaction((users: { email: string; name: string }[]) => {
  for (const user of users) {
    insertUser.run({ $email: user.email, $name: user.name });
  }
  return users.length;
});
 
const count = insertMany([
  { email: "bob@example.com", name: "Bob" },
  { email: "carol@example.com", name: "Carol" },
]);
console.log(`Inserted ${count} users`);

// math.test.ts
import { describe, it, expect } from "bun:test";
 
describe("math utilities", () => {
  it("adds numbers correctly", () => {
    expect(1 + 2).toBe(3);
  });
 
  it("handles floating point", () => {
    expect(0.1 + 0.2).toBeCloseTo(0.3);
  });
});

# 모든 테스트 실행
bun test
 
# 특정 파일 실행
bun test math.test.ts
 
# 패턴과 일치하는 테스트 실행
bun test --test-name-pattern "adds numbers"
 
# 워치 모드
bun test --watch
 
# 커버리지
bun test --coverage

import { describe, it, expect, mock, spyOn } from "bun:test";
import { fetchUsers } from "./api";
 
// 모듈 모킹
mock.module("./database", () => ({
  query: mock(() => [{ id: 1, name: "Alice" }]),
}));
 
describe("fetchUsers", () => {
  it("returns users from database", async () => {
    const users = await fetchUsers();
    expect(users).toHaveLength(1);
    expect(users[0].name).toBe("Alice");
  });
});
 
// 객체 메서드 스파이
describe("console", () => {
  it("tracks console.log calls", () => {
    const logSpy = spyOn(console, "log");
    console.log("test message");
    expect(logSpy).toHaveBeenCalledWith("test message");
    logSpy.mockRestore();
  });
});

# 단일 진입점 번들
bun build ./src/index.ts --outdir ./dist
 
# 다른 대상에 맞게 번들
bun build ./src/index.ts --outdir ./dist --target browser
bun build ./src/index.ts --outdir ./dist --target bun
bun build ./src/index.ts --outdir ./dist --target node
 
# 압축
bun build ./src/index.ts --outdir ./dist --minify
 
# 소스맵 생성
bun build ./src/index.ts --outdir ./dist --sourcemap external

const result = await Bun.build({
  entrypoints: ["./src/index.ts", "./src/worker.ts"],
  outdir: "./dist",
  target: "browser",
  minify: {
    whitespace: true,
    identifiers: true,
    syntax: true,
  },
  splitting: true, // 코드 분할
  sourcemap: "external",
  external: ["react", "react-dom"], // 이것들은 번들하지 않음
  naming: "[dir]/[name]-[hash].[ext]",
  define: {
    "process.env.NODE_ENV": JSON.stringify("production"),
  },
});
 
if (!result.success) {
  console.error("Build failed:");
  for (const log of result.logs) {
    console.error(log);
  }
  process.exit(1);
}
 
for (const output of result.outputs) {
  console.log(`${output.path} — ${output.size} bytes`);
}

// utils.ts
export function used() {
  return "I'll be in the bundle";
}
 
export function unused() {
  return "I'll be tree-shaken away";
}
 
// index.ts
import { used } from "./utils";
console.log(used());

bun build ./src/index.ts --outdir ./dist --minify
# `unused` 함수는 출력에 나타나지 않습니다

// build-info.ts — 이 파일은 런타임이 아닌 빌드 타임에 실행됩니다
export function getBuildInfo() {
  return {
    builtAt: new Date().toISOString(),
    gitSha: require("child_process").execSync("git rev-parse --short HEAD").toString().trim(),
    nodeVersion: process.version,
  };
}

// app.ts
import { getBuildInfo } from "./build-info" with { type: "macro" };
 
// getBuildInfo()는 번들 타임에 실행됩니다
// 결과는 정적 값으로 인라인됩니다
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

# Bun으로 의존성 설치, 그런 다음 Node.js로 Next.js 실행
bun install
bun run dev    # 실제로는 기본적으로 Node.js를 통해 "dev" 스크립트를 실행합니다
bun run build
bun run start

# Bun의 런타임에서 Next.js를 강제 실행
bun --bun run dev

# Bun 런타임으로 빌드
bun --bun run build
 
# Bun 런타임으로 프로덕션 서버 시작
bun --bun run start

{
  "scripts": {
    "dev": "next dev --turbopack",
    "build": "next build",
    "start": "next start"
  }
}

# 일상 워크플로우
bun install      # 빠른 패키지 설치
bun run dev      # Node.js를 통해 "next dev" 실행
bun run build    # Node.js를 통해 "next build" 실행

FROM oven/bun:1 AS base
WORKDIR /app
 
# 의존성 설치
FROM base AS deps
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# 빌드 (필요한 경우)
FROM base AS build
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build
 
# 프로덕션
FROM base AS production
WORKDIR /app
 
# root로 실행하지 않기
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=deps /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY --from=build /app/package.json ./
 
EXPOSE 3000
CMD ["bun", "run", "dist/server.js"]

# 빌드 단계: 모든 의존성이 포함된 풀 Bun 이미지
FROM oven/bun:1 AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun build ./src/index.ts --target bun --outdir ./dist --minify
 
# 런타임 단계: 더 작은 베이스 이미지
FROM oven/bun:1-slim AS runtime
WORKDIR /app
 
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=builder /app/dist ./dist
 
EXPOSE 3000
CMD ["bun", "run", "dist/index.js"]

# 앱을 단일 실행 파일로 컴파일
bun build --compile ./src/server.ts --outfile server
 
# 출력은 독립 실행형 바이너리입니다 — 실행에 Bun이나 Node.js가 필요 없습니다
./server

# 컴파일된 바이너리를 사용하는 초소형 Docker 이미지
FROM oven/bun:1 AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun build --compile ./src/server.ts --outfile server
 
# 최종 이미지 — 바이너리만
FROM debian:bookworm-slim
WORKDIR /app
 
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=builder /app/server ./server
 
EXPOSE 3000
CMD ["./server"]

# Node.js 이미지
docker images | grep node
# node:20-slim    ~180MB
 
# Bun 이미지
docker images | grep bun
# oven/bun:1-slim  ~130MB
 
# debian:bookworm-slim 위의 컴파일된 바이너리
# ~80MB 베이스 + ~70MB 바이너리 = ~150MB 합계
 
# Alpine과 Node.js 비교
# node:20-alpine   ~130MB + node_modules

# npm/yarn/pnpm을 bun install로 교체
# CI 파이프라인 변경:
# 변경 전:
npm ci
 
# 변경 후:
bun install --frozen-lockfile

# 개발 스크립트에 bun 사용
bun run dev
bun run lint
bun run format
 
# 일회성 스크립트에 bun 사용
bun run scripts/seed-database.ts
bun run scripts/migrate.ts

# 간단한 테스트 스위트에서 vitest/jest를 bun test로 교체
bun test
 
# 복잡한 테스트 설정에는 vitest 유지
# (Testing Library, MSW, 커스텀 환경)

// 새 마이크로서비스나 API — 처음부터 Bun으로 시작
Bun.serve({
  port: 3000,
  fetch(req) {
    // 여기에 새 서비스
  },
});

# 철저한 테스트 후에만:
# 기존 서비스의 node를 bun으로 교체
# 변경 전:
node dist/server.js
 
# 변경 후:
bun dist/server.js

# .env
DATABASE_URL=postgresql://localhost:5432/myapp
API_KEY=sk-test-12345
PORT=3000

// 어떤 import 없이도 사용 가능
console.log(process.env.DATABASE_URL);
console.log(process.env.API_KEY);
console.log(Bun.env.PORT); // Bun 전용 대안

# Bun의 디버거 — VS Code에서 작동
bun --inspect run server.ts
 
# Bun의 inspect-brk — 첫 번째 줄에서 일시 정지
bun --inspect-brk run server.ts

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "bun",
      "request": "launch",
      "name": "Debug Bun",
      "program": "${workspaceFolder}/src/server.ts",
      "cwd": "${workspaceFolder}",
      "stopOnEntry": false,
      "watchMode": false
    }
  ]
}

# 의존성 수 비교
# 일반적인 Express + SQLite + WebSocket 프로젝트:
npm ls --all | wc -l
# ~340개 패키지
 
# Bun 내장 기능으로 같은 기능:
bun pm ls --all | wc -l
# ~12개 패키지 (애플리케이션 코드만)

// 프로덕션 튜닝을 위한 Bun.serve() 옵션
Bun.serve({
  port: 3000,
 
  // 최대 요청 body 크기 증가 (기본값 128MB)
  maxRequestBodySize: 1024 * 1024 * 50, // 50MB
 
  // 더 나은 에러 페이지를 위한 개발 모드 활성화
  development: process.env.NODE_ENV !== "production",
 
  // 포트 재사용 (무중단 재시작에 유용)
  reusePort: true,
 
  fetch(req) {
    return new Response("OK");
  },
});

// 런타임 코드 변환을 위한 Bun.Transpiler 사용
const transpiler = new Bun.Transpiler({
  loader: "tsx",
  target: "browser",
});
 
const code = transpiler.transformSync(`
  const App: React.FC = () => <div>Hello</div>;
  export default App;
`);

# Bun의 메모리 사용 플래그
bun --smol run server.ts  # 메모리 사용량 감소 (약간 느려짐)
 
# 최대 힙 크기 설정
BUN_JSC_forceRAMSize=512000000 bun run server.ts  # ~512MB 제한

// Node.js 18+ fetch와 Bun의 fetch는
// 특정 헤더와 리다이렉트 처리 방식이 약간 다릅니다
 
// Bun은 기본적으로 리다이렉트를 따릅니다 (브라우저처럼)
// Node.js fetch도 리다이렉트를 따르지만, 특정 상태 코드
// (303, 307, 308)에서 동작이 다를 수 있습니다
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // 리다이렉트 처리를 명시적으로 지정
});

// Bun은 이벤트 루프가 비면 종료됩니다
// Node.js는 때때로 남아있는 핸들 때문에 계속 실행됩니다
 
// Bun 스크립트가 예상치 않게 종료되면, 이벤트 루프를
// 유지하는 것이 없다는 의미입니다
 
// 이것은 Bun에서 즉시 종료됩니다:
setTimeout(() => {}, 0);
 
// 이것은 계속 실행됩니다:
setTimeout(() => {}, 1000);
// (타임아웃이 실행된 후 Bun이 종료됩니다)

// Bun은 자체 tsconfig 기본값을 가지고 있습니다
// Bun과 Node.js 간에 프로젝트를 공유하는 경우,
// tsconfig.json에서 명시적으로 지정하세요:
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // Bun 타입 정의 추가
  }
}

# Bun 타입 설치
bun add -d @types/bun

# Bun에는 내장 워치 모드가 있습니다
bun --watch run server.ts
 
# 파일 변경 시 프로세스를 재시작합니다
# HMR(핫 모듈 교체)이 아닌 전체 재시작입니다
# 하지만 Bun이 너무 빨리 시작하기 때문에, 즉시처럼 느껴집니다

# bunfig.toml — Bun의 설정 파일 (선택사항)
 
[install]
# 프라이빗 레지스트리 사용
registry = "https://npm.mycompany.com"
 
# 스코프 레지스트리
[install.scopes]
"@mycompany" = "https://npm.mycompany.com"
 
[test]
# 테스트 설정
coverage = true
coverageReporter = ["text", "lcov"]
 
[run]
# bun run에 사용할 셸
shell = "bash"