Bun in Produktion: Was funktioniert, was nicht und was mich überrascht hat | Akousa

bash

# Clean-Install-Benchmark — node_modules und Lockfile vorher löschen
rm -rf node_modules bun.lockb package-lock.json
 
# npm timen
time npm install
# Real: ~18.4s (typisches mittelgroßes Projekt)
 
# bun timen
time bun install
# Real: ~2.1s

bash

# Schneller und unsauberer Benchmark mit bombardier
# Eine einfache "Hello World"-Antwort testen
 
# Bun Server
bombardier -c 100 -d 10s http://localhost:3000
# Requests/sec: ~105,000
 
# Node.js (natives http-Modul)
bombardier -c 100 -d 10s http://localhost:3001
# Requests/sec: ~48,000
 
# Node.js (Express)
bombardier -c 100 -d 10s http://localhost:3002
# Requests/sec: ~15,000

typescript

// fibonacci.ts — das ist Engine-gebunden, nicht Runtime-gebunden
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

# hyperfine für ordentliches Benchmarking installieren
brew install hyperfine  # macOS
# oder: cargo install hyperfine
 
# Startzeit + Ausführung deiner tatsächlichen App benchmarken
hyperfine --warmup 3 \
  'node dist/server.js' \
  'bun src/server.ts' \
  --prepare 'sleep 0.1'
 
# Für HTTP-Server bombardier oder wrk verwenden
# Wichtig: mit realistischen Payloads testen, nicht "Hello World"
bombardier -c 50 -d 30s -l http://localhost:3000/api/users
 
# Speichervergleich
/usr/bin/time -v node server.js  # Linux
/usr/bin/time -l bun server.ts   # macOS

bash

# Alle Dependencies aus package.json installieren
bun install
 
# Dependency hinzufügen
bun add express
 
# Dev-Dependency hinzufügen
bun add -d vitest
 
# Dependency entfernen
bun remove express
 
# Dependency aktualisieren
bun update express
 
# Bestimmte Version installieren
bun add express@4.18.2

bash

# Dependencies für alle Workspaces installieren
bun install
 
# Script in einem bestimmten Workspace ausführen
bun run --filter packages/shared build
 
# Dependency zu einem bestimmten Workspace hinzufügen
bun add react --filter apps/web

bash

# Schritt 1: Bestehenden Lockfile und node_modules löschen
rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
 
# Schritt 2: Mit Bun installieren
bun install
 
# Schritt 3: Verifizieren, dass deine App noch funktioniert
bun run dev
# oder: node dist/server.js  (Bun Package Manager, Node Runtime)

typescript

// Diese funktionieren alle wie erwartet in 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

// Das funktioniert NICHT in Bun — V8-spezifisch
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// Das FUNKTIONIERT — verwende Buns Äquivalent oder einen Cross-Runtime-Ansatz
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

// Dateien lesen
const file = Bun.file("./config.json");
const text = await file.text(); // Als String lesen
const json = await file.json(); // Direkt als JSON parsen
const bytes = await file.arrayBuffer(); // Als ArrayBuffer lesen
const stream = file.stream(); // Als ReadableStream lesen
 
// Dateimetadaten
console.log(file.size); // Größe in Bytes
console.log(file.type); // MIME-Typ (z.B. "application/json")
 
// Dateien schreiben
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 in eine Datei schreiben
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) {
      // An alle Subscriber broadcasten
      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";
 
// Datenbank öffnen oder erstellen
const db = new Database("myapp.db");
 
// WAL-Modus für bessere parallele Leseleistung
db.exec("PRAGMA journal_mode = WAL");
 
// Tabellen erstellen
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'))
  )
`);
 
// Prepared Statements (wiederverwendbar, schneller für wiederholte Abfragen)
const insertUser = db.prepare("INSERT INTO users (email, name) VALUES ($email, $name) RETURNING *");
 
const findByEmail = db.prepare("SELECT * FROM users WHERE email = $email");
 
// Verwendung
const user = insertUser.get({
  $email: "alice@example.com",
  $name: "Alice",
});
console.log(user); // { id: 1, email: "alice@example.com", name: "Alice", ... }
 
// Transaktionen
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

# Alle Tests ausführen
bun test
 
# Bestimmte Datei ausführen
bun test math.test.ts
 
# Tests mit Muster ausführen
bun test --test-name-pattern "adds numbers"
 
# Watch-Modus
bun test --watch
 
# Coverage
bun test --coverage

typescript

import { describe, it, expect, mock, spyOn } from "bun:test";
import { fetchUsers } from "./api";
 
// Modul mocken
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");
  });
});
 
// Methode auf einem Objekt ausspionieren
describe("console", () => {
  it("tracks console.log calls", () => {
    const logSpy = spyOn(console, "log");
    console.log("test message");
    expect(logSpy).toHaveBeenCalledWith("test message");
    logSpy.mockRestore();
  });
});

bash

# Einzelnen Entry Point bundeln
bun build ./src/index.ts --outdir ./dist
 
# Für verschiedene Targets bundeln
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
 
# Minifizieren
bun build ./src/index.ts --outdir ./dist --minify
 
# Sourcemaps generieren
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, // Code Splitting
  sourcemap: "external",
  external: ["react", "react-dom"], // Diese nicht bundeln
  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

// build-info.ts — diese Datei läuft zur BUILD-ZEIT, nicht zur Laufzeit
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() wird zur Bundle-Zeit ausgeführt
// Das Ergebnis wird als statischer Wert inlined
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

bash

# Bun verwenden, um Dependencies zu installieren, dann Node.js um Next.js auszuführen
bun install
bun run dev    # Das führt tatsächlich das "dev"-Script standardmäßig über Node.js aus
bun run build
bun run start

dockerfile

FROM oven/bun:1 AS base
WORKDIR /app
 
# Dependencies installieren
FROM base AS deps
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# Build (falls nötig)
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
 
# Nicht als root laufen
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"]

bash

# Deine App in ein eigenständiges Executable kompilieren
bun build --compile ./src/server.ts --outfile server
 
# Der Output ist ein eigenständiges Binary — kein Bun oder Node.js zum Ausführen nötig
./server

dockerfile

# Ultra-minimales Docker Image mit kompiliertem Binary
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
 
# Finales Image — nur das Binary
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 Image
docker images | grep node
# node:20-slim    ~180MB
 
# Bun Image
docker images | grep bun
# oven/bun:1-slim  ~130MB
 
# Kompiliertes Binary auf debian:bookworm-slim
# ~80MB Basis + ~70MB Binary = ~150MB gesamt
 
# vs. Alpine mit Node.js
# node:20-alpine   ~130MB + node_modules

typescript

// Node.js 18+ fetch und Buns fetch unterscheiden sich leicht
// in der Handhabung bestimmter Header und Redirects
 
// Bun folgt Redirects standardmäßig (wie Browser)
// Node.js fetch folgt auch Redirects, aber das Verhalten
// bei bestimmten Statuscodes (303, 307, 308) kann sich unterscheiden
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // Explizit die Redirect-Handhabung angeben
});

typescript

// Bun beendet sich, wenn die Event Loop leer ist
// Node.js läuft manchmal weiter wegen verbleibender Handles
 
// Wenn dein Bun-Script unerwartet beendet wird, hält etwas
// die Event Loop nicht am Leben
 
// Das beendet sich sofort in Bun:
setTimeout(() => {}, 0);
 
// Das läuft weiter:
setTimeout(() => {}, 1000);
// (Bun beendet sich, nachdem der Timeout feuert)

typescript

// Bun hat eigene tsconfig-Defaults
// Wenn du ein Projekt zwischen Bun und Node.js teilst,
// sei explizit in deiner tsconfig.json:
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // Bun-Typdefinitionen hinzufügen
  }
}

bash

# Bun hat eingebauten Watch-Modus
bun --watch run server.ts
 
# Das startet den Prozess bei Dateiänderungen neu
# Es ist kein HMR (Hot Module Replacement) — es ist ein voller Neustart
# Aber weil Bun so schnell startet, fühlt es sich instant an

toml

# bunfig.toml — Buns Config-Datei (optional)
 
[install]
# Private Registry verwenden
registry = "https://npm.mycompany.com"
 
# Scoped Registries
[install.scopes]
"@mycompany" = "https://npm.mycompany.com"
 
[test]
# Test-Konfiguration
coverage = true
coverageReporter = ["text", "lcov"]
 
[run]
# Shell für bun run
shell = "bash"

Was Bun eigentlich ist

Die tatsächlichen Benchmarks

Startzeit

Paketinstallation

HTTP-Server-Durchsatz

Wo der Unterschied vernachlässigbar ist

Eigene Benchmarks durchführen

Bun als Package Manager

Die Grundlagen

Die Lockfile-Situation

Workspace-Support

Kompatibilität mit bestehenden Projekten

Node.js-Kompatibilität

Was funktioniert

Was nicht funktioniert (oder Probleme hat)

Der Kompatibilitäts-Tracker

Buns eingebaute APIs

Bun.serve() — Der eingebaute HTTP-Server

Bun.file() und Bun.write() — Datei-I/O

Eingebauter WebSocket-Support

Eingebautes SQLite mit bun:sqlite

Bun Test Runner

Grundlegende Nutzung

Mocking

Bun Test vs. Vitest — Mein ehrlicher Vergleich

Bun Bundler

Grundlegendes Bundling

Programmatisches API

Wo Bun Build Grenzen hat

Bun Macros

Bun mit Next.js verwenden

Was heute funktioniert

Was noch experimentell ist

Meine Empfehlung für Next.js

Docker mit Bun

Einfaches Dockerfile

Kompilierung in ein einzelnes Binary

Größenvergleich

Migrationsmuster

Phase 1: Nur Package Manager (Null Risiko)

Phase 2: Scripts und Tooling

Phase 3: Test Runner (Mittleres Risiko)

Phase 4: Runtime für neue Services (Kalkuliertes Risiko)

Phase 5: Runtime-Migration (Fortgeschritten)

Umgebungsvariablen und Konfiguration

Häufige Stolperfallen

1. Unterschiedliches globales Fetch-Verhalten

2. Process-Exit-Verhalten

3. TypeScript-Konfiguration

4. Hot Reload in der Entwicklung

5. Die bunfig.toml-Konfigurationsdatei

Mein Fazit

Wo ich Bun heute einsetze

Wo ich bei Node.js bleibe

Was ich beobachte

Abschluss

Ähnliche Beiträge

Regex Cheat Sheet 2026 — Regular Expressions Made Simple

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

5. Die `bunfig.toml`-Konfigurationsdatei