Bun у продакшені: Що працює, що ні, і що мене здивувало | Akousa

2 січня 2026 р.24 хв читання

Bun у продакшені: Що працює, що ні, і що мене здивувало

Bun як рантайм, пакетний менеджер, бандлер та тест-раннер. Реальні бенчмарки, прогалини сумісності з Node.js, патерни міграції та де я використовую Bun у продакшені сьогодні.

Кожні кілька років в екосистемі JavaScript з'являється новий рантайм, і дискурс іде за передбачуваною дугою. Хайп. Бенчмарки. "X мертвий." Перевірка реальністю. Усталення у фактичних випадках використання, де новий інструмент справді блищить.

Bun зараз посередині цієї дуги. І на відміну від більшості претендентів, він залишається. Не тому, що він "швидший" (хоча часто це так), а тому, що він вирішує справді іншу проблему: ланцюжок інструментів JavaScript має забагато рухомих частин, і Bun зводить їх в одне ціле.

Я використовую Bun у різних якостях вже понад рік. Дещо в продакшені. Дещо замінюючи інструменти, які я думав, що ніколи не замінюватиму. Цей пост — чесний звіт про те, що працює, що ні, і де прогалини досі мають значення.

Що таке Bun насправді

Перше хибне уявлення, яке треба розвіяти: Bun — це не "швидший Node.js." Таке формулювання його недооцінює.

Bun — це чотири інструменти в одному бінарнику:

Рантайм JavaScript/TypeScript — виконує ваш код, як Node.js або Deno

bash

# Перевірте версію Bun
bun --version
 
# Запустіть TypeScript файл напряму — без tsconfig, без кроку компіляції
bun run server.ts
 
# Встановіть пакети
bun install
 
# Запустіть тести
bun test
 
# Зберіть для продакшену
bun build ./src/index.ts --outdir ./dist

bash

# Вимірювання часу запуску — запустити кожен 100 разів
hyperfine --warmup 5 'node -e "console.log(1)"' 'bun -e "console.log(1)"'
 
# Типові результати:
# node:  ~40мс
# bun:   ~6мс

bash

# Бенчмарк чистого встановлення — спершу видаліть node_modules і lockfile
rm -rf node_modules bun.lockb package-lock.json
 
# Час npm
time npm install
# Real: ~18.4с (типовий проєкт середнього розміру)
 
# Час bun
time bun install
# Real: ~2.1с

bash

# Швидкий і брудний бенчмарк з 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

typescript

// 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)}мс`);

bash

# Встановіть 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

bash

# Встановити всі залежності з package.json
bun install
 
# Додати залежність
bun add express
 
# Додати dev-залежність
bun add -d vitest
 
# Видалити залежність
bun remove express
 
# Оновити залежність
bun update express
 
# Встановити конкретну версію
bun add express@4.18.2

bash

# Ви можете вивантажити lockfile у читабельний формат
bun bun.lockb > lockfile-dump.txt
 
# Або використати вбудований текстовий вивід
bun install --yarn
# Це генерує yarn.lock поряд з bun.lockb

bash

# Встановити залежності для всіх воркспейсів
bun install
 
# Запустити скрипт у конкретному воркспейсі
bun run --filter packages/shared build
 
# Додати залежність до конкретного воркспейсу
bun add react --filter apps/web

bash

# Крок 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 рантайм)

typescript

// Все це працює як очікується в 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";

typescript

// Це НЕ працюватиме в Bun — специфічне для V8
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// Це ПРАЦЮВАТИМЕ — використовуйте еквівалент Bun або крос-рантайм підхід
const encoded = new TextEncoder().encode(JSON.stringify({ data: "test" }));

bash

# Запустіть вбудовану перевірку сумісності Bun для вашого проєкту
bun --bun node_modules/.bin/your-tool
 
# Прапор --bun примусово використовує рантайм Bun навіть для скриптів node_modules

bash

# Швидка перевірка сумісності — запустіть повний тестовий набір під Bun
bun test  # Якщо ви використовуєте тест-раннер bun
# або
bun run vitest  # Якщо ви використовуєте vitest

typescript

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}`);

typescript

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}`);

typescript

// Читання файлів
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);

typescript

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");
    },
  },
});

typescript

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`);

typescript

// 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);
  });
});

bash

# Запустити всі тести
bun test
 
# Запустити конкретний файл
bun test math.test.ts
 
# Запустити тести за патерном
bun test --test-name-pattern "adds numbers"
 
# Режим спостереження
bun test --watch
 
# Покриття
bun test --coverage

typescript

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();
  });
});

bash

# Зібрати одну точку входу
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
 
# Генерація sourcemaps
bun build ./src/index.ts --outdir ./dist --sourcemap external

typescript

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`);
}

typescript

// 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());

typescript

// 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,
  };
}

typescript

// app.ts
import { getBuildInfo } from "./build-info" with { type: "macro" };
 
// getBuildInfo() виконується під час збирання
// Результат вставляється як статичне значення
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

bash

# Використовуйте Bun для встановлення залежностей, потім використовуйте Node.js для запуску Next.js
bun install
bun run dev    # Це фактично запускає скрипт "dev" через Node.js за замовчуванням
bun run build
bun run start

bash

# Щоденний робочий процес
bun install      # Швидке встановлення пакетів
bun run dev      # Запускає "next dev" через Node.js
bun run build    # Запускає "next build" через Node.js

dockerfile

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"]

dockerfile

# Етап збирання: повний образ 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"]

bash

# Компілювати ваш застосунок в єдиний виконуваний файл
bun build --compile ./src/server.ts --outfile server
 
# Вивід — це автономний бінарник — не потрібен Bun або Node.js для запуску
./server

dockerfile

# Ультра-мінімальний 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"]

bash

# Образ Node.js
docker images | grep node
# node:20-slim    ~180МБ
 
# Образ Bun
docker images | grep bun
# oven/bun:1-slim  ~130МБ
 
# Скомпільований бінарник на debian:bookworm-slim
# ~80МБ база + ~70МБ бінарник = ~150МБ загалом
 
# проти Alpine з Node.js
# node:20-alpine   ~130МБ + node_modules

bash

# Використовуйте bun для запуску скриптів розробки
bun run dev
bun run lint
bun run format
 
# Використовуйте bun для одноразових скриптів
bun run scripts/seed-database.ts
bun run scripts/migrate.ts

bash

# Замінити vitest/jest на bun test для простих тестових наборів
bun test
 
# Залишити vitest для складних тестових налаштувань
# (Testing Library, MSW, кастомні середовища)

typescript

// Нові мікросервіси або API — починайте з Bun з першого дня
Bun.serve({
  port: 3000,
  fetch(req) {
    // Ваш новий сервіс тут
  },
});

bash

# Тільки після ретельного тестування:
# Замінити node на bun для існуючих сервісів
# Було:
node dist/server.js
 
# Стало:
bun dist/server.js

typescript

// Вони доступні без будь-якого імпорту
console.log(process.env.DATABASE_URL);
console.log(process.env.API_KEY);
console.log(Bun.env.PORT); // Bun-специфічна альтернатива

json

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

bash

# Порівняння кількості залежностей
# Типовий проєкт Express + SQLite + WebSocket:
npm ls --all | wc -l
# ~340 пакетів
 
# Та сама функціональність з вбудованими можливостями Bun:
bun pm ls --all | wc -l
# ~12 пакетів (лише код вашого застосунку)

typescript

// Використовуйте опції Bun.serve() для продакшн-налаштування
Bun.serve({
  port: 3000,
 
  // Збільшити максимальний розмір тіла запиту (за замовчуванням 128МБ)
  maxRequestBodySize: 1024 * 1024 * 50, // 50МБ
 
  // Увімкнути режим розробки для кращих сторінок помилок
  development: process.env.NODE_ENV !== "production",
 
  // Повторне використання порту (корисно для перезапусків без простою)
  reusePort: true,
 
  fetch(req) {
    return new Response("OK");
  },
});

typescript

// Використовуйте 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;
`);

bash

# Прапори використання пам'яті Bun
bun --smol run server.ts  # Зменшити відбиток пам'яті (трохи повільніше)
 
# Встановити максимальний розмір кучі
BUN_JSC_forceRAMSize=512000000 bun run server.ts  # ~512МБ ліміт

typescript

// Node.js 18+ fetch і fetch Bun трохи відрізняються
// у тому, як вони обробляють певні заголовки та перенаправлення
 
// Bun слідує за перенаправленнями за замовчуванням (як браузери)
// Node.js fetch також слідує за перенаправленнями, але поведінка
// з певними кодами статусу (303, 307, 308) може відрізнятися
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // Будьте явними щодо обробки перенаправлень
});

typescript

// Bun завершується, коли цикл подій порожній
// Node.js іноді продовжує працювати через залишкові хендли
 
// Якщо ваш скрипт Bun несподівано завершується, щось не
// тримає цикл подій активним
 
// Це завершиться негайно в Bun:
setTimeout(() => {}, 0);
 
// Це продовжить працювати:
setTimeout(() => {}, 1000);
// (Bun завершується після спрацювання таймауту)

typescript

// Bun має власні значення за замовчуванням для tsconfig
// Якщо ви ділите проєкт між Bun і Node.js,
// будьте явними у вашому tsconfig.json:
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // Додати визначення типів Bun
  }
}

bash

# Bun має вбудований режим спостереження
bun --watch run server.ts
 
# Це перезапускає процес при змінах файлів
# Це не HMR (Hot Module Replacement) — це повний перезапуск
# Але оскільки Bun запускається так швидко, це відчувається миттєво

toml

# 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"

Що таке Bun насправді

Заявки про швидкість — чесні бенчмарки

Час запуску

Встановлення пакетів

Пропускна здатність HTTP-сервера

Де різниця незначна

Як запускати власні бенчмарки

Bun як пакетний менеджер

Основи

Ситуація з lockfile

Підтримка воркспейсів

Сумісність з існуючими проєктами

Сумісність з Node.js

Що працює

Що не працює (або має проблеми)

Трекер сумісності

Вбудовані API Bun

Bun.serve() — вбудований HTTP-сервер

Bun.file() та Bun.write() — файловий I/O

Вбудована підтримка WebSocket

Вбудований SQLite з bun:sqlite

Тест-раннер Bun

Базове використання

Мокінг

Bun Test проти Vitest — моє чесне порівняння

Бандлер Bun

Базове збирання

Програмний API

Tree-Shaking

Де Bun Build програє

Макроси Bun

Використання Bun з Next.js

Що працює сьогодні

Що все ще експериментальне

Моя рекомендація для Next.js

Docker з Bun

Базовий Dockerfile

Багатоетапна збірка для мінімального образу

Компіляція в один бінарник

Порівняння розмірів

Патерни міграції

Фаза 1: Лише пакетний менеджер (нульовий ризик)

Фаза 2: Скрипти та інструменти

Фаза 3: Тест-раннер (середній ризик)

Фаза 4: Рантайм для нових сервісів (зважений ризик)

Фаза 5: Міграція рантайму (просунутий рівень)

Змінні середовища та конфігурація

Обробка помилок та дебагінг

Міркування щодо безпеки

Налаштування продуктивності

Поширені підводні камені

1. Поведінка глобального Fetch відрізняється

2. Поведінка завершення процесу

3. Конфігурація TypeScript

4. Гаряче перезавантаження в розробці

5. Конфігураційний файл bunfig.toml

Мій вердикт

Де я використовую Bun сьогодні

Де я залишаюся з Node.js

Що я спостерігаю

Підсумок

Схожі записи

Regex Cheat Sheet 2026 — Regular Expressions Made Simple

How to Compress Images Without Losing Quality: The Complete 2026 Guide

5. Конфігураційний файл `bunfig.toml`