Zum Inhalt springen
Deutsch

Hono-Backend

Hono ist ein runtime-agnostisches HTTP- Framework — derselbe Code läuft auf Bun, Node, Deno, Cloudflare Workers, AWS Lambda, Vercel usw. HonoBackend wickelt es für actor-ts ein.

import { ActorSystem } from 'actor-ts';
import { HttpExtensionId } from 'actor-ts/http';
import { HonoBackend, HonoBackendOptions } from 'actor-ts/http';
const http = system.extension(HttpExtensionId);
await http.newServerAt('0.0.0.0', 8080)
.useBackend(new HonoBackend())
.bind(routes);

Hono ist die richtige Wahl, wenn:

  • Edge / Serverless — Cloudflare Workers, Vercel Edge, Deno Deploy. Hono ist eines der wenigen HTTP-Frameworks, die in solchen Umgebungen laufen.
  • Cross-Runtime-Portabilität — derselbe Code auf Bun + Node
    • Edge.
  • Minimaler Overhead — Hono ist leichter als Fastify, schneller als Express.

Für einen typischen, langlebigen Produktionsserver ist Fastify meist vorzuziehen — größeres Plugin-Ökosystem, mehr Produktionsstunden. Hono glänzt, wenn “läuft an vielen Orten” harte Anforderung ist.

// Auf einer langlebigen VM: das funktioniert
await http.newServerAt('0.0.0.0', 8080)
.useBackend(new HonoBackend())
.bind(routes);
// Auf Cloudflare Workers: es gibt kein "newServerAt(host, port)"
// Die Runtime ruft pro Request einen Handler auf.

HonoBackend exponiert seine zugrunde liegende Hono-Instanz:

const backend = new HonoBackend();
const honoApp = backend.getApp(); // ← in die Edge-Runtime exportieren

In Cloudflare Workers:

worker.ts
export default { fetch: honoApp.fetch };

Die actor-ts-Seite läuft dann In-Memory innerhalb des Isolates — kurzlebig, kein Clustering, keine Persistenz. Nützlich für zustandslose Request-Handling-Logik, die von Actor-Mustern profitiert (Zustandsautomaten, Validierungs-Pipelines).

Für langlebige Actor-Systeme mit Cluster + Persistenz läuft nicht auf Edge-Runtimes — die sind Isolate-pro-Request, keine langlebigen Prozesse.

// Hono selbst hat minimale Konfiguration; die meisten Einstellungen kommen über Routen / Middleware.
// Das Request-Body-Limit steht wie auf jedem Backend per Default auf 1 MiB;
// heb es mit HonoBackendOptions an, wo ein Endpunkt mehr annimmt:
const honoBackendOptions = HonoBackendOptions.create().withMaxBodyBytes(4 * 1024 * 1024);
new HonoBackend(honoBackendOptions);

Das serverweite actor-ts.http.server.max-content-length setzt dasselbe Limit, ohne das Backend anzufassen, und es greift auf jeder Runtime, auf der dieses Backend läuft: den Body liest dieses Backend mit eigenem Code, Bun und Deno zählen ihn also genau wie Node — eine angekündigte Länge darüber wird abgelehnt, bevor ein Byte gelesen ist, ein Chunked-Body wird abgebrochen, sobald er sie überschreitet. Ein Backend, das mit einem anderen withMaxBodyBytes gebaut wurde, wird bei bind() abgelehnt, mit beiden Zahlen in der Meldung.

Jede Response, die dieses Backend schreibt, trägt X-Content-Type-Options: nosniff — inklusive seines Fehler-Mappings, des fallback-404 und des 413 bei zu großem Body, die keine Middleware sieht. Ein Header aus der Response selbst gewinnt weiterhin.

Konfiguriert wird das pro Server, nicht pro Backend — eine Oberfläche statt dreier:

await http.newServerAt('0.0.0.0', 8080)
.useBackend(new HonoBackend())
.withSecurityHeaders(false) // oder ein SecurityHeadersOptions-Bündel
.bind(routes);

Siehe Sicherheit.

import { logger, cors, secureHeaders } from 'hono/middleware';
const backend = new HonoBackend();
await http.newServerAt('0.0.0.0', 8080)
.useBackend(backend)
.bind(routes);
backend.getApp().use('*', logger());
backend.getApp().use('/api/*', cors());
backend.getApp().use('*', secureHeaders());

Honos Middleware-Ökosystem ist kleiner als das von Express, deckt aber die üblichen Fälle ab — CORS, Security-Header, JWT-Auth, Basic-Auth, Komprimierung. Für JWT-Prüfung, die sich auf jedem Backend gleich verhält, nimm statt Honos eigener das portable JwtAuth.

Terminal-Fenster
npm install hono
# oder: bun add hono

Grobe Zahlen:

  • 100K–150K req/sec auf Bun für triviale Routen.
  • Etwas langsamer als Fastify auf Node.
  • Edge-Runtime-Zahlen hängen von der Plattform ab (Cloudflare Workers: ~50K req/sec pro Worker; von der Plattform gedrosselt).

websocket()-Routen funktionieren auf jeder Runtime, auf der dieses Backend läuft, über Honos eigenen Adapter für jede. Was abort() einer Verbindung tut — und ein Server-Shutdown, der ihre Sockets kappt —, hängt vom Socket ab, den dieser Adapter übergibt. Auf Bun (der ServerWebSocket von Bun.serve) und auf Node (@hono/node-ws, das einen ws-Socket übergibt) hat der Socket ein hartes Schließen, abort() lässt die Verbindung also sofort fallen: der Client sieht sie mit 1006 und ohne Close-Frame enden, wie auf den Backends Fastify und Express. Auf Deno ist der Socket ein gewöhnliches WebSocket, das kein hartes Schließen kennt, also fällt abort() auf einen Close-Frame mit seinem Code und seinem Grund zurück. Gemessen auf bun 1.4.2, bun 1.4.4, node v26.10.0 und deno 2.6.8.

Wie bei jedem Backend an den Server-Optionen gesetzt (siehe TLS und HTTP/2); Hono reicht das Paar an die Runtime weiter, auf der es läuft:

RuntimeTLShttp2: true
BunBun.serve({ tls })Bun.serve({ http2: true }) — h2 über ALPN, HTTP/1.1 bleibt; Bun ≥ 1.4.1, auf einem älteren abgelehnt
Nodehttps.createServer unter @hono/node-serverhttp2.createSecureServer mit allowHTTP1
DenoDeno.serve({ cert, key })ausgehandelt, sobald TLS an ist; kein Schalter, das Flag dokumentiert die Absicht

Client-Zertifikate (requestClientCert) erreichen die Sockets von Bun und Node; Deno.serve kennt keine Client-Auth-Option, auf Deno wird die Einstellung deshalb beim Binden abgelehnt, statt angenommen und nicht angewendet zu werden. Sie braucht eine ca, gegen die geprüft wird: ohne sie lehnt das Binden sie auf jeder Runtime ab, weil der TLS-Stack Client-Zertifikate sonst gegen den Standard-Trust-Store der Runtime prüfen und jedes Zertifikat einer öffentlichen CA zulassen würde.