Un rate limiting mal conçu produit deux types de dégâts symétriques : trop permissif, il ne protège rien et un client mal configuré ou malveillant peut saturer l'API en quelques secondes ; trop strict ou mal implémenté, il bloque des utilisateurs légitimes qui font exactement ce qu'on attend d'eux, souvent au pire moment (un pic de trafic légitime pendant une promotion, par exemple). La difficulté n'est pas d'ajouter une limite, c'est de choisir le bon algorithme pour le bon pattern de trafic.
Fenêtre fixe : simple, mais avec un angle mort connu
L'implémentation la plus directe compte les requêtes par client sur une fenêtre de temps fixe (par exemple, chaque minute calendaire) :
async function fixedWindowLimit(clientId, limit = 100) {
const window = Math.floor(Date.now() / 60000); // minute courante
const key = `ratelimit:${clientId}:${window}`;
const count = await redis.incr(key);
if (count === 1) {
await redis.expire(key, 60);
}
return count <= limit;
}
Le défaut structurel de cette approche : un client peut envoyer 100 requêtes à la toute fin d'une fenêtre (59e seconde) et 100 autres au tout début de la fenêtre suivante (0e seconde), soit 200 requêtes en deux secondes, tout en respectant la limite de 100 par minute sur chaque fenêtre individuelle. Ce n'est pas un bug d'implémentation, c'est une limite inhérente à la fenêtre fixe : elle ne regarde jamais le trafic à la frontière entre deux fenêtres.
Fenêtre glissante : corriger l'angle mort
La fenêtre glissante élimine cet effet de bord en comptant les requêtes sur les 60 dernières secondes à tout instant, pas sur une fenêtre calendaire fixe. L'implémentation la plus directe avec Redis utilise un SORTED SET où chaque requête est horodatée :
async function slidingWindowLimit(clientId, limit = 100, windowMs = 60000) {
const now = Date.now();
const key = `ratelimit:${clientId}`;
await redis.zremrangebyscore(key, 0, now - windowMs);
const count = await redis.zcard(key);
if (count >= limit) {
return false;
}
await redis.zadd(key, now, `${now}-${Math.random()}`);
await redis.expire(key, Math.ceil(windowMs / 1000));
return true;
}
zremrangebyscore purge les entrées plus anciennes que la fenêtre avant de compter, ce qui garantit que le compte reflète toujours exactement les requêtes des 60 dernières secondes glissantes, peu importe où on se trouve dans le temps. Le coût : chaque vérification de limite nécessite plusieurs opérations Redis au lieu d'une seule, et la structure SORTED SET grossit avec le volume de requêtes par client avant d'être purgée.
Token bucket : absorber les rafales légitimes
Le token bucket part d'un principe différent : chaque client dispose d'un réservoir de jetons qui se remplit à débit constant (par exemple 10 jetons par seconde), jusqu'à une capacité maximale. Chaque requête consomme un jeton ; sans jeton disponible, la requête est rejetée.
-- token_bucket.lua (exécuté via EVAL pour garantir l'atomicité)
local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local refillRate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local bucket = redis.call('HMGET', key, 'tokens', 'timestamp')
local tokens = tonumber(bucket[1]) or capacity
local lastRefill = tonumber(bucket[2]) or now
local elapsed = math.max(0, now - lastRefill)
tokens = math.min(capacity, tokens + elapsed * refillRate / 1000)
if tokens < 1 then
redis.call('HMSET', key, 'tokens', tokens, 'timestamp', now)
return 0
end
tokens = tokens - 1
redis.call('HMSET', key, 'tokens', tokens, 'timestamp', now)
redis.call('EXPIRE', key, 3600)
return 1
L'avantage du token bucket sur la fenêtre glissante : il absorbe naturellement une rafale ponctuelle tant que le réservoir contient des jetons accumulés pendant une période d'inactivité, ce qui correspond mieux au pattern réel d'un client légitime (une app mobile qui synchronise plusieurs écrans d'un coup à l'ouverture, par exemple), sans pour autant permettre un débit moyen supérieur à la limite voulue. C'est l'algorithme utilisé par la majorité des API gateways commerciales (Stripe, GitHub) parce qu'il concilie le mieux protection et tolérance aux pics légitimes.
Diagnostiquer : qui bloque-t-on vraiment
Avant de resserrer ou desserrer une limite, il faut savoir qui elle affecte. Logger systématiquement les rejets 429 avec l'identifiant client, l'endpoint et le débit observé permet de distinguer deux populations très différentes : les clients qui dépassent la limite de façon ponctuelle (souvent un bug côté client, une boucle de retry mal configurée) et ceux qui la dépassent de façon soutenue (souvent un abus ou un scraping).
app.use((req, res, next) => {
res.on('finish', () => {
if (res.statusCode === 429) {
logger.warn('rate_limit_exceeded', {
clientId: req.user?.id ?? req.ip,
endpoint: req.path,
timestamp: Date.now(),
});
}
});
next();
});
Un pic de 429 concentré sur un seul client et un seul endpoint, juste après un déploiement front-end, pointe presque toujours vers une régression côté client (un useEffect qui boucle, un retry sans backoff) plutôt que vers un abus réel. Corriger la limite dans ce cas masquerait le vrai bug.
Granularité : par IP, par utilisateur, ou par clé d'API
Limiter par adresse IP protège contre un abus non authentifié, mais pénalise injustement tous les utilisateurs derrière une même IP partagée (un réseau d'entreprise, un NAT mobile) en leur faisant partager le même quota. Limiter par identifiant utilisateur ou par clé d'API authentifiée est plus précis mais ne protège pas les endpoints publics non authentifiés (login, inscription), qui restent la cible privilégiée des attaques par credential stuffing.
La pratique courante combine les deux niveaux : une limite large par IP sur les endpoints non authentifiés pour contenir les abus bruts, et une limite par compte/clé d'API sur les endpoints authentifiés, avec des quotas différenciés par plan tarifaire.
const limits = {
free: { requests: 100, windowMs: 60000 },
pro: { requests: 1000, windowMs: 60000 },
enterprise: { requests: 10000, windowMs: 60000 },
};
async function checkLimit(req) {
const plan = req.user?.plan ?? 'anonymous';
const config = limits[plan] ?? { requests: 20, windowMs: 60000 };
return slidingWindowLimit(req.user?.id ?? req.ip, config.requests, config.windowMs);
}
Répondre correctement au client
Un rejet de rate limiting devrait toujours inclure les en-têtes standard qui permettent au client de s'adapter plutôt que de réessayer en boucle à l'aveugle :
res.set({
'X-RateLimit-Limit': limit,
'X-RateLimit-Remaining': Math.max(0, limit - count),
'X-RateLimit-Reset': resetTimestamp,
'Retry-After': retryAfterSeconds,
});
res.status(429).json({ error: 'rate_limit_exceeded' });
Retry-After est la différence entre un client qui réessaye intelligemment après le délai indiqué et un client qui réessaye immédiatement en boucle, ce qui aggrave la charge que le rate limiting était censé contenir.
Quand la solution facile ne suffit plus
Un rate limiting purement applicatif, implémenté dans le code de l'API, protège l'API elle-même mais pas l'infrastructure en amont (base de données, service tiers facturé à l'appel) si plusieurs instances de l'API partagent ces ressources sans limite globale coordonnée. Dans ce cas, le rate limiting doit se faire au niveau d'une gateway partagée (Kong, un reverse proxy avec un module de limitation, ou un service managé comme AWS API Gateway), avec un compteur centralisé dans Redis partagé entre toutes les instances, plutôt qu'un compteur local à chaque processus qui sous-estime le trafic réel agrégé.
Pour des attaques distribuées sur un grand nombre d'IP (botnet), le rate limiting par client devient insuffisant à lui seul : il faut le combiner avec une détection comportementale (fingerprinting, CAPTCHA adaptatif) en amont de l'API.
À retenir
La fenêtre fixe est simple mais laisse passer un doublement de débit à la frontière des fenêtres ; la fenêtre glissante corrige ce défaut au prix de plus d'opérations Redis ; le token bucket est le meilleur compromis pour absorber des rafales légitimes sans relâcher la limite moyenne. Dans tous les cas, logger les rejets avec assez de contexte pour distinguer un bug client d'un abus réel évite de corriger la mauvaise chose.
