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);Wann Hono
Abschnitt betitelt „Wann Hono“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.
Cross-Runtime- + Serverless-Vorbehalt
Abschnitt betitelt „Cross-Runtime- + Serverless-Vorbehalt“// Auf einer langlebigen VM: das funktioniertawait 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 exportierenIn Cloudflare Workers:
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.
Konfiguration
Abschnitt betitelt „Konfiguration“// 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.
Security-Header
Abschnitt betitelt „Security-Header“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.
Hono-Middleware
Abschnitt betitelt „Hono-Middleware“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.
Peer-Dependency
Abschnitt betitelt „Peer-Dependency“npm install hono# oder: bun add honoPerformance
Abschnitt betitelt „Performance“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).
Edge-Runtime-Vorbehalte
Abschnitt betitelt „Edge-Runtime-Vorbehalte“WebSockets und abort()
Abschnitt betitelt „WebSockets und abort()“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.
TLS und HTTP/2
Abschnitt betitelt „TLS und HTTP/2“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:
| Runtime | TLS | http2: true |
|---|---|---|
| Bun | Bun.serve({ tls }) | Bun.serve({ http2: true }) — h2 über ALPN, HTTP/1.1 bleibt; Bun ≥ 1.4.1, auf einem älteren abgelehnt |
| Node | https.createServer unter @hono/node-server | http2.createSecureServer mit allowHTTP1 |
| Deno | Deno.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.
Wohin als Nächstes
Abschnitt betitelt „Wohin als Nächstes“- HTTP-Übersicht — das große Bild.
- Fastify-Backend — für Node-/Bun-Produktionsserver.
- Express-Backend — für Express-Middleware-reiche Apps.
- Hono-Docs — Honos eigene Dokumentation.
