HTTP-Dienst erstellen

Elide beantwortet HTTP über einen Fetch-Handler oder über node:http; diese Seite baut einen Dienst auf beide Arten.

Zwei Arten der Bereitstellung

	Fetch-Handler	`node:http`
Einstiegspunkt	`export default { fetch }` oder `Elide.serve({ fetch })`	`http.createServer(listener).listen(port)`
Anfrage und Antwort	Web-`Request`, `Response`	`IncomingMessage`, `ServerResponse`
HTTPS und HTTP/2	Optionen `cert` und `key`	Nicht verfügbar
`--contexts`	Ja	Nein; die zweite Kopie scheitert mit `EADDRINUSE`

// server.ts
export default {
  port: Number(process.env.PORT ?? 3000),
  fetch(request: Request): Response {
    return new Response("hello\n");
  },
};

// node-server.ts
import { createServer } from "node:http";

const port = Number(process.env.PORT ?? 3000);

createServer((req, res) => {
  res.writeHead(200, { "content-type": "text/plain" });
  res.end("hello\n");
}).listen(port, "127.0.0.1");

elide run server.ts
curl -i http://127.0.0.1:3000/

HTTP/1.1 200 OK
Content-Type: text/plain;charset=UTF-8
content-length: 6
server: elide
date: Sat, 10 Oct 2026 00:18:12 GMT

hello

elide run node-server.ts beantwortet dieselbe Anfrage mit Transfer-Encoding: chunked und Connection: keep-alive.

Woran jede Variante bindet, wenn Sie keine Adresse angeben:

Server	Standardadresse
`export default { fetch }` unter `elide run`	`127.0.0.1:8080`
`export default { fetch }` unter `elide serve` / `elide dev`	`127.0.0.1:8080` / `127.0.0.1:3000`; `--host` und `--port` überschreiben sie
`Elide.serve({ port, fetch })`	`0.0.0.0` auf `port`

Routen, JSON und Streaming

URLPattern, Request.json(), Response.json() und ReadableStream-Bodys sind global verfügbar. Dieser Server hat eine API, eine gestreamte Antwort und statische Dateien aus public/:

// app.ts
import { readFile } from "node:fs/promises";
import { extname, join, normalize } from "node:path";

const users = new URLPattern({ pathname: "/api/users/:id" });
const types: Record<string, string> = {
  ".html": "text/html; charset=utf-8",
  ".css": "text/css",
  ".js": "text/javascript",
};

async function api(request: Request): Promise<Response | null> {
  const url = new URL(request.url);
  const match = users.exec(url);
  if (match && request.method === "GET") {
    return Response.json({ id: match.pathname.groups.id });
  }
  if (url.pathname === "/api/users" && request.method === "POST") {
    const body = await request.json();
    return Response.json({ created: body.name }, { status: 201 });
  }
  if (url.pathname === "/api/ticks") {
    let n = 0;
    const stream = new ReadableStream({
      async pull(controller) {
        controller.enqueue(new TextEncoder().encode(`tick ${++n}\n`));
        await new Promise((r) => setTimeout(r, 200));
        if (n === 3) controller.close();
      },
    });
    return new Response(stream, { headers: { "content-type": "text/plain" } });
  }
  return null;
}

async function file(pathname: string): Promise<Response> {
  const path = join("public", normalize(pathname === "/" ? "/index.html" : pathname));
  try {
    const body = await readFile(path);
    return new Response(body, { headers: { "content-type": types[extname(path)] ?? "application/octet-stream" } });
  } catch {
    return new Response("not found\n", { status: 404 });
  }
}

export default {
  port: Number(process.env.PORT ?? 3000),
  async fetch(request: Request): Promise<Response> {
    return (await api(request)) ?? file(new URL(request.url).pathname);
  },
};

elide run app.ts
curl http://127.0.0.1:3000/api/users/42
curl -X POST -H 'content-type: application/json' -d '{"name":"ada"}' http://127.0.0.1:3000/api/users
curl -N http://127.0.0.1:3000/api/ticks

{"id":"42"}
{"created":"ada"}
tick 1
tick 2
tick 3

Der POST antwortet mit 201 Created. Die drei Ticks kommen im Abstand von 200 ms an. / liefert public/index.html, eine fehlende Datei liefert 404.

Dieselbe API auf node:http liest den Body mit node:stream/consumers und streamt mit res.write:

// node-app.ts
import { createServer } from "node:http";
import { text } from "node:stream/consumers";

createServer(async (req, res) => {
  if (req.method === "POST" && req.url === "/api/users") {
    const body = JSON.parse(await text(req));
    res.writeHead(201, { "content-type": "application/json" });
    res.end(JSON.stringify({ created: body.name }));
    return;
  }
  if (req.url === "/api/ticks") {
    res.writeHead(200, { "content-type": "text/plain" });
    for (let n = 1; n <= 3; n++) {
      res.write(`tick ${n}\n`);
      await new Promise((r) => setTimeout(r, 200));
    }
    res.end();
    return;
  }
  res.writeHead(404).end();
}).listen(Number(process.env.PORT ?? 3000), "127.0.0.1");

Um nur Dateien bereitzustellen, verwenden Sie elide serve ./public; siehe Entwicklungsserver.

Fehler

Ein Fetch-Handler, der eine Ausnahme wirft oder dessen Promise abgelehnt wird, antwortet mit 500 Internal Server Error und bedient weiter Anfragen. Der Fehler wird nicht ausgegeben; fangen und protokollieren Sie ihn selbst:

curl -i -d 'not json' http://127.0.0.1:3000/api/users

HTTP/1.1 500 Internal Server Error
Content-Type: text/plain; charset=utf-8
content-length: 21
server: elide
date: Sat, 10 Oct 2026 00:34:28 GMT

Internal Server Error

TLS

Übergeben Sie PEM-Strings als cert und key an Elide.serve oder als Eigenschaften des exportierten Objekts. Der Schlüssel muss unverschlüsseltes PKCS#8 sein (BEGIN PRIVATE KEY). Clients, die HTTP/2 anbieten, erhalten HTTP/2.

// tls.ts
import { readFileSync } from "node:fs";

Elide.serve({
  port: Number(process.env.PORT ?? 8443),
  cert: readFileSync("cert.pem", "utf8"),
  key: readFileSync("key.pem", "utf8"),
  fetch(request) {
    return new Response("hello over tls\n");
  },
});

elide run tls.ts
curl -i --cacert cert.pem https://localhost:8443/

HTTP/2 200
content-type: text/plain;charset=UTF-8
content-length: 15
server: elide
date: Sat, 10 Oct 2026 00:18:52 GMT

hello over tls

elide serve und elide dev haben keine TLS-Flags, und elide.pkl hat keine TLS-Einstellungen. https.createServer wirft:

Error: HTTPS server is not supported in this runtime (no host TLS listener); use http.createServer behind a TLS terminator, or https client APIs.

Mehrere Kontexte

--contexts=N führt unter Linux N Kopien einer App mit Fetch-Handler auf einem Port aus. Jede Kopie hat ihren eigenen Modulzustand:

// counter.ts
let count = 0;

export default {
  fetch(): Response {
    count += 1;
    return new Response(`${count}\n`);
  },
};

elide serve --no-tui --contexts=4 counter.ts
for i in 1 2 3 4 5 6 7 8; do curl -s http://127.0.0.1:8080/; done

Halten Sie gemeinsamen Zustand in einer Datenbank oder einem anderen Dienst. --contexts=auto bemisst die Anzahl nach den CPU-Kernen; engine.contexts in elide.pkl legt sie pro Projekt fest (Engine-Kontexte).

Frameworks

Installieren Sie sie mit elide install --ecosystems=npm.

Framework	Status
Hono	Funktioniert: `export default { fetch: app.fetch }` oder `export default app`.
Express 5	Routing, `res.json`, `express.raw()` und das manuelle Lesen von `req` funktionieren. `express.json()` und `express.text()` beenden den Prozess mit `TypeError: Buffer.isBuffer is not a function`.
Fastify 5	Scheitert beim Import: `Error: No such built-in module: node:http2`.

// hono-app.ts
import { Hono } from "hono";

const app = new Hono();
app.get("/users/:id", (c) => c.json({ id: c.req.param("id") }));
app.post("/users", async (c) => c.json({ created: (await c.req.json()).name }, 201));

export default {
  port: Number(process.env.PORT ?? 3000),
  fetch: app.fetch,
};