Rate Limiting en TypeScript : bibliothèques, outils et exemples d'implémentation

Rate Limiting en TypeScript : guide complet des outils et de l'implémentation

Le rate limiting (limitation du taux de requêtes) est l'une des techniques clés pour protéger les applications web et les API contre les abus, les attaques DDoS et les charges excessives. En TypeScript, grâce à un typage strict et aux fonctionnalités modernes, l'implémentation du rate limiting devient particulièrement élégante et fiable. Dans cet article, nous examinerons les meilleures bibliothèques, algorithmes et exemples de code pour TypeScript.

Pourquoi le Rate Limiting est-il nécessaire ?

Sans limitation du taux de requêtes, votre application peut rencontrer :

• Surcharge du serveur — un seul client peut envoyer des milliers de requêtes par seconde
• Attaques par force brute — tentative de deviner des mots de passe ou des jetons
• Pertes financières — si chaque requête nécessite des ressources payantes (par exemple, l'API OpenAI)
• Répartition inégale des ressources — un utilisateur peut monopoliser toute la bande passante

Bibliothèques populaires pour le Rate Limiting en TypeScript

1. bottleneck — limiteur universel

L'une des bibliothèques les plus populaires pour le rate limiting en JavaScript/TypeScript. Elle prend en charge à la fois la limitation du nombre de requêtes par seconde/minute et la mise en file d'attente des requêtes.

import Bottleneck from 'bottleneck';

const limiter = new Bottleneck({  maxConcurrent: 2,        // maximum 2 requêtes simultanées  minTime: 1000,           // minimum 1 seconde entre les requêtes  reservoir: 10,           // limite totale pour la période  reservoirRefreshAmount: 10,  reservoirRefreshInterval: 60 * 1000 // rafraîchissement toutes les minutes});

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

// Utilisationconst users = await Promise.all([  fetchData('/api/users/1'),  fetchData('/api/users/2'),  fetchData('/api/users/3'), // cette requête attendra]);

2. express-rate-limit — pour Express.js

Solution standard pour limiter les requêtes dans les applications Express. Fonctionne parfaitement avec TypeScript.

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

const app = express();

const apiLimiter = rateLimit({  windowMs: 15 * 60 * 1000, // 15 minutes  max: 100,                 // maximum 100 requêtes  standardHeaders: true,    // retourner les en-têtes RateLimit-*  legacyHeaders: false,  message: {    status: 429,    message: 'Trop de requêtes, veuillez réessayer plus tard'  }});

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

app.listen(3000);

3. rate-limiter-flexible — solution flexible pour Redis et mémoire intégrée

Bibliothèque prenant en charge différents stockages (Redis, Memory, MongoDB, Postgres) et algorithmes (Token Bucket, Sliding Window).

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

const rateLimiter = new RateLimiterMemory({  points: 5,        // 5 requêtes  duration: 1,      // en 1 seconde});

async function checkRateLimit(key: string): Promise<boolean> {  try {    await rateLimiter.consume(key);    return true; // requête autorisée  } catch (error) {    return false; // limite dépassée  }}

// Exemple d'utilisation dans Expressapp.post('/api/login', async (req, res) => {  const allowed = await checkRateLimit(req.ip);  if (!allowed) {    return res.status(429).json({ error: 'Too Many Requests' });  }  // traitement de la connexion...});

Algorithmes de Rate Limiting

• Token Bucket — un "seau" de jetons qui se remplit à une vitesse constante. Chaque requête consomme un jeton. Permet des pics temporaires.
• Sliding Window — fenêtre glissante dans le temps (par exemple, 1 minute). Prend en compte les requêtes non pas sur des intervalles fixes, mais sur la dernière