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とロックファイルを削除
rm -rf node_modules bun.lockb package-lock.json
 
# npmの時間計測
time npm install
# Real: 〜18.4秒（典型的な中規模プロジェクト）
 
# bunの時間計測
time bun install
# Real: 〜2.1秒

# 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

# ロックファイルを人間が読める形式にダンプ
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：既存のロックファイルと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(`サーバー起動中: 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: "タイトルは必須です" }, { 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: "見つかりません" }, { status: 404 });
    } catch (error) {
      console.error("リクエストエラー:", error);
      return Response.json({ error: "内部サーバーエラー" }, { status: 500 });
    }
  },
});
 
console.log(`サーバーがポート ${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ボディをファイルに書き込み
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アップグレードに失敗", { status: 400 });
      }
      return undefined;
    }
 
    return new Response("WebSocket接続には /ws を使用してください");
  },
 
  websocket: {
    open(ws) {
      console.log(`クライアント接続: ${ws.data.userId}`);
      ws.subscribe("chat");
    },
 
    message(ws, message) {
      // すべてのサブスクライバーにブロードキャスト
      server.publish("chat", `${ws.data.userId}: ${message}`);
    },
 
    close(ws) {
      console.log(`クライアント切断: ${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(`${count}人のユーザーを挿入`);

// math.test.ts
import { describe, it, expect } from "bun:test";
 
describe("数学ユーティリティ", () => {
  it("数値を正しく加算する", () => {
    expect(1 + 2).toBe(3);
  });
 
  it("浮動小数点を処理する", () => {
    expect(0.1 + 0.2).toBeCloseTo(0.3);
  });
});

# すべてのテストを実行
bun test
 
# 特定のファイルを実行
bun test math.test.ts
 
# パターンに一致するテストを実行
bun test --test-name-pattern "数値を正しく加算"
 
# ウォッチモード
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("データベースからユーザーを返す", async () => {
    const users = await fetchUsers();
    expect(users).toHaveLength(1);
    expect(users[0].name).toBe("Alice");
  });
});
 
// オブジェクトメソッドをスパイ
describe("console", () => {
  it("console.logの呼び出しを追跡する", () => {
    const logSpy = spyOn(console, "log");
    console.log("テストメッセージ");
    expect(logSpy).toHaveBeenCalledWith("テストメッセージ");
    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("ビルド失敗:");
  for (const log of result.logs) {
    console.error(log);
  }
  process.exit(1);
}
 
for (const output of result.outputs) {
  console.log(`${output.path} — ${output.size} バイト`);
}

// utils.ts
export function used() {
  return "バンドルに含まれる";
}
 
export function unused() {
  return "ツリーシェイキングで除去される";
}
 
// 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(`ビルド日時: ${info.builtAt}, コミット: ${info.gitSha}`);

# Bunで依存関係をインストールし、Node.jsでNext.jsを実行
bun install
bun run dev    # デフォルトではNode.js経由で「dev」スクリプトを実行
bun run build
bun run start

# Next.jsをBunのランタイムで強制実行
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

// インポートなしでこれらが利用可能
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,
 
  // 最大リクエストボディサイズを増加（デフォルトは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"