Rate Limiting in TypeScript: Bibliotheken, Tools und Implementierungsbeispiele

Rate Limiting in TypeScript: Vollständiger Leitfaden zu Tools und Implementierung

Rate Limiting (Anfragegeschwindigkeitsbegrenzung) ist eine der wichtigsten Techniken zum Schutz von Webanwendungen und APIs vor Missbrauch, DDoS-Angriffen und übermäßiger Last. In TypeScript wird die Implementierung von Rate Limiting dank strenger Typisierung und moderner Möglichkeiten besonders elegant und zuverlässig. In diesem Artikel behandeln wir die besten Bibliotheken, Algorithmen und Codebeispiele für TypeScript.

Warum ist Rate Limiting notwendig?

Ohne Anfragegeschwindigkeitsbegrenzung kann Ihre Anwendung auf folgende Probleme stoßen:

• Serverüberlastung – ein einzelner Client kann Tausende von Anfragen pro Sekunde senden
• Brute-Force-Angriffe – Erraten von Passwörtern oder Tokens
• Finanzielle Verluste – wenn jede Anfrage kostenpflichtige Ressourcen erfordert (z. B. OpenAI API)
• Ungleichmäßige Ressourcenverteilung – ein Benutzer kann die gesamte Bandbreite beanspruchen

Beliebte Bibliotheken für Rate Limiting in TypeScript

1. bottleneck – universeller Begrenzer

Eine der beliebtesten Bibliotheken für Rate Limiting in JavaScript/TypeScript. Unterstützt sowohl die Begrenzung der Anzahl von Anfragen pro Sekunde/Minute als auch das "Hängen" (Sammeln) von Anfragen in einer Warteschlange.

import Bottleneck from 'bottleneck';

const limiter = new Bottleneck({  maxConcurrent: 2,        // maximal 2 gleichzeitige Anfragen  minTime: 1000,           // mindestens 1 Sekunde zwischen Anfragen  reservoir: 10,           // Gesamtlimit pro Zeitraum  reservoirRefreshAmount: 10,  reservoirRefreshInterval: 60 * 1000 // Aktualisierung jede Minute});

async function fetchData(url: string): Promise<any> {  return limiter.schedule(() => fetch(url));}

// Verwendungconst users = await Promise.all([  fetchData('/api/users/1'),  fetchData('/api/users/2'),  fetchData('/api/users/3'), // diese Anfrage wird warten]);

2. express-rate-limit – für Express.js

Die Standardlösung zur Begrenzung von Anfragen in Express-Anwendungen. Funktioniert hervorragend mit TypeScript.

import express from 'express';import rateLimit from 'express-rate-limit';

const app = express();

const apiLimiter = rateLimit({  windowMs: 15 * 60 * 1000, // 15 Minuten  max: 100,                 // maximal 100 Anfragen  standardHeaders: true,    // RateLimit-*-Header zurückgeben  legacyHeaders: false,  message: {    status: 429,    message: 'Zu viele Anfragen, bitte versuchen Sie es später erneut'  }});

app.use('/api/', apiLimiter);

app.listen(3000);

3. rate-limiter-flexible – flexible Lösung für Redis und integrierten Speicher

Bibliothek mit Unterstützung für verschiedene Speicher (Redis, Memory, MongoDB, Postgres) und Algorithmen (Token Bucket, Sliding Window).

import { RateLimiterMemory } from 'rate-limiter-flexible';

const rateLimiter = new RateLimiterMemory({  points: 5,        // 5 Anfragen  duration: 1,      // pro 1 Sekunde});

async function checkRateLimit(key: string): Promise<boolean> {  try {    await rateLimiter.consume(key);    return true; // Anfrage erlaubt  } catch (error) {    return false; // Limit überschritten  }}

// Beispielverwendung in Expressapp.post('/api/login', async (req, res) => {  const allowed = await checkRateLimit(req.ip);  if (!allowed) {    return res.status(429).json({ error: 'Too Many Requests' });  }  // Login-Verarbeitung...});

Rate-Limiting-Algorithmen

• Token Bucket – ein "Eimer" mit Tokens, die mit konstanter Geschwindigkeit aufgefüllt werden. Jede Anfrage verbraucht einen Token. Erlaubt kurzfristige Lastspitzen.
• Sliding Window – ein gleitendes Zeitfenster (z. B. 1 Minute). Berücksichtigt Anfragen nicht über feste Intervalle, sondern über den let