SSL-Zertifikate mit Node.js verwenden

2026-05-08

nodejsexpresssslhttpsjavascript

Node.js bietet integrierte HTTPS-Unterstützung über das https-Modul. Sie laden Ihre Zertifikatsdateien und erstellen einen HTTPS-Server. Diese Anleitung behandelt reines Node.js, Express und die empfohlene Produktionskonfiguration.

Einfacher HTTPS-Server

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('/etc/ssl/privkey.pem'),
  cert: fs.readFileSync('/etc/ssl/fullchain.pem'),
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('Hello HTTPS');
}).listen(443);

Express mit HTTPS

const https = require('https');
const fs = require('fs');
const express = require('express');

const app = express();

app.get('/', (req, res) => {
  res.send('Hello HTTPS');
});

const options = {
  key: fs.readFileSync('/etc/ssl/privkey.pem'),
  cert: fs.readFileSync('/etc/ssl/fullchain.pem'),
};

https.createServer(options, app).listen(443, () => {
  console.log('HTTPS server running on port 443');
});

HTTP auf HTTPS umleiten

Betreiben Sie sowohl einen HTTP- als auch einen HTTPS-Server:

const http = require('http');
const https = require('https');
const fs = require('fs');
const express = require('express');

const app = express();
// ... Ihre Routen

const options = {
  key: fs.readFileSync('/etc/ssl/privkey.pem'),
  cert: fs.readFileSync('/etc/ssl/fullchain.pem'),
};

// HTTPS server
https.createServer(options, app).listen(443);

// HTTP redirect
http.createServer((req, res) => {
  res.writeHead(301, { Location: `https://${req.headers.host}${req.url}` });
  res.end();
}).listen(80);

Produktionsempfehlung: Reverse Proxy

Für die Produktion sollten Sie TLS nicht direkt in Node.js terminieren. Verwenden Sie stattdessen einen Reverse Proxy (Nginx, Caddy oder einen Load Balancer):

Client ──HTTPS──→ Nginx (TLS-Terminierung) ──HTTP──→ Node.js (Port 3000)

Gründe:

Nginx verarbeitet TLS effizienter (C vs. JavaScript)
Zertifikatserneuerung erfordert keinen Neustart von Node.js
Port 443 erfordert Root-Rechte — Node.js sollte nicht als Root laufen
Ratenbegrenzung, Caching, Komprimierung werden vom Proxy übernommen
HTTP/2-Unterstützung ist in Nginx ausgereifter

Direktes HTTPS in Node.js ist für Entwicklung, interne Dienste oder kleine Projekte in Ordnung.

Gängige Frameworks

Fastify

const fastify = require('fastify')({
  https: {
    key: fs.readFileSync('/etc/ssl/privkey.pem'),
    cert: fs.readFileSync('/etc/ssl/fullchain.pem'),
  },
});

fastify.get('/', async () => ({ hello: 'https' }));
fastify.listen({ port: 443, host: '0.0.0.0' });

Koa

const Koa = require('koa');
const https = require('https');
const fs = require('fs');

const app = new Koa();
app.use(ctx => { ctx.body = 'Hello HTTPS'; });

https.createServer({
  key: fs.readFileSync('/etc/ssl/privkey.pem'),
  cert: fs.readFileSync('/etc/ssl/fullchain.pem'),
}, app.callback()).listen(443);

Next.js / Nuxt / andere Framework-Entwicklungsserver

Framework-Entwicklungsserver bieten normalerweise ein --https-Flag für die lokale Entwicklung. Für die Produktion verwenden Sie immer einen Reverse Proxy — diese Frameworks liefern statische Dateien oder führen SSR hinter Nginx, Caddy oder einem Cloud Load Balancer aus.

Umgebungsvariablen-Muster

Schreiben Sie Zertifikatspfade nicht fest in den Code. Verwenden Sie Umgebungsvariablen, damit derselbe Code in Entwicklung und Produktion funktioniert:

const options = process.env.SSL_KEY ? {
  key: fs.readFileSync(process.env.SSL_KEY),
  cert: fs.readFileSync(process.env.SSL_CERT),
} : null;

if (options) {
  https.createServer(options, app).listen(443);
  console.log('HTTPS server on port 443');
} else {
  app.listen(3000);
  console.log('HTTP server on port 3000 (no SSL_KEY set)');
}

Entwicklung mit selbstsignierten Zertifikaten

Für die lokale Entwicklung generieren Sie ein selbstsigniertes Zertifikat (nicht für Produktion):

openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 \
  -keyout dev-key.pem -out dev-cert.pem -days 365 -nodes \
  -subj "/CN=localhost"

const options = {
  key: fs.readFileSync('./dev-key.pem'),
  cert: fs.readFileSync('./dev-cert.pem'),
};

Ihr Browser zeigt eine Warnung an (selbstsignierte Zertifikate sind nicht vertrauenswürdig) — klicken Sie sich für die Entwicklung durch.

Zertifikate im laufenden Betrieb neu laden

Um Zertifikate ohne Neustart neu zu laden (nützlich für die Erneuerung von Let’s Encrypt):

const tls = require('tls');

function loadCerts() {
  return {
    key: fs.readFileSync('/etc/ssl/privkey.pem'),
    cert: fs.readFileSync('/etc/ssl/fullchain.pem'),
  };
}

const server = https.createServer({
  SNICallback: (hostname, cb) => {
    const ctx = tls.createSecureContext(loadCerts());
    cb(null, ctx);
  },
}, app);

Dies liest die Dateien bei jeder neuen Verbindung erneut. Für bessere Leistung fügen Sie einen Datei-Watcher hinzu, der nur bei Dateiänderungen neu lädt.

Häufig gestellte Fragen

Sollte ich SSL in Node.js handhaben oder einen Reverse Proxy verwenden?

Für die Produktion: Verwenden Sie einen Reverse Proxy. Für Entwicklung, kleine Projekte oder interne Dienste: Direktes HTTPS in Node.js ist in Ordnung. Das Reverse-Proxy-Muster ist Standard, weil es Zuständigkeiten trennt und TLS effizienter verarbeitet.

Kann ich GetHTTPS-Zertifikate mit Node.js verwenden?

Ja. GetHTTPS erzeugt standardmäßige PEM-Dateien (privkey.pem, fullchain.pem), die Node.js direkt mit fs.readFileSync() liest.

Wie handhabe ich die Zertifikatserneuerung in Node.js?

Bei Verwendung eines Reverse Proxys ersetzen Sie einfach die Dateien und laden den Proxy neu — Node.js muss nicht neu gestartet werden. Bei direkter TLS-Handhabung verwenden Sie den oben gezeigten SNICallback-Ansatz oder starten den Node.js-Prozess nach dem Ersetzen der Zertifikatsdateien neu.

Was ist mit localhost-SSL für die Entwicklung?

Verwenden Sie ein selbstsigniertes Zertifikat (oben gezeigt) oder mkcert für ein lokal vertrauenswürdiges Entwicklungszertifikat. Verwenden Sie Let’s Encrypt nicht für localhost — es kann keine Domain validieren, die nicht öffentlich erreichbar ist.

Kann ich GetHTTPS-Zertifikate mit Deno oder Bun verwenden?

Ja. Sowohl Deno als auch Bun unterstützen TLS mit PEM-Dateien:

Deno:

Deno.serve({
  port: 443,
  cert: Deno.readTextFileSync("/etc/ssl/fullchain.pem"),
  key: Deno.readTextFileSync("/etc/ssl/privkey.pem"),
}, (req) => new Response("Hello HTTPS"));

Bun:

Bun.serve({
  port: 443,
  tls: {
    cert: Bun.file("/etc/ssl/fullchain.pem"),
    key: Bun.file("/etc/ssl/privkey.pem"),
  },
  fetch(req) { return new Response("Hello HTTPS"); },
});

Dieselben PEM-Dateien von GetHTTPS funktionieren mit allen JavaScript-Laufzeitumgebungen.