So erstellen Sie ein sicheres API-Gateway mit Node.js

Microservices bieten gegenüber Monolithen erhebliche Vorteile. Sie können die Entwicklung einfacher skalieren und die Skalierung der Infrastruktur präzise steuern. Außerdem verkürzen häufige kleine Updates und schrittweise Rollouts die Time-to-Market deutlich.

Trotz dieser Vorteile bringt eine Microservices-Architektur ein Problem mit sich: Auf ihre Services kann nicht von außen zugegriffen werden. Ein API-Gateway kann dieses Problem glücklicherweise lösen.

API-Gateways können Ihren Frontend-Anwendungen (z. B. Websites und nativen Apps) einen klaren Zugriffsweg auf sämtliche Backend-Funktionen bieten. Sie können als Aggregatoren für die Microservices und als Middleware für allgemeine Aufgaben wie Authentifizierung und Autorisierung dienen. Außerdem erleichtern API-Gateways die Zusammenfassung und Vereinheitlichung von Services, indem sie Ausgabeformate wie XML und JSON in ein einzelnes Format überführen.

API-Gateways sind ein wichtiges Instrument für Sicherheit und Zuverlässigkeit. Sie bieten Sitzungsverwaltung, Eingabebereinigung, Schutz vor Distributed-Denial-of-Service-Angriffen (DDoS), Rate-Limiting und Transaktionsprotokollierung.

In diesem Artikel erstellen wir von Grund auf ein sicheres API-Gateway – nur mit Node.js und einigen Open-Source-Paketen. Sie benötigen lediglich grundlegende Kenntnisse im Umgang mit dem Terminal, Node.js Version 14 oder höher und JavaScript. Den fertigen Projektcode finden Sie hier.

Legen wir los!

Unser API-Gateway erstellen

Zwar könnten wir einen Webserver in Node.js von Grund auf schreiben, doch überlassen wir die Hauptarbeit hier einem bestehenden Framework. Die wohl beliebteste Wahl für Node.js ist Express: Es ist schlank, ausreichend schnell und lässt sich leicht erweitern. Außerdem können Sie fast jedes benötigte Paket in Express integrieren.

Erstellen wir zunächst ein neues Node.js-Projekt und installieren Express:

1npm init -y
2npm install express --save

Mit diesen beiden Befehlen haben wir ein neues Node.js-Projekt mit den Standardeinstellungen erstellt und das Paket express installiert. In unserem Projektverzeichnis sollten sich nun die Datei package.json und das Verzeichnis node_modules befinden.

Erstellen Sie nun eine Datei namens index.js und legen Sie sie neben package.json ab. Der Dateiinhalt sollte zunächst so aussehen:

1const express = require("express");
2
3const app = express();
4const port = 3000;
5
6app.get("/", (req, res) => {
7  const { name = "user" } = req.query;
8  res.send(`Hello ${name}!`);
9});
10
11app.listen(port, () => {
12  console.log(`Server running at http://localhost:${port}`);
13});

Damit sollte ein einfacher Webserver mit einem Endpunkt laufen. Starten Sie ihn mit dem folgenden Befehl im Terminal:

1node index.js

Rufen Sie anschließend in Ihrem Browser http://localhost:3000 auf. Auf dem Bildschirm sollte „Hello user!“ erscheinen. Wenn Sie der URL eine Abfrage anhängen, zum Beispiel ?name=King, sollte „Hello King!“ angezeigt werden.

Als Nächstes richten wir die Authentifizierung ein. Dazu verwenden wir das Paket express-session. Es nutzt ein Cookie, um unsere Endpunkte zu schützen. Nutzerinnen und Nutzer ohne gültiges Sitzungscookie erhalten eine entsprechende Antwort mit dem HTTP-Statuscode HTTP 401 (Unauthorized) oder 403 (Forbidden).

Außerdem schützen wir unser Passwort besser, indem wir es in einer Umgebungsvariable speichern. Mit dem Paket dotenv laden wir die Variable SESSION_SECRET aus einer .env-Datei in process.env.

Beenden Sie zunächst den vorherigen Prozess, indem Sie in der Konsole Ctrl + C eingeben. Installieren Sie anschließend express-session und dotenv mit folgendem Befehl:

1npm install express-session dotenv --save

Weitere Anweisungen zum Einrichten einer sicheren Sitzung finden Sie in der Dokumentation zu express-session auf GitHub. Dazu gehört etwa, das Cookie-Flag secure auf true zu setzen, damit das Cookie nur über HTTPS-Verbindungen übertragen wird. Berücksichtigen Sie bei der Sitzungsverwaltung auch weitere Sicherheitsmaßnahmen, beispielsweise das Erneuern der Sitzungs-ID bei sensiblen Vorgängen wie der Anmeldung oder einer Passwortänderung.

Erstellen Sie als Nächstes im Stammverzeichnis Ihres Projekts eine .env-Datei und fügen Sie den folgenden Code ein:

1SESSION_SECRET=`<your_secret>`

Umgebungsvariablen werden üblicherweise in Großbuchstaben geschrieben. Verwenden Sie unbedingt ein einzigartiges, zufällig generiertes Geheimnis – ein starkes Passwort eignet sich dafür.

Unsere Ergänzungen in index.js sollten so aussehen. Dieses Snippet verwenden wir später beim Zusammenfügen der Lösung:

1require("dotenv").config();
2
3const session = require("express-session");
4
5const secret = process.env.SESSION_SECRET;
6const store = new session.MemoryStore();
7const protect = (req, res, next) => {
8  const { authenticated } = req.session;
9
10  if (!authenticated) {
11    res.sendStatus(401);
12  } else {
13    next();
14  }
15};
16
17app.use(
18  session({
19    secret,
20    resave: false,
21    saveUninitialized: true,
22    store,
23  })
24);

Mit dieser Einrichtung erhalten wir eine sitzungsbasierte Verwaltung im Arbeitsspeicher, mit der Sie Endpunkte schützen können. Verwenden wir sie für einen neuen Endpunkt und richten wir spezielle Endpunkte für die Anmeldung und Abmeldung ein. Fügen Sie den folgenden Code am Ende von index.js ein:

1app.get("/login", (req, res) => {
2  const { authenticated } = req.session;
3
4  if (!authenticated) {
5    req.session.authenticated = true;
6    res.send("Successfully authenticated");
7  } else {
8    res.send("Already authenticated");
9  }
10});
11
12app.get("/logout", protect, (req, res) => {
13  req.session.destroy(() => {
14    res.send("Successfully logged out");
15  });
16});
17
18app.get("/protected", protect, (req, res) => {
19  const { name = "user" } = req.query;
20  res.send(`Hello ${name}!`);
21});

Führen Sie den Code nun erneut mit dem Befehl node index.js aus und probieren Sie ihn selbst aus.

Wie funktioniert das Ganze? Hier ist ein einfacher Ablauf:

• Der Aufruf von / funktioniert.

• Der Aufruf von /protected gibt den HTTP-Statuscode 401 (Unauthorized) zurück.

• Der Aufruf von /login meldet Sie automatisch an und zeigt „Successfully authenticated.“ an.

• Ein erneuter Aufruf von /login zeigt „Already authenticated.“ an.

• Wenn Sie /protected aufrufen, funktioniert die Seite nun.

• Der Aufruf von /logout setzt die Sitzung zurück und zeigt „Successfully logged out.“ an.

• Anschließend ist /protected wieder nicht zugänglich und gibt den Statuscode 401 zurück.

• Auch ein erneuter Aufruf von /logout gibt den Statuscode 401 zurück.

Mit der Middleware protect vor dem Request-Handler können wir einen Endpunkt schützen und sicherstellen, dass Nutzerinnen und Nutzer angemeldet sind. Zusätzlich dienen die Endpunkte /login und /logout dazu, diese Funktionen zu ergänzen.

Beenden Sie den Prozess erneut mit Ctrl + C. Bevor wir uns dem Kern unseres API-Gateways widmen, sehen wir uns Protokollierung und korrektes Rate-Limiting an.

Rate-Limiting

Rate-Limiting begrenzt, wie oft innerhalb eines festgelegten Zeitraums auf Ihre API zugegriffen werden kann. So schützen Sie sie vor einer Überlastung der Bandbreite durch normalen Datenverkehr und DoS-Angriffe. Sie können Ratenlimits für Datenverkehr aus bestimmten Quellen konfigurieren. Außerdem gibt es verschiedene Möglichkeiten, das Zeitfenster zu berechnen und durchzusetzen, in dem Anfragen verarbeitet werden.

Installieren Sie zunächst ein Paket für Rate-Limiting:

1npm install express-rate-limit --save

Konfigurieren Sie anschließend das Paket. Fügen Sie diesen Code in die Datei index.js ein, und zwar vor den Routen, für die das Limit gelten soll:

1const rateLimit = require("express-rate-limit");
2
3app.use(
4  rateLimit({
5    windowMs: 15 * 60 * 1000, // 15 minutes
6    max: 5, // 5 calls
7  })
8);

Testen Sie die Konfiguration, indem Sie den Server mit dem Befehl node index.js neu starten und unseren ersten Endpunkt mehrmals aufrufen. Sobald Sie innerhalb von 15 Minuten das Limit von fünf Anfragen erreicht haben, sollte die Meldung „Too many requests, please try again later.“ angezeigt werden. Standardmäßig gibt express-rate-limit auch den korrekten HTTP-Statuscode 429 (Too Many Requests) zurück.

Beenden Sie den Prozess, bevor Sie zum nächsten Schritt übergehen, um Ihr Limit zurückzusetzen.

Protokollierung

Für die Protokollierung können wir winston verwenden. Dazu gehört auch eine spezielle Middleware für Express: express-winston. Außerdem möchten wir möglicherweise die Antwortzeiten der Endpunkte protokollieren, um sie später genauer zu untersuchen. Das Paket response-time eignet sich dafür. Installieren wir diese Pakete.

1npm install winston express-winston response-time --save

Die Integration dieser Pakete ist unkompliziert. Fügen Sie den folgenden Code vor dem Code ein, den Sie protokollieren möchten – am besten also vor dem Rate-Limiting-Code in index.js:

1const winston = require("winston");
2const expressWinston = require("express-winston");
3const responseTime = require("response-time");
4
5app.use(responseTime());
6
7app.use(
8  expressWinston.logger({
9    transports: [new winston.transports.Console()],
10    format: winston.format.json(),
11    statusLevels: true,
12    meta: false,
13    msg: "HTTP {{req.method}} {{req.url}} {{res.statusCode}} {{res.responseTime}}ms",
14    expressFormat: true,
15    ignoreRoute() {
16      return false;
17    },
18  })
19);

Mit dieser Konfiguration erhalten wir zusätzliche Ausgaben. Wenn Sie nun den Server starten und / aufrufen, sollte die Konsole so aussehen:

1Server running at http://localhost:3000
2{"level":"info","message":"GET / 200 8ms","meta":{}}
3{"level":"warn","message":"GET /favicon.ico 404 3ms","meta":{}}

Wenn Sie fortfahren möchten, beenden Sie den Prozess mit Ctrl + C.

Cross-Origin Resource Sharing (CORS)

Da unser API-Gateway als Vermittlungsschicht zwischen Frontend- und Backend-Services dient, übernehmen wir hier die Konfiguration von Cross-Origin Resource Sharing (CORS). CORS ist ein browserbasierter Sicherheitsmechanismus, der sicherstellt, dass das Backend bestimmte Cross-Origin-Anfragen akzeptiert, zum Beispiel Anfragen von www.company.com an api.company.com.

Dazu senden wir vor der eigentlichen Anfrage eine spezielle Anfrage. Sie verwendet die HTTP-Methode OPTION HTTP und erwartet spezielle Header in der Antwort, die nachfolgende Anfragen erlauben oder ablehnen.

Um CORS in unserem Gateway zu aktivieren, installieren wir das Paket cors. Außerdem können wir mit dem praktischen Paket helmet weitere Sicherheits-Header hinzufügen. Installieren Sie beide Pakete mit dem folgenden Befehl:

1npm install cors helmet --save

So können wir die Pakete integrieren:

1const cors = require("cors");
2const helmet = require("helmet");
3
4app.use(cors());
5app.use(helmet());

Mit dieser Konfiguration können alle Domains auf die API zugreifen. Wir könnten die Einstellungen auch detaillierter abstimmen, aber vorerst reicht die obige Konfiguration aus.

Proxying

Ein API-Gateway leitet hauptsächlich Anfragen an bestimmte Microservices weiter, um Geschäftslogik- und andere HTTP-Anfragen zu routen. Dafür benötigen wir ein Paket, das diese Weiterleitung übernimmt – einen Proxy. Wir verwenden http-proxy-middleware. Sie können es mit dem folgenden Befehl installieren:

1npm install http-proxy-middleware --save

Fügen wir es nun zusammen mit einem neuen Endpunkt hinzu:

1const { createProxyMiddleware } = require("http-proxy-middleware");
2
3app.use(
4  "/search",
5  createProxyMiddleware({
6    target: "http://api.duckduckgo.com/",
7    changeOrigin: true,
8    pathRewrite: {
9      [`^/search`]: "",
10    },
11  })
12);

Testen Sie die Konfiguration, indem Sie den Server starten und /search?q=x&format=json aufrufen. Dieser Endpunkt gibt die Ergebnisse zurück, die durch die Weiterleitung der Anfrage an http://api.duckduckgo.com/ abgerufen wurden. Wenn Sie den Code ausführen, beenden Sie den Prozess anschließend, bevor Sie mit den letzten Änderungen fortfahren.

Konfiguration

Da wir nun alle Komponenten haben, konfigurieren wir sie so, dass sie zusammenarbeiten. Erstellen Sie dazu im selben Verzeichnis wie die anderen Dateien eine neue Datei namens config.js:

1require("dotenv").config();
2
3exports.serverPort = 3000;
4exports.sessionSecret = process.env.SESSION_SECRET;
5exports.rate = {
6  windowMs: 5 * 60 * 1000,
7  max: 100,
8};
9exports.proxies = {
10  "/search": {
11    protected: true,
12    target: "http://api.duckduckgo.com/",
13    changeOrigin: true,
14    pathRewrite: {
15      [`^/search`]: "",
16    },
17  },
18};

Hier haben wir die grundlegende Konfiguration unseres API-Gateways erstellt. Wir legen den Port, den Verschlüsselungsschlüssel für Sitzungscookies und die verschiedenen Proxy-Endpunkte fest. Die Optionen für jeden Proxy entsprechen denen der Funktion createProxyMiddleware, ergänzt um den Schlüssel protected.

Passen wir nun auch die Deklarationen für secret und port sowie den Aufruf von rateLimit in index.js an, damit sie auf die Werte in unserer Konfigurationsdatei verweisen:

1const secret = config.sessionSecret;
2...
3const port = config.serverPort;
4...
5app.use(rateLimit(config.rate));

Entfernen Sie außerdem den Code, dessen Funktionalität wir nach config.js verschoben haben, sowie unseren anfänglichen Code zum Testen des Endpunkts. Löschen Sie den folgenden Code aus index.js:

1require("dotenv").config();
2...
3app.use(
4 "/search",
5 createProxyMiddleware({
6   target: "http://api.duckduckgo.com/",
7   changeOrigin: true,
8   pathRewrite: {
9 [`^/search`]: "",
10   },
11 })
12);
13...
14app.get("/", (req, res) => {
15 const { name = "user" } = req.query;
16 res.send(`Hello ${name}!`);
17});
18...
19app.get("/protected", protect, (req, res) => {
20 const { name = "user" } = req.query;
21 res.send(`Hello ${name}!`);
22});

Die fertige Anwendung

Sehen wir uns den Inhalt der fertigen Datei index.js an, die wir um einige kleine Ergänzungen erweitert haben:

1// import all the required packages
2const cors = require("cors");
3const express = require("express");
4const session = require("express-session");
5const rateLimit = require("express-rate-limit");
6const expressWinston = require("express-winston");
7const helmet = require("helmet");
8const { createProxyMiddleware } = require("http-proxy-middleware");
9const responseTime = require("response-time");
10const winston = require("winston");
11const config = require("./config");
12
13// configure the application
14const app = express();
15const port = config.serverPort;
16const secret = config.sessionSecret;
17const store = new session.MemoryStore();

Wir ergänzen eine Logik, um die Werte der geschützten Eigenschaften der Proxys zu prüfen, die wir in config.js auflisten. Wenn sie auf false gesetzt sind, übergibt die hier definierte Funktion alwaysAllow die Steuerung an den nächsten Handler:

1const alwaysAllow = (_1, _2, next) => {
2  next();
3};
4const protect = (req, res, next) => {
5  const { authenticated } = req.session;
6
7  if (!authenticated) {
8    res.sendStatus(401);
9  } else {
10    next();
11  }
12};

Einige ältere Servertechnologien fügen im HTTP-Header außerdem nicht funktionsrelevante Beschreibungsdaten zum Server hinzu. Um unser API sicher zu halten, entfernen wir diese Daten und geben potenziell böswilligen Akteuren weniger Informationen preis:

1app.disable("x-powered-by");
2
3app.use(helmet());
4
5app.use(responseTime());
6
7app.use(
8  expressWinston.logger({
9    transports: [new winston.transports.Console()],
10    format: winston.format.json(),
11    statusLevels: true,
12    meta: false,
13    level: "debug",
14    msg: "HTTP {{req.method}} {{req.url}} {{res.statusCode}} {{res.responseTime}}ms",
15    expressFormat: true,
16    ignoreRoute() {
17      return false;
18    },
19  })
20);
21
22app.use(cors());
23
24app.use(rateLimit(config.rate));
25
26app.use(
27  session({
28    secret,
29    resave: false,
30    saveUninitialized: true,
31    store,
32  })
33);
34
35app.get("/login", (req, res) => {
36  const { authenticated } = req.session;
37
38  if (!authenticated) {
39    req.session.authenticated = true;
40    res.send("Successfully authenticated");
41  } else {
42    res.send("Already authenticated");
43  }
44});

Als Nächstes durchlaufen wir die in config.js aufgeführten Proxys, prüfen den Wert ihres Parameters protected, rufen entweder die zuvor definierte Funktion protect oder alwaysAllow auf und fügen für jeden konfigurierten Eintrag einen neuen Proxy hinzu:

1Object.keys(config.proxies).forEach((path) => {
2  const { protected, ...options } = config.proxies[path];
3  const check = protected ? protect : alwaysAllow;
4  app.use(path, check, createProxyMiddleware(options));
5});
6
7app.get("/logout", protect, (req, res) => {
8  req.session.destroy(() => {
9    res.send("Successfully logged out");
10  });
11});
12
13app.listen(port, () => {
14  console.log(`Server running at http://localhost:${port}`);
15});

Dieser Code ist bereits recht flexibel, verwendet jedoch standardmäßig HTTP statt HTTPS. In vielen Fällen ist das ausreichend. In Kubernetes kann der Code beispielsweise hinter einem NGINX-Ingress laufen, der TLS verarbeitet und für das Zertifikat zuständig ist.

Manchmal möchten wir den laufenden Code jedoch direkt dem Internet zugänglich machen. In diesem Fall benötigen wir ein gültiges Zertifikat.

Ein Zertifikatsanbieter wie Let’s Encrypt bietet zahlreiche Möglichkeiten, HTTPS zu aktivieren. Mit einem Client wie Greenlock Express können Sie Ihre Zertifikate automatisch verwalten. Alternativ können Sie mit einem Client wie Publishlab acme-client einen detaillierteren Ansatz umsetzen.

1const { readFileSync } = require('fs');
2const { createServer } = require('https');
3
4// assumes that the key and certificate are stored in a "cert" directory
5const credentials = {
6  key: readFileSync('cert/server.key', 'utf8'),
7  cert: readFileSync('cert/server.crt', 'utf8'),
8};
9
10// here we use the express "app" to attach to the created server
11const httpsServer = createServer(credentials, app);

Beachten Sie, dass hierfür sudo erforderlich ist. Das ist ohnehin zu erwarten, denn HTTPS ist hier nur erforderlich, wenn der Server direkt erreichbar ist. Deshalb benötigen wir Port 443 statt eines öffentlichen Ports wie 8443.

1// use standard HTTPS port
2httpsServer.listen(443);

Fazit

Wir haben jetzt ein sicheres API-Gateway von Grund auf mit Node.js entwickelt. Dabei haben wir Funktionen wie Sitzungsverwaltung, Drosselung, Proxys, Protokollierung und CORS implementiert. Außerdem haben wir gelernt, Node.js so zu konfigurieren, dass TLS verwendet und der Zugriff über HTTPS erzwungen wird.

Ein API-Gateway bietet erhebliche Vorteile für größere Back-End-Infrastrukturen. Wenn die Back-End-Services hinter einem API-Gateway verborgen sind, lassen sich gemeinsame Sicherheitsprotokolle einfach durchsetzen. Dadurch werden unsere Services deutlich einfacher und vor alltäglichen Schwachstellen geschützt.