Bun.serve()

Verwenden Sie Bun.serve(), um einen HTTP-Server zu erstellen. Es akzeptiert ein Konfigurationsobjekt und gibt ein Server-Objekt zurück.

server.ts

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hallo!");
  },
});

console.log(`Server läuft unter http://localhost:${server.port}`);

fetch-Handler

Der fetch-Handler ist eine Funktion, die eine Request empfängt und eine Response zurückgibt.

Bun.serve({
  fetch(req) {
    return new Response("Hallo!");
  },
});

Der Handler unterstützt async/await:

Bun.serve({
  async fetch(req) {
    await Bun.sleep(100);
    return new Response("Hallo nach 100ms!");
  },
});

routes-Objekt

Sie können auch ein routes-Objekt verwenden, um Routen zu definieren:

Bun.serve({
  routes: {
    "/": () => new Response("Startseite"),
    "/api": () => Response.json({ success: true }),
  },
  fetch(req) {
    return new Response("Nicht gefunden");
  },
});

---

Server-Objekt

Das von Bun.serve() zurückgegebene Server-Objekt hat die folgenden Eigenschaften und Methoden:

interface Server {
  // Eigenschaften
  port: number;
  hostname: string;
  url: URL;
  protocol: "http" | "https";

  // Methoden
  reload(options: ServeOptions): void;
  requestIP(request: Request): SocketAddress | null;
  upgrade(request: Request, options: UpgradeOptions): boolean;
  publish(topic: string, data: string | ArrayBuffer | ArrayBufferView): number;
  isSubscribed(topic: string): boolean;
  subscribe(ws: WebSocket, topic: string): void;
  unsubscribe(ws: WebSocket, topic: string): void;
}

server.port

Die Portnummer, auf der der Server läuft.

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hallo!");
  },
});

console.log(server.port); // 3000

server.hostname

Der Hostname, an den der Server gebunden ist.

const server = Bun.serve({
  hostname: "0.0.0.0",
  fetch(req) {
    return new Response("Hallo!");
  },
});

console.log(server.hostname); // "0.0.0.0"

server.url

Eine vollständige URL zum Server.

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hallo!");
  },
});

console.log(server.url); // http://localhost:3000/

server.protocol

Das Protokoll, das der Server verwendet ("http" oder "https").

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hallo!");
  },
});

console.log(server.protocol); // "http"

server.reload()

Aktualisiert die Serverkonfiguration ohne Neustart.

const server = Bun.serve({
  port: 3000,
  routes: {
    "/": () => new Response("Version 1"),
  },
});

// Serverkonfiguration aktualisieren
server.reload({
  routes: {
    "/": () => new Response("Version 2"),
  },
});

server.requestIP()

Ruft die IP-Adresse einer Anfrage ab.

Bun.serve({
  fetch(req, server) {
    const ip = server.requestIP(req);
    return new Response(`Ihre IP ist ${ip.address}`);
  },
});

server.upgrade()

Upgradet eine HTTP-Anfrage zu einer WebSocket-Verbindung.

Bun.serve({
  fetch(req, server) {
    if (req.headers.get("upgrade") === "websocket") {
      server.upgrade(req);
      return;
    }
    return new Response("Kein WebSocket");
  },
});

server.publish()

Sendet eine Nachricht an alle WebSocket-Abonnenten eines Themas.

Bun.serve({
  websocket: {
    message(ws, message) {
      // Nachricht an alle Abonnenten des "chat"-Themas senden
      ws.publish("chat", message);
    },
  },
});

server.subscribe()

Abonniert ein WebSocket-Thema.

Bun.serve({
  websocket: {
    open(ws) {
      ws.subscribe("chat");
    },
  },
});

server.unsubscribe()

Kündigt ein WebSocket-Thema ab.

Bun.serve({
  websocket: {
    close(ws) {
      ws.unsubscribe("chat");
    },
  },
});

server.isSubscribed()

Prüft, ob ein WebSocket ein Thema abonniert hat.

Bun.serve({
  websocket: {
    message(ws, message) {
      if (ws.isSubscribed("chat")) {
        console.log("Abonniert chat");
      }
    },
  },
});

---

Konfigurationsoptionen

port

Die Portnummer, auf der der Server laufen soll. Standardmäßig wird ein verfügbarer Port gewählt.

Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hallo!");
  },
});

hostname

Der Hostname, an den der Server gebunden werden soll. Standardmäßig "0.0.0.0" (alle Schnittstellen).

Bun.serve({
  hostname: "localhost",
  fetch(req) {
    return new Response("Hallo!");
  },
});

tls

TLS/SSL-Konfiguration für HTTPS-Server.

Bun.serve({
  port: 443,
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  fetch(req) {
    return new Response("Hallo über HTTPS!");
  },
});

development

Aktiviert den Entwicklungsmodus mit detaillierteren Fehlermeldungen. Standardmäßig true, wenn NODE_ENV "development" ist.

Bun.serve({
  development: true,
  fetch(req) {
    return new Response("Hallo!");
  },
});

error

Ein benutzerdefinierter Fehlerhandler.

Bun.serve({
  fetch(req) {
    throw new Error("Ups!");
  },
  error(error) {
    console.error(error);
    return new Response("Interner Serverfehler", { status: 500 });
  },
});

---

Beispiele

Einfacher Server

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hallo Welt!");
  },
});

console.log(`Server läuft unter ${server.url}`);

JSON-API

Bun.serve({
  port: 3000,
  fetch(req) {
    return Response.json({
      message: "Hallo!",
      timestamp: new Date().toISOString(),
    });
  },
});

Statische Dateien bereitstellen

Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);
    const path = url.pathname;
    
    // Statische Datei bereitstellen
    return new Response(Bun.file(`./public${path}`));
  },
});

Request-Weiterleitung

Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);
    
    if (url.pathname === "/old") {
      return Response.redirect("/new");
    }
    
    return new Response("Hallo!");
  },
});

Mehrere Ports

// HTTP-Server
const http = Bun.serve({
  port: 80,
  fetch(req) {
    return new Response("HTTP");
  },
});

// HTTPS-Server
const https = Bun.serve({
  port: 443,
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  fetch(req) {
    return new Response("HTTPS");
  },
});