Rate Limiting und API-Sicherheit

Sobald deine API öffentlich erreichbar ist, wird sie auch missbraucht: durch versehentliche Endlosschleifen, aggressive Crawler oder gezielte Angriffe. Rate Limiting begrenzt, wie viele Anfragen ein Client in einem Zeitfenster stellen darf, und ist damit eine der wichtigsten Schutzmaßnahmen. In diesem Beitrag schauen wir uns Rate Limiting und weitere Grundlagen der API-Sicherheit an.

Warum Rate Limiting wichtig ist

Ohne Begrenzung kann ein einzelner Client deine API mit Anfragen überfluten. Das kostet Rechenleistung, treibt deine Kosten in die Höhe und kann den Dienst für alle anderen lahmlegen. Rate Limiting schützt vor:

• Überlastung durch zu viele gleichzeitige Anfragen,
• Brute-Force-Angriffen auf Login-Endpunkte,
• Missbrauch teurer Operationen wie Suchen oder Exporten.

Die Idee ist simpel: Du zählst die Anfragen pro Client und blockst, sobald ein Limit überschritten ist.

Der Statuscode 429

Wird ein Limit überschritten, antwortest du mit dem HTTP-Statuscode 429 Too Many Requests. Oft schickst du zusätzlich einen Retry-After-Header, der dem Client sagt, wann er es erneut versuchen darf:

HTTP/1.1 429 Too Many Requests
Retry-After: 60
Content-Type: application/json

{ "error": "Zu viele Anfragen. Bitte spaeter erneut versuchen." }

So weiß ein gut gebauter Client, dass er kurz warten und dann fortfahren soll, statt sofort wieder anzufragen.

Rate Limiting in Express

In Node.js erledigt die Bibliothek express-rate-limit die Arbeit. Du definierst ein Zeitfenster und ein Maximum an Anfragen:

const rateLimit = require("express-rate-limit");

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 Minuten
  max: 100,                 // max. 100 Anfragen pro IP
  message: { error: "Zu viele Anfragen" }
});

// Auf alle Routen anwenden
app.use(limiter);

Hier darf jede IP maximal 100 Anfragen in 15 Minuten stellen. Sensible Endpunkte wie das Login solltest du noch strenger begrenzen.

Ein einfacher eigener Limiter

Um das Prinzip zu verstehen, kannst du einen einfachen Zähler selbst schreiben. Pro IP merkst du dir, wie viele Anfragen schon kamen:

const anfragen = new Map();

function eigenerLimiter(req, res, next) {
  const ip = req.ip;
  const anzahl = (anfragen.get(ip) || 0) + 1;
  anfragen.set(ip, anzahl);

  if (anzahl > 100) {
    return res.status(429).json({ error: "Zu viele Anfragen" });
  }
  next();
}

// Zaehler regelmaessig zuruecksetzen
setInterval(() => anfragen.clear(), 15 * 60 * 1000);

In der Praxis nutzt du dafür Redis, damit der Zähler über mehrere Server hinweg gilt. Das Beispiel zeigt aber gut, was im Hintergrund passiert.

Weitere Sicherheitsmaßnahmen

Rate Limiting allein reicht nicht. Eine sichere API braucht mehrere Schichten:

• Authentifizierung: Stelle sicher, dass nur berechtigte Clients zugreifen, etwa über API-Keys oder Tokens.
• Eingabevalidierung: Prüfe jede Eingabe, um Injection-Angriffe zu verhindern.
• HTTPS: Verschlüssele die Übertragung, damit niemand mitlesen kann.
• Security-Header: Setze sinnvolle HTTP-Header, zum Beispiel mit der Bibliothek helmet.

const helmet = require("helmet");
app.use(helmet()); // setzt mehrere Sicherheits-Header automatisch

Fazit

Rate Limiting ist eine einfache, aber wirkungsvolle Verteidigung gegen Überlastung und Missbrauch deiner API. Antworte mit Statuscode 429 und einem Retry-After-Header, damit Clients sauber reagieren können. Kombiniere die Begrenzung mit Authentifizierung, Validierung, HTTPS und Security-Headern. Erst zusammen ergeben diese Maßnahmen eine robuste und sichere Schnittstelle.