TryQuickToolBox

Limitation de débit des API : algorithmes et implémentations

Security2026-09-20TryQuickToolBox

Votre API est attaquée. Pas par des pirates sophistiqués, mais par un simple script qui martèle vos points de terminaison des milliers de fois par seconde, consommant des ressources et dégradant le service pour les utilisateurs légitimes. Sans limitation de débit, un seul client malveillant peut faire tomber toute votre application. Ce guide explique les algorithmes de base et montre des implémentations pratiques en Node.js et Nginx pour protéger votre API.

Pourquoi la limitation de débit est importante

La limitation de débit contrôle le nombre de requêtes qu'un client peut effectuer dans une fenêtre de temps donnée. C'est votre première ligne de défense contre :

Au-delà de la sécurité, la limitation de débit garantit une utilisation équitable et vous aide à appliquer des règles métier, telles que les plans tarifaires à plusieurs niveaux.

Algorithmes de limitation de débit

Quatre algorithmes dominent la limitation de débit des API. Chacun présente des compromis en termes de précision, d'utilisation de la mémoire et de gestion des rafales.

1. Fenêtre fixe

Comptez les requêtes dans des intervalles de temps fixes (par exemple, 100 requêtes par minute). Lorsque la fenêtre se réinitialise, le compteur se réinitialise.

2. Fenêtre glissante

Suivez les horodatages de chaque requête et comptez combien tombent dans les N dernières secondes. Cela lisse les rafales.

3. Token Bucket

Un seau contient des jetons. Les jetons sont ajoutés à un rythme fixe. Chaque requête consomme un jeton. Si le seau est vide, la requête est refusée.

4. Leaky Bucket

Les requêtes entrent dans une file d'attente (seau) et sont traitées à un rythme constant. Si la file d'attente est pleine, les requêtes sont abandonnées.

AlgorithmeGestion des rafalesMémoireCas d'utilisation
Fenêtre fixeFaibleBasseAPI simples
Fenêtre glissanteBonneMoyenneUsage général
Token BucketExcellenteMoyenneAPI avec tolérance aux rafales
Leaky BucketAucuneMoyenneLissage du trafic

Implémentation de la limitation de débit en Node.js

Nous allons implémenter un limiteur de débit token bucket en utilisant Express et Redis pour un état distribué. Redis est essentiel lorsque vous avez plusieurs instances de serveur.

Étape 1 : Installer les dépendances

npm install express redis

Étape 2 : Créer le middleware de limitation de débit

const redis = require('redis');
const client = redis.createClient();

async function tokenBucketLimiter(req, res, next) {
  const key = `rate_limit:${req.ip}`;
  const capacity = 10; // max tokens
  const refillRate = 1; // tokens per second

  const now = Date.now();
  const data = await client.hGetAll(key);
  let tokens = data.tokens ? parseFloat(data.tokens) : capacity;
  let lastRefill = data.lastRefill ? parseInt(data.lastRefill) : now;

  // Refill tokens based on elapsed time
  const elapsed = (now - lastRefill) / 1000;
  tokens = Math.min(capacity, tokens + elapsed * refillRate);

  if (tokens < 1) {
    return res.status(429).json({ error: 'Too many requests' });
  }

  tokens -= 1;
  await client.hSet(key, {
    tokens: tokens.toString(),
    lastRefill: now.toString()
  });
  await client.expire(key, 60); // auto-cleanup

  next();
}

app.use(tokenBucketLimiter);

Ce middleware vérifie et met à jour le nombre de jetons de manière atomique. Pour la production, utilisez des transactions Redis ou des scripts Lua pour éviter les conditions de course.

Implémentation de la limitation de débit dans Nginx

Nginx offre une limitation de débit intégrée avec le module limit_req. Il utilise un algorithme de leaky bucket.

Étape 1 : Définir une zone de limitation de débit

Dans le bloc http de nginx.conf :

limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;

Cela crée une zone de 10 Mo nommée api qui autorise 10 requêtes par seconde par IP.

Étape 2 : Appliquer la limite

Dans votre bloc location :

location /api/ {
    limit_req zone=api burst=20 nodelay;
    proxy_pass http://backend;
}

burst=20 autorise des rafales courtes jusqu'à 20 requêtes. nodelay traite les requêtes en rafale immédiatement au lieu de les mettre en file d'attente.

Bonnes pratiques pour la limitation de débit des API

FAQ

Quelle est la différence entre limitation de débit et throttling ?

La limitation de débit bloque les requêtes au-delà d'un seuil, tandis que le throttling les ralentit (par exemple, en les mettant en file d'attente ou en les retardant). La limitation de débit est binaire ; le throttling est progressif.

Quel algorithme de limitation de débit dois-je utiliser ?

Pour la plupart des API, le token bucket offre un bon équilibre : il permet des rafales mais applique un taux moyen. Si vous avez besoin d'un lissage strict, utilisez le leaky bucket. Pour plus de simplicité, la fenêtre fixe fonctionne pour les API à faible trafic.

Comment gérer la limitation de débit pour les utilisateurs authentifiés vs anonymes ?

Appliquez des limites plus strictes aux utilisateurs anonymes (par exemple, par IP) et des limites plus généreuses aux utilisateurs authentifiés (par exemple, par clé API). Vous pouvez également mettre en place des limites par paliers en fonction des plans d'abonnement.

Prêt à analyser votre trafic API ? Utilisez notre Nginx Log Analyzer pour analyser les journaux, repérer les violations de limitation de débit et optimiser vos seuils.