Rate limiting en C++ : bibliothèques et outils

Rate limiting en C++ : guide complet pour la limitation des requêtes

Le rate limiting (limitation du débit des requêtes) est un mécanisme essentiel pour protéger les serveurs, les API et les systèmes distribués contre les surcharges, les attaques DDoS et les pics de trafic soudains. En C++, l'implémentation du rate limiting nécessite des algorithmes efficaces et un choix judicieux de bibliothèques. Dans cet article, nous analyserons les approches principales, les bibliothèques populaires et fournirons des exemples de code prêts à l'emploi.

Qu'est-ce que le rate limiting et pourquoi est-il nécessaire ?

Le rate limiting fixe le nombre maximum de requêtes qu'un client ou un système peut effectuer dans un intervalle de temps donné. Objectifs principaux :

Protection contre les abus et la surcharge du serveur
Assurer une répartition équitable des ressources entre les utilisateurs
Prévention des attaques DDoS et par force brute
Contrôle de la consommation des quotas API

Algorithmes principaux de rate limiting

En C++, trois algorithmes classiques sont le plus souvent utilisés :

1. Token Bucket (Seau de jetons)

L'algorithme le plus populaire. Il représente un "seau" contenant des jetons qui se remplissent à un rythme constant. Chaque requête consomme un jeton. S'il n'y a plus de jetons, la requête est rejetée.

#include <chrono>#include <mutex>

class TokenBucket {private:    double tokens;    double maxTokens;    double refillRate; // jetons par seconde    std::chrono::steady_clock::time_point lastRefill;    std::mutex mtx;

public:    TokenBucket(double maxTokens, double refillRate)         : tokens(maxTokens), maxTokens(maxTokens), refillRate(refillRate) {        lastRefill = std::chrono::steady_clock::now();    }

    bool tryConsume() {        std::lock_guard<std::mutex> lock(mtx);        refill();        if (tokens >= 1.0) {            tokens -= 1.0;            return true;        }        return false;    }

private:    void refill() {        auto now = std::chrono::steady_clock::now();        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastRefill).count() / 1000.0;        tokens = std::min(maxTokens, tokens + elapsed * refillRate);        lastRefill = now;    }};

2. Leaky Bucket (Seau percé)

Les requêtes arrivent dans une file d'attente (le seau) qui est traitée à un rythme fixe. Si le seau déborde, les requêtes sont rejetées.

#include <queue>#include <chrono>

class LeakyBucket {private:    std::queue<int> bucket;    size_t capacity;    double leakRate; // requêtes par seconde    std::chrono::steady_clock::time_point lastLeak;    std::mutex mtx;

public:    LeakyBucket(size_t capacity, double leakRate)         : capacity(capacity), leakRate(leakRate) {        lastLeak = std::chrono::steady_clock::now();    }

    bool addRequest(int request) {        std::lock_guard<std::mutex> lock(mtx);        leak();        if (bucket.size() < capacity) {            bucket.push(request);            return true;        }        return false;    }

private:    void leak() {        auto now = std::chrono::steady_clock::now();        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastLeak).count() / 1000.0;        size_t toRemove = static_cast<size_t>(elapsed * leakRate);        while (toRemove > 0 && !bucket.empty()) {            bucket.pop();            toRemove--;        }        lastLeak = now;    }};