Bun i produktion: Vad som fungerar, vad som inte gör det och vad som överraskade mig | Akousa

bash

# Kontrollera din Bun-version
bun --version
 
# Kör en TypeScript-fil direkt — ingen tsconfig, inget kompileringssteg
bun run server.ts
 
# Installera paket
bun install
 
# Kör tester
bun test
 
# Bundla för produktion
bun build ./src/index.ts --outdir ./dist

bash

# Benchmark för ren installation — radera node_modules och lockfil först
rm -rf node_modules bun.lockb package-lock.json
 
# Tidsätt npm
time npm install
# Real: ~18.4s (typiskt medelstort projekt)
 
# Tidsätt bun
time bun install
# Real: ~2.1s

bash

# Snabbt och enkelt benchmark med bombardier
# Testar en enkel "Hello World"-respons
 
# Bun-server
bombardier -c 100 -d 10s http://localhost:3000
# Requests/sek: ~105 000
 
# Node.js (nativa http-modulen)
bombardier -c 100 -d 10s http://localhost:3001
# Requests/sek: ~48 000
 
# Node.js (Express)
bombardier -c 100 -d 10s http://localhost:3002
# Requests/sek: ~15 000

typescript

// fibonacci.ts — detta är motorbundet, inte runtimebundet
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`);

bash

# Installera hyperfine för ordentlig benchmarking
brew install hyperfine  # macOS
# eller: cargo install hyperfine
 
# Benchmarka starttid + exekvering av din faktiska app
hyperfine --warmup 3 \
  'node dist/server.js' \
  'bun src/server.ts' \
  --prepare 'sleep 0.1'
 
# För HTTP-servrar, använd bombardier eller wrk
# Viktigt: testa med realistiska payloads, inte "Hello World"
bombardier -c 50 -d 30s -l http://localhost:3000/api/users
 
# Minnesjämförelse
/usr/bin/time -v node server.js  # Linux
/usr/bin/time -l bun server.ts   # macOS

bash

# Installera alla beroenden från package.json
bun install
 
# Lägg till ett beroende
bun add express
 
# Lägg till ett dev-beroende
bun add -d vitest
 
# Ta bort ett beroende
bun remove express
 
# Uppdatera ett beroende
bun update express
 
# Installera en specifik version
bun add express@4.18.2

bash

# Installera beroenden för alla workspaces
bun install
 
# Kör ett skript i en specifik workspace
bun run --filter packages/shared build
 
# Lägg till ett beroende i en specifik workspace
bun add react --filter apps/web

bash

# Steg 1: Radera befintlig lockfil och node_modules
rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
 
# Steg 2: Installera med Bun
bun install
 
# Steg 3: Verifiera att din app fortfarande fungerar
bun run dev
# eller: node dist/server.js  (Bun pakethanterare, Node runtime)

typescript

// Alla dessa fungerar som förväntat i 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

// Detta fungerar INTE i Bun — V8-specifikt
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// Detta FUNGERAR — använd Buns motsvarighet eller ett tvärplattformsangreppssätt
const encoded = new TextEncoder().encode(JSON.stringify({ data: "test" }));

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

// Läsa filer
const file = Bun.file("./config.json");
const text = await file.text(); // Läs som sträng
const json = await file.json(); // Parsa som JSON direkt
const bytes = await file.arrayBuffer(); // Läs som ArrayBuffer
const stream = file.stream(); // Läs som ReadableStream
 
// Filmetadata
console.log(file.size); // Storlek i bytes
console.log(file.type); // MIME-typ (t.ex. "application/json")
 
// Skriva filer
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"));
 
// Skriv en Response-body till en fil
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) {
      // Sända till alla prenumeranter
      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";
 
// Öppna eller skapa en databas
const db = new Database("myapp.db");
 
// WAL-läge för bättre concurrent läsprestanda
db.exec("PRAGMA journal_mode = WAL");
 
// Skapa tabeller
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'))
  )
`);
 
// Preparerade satser (återanvändbara, snabbare för upprepade frågor)
const insertUser = db.prepare("INSERT INTO users (email, name) VALUES ($email, $name) RETURNING *");
 
const findByEmail = db.prepare("SELECT * FROM users WHERE email = $email");
 
// Användning
const user = insertUser.get({
  $email: "alice@example.com",
  $name: "Alice",
});
console.log(user); // { id: 1, email: "alice@example.com", name: "Alice", ... }
 
// Transaktioner
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

# Kör alla tester
bun test
 
# Kör specifik fil
bun test math.test.ts
 
# Kör tester som matchar ett mönster
bun test --test-name-pattern "adds numbers"
 
# Watch-läge
bun test --watch
 
# Täckning
bun test --coverage

typescript

import { describe, it, expect, mock, spyOn } from "bun:test";
import { fetchUsers } from "./api";
 
// Mocka en modul
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");
  });
});
 
// Spionera på en objektmetod
describe("console", () => {
  it("tracks console.log calls", () => {
    const logSpy = spyOn(console, "log");
    console.log("test message");
    expect(logSpy).toHaveBeenCalledWith("test message");
    logSpy.mockRestore();
  });
});

bash

# Bundla en enda ingångspunkt
bun build ./src/index.ts --outdir ./dist
 
# Bundla för olika mål
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
 
# Minifiera
bun build ./src/index.ts --outdir ./dist --minify
 
# Generera 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, // Koddelning
  sourcemap: "external",
  external: ["react", "react-dom"], // Bundla inte dessa
  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 — denna fil körs vid BYGGTID, inte runtime
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() körs vid bundletid
// Resultatet infogas som ett statiskt värde
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

bash

# Använd Bun för att installera beroenden, sedan Node.js för att köra Next.js
bun install
bun run dev    # Detta kör faktiskt "dev"-skriptet via Node.js som standard
bun run build
bun run start

dockerfile

FROM oven/bun:1 AS base
WORKDIR /app
 
# Installera beroenden
FROM base AS deps
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# Bygg (om det behövs)
FROM base AS build
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build
 
# Produktion
FROM base AS production
WORKDIR /app
 
# Kör inte som 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

# Byggsteg: fullständig Bun-avbildning med alla beroenden
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
 
# Runtime-steg: mindre basavbildning
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

# Kompilera din app till en enda körbar fil
bun build --compile ./src/server.ts --outfile server
 
# Utdatan är en fristående binärfil — varken Bun eller Node.js behövs för att köra den
./server

dockerfile

# Ultraminimal Docker-avbildning med kompilerad binärfil
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
 
# Slutgiltig avbildning — bara binärfilen
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-avbildning
docker images | grep node
# node:20-slim    ~180MB
 
# Bun-avbildning
docker images | grep bun
# oven/bun:1-slim  ~130MB
 
# Kompilerad binärfil på debian:bookworm-slim
# ~80MB bas + ~70MB binärfil = ~150MB totalt
 
# jämfört med Alpine med Node.js
# node:20-alpine   ~130MB + node_modules

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

# Jämför antal beroenden
# Ett typiskt Express + SQLite + WebSocket-projekt:
npm ls --all | wc -l
# ~340 paket
 
# Samma funktionalitet med Buns inbyggda funktioner:
bun pm ls --all | wc -l
# ~12 paket (bara din applikationskod)

typescript

// Använd Bun.serve()-alternativ för produktionsjustering
Bun.serve({
  port: 3000,
 
  // Öka maximal storlek för request body (standard är 128MB)
  maxRequestBodySize: 1024 * 1024 * 50, // 50MB
 
  // Aktivera utvecklingsläge för bättre felsidor
  development: process.env.NODE_ENV !== "production",
 
  // Återanvänd port (användbart för nollavbrottsomstarter)
  reusePort: true,
 
  fetch(req) {
    return new Response("OK");
  },
});

typescript

// Använd Bun.Transpiler för runtime-kodtransformering
const transpiler = new Bun.Transpiler({
  loader: "tsx",
  target: "browser",
});
 
const code = transpiler.transformSync(`
  const App: React.FC = () => <div>Hello</div>;
  export default App;
`);

bash

# Buns minnesanvändningsflaggor
bun --smol run server.ts  # Minska minnesavtrycket (något långsammare)
 
# Ange maximal heapstorlek
BUN_JSC_forceRAMSize=512000000 bun run server.ts  # ~512MB gräns

typescript

// Node.js 18+ fetch och Buns fetch är något olika
// i hur de hanterar vissa headers och omdirigeringar
 
// Bun följer omdirigeringar som standard (som webbläsare)
// Node.js fetch följer också omdirigeringar, men beteendet
// med vissa statuskoder (303, 307, 308) kan skilja sig
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // Var explicit om omdirigeringshantering
});

typescript

// Bun avslutas när händelseslingan är tom
// Node.js fortsätter ibland köra på grund av kvarvarande handtag
 
// Om ditt Bun-skript avslutas oväntat håller inget
// händelseslingan vid liv
 
// Detta avslutas omedelbart i Bun:
setTimeout(() => {}, 0);
 
// Detta fortsätter köra:
setTimeout(() => {}, 1000);
// (Bun avslutas efter att timeouten har utlösts)

typescript

// Bun har sina egna tsconfig-standardvärden
// Om du delar ett projekt mellan Bun och Node.js,
// var explicit i din tsconfig.json:
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // Lägg till Buns typdefinitioner
  }
}

bash

# Bun har inbyggt watch-läge
bun --watch run server.ts
 
# Detta startar om processen vid filändringar
# Det är inte HMR (Hot Module Replacement) — det är en fullständig omstart
# Men eftersom Bun startar så snabbt känns det omedelbart

toml

# bunfig.toml — Buns konfigurationsfil (valfri)
 
[install]
# Använd ett privat register
registry = "https://npm.mycompany.com"
 
# Scopade register
[install.scopes]
"@mycompany" = "https://npm.mycompany.com"
 
[test]
# Testkonfiguration
coverage = true
coverageReporter = ["text", "lcov"]
 
[run]
# Shell att använda för bun run
shell = "bash"

Vad Bun faktiskt är

Hastighetsargumenten — Ärliga benchmarks

Starttid

Paketinstallation

HTTP-serverprestanda

Där skillnaden är försumbar

Hur du kör dina egna benchmarks

Bun som pakethanterare

Grunderna

Lockfil-situationen

Workspace-stöd

Kompatibilitet med befintliga projekt

Node.js-kompatibilitet

Vad som fungerar

Vad som inte fungerar (eller har problem)

Kompatibilitetsspåraren

Buns inbyggda API:er

Bun.serve() — Den inbyggda HTTP-servern

Bun.file() och Bun.write() — Fil-I/O

Inbyggt WebSocket-stöd

Inbyggd SQLite med bun:sqlite

Buns testkörare

Grundläggande användning

Mockning

Bun Test mot Vitest — Min ärliga jämförelse

Buns bundler

Grundläggande bundling

Programmatiskt API

Tree-Shaking

Där Bun Build brister

Bun Macros

Att använda Bun med Next.js

Vad som fungerar idag

Vad som fortfarande är experimentellt

Min rekommendation för Next.js

Docker med Bun

Grundläggande Dockerfile

Flerstegbygge för minimal avbildning

Kompilering till en enda binärfil

Storleksjämförelse

Migrationsmönster

Fas 1: Enbart pakethanterare (Noll risk)

Fas 2: Skript och verktyg

Fas 3: Testkörare (Medelhög risk)

Fas 4: Runtime för nya tjänster (Beräknad risk)

Fas 5: Runtime-migrering (Avancerat)

Miljövariabler och konfiguration

Felhantering och felsökning

Säkerhetsöverväganden

Prestandajustering

Vanliga fallgropar

1. Globalt Fetch-beteende skiljer sig

2. Processavslutningsbeteende

3. TypeScript-konfiguration

4. Hot Reload under utveckling

5. Konfigurationsfilen bunfig.toml

Min bedömning

Där jag använder Bun idag

Där jag håller mig till Node.js

Vad jag bevakar

Avslutning

Relaterade inlägg

Regex Cheat Sheet 2026 — Regular Expressions Made Simple

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

5. Konfigurationsfilen `bunfig.toml`