curiositech/windags-skills

Expert en Limitation de Débit & Anti-Suralimentation d'API

Implémentez une limitation de débit équitable et efficace en utilisant des algorithmes de bucket à jetons, fenêtre glissante et fenêtre fixe avec des compteurs distribués basés sur Redis.

Déclencheurs d'Activation

Activer sur : "rate limiting", "throttling", "token bucket", "sliding window", "API abuse", "DDoS protection", "quota management", "429 Too Many Requests", "request limits"

PAS pour : Configuration de passerelle API → api-gateway-reverse-proxy-expert | Stratégies de mise en cache → cache-strategy-invalidation-expert | Règles WAF/firewall → compétence sécurité appropriée

Démarrage Rapide

1. Définir les limites — requêtes/minute par clé API, IP ou niveau d'utilisateur
2. Choisir un algorithme — journal de fenêtre glissante (précis), bucket à jetons (à rafales), fenêtre fixe (simple)
3. Utiliser Redis — opérations atomiques avec MULTI/EXEC ou scripts Lua pour la limitation de débit distribuée
4. Retourner les en-têtes appropriés — X-RateLimit-Limit, X-RateLimit-Remaining, Retry-After
5. Différencier les niveaux — gratuit/pro/entreprise obtiennent des limites différentes

Capacités Principales

Domaine	Technologies
Algorithmes	Bucket à jetons, journal de fenêtre glissante, compteur de fenêtre glissante, fenêtre fixe
Stockage	Redis 7.4+, Valkey, DragonflyDB, en mémoire (nœud unique)
Bibliothèques	rate-limiter-flexible, @upstash/ratelimit, express-rate-limit
Plugins de Passerelle	Kong rate-limiting, Nginx limit_req, Traefik ratelimit
Standards	RFC 6585 (429), En-têtes RateLimit (draft-ietf-httpapi-ratelimit)

Modèles d'Architecture

Compteur de Fenêtre Glissante (Lua Redis)

-- Script Lua Redis : limiteur de débit à fenêtre glissante
-- KEYS[1] = clé de limite de débit
-- ARGV[1] = taille de la fenêtre (secondes)
-- ARGV[2] = nombre maximum de requêtes
-- ARGV[3] = horodatage actuel

local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

-- Supprimer les entrées expirées
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

-- Compter dans la fenêtre actuelle
local count = redis.call('ZCARD', key)

if count < limit then
  redis.call('ZADD', key, now, now .. '-' .. math.random(1000000))
  redis.call('EXPIRE', key, window)
  return {1, limit - count - 1}  -- autorisé, restant
else
  return {0, 0}  -- refusé, 0 restant
end

Limitation de Débit Multi-Niveaux

Requête → Limite de débit IP (100/min)
              │ passe
              ↓
         Vérification Auth → Limite de débit par clé API (basée sur le niveau)
              │           Gratuit :  60/min
              │           Pro :   600/min
              │           Entreprise : 6000/min
              ↓ passe
         Limite de débit par point de terminaison (par route)
              │   POST /upload: 10/min
              │   GET /search:  120/min
              ↓ passe
         Traiter la Requête

En-têtes de Réponse (Projet de Norme IETF)

// Middleware : attacher les en-têtes de limite de débit
function rateLimitHeaders(limit: number, remaining: number, resetAt: number) {
  return {
    'RateLimit-Limit': limit.toString(),
    'RateLimit-Remaining': Math.max(0, remaining).toString(),
    'RateLimit-Reset': Math.ceil((resetAt - Date.now()) / 1000).toString(),
  };
}

// Sur réponse 429 :
res.status(429).set({
  ...rateLimitHeaders(limit, 0, resetAt),
  'Retry-After': Math.ceil((resetAt - Date.now()) / 1000).toString(),
}).json({ error: 'Trop de Requêtes', retryAfter: resetAt });

Anti-Patrons

1. Compteurs en mémoire dans les systèmes distribués — les limites de débit doivent être partagées entre les instances ; utilisez Redis ou équivalent
2. En-tête Retry-After manquant — les réponses 429 sans Retry-After forcent les clients à deviner, ce qui entraîne un effet de troupeau
3. Limitation de débit uniquement par IP — les limites IP ne détectent pas les abus authentifiés et pénalisent les IP partagées (NAT, VPN) ; combinez avec des limites par clé API
4. Coupure brutale sans rafale — le bucket à jetons autorise de petites rafales tout en maintenant un débit moyen ; une fenêtre fixe pure est trop rigide
5. Pas de limite de débit sur les API internes — un service interne défaillant peut faire cascader votre base de données ; limitez toujours

Checklist Qualité

• Les limites de débit utilisent un stockage distribué (Redis/Valkey), pas en mémoire
• En-têtes RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset sur chaque réponse
• En-tête Retry-After sur les réponses 429
• Limites différentes par niveau d'authentification (gratuit/pro/entreprise)
• Limites par point de terminaison pour les opérations coûteuses (upload, recherche)
• Script Lua ou pipeline atomique pour l'incrémentation du compteur (pas de conditions de course)
• Les clés de limite de débit incluent à la fois l'identité (clé API) et la portée (point de terminaison)
• Tableau de bord de surveillance montrant les hits, refus et principaux consommateurs de limites de débit
• Dégradation gracieuse : mettre en file d'attente ou ralentir plutôt que rejeter brutalement quand c'est possible