Bun в продакшене: что работает, что нет и что удивило | Akousa

2 января 2026 г.24 мин чтения

Bun в продакшене: что работает, что нет и что удивило

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

Раз в несколько лет в экосистеме JavaScript появляется новый рантайм, и дискуссия развивается по предсказуемой дуге. Хайп. Бенчмарки. «X мёртв». Проверка реальностью. Определение реальных сценариев, где новый инструмент действительно хорош.

Bun сейчас как раз на середине этой дуги. И в отличие от большинства конкурентов, он никуда не уходит. Не потому, что он «быстрее» (хотя зачастую так и есть), а потому, что он решает принципиально другую проблему: в инструментарии JavaScript слишком много движущихся частей, и Bun объединяет их в одно целое.

Я использую Bun в различных форматах уже больше года. Частично в продакшене. Частично — заменяя инструменты, которые думал, что никогда не заменю. Этот пост — честный отчёт о том, что работает, что нет и где пробелы всё ещё имеют значение.

Что такое Bun на самом деле

Первое заблуждение, которое нужно развеять: Bun — это не «более быстрый Node.js». Такая формулировка его недооценивает.

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

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

# Установка зависимостей для всех workspace
bun install
 
# Запуск скрипта в конкретном workspace
bun run --filter packages/shared build
 
# Добавление зависимости в конкретный workspace
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";

bash

# Проверьте, использует ли пакет нативные аддоны
ls node_modules/your-package/binding.gyp  # Если файл существует — значит нативный

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 test runner
# или
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(`Сервер запущен по адресу 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("Ошибка запроса:", error);
      return Response.json({ error: "Internal server error" }, { status: 500 });
    }
  },
});
 
console.log(`Сервер запущен на порту ${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(`Клиент подключился: ${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");
    },
  },
});

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(`Вставлено ${count} пользователей`);

typescript

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

bash

# Запуск всех тестов
bun test
 
# Запуск конкретного файла
bun test math.test.ts
 
# Запуск тестов по паттерну
bun test --test-name-pattern "складывает числа"
 
# Режим наблюдения
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("возвращает пользователей из базы данных", 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();
  });
});

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
 
# Генерация sourcemap
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("Сборка не удалась:");
  for (const log of result.logs) {
    console.error(log);
  }
  process.exit(1);
}
 
for (const output of result.outputs) {
  console.log(`${output.path} — ${output.size} байт`);
}

typescript

// utils.ts
export function used() {
  return "Я попаду в бандл";
}
 
export function unused() {
  return "Меня удалит tree-shaking";
}
 
// 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(`Собрано ${info.builtAt}, коммит ${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МБ итого
 
# vs. 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

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

typescript

// Bun завершается, когда event loop пуст
// Node.js иногда продолжает работать из-за висящих хендлов
 
// Если ваш скрипт на Bun неожиданно завершается,
// что-то не удерживает event loop активным
 
// Это немедленно завершится в 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

Поддержка Workspace

Совместимость с существующими проектами

Совместимость с Node.js

Что работает

Что не работает (или имеет проблемы)

Трекер совместимости

Встроенные API Bun

Bun.serve() — встроенный HTTP-сервер

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

Встроенная поддержка WebSocket

Встроенный SQLite с bun:sqlite

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

Базовое использование

Мокирование

Bun Test vs. 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`