Bun en producción: qué funciona, qué no y qué me sorprendió | Akousa

bash

# Verificar tu versión de Bun
bun --version
 
# Ejecutar un archivo TypeScript directamente — sin tsconfig, sin paso de compilación
bun run server.ts
 
# Instalar paquetes
bun install
 
# Ejecutar tests
bun test
 
# Empaquetar para producción
bun build ./src/index.ts --outdir ./dist

bash

# Benchmark de instalación limpia — eliminar node_modules y lockfile primero
rm -rf node_modules bun.lockb package-lock.json
 
# Cronometrar npm
time npm install
# Real: ~18.4s (proyecto de tamaño medio típico)
 
# Cronometrar bun
time bun install
# Real: ~2.1s

bash

# Benchmark rápido con bombardier
# Probando una respuesta simple "Hello World"
 
# Servidor Bun
bombardier -c 100 -d 10s http://localhost:3000
# Requests/sec: ~105,000
 
# Node.js (módulo http nativo)
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 — esto depende del motor, no del runtime
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

# Instalar hyperfine para benchmarking adecuado
brew install hyperfine  # macOS
# o: cargo install hyperfine
 
# Benchmark de arranque + ejecución de tu app real
hyperfine --warmup 3 \
  'node dist/server.js' \
  'bun src/server.ts' \
  --prepare 'sleep 0.1'
 
# Para servidores HTTP, usa bombardier o wrk
# Importante: prueba con payloads realistas, no "Hello World"
bombardier -c 50 -d 30s -l http://localhost:3000/api/users
 
# Comparación de memoria
/usr/bin/time -v node server.js  # Linux
/usr/bin/time -l bun server.ts   # macOS

bash

# Instalar todas las dependencias desde package.json
bun install
 
# Añadir una dependencia
bun add express
 
# Añadir una dependencia de desarrollo
bun add -d vitest
 
# Eliminar una dependencia
bun remove express
 
# Actualizar una dependencia
bun update express
 
# Instalar una versión específica
bun add express@4.18.2

bash

# Instalar dependencias para todos los workspaces
bun install
 
# Ejecutar un script en un workspace específico
bun run --filter packages/shared build
 
# Añadir una dependencia a un workspace específico
bun add react --filter apps/web

bash

# Paso 1: Eliminar lockfile existente y node_modules
rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
 
# Paso 2: Instalar con Bun
bun install
 
# Paso 3: Verificar que tu app aún funciona
bun run dev
# o: node dist/server.js  (gestor de paquetes Bun, runtime Node)

typescript

// Todos estos funcionan como se espera en 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

// Esto NO funcionará en Bun — específico de V8
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// Esto SÍ funcionará — usa el equivalente de Bun o un enfoque multiplataforma
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

// Leyendo archivos
const file = Bun.file("./config.json");
const text = await file.text(); // Leer como string
const json = await file.json(); // Parsear como JSON directamente
const bytes = await file.arrayBuffer(); // Leer como ArrayBuffer
const stream = file.stream(); // Leer como ReadableStream
 
// Metadatos del archivo
console.log(file.size); // Tamaño en bytes
console.log(file.type); // Tipo MIME (ej., "application/json")
 
// Escribiendo archivos
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"));
 
// Escribir el body de un Response a un archivo
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) {
      // Transmitir a todos los suscriptores
      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";
 
// Abrir o crear una base de datos
const db = new Database("myapp.db");
 
// Modo WAL para mejor rendimiento de lectura concurrente
db.exec("PRAGMA journal_mode = WAL");
 
// Crear tablas
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'))
  )
`);
 
// Sentencias preparadas (reutilizables, más rápidas para consultas repetidas)
const insertUser = db.prepare("INSERT INTO users (email, name) VALUES ($email, $name) RETURNING *");
 
const findByEmail = db.prepare("SELECT * FROM users WHERE email = $email");
 
// Uso
const user = insertUser.get({
  $email: "alice@example.com",
  $name: "Alice",
});
console.log(user); // { id: 1, email: "alice@example.com", name: "Alice", ... }
 
// Transacciones
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

# Ejecutar todos los tests
bun test
 
# Ejecutar un archivo específico
bun test math.test.ts
 
# Ejecutar tests que coincidan con un patrón
bun test --test-name-pattern "adds numbers"
 
# Modo watch
bun test --watch
 
# Cobertura
bun test --coverage

typescript

import { describe, it, expect, mock, spyOn } from "bun:test";
import { fetchUsers } from "./api";
 
// Mockear un módulo
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");
  });
});
 
// Espiar un método de objeto
describe("console", () => {
  it("tracks console.log calls", () => {
    const logSpy = spyOn(console, "log");
    console.log("test message");
    expect(logSpy).toHaveBeenCalledWith("test message");
    logSpy.mockRestore();
  });
});

bash

# Empaquetar un solo punto de entrada
bun build ./src/index.ts --outdir ./dist
 
# Empaquetar para diferentes objetivos
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
 
# Minificar
bun build ./src/index.ts --outdir ./dist --minify
 
# Generar 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, // Code splitting
  sourcemap: "external",
  external: ["react", "react-dom"], // No empaquetar estos
  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 — este archivo se ejecuta en TIEMPO DE BUILD, no en 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() se ejecuta en tiempo de empaquetado
// El resultado se incrusta como un valor estático
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

bash

# Usar Bun para instalar dependencias, luego usar Node.js para ejecutar Next.js
bun install
bun run dev    # Esto realmente ejecuta el script "dev" via Node.js por defecto
bun run build
bun run start

dockerfile

FROM oven/bun:1 AS base
WORKDIR /app
 
# Instalar dependencias
FROM base AS deps
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# Build (si es necesario)
FROM base AS build
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build
 
# Producción
FROM base AS production
WORKDIR /app
 
# No ejecutar como 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

# Etapa de build: imagen completa de Bun con todas las dependencias
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
 
# Etapa de runtime: imagen base más pequeña
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"]

dockerfile

# Imagen Docker ultra-mínima usando binario compilado
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
 
# Imagen final — solo el binario
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

# Imagen Node.js
docker images | grep node
# node:20-slim    ~180MB
 
# Imagen Bun
docker images | grep bun
# oven/bun:1-slim  ~130MB
 
# Binario compilado sobre debian:bookworm-slim
# ~80MB base + ~70MB binario = ~150MB total
 
# vs. Alpine con 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

# Comparar conteo de dependencias
# Un proyecto típico de Express + SQLite + WebSocket:
npm ls --all | wc -l
# ~340 paquetes
 
# La misma funcionalidad con las funcionalidades integradas de Bun:
bun pm ls --all | wc -l
# ~12 paquetes (solo el código de tu aplicación)

typescript

// Usar opciones de Bun.serve() para ajuste en producción
Bun.serve({
  port: 3000,
 
  // Aumentar tamaño máximo del body de request (por defecto es 128MB)
  maxRequestBodySize: 1024 * 1024 * 50, // 50MB
 
  // Habilitar modo desarrollo para mejores páginas de error
  development: process.env.NODE_ENV !== "production",
 
  // Reutilizar puerto (útil para reinicios sin downtime)
  reusePort: true,
 
  fetch(req) {
    return new Response("OK");
  },
});

typescript

// Usar Bun.Transpiler para transformación de código en runtime
const transpiler = new Bun.Transpiler({
  loader: "tsx",
  target: "browser",
});
 
const code = transpiler.transformSync(`
  const App: React.FC = () => <div>Hello</div>;
  export default App;
`);

bash

# Flags de uso de memoria de Bun
bun --smol run server.ts  # Reducir huella de memoria (ligeramente más lento)
 
# Establecer tamaño máximo del heap
BUN_JSC_forceRAMSize=512000000 bun run server.ts  # ~512MB límite

typescript

// El fetch de Node.js 18+ y el fetch de Bun son ligeramente diferentes
// en cómo manejan ciertos headers y redirecciones
 
// Bun sigue redirecciones por defecto (como los navegadores)
// El fetch de Node.js también sigue redirecciones, pero el comportamiento
// con ciertos códigos de estado (303, 307, 308) puede diferir
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // Ser explícito sobre el manejo de redirecciones
});

typescript

// Bun sale cuando el event loop está vacío
// Node.js a veces sigue ejecutándose debido a handles persistentes
 
// Si tu script de Bun sale inesperadamente, algo no está
// manteniendo vivo el event loop
 
// Esto saldrá inmediatamente en Bun:
setTimeout(() => {}, 0);
 
// Esto seguirá ejecutándose:
setTimeout(() => {}, 1000);
// (Bun sale después de que el timeout se dispare)

typescript

// Bun tiene sus propios valores por defecto de tsconfig
// Si estás compartiendo un proyecto entre Bun y Node.js,
// sé explícito en tu tsconfig.json:
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // Añadir definiciones de tipos de Bun
  }
}

bash

# Bun tiene modo watch integrado
bun --watch run server.ts
 
# Esto reinicia el proceso cuando cambian los archivos
# No es HMR (Hot Module Replacement) — es un reinicio completo
# Pero como Bun arranca tan rápido, se siente instantáneo

toml

# bunfig.toml — archivo de configuración de Bun (opcional)
 
[install]
# Usar un registro privado
registry = "https://npm.mycompany.com"
 
# Registros por scope
[install.scopes]
"@mycompany" = "https://npm.mycompany.com"
 
[test]
# Configuración de tests
coverage = true
coverageReporter = ["text", "lcov"]
 
[run]
# Shell a usar para bun run
shell = "bash"

Qué es realmente Bun

Las afirmaciones de velocidad — Benchmarks honestos

Tiempo de arranque

Instalación de paquetes

Rendimiento del servidor HTTP

Dónde la diferencia es insignificante

Cómo ejecutar tus propios benchmarks

Bun como gestor de paquetes

Lo básico

La situación del lockfile

Soporte de workspaces

Compatibilidad con proyectos existentes

Compatibilidad con Node.js

Qué funciona

Qué no funciona (o tiene problemas)

El rastreador de compatibilidad

APIs integradas de Bun

Bun.serve() — El servidor HTTP integrado

Bun.file() y Bun.write() — I/O de archivos

Soporte integrado de WebSocket

SQLite integrado con bun:sqlite

Test Runner de Bun

Uso básico

Mocking

Bun Test vs. Vitest — Mi comparación honesta

Bundler de Bun

Empaquetado básico

API programática

Tree-Shaking

Dónde Bun Build se queda corto

Macros de Bun

Usando Bun con Next.js

Qué funciona hoy

Qué es aún experimental

Mi recomendación para Next.js

Docker con Bun

Dockerfile básico

Build multi-stage para imagen mínima

Compilación a un solo binario

Comparación de tamaño

Patrones de migración

Fase 1: Solo gestor de paquetes (riesgo cero)

Fase 2: Scripts y herramientas

Fase 3: Test runner (riesgo medio)

Fase 4: Runtime para nuevos servicios (riesgo calculado)

Fase 5: Migración de runtime (avanzado)

Variables de entorno y configuración

Manejo de errores y depuración

Consideraciones de seguridad

Ajuste de rendimiento

Trampas comunes

1. El comportamiento del Fetch global difiere

2. Comportamiento de salida del proceso

3. Configuración de TypeScript

4. Hot Reload en desarrollo

5. El archivo de configuración bunfig.toml

Mi veredicto

Dónde uso Bun hoy

Dónde me quedo con Node.js

Qué estoy observando

Conclusión

Artículos relacionados

Regex Cheat Sheet 2026 — Regular Expressions Made Simple

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

5. El archivo de configuración `bunfig.toml`