API Rate Limiting: 5 Muster für ausfallsichere Systeme
Rate Limiting wird in vielen Backend-Projekten stiefmütterlich behandelt. Oft endet es bei einer naiven IP-basierten Middleware, die im In-Memory-Speicher einer einzelnen Node.js- oder FastAPI-Instanz läuft. Sobald die Anwendung horizontal skaliert, hinter einem Cloud-Load-Balancer mit CGNAT sitzt oder gezieltem Credential Stuffing ausgesetzt ist, bricht dieses Kartenhaus zusammen.
Effektives Rate Limiting schützt nicht nur vor DoS-Attacken, sondern sichert die Stabilität granularer Microservice-Architekturen, verhindert das Noisy-Neighbor-Problem in Multi-Tenant-Umgebungen und schützt Datenbanken vor Thundering Herds.
Algorithmen im Härtetest: Die richtige Mechanik wählen
Nicht jeder Anwendungsfall verlangt denselben Algorithmus. Wer den falschen Mechanismus wählt, riskiert unberechtigte Rejections oder Systemüberlastung.
1. Fixed Window Counter
Der einfachste Ansatz unterteilt Zeit in feste Blöcke (z. B. 00:00 bis 00:01). Jeder Request inkrementiert einen Counter.
- Problem: Das 2x-Burst-Phänomen an den Intervallgrenzen. Erlaubt man 100 Requests pro Minute und ein Client sendet 100 Requests um 00:00:59 sowie weitere 100 um 00:01:01, verarbeitet das Backend 200 Anfragen innerhalb von zwei Sekunden – eine Verdopplung der Maximallast.
2. Sliding Window Counter (Approximation)
Statt den exakten Zeitstempel jedes Requests in speicherhungrigen Redis ZSETs (Sliding Log) abzulegen, gewichtet dieser Ansatz den Zähler des vorherigen Fensters proportional zur verbleibenden Zeit: $$\text{Requests} = \text{Count}{\text{prev}} \times (1 - \text{Offset}) + \text{Count}{\text{current}}$$ Dies reduziert den RAM-Bedarf um bis zu 95 % gegenüber Sorted Sets bei über 99 % statistischer Genauigkeit. Ideal für hochfrequente Public APIs.
3. Token Bucket
Tokens werden kontinuierlich mit einer festen Rate in einen Eimer gefüllt, bis ein Maximum erreicht ist. Jeder Request verbraucht ein Token.
- Stärke: Erlaubt elastische Bursts bei kontinuierlich definiertem Durchsatz. Perfekt für Standard-REST-APIs, bei denen Clients nach Seitenaufrufen kurzfristig parallele Ressourcen abrufen müssen.
4. Leaky Bucket
Anfragen tröpfeln mit konstanter Rate aus einer Queue in das Backend; läuft die Queue voll, werden neue Requests verworfen.
- Stärke: Reines Traffic Shaping. Unverzichtbar vor fragilen Legacy-Systemen, Third-Party-APIs mit harten SLAs oder ressourcenintensiven PDF- und Bildverarbeitungs-Pipelines.
Redis & Atomizität: Race Conditions eliminieren
Ein klassischer Implementierungsfehler im verteilten System ist die Sequenz GET key -> IF count < limit -> INCR key. Bei 20 parallelen Requests desselben Clients lesen alle denselben alten Stand aus. Das Limit wird massiv überzogen.
Redis-Transaktionen (MULTI/EXEC) lösen dieses Problem nur bedingt, da Zwischenergebnisse nicht innerhalb der Transaktion ausgewertet werden können. Die einzig performante und atomare Lösung sind server-seitige Lua-Skripte, die Latenzen auf genau einen Network-Roundtrip reduzieren.
Speicheroptimierter Sliding Window Counter in Redis-Lua
Dieses Skript implementiert die Approximation über zwei Fenster ohne ZSET-Overhead:
-- Redis Lua: Sliding Window Counter (Memory-efficient)
local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])
local current_window_bucket = math.floor(now / window)
local prev_window_bucket = current_window_bucket - 1
local cur_key = key .. ':' .. current_window_bucket
local prev_key = key .. ':' .. prev_window_bucket
local current_count = tonumber(redis.call('GET', cur_key) or '0')
local prev_count = tonumber(redis.call('GET', prev_key) or '0')
local time_into_current = now % window
local weight = (window - time_into_current) / window
local estimated_count = math.floor(prev_count * weight + current_count)
if estimated_count < limit then
redis.call('INCR', cur_key)
redis.call('EXPIRE', cur_key, window * 2)
return {1, limit - estimated_count - 1}
else
return {0, 0}
end
Das Skript gibt atomar zurück, ob der Request erlaubt ist (1 oder 0) sowie die verbleibende Kontingentmenge für den X-RateLimit-Remaining-Header.
Defense-in-Depth: Edge Offloading vor dem Application Server
Rate Limiting darf niemals ausschließlich in der Business-Logik sitzen. Wenn 50.000 unautorisierte Requests pro Sekunde auf eine Python- oder Node.js-Instanz treffen, blockiert allein der TLS-Handshake und der HTTP-Parsing-Overhead die Event Loop bzw. Worker-Threads.
Ein robustes Setup nutzt hierarchische Schutzschichten:
- Edge Reverse Proxy (Nginx/Envoy): Fängt rohe Denial-of-Service-Spitzen latenzarm per In-Memory Token Bucket ab.
- Cluster Gateway: Setzt globale, tenant-übergreifende Quoten via zentralem Redis durch.
Nginx: Multi-Tier Limiting mit Burst und Nodelay
# Nginx: Multi-Tier Limiting mit Burst, Nodelay und custom 429
http {
limit_req_status 429;
limit_conn_status 429;
limit_req_zone $binary_remote_addr zone=ip_strict:10m rate=5r/s;
limit_req_zone $http_x_tenant_id zone=tenant_zone:20m rate=100r/s;
server {
location /api/v1/auth/login {
# Strenges Limit gegen Credential Stuffing
limit_req zone=ip_strict burst=2 nodelay;
proxy_pass http://auth_backend;
}
location /api/ {
# Tenant Fair-Use mit kontrolliertem Puffer
limit_req zone=tenant_zone burst=50 nodelay;
proxy_pass http://api_backend;
}
}
}
burst=50 nodelay bedeutet: Ein Client darf 50 Requests auf einmal feuern (wichtig für SPAs), muss danach aber strikt im 100r/s-Takt bleiben, ohne dass Nginx künstliche Latenzen einführt.
Envoy: Lokale Absicherung des Redis-Clusters
In Service-Mesh-Umgebungen schützt ein lokaler Filter den zentralen Redis-Cluster vor Ausfällen:
# Envoy HTTP Connection Manager: Local Rate Limit Filter (Token Bucket)
typed_per_filter_config:
envoy.filters.http.local_ratelimit:
"@type": type.googleapis.com/envoy.extensions.filters.http.local_ratelimit.v3.LocalRateLimit
stat_prefix: http_local_rate_limiter
token_bucket:
max_tokens: 100
tokens_per_fill: 20
fill_interval: 1s
filter_enabled:
runtime_key: local_rate_limit_enabled
default_value:
numerator: 100
denominator: HUNDRED
filter_enforced:
runtime_key: local_rate_limit_enforced
default_value:
numerator: 100
denominator: HUNDRED
response_headers_to_add:
- append_action: OVERWRITE_IF_EXISTS_OR_ADD
header:
key: x-local-rate-limit
value: 'true'
Multi-Tenant Fair Sharing & Noisy Neighbors
In B2B-SaaS-Plattformen teilt sich eine Vielzahl von Unternehmen dieselbe relationale Datenbank und dieselben Worker. Wenn Tenant A ein Skript fehlerhaft konfiguriert und Millionen Requests sendet, darf Tenant B nicht unter Latenzspitzen leiden.
Hier reicht kein globales oder IP-basiertes Limiting. Wir benötigen hierarchische Schlüsselstrukturen:
ratelimit:tier_{tier_id}:tenant_{tenant_id}:user_{user_id}
Ein Enterprise-Tenant erhält höhere Limits als ein Free-Tier-Tenant. Gleichzeitig wird innerhalb des Tenants sichergestellt, dass ein einzelner API-Key nicht das gesamte Kontingent des Kunden ausschöpft.
Credential Stuffing: Mehrdimensional limitieren
Reines IP-Limiting ist auf Login-Routen wirkungslos:
- Angreifer rotieren IPv6-Subnetze oder Residential Proxies.
- Mehrere legitime Nutzer sitzen hinter derselben Firmen-Firewall oder Carrier-Grade NAT (CGNAT/Mobilfunk).
Best Practices für Auth-Endpunkte:
- Zusammengesetzte Identifier: Drosselung auf Basis von
hash(Target-Username + Subnet). Für IPv6 aggregieren wir auf/64-Blöcke, da Provider Endnutzern meist ein ganzes /64-Subnetz zuweisen. - Tracking von Fehlerraten: Nicht jeder Login-Request zählt gleich. Erfolgreiche Logins (200 OK) belasten das Limit kaum; fehlerhafte Versuche (401 Unauthorized) senken den Token Bucket drastisch.
- Progressive Delays: Nach drei Fehlversuchen wird die Antwort künstlich verzögert (z. B. 500 ms, 1000 ms, 2000 ms). Dies zerstört den Durchsatz automatisierter Tools, ohne echte Nutzer dauerhaft auszusperren.
Thundering Herds verhindern: Jitter im Retry-After Header
Wenn Tausende automatisierte Clients bei Erreichen des Limits synchron auf einen harten Reset-Zeitpunkt warten, erzeugen sie beim Ablauf des Fensters eine synchrone Lastwelle, die das Backend erneut überlastet.
Statt statischer Zeitfenster (Retry-After: 60) muss die API dem Client zwingend randomisierten Jitter mitgeben:
$$\text{Retry-After} = \text{Base-Backoff} + \text{random}(1, 5)$$
Durch diese Streuung glätten sich die erneuten Anfragen über ein Zeitfenster und die Last normalisiert sich kontinuierlich.
Planst du die Absicherung deiner APIs oder suchst Unterstützung bei hochverfügbaren Backend-Architekturen? Auf buengener-software.de erfährst du, wie wir gemeinsam skalierbare und sichere Systeme für dein Unternehmen realisieren.