Rate limiting in C++: Bibliotheken und Werkzeuge

Rate limiting in C++: Vollständiger Leitfaden zur Anfragenbegrenzung

Rate limiting (Begrenzung der Anfragenrate) ist ein kritischer Mechanismus zum Schutz von Servern, APIs und verteilten Systemen vor Überlastung, DDoS-Angriffen und zufälligen Verkehrsspitzen. In C++ erfordert die Implementierung von Rate limiting effiziente Algorithmen und die richtige Auswahl von Bibliotheken. In diesem Artikel behandeln wir die grundlegenden Ansätze, beliebte Bibliotheken und liefern fertige Codebeispiele.

Was ist Rate limiting und warum wird es benötigt?

Rate limiting legt die maximale Anzahl von Anfragen fest, die ein Client oder ein System in einem bestimmten Zeitraum ausführen kann. Hauptziele:

Schutz vor Missbrauch und Serverüberlastung
Sicherstellung einer gleichmäßigen Ressourcenverteilung zwischen Benutzern
Verhinderung von DDoS-Angriffen und Brute-Force-Angriffen
Kontrolle des API-Kontingentverbrauchs

Grundlegende Rate-Limiting-Algorithmen

In C++ werden am häufigsten drei klassische Algorithmen verwendet:

1. Token Bucket (Token-Eimer)

Der beliebteste Algorithmus. Stellt einen "Eimer" mit Token dar, die mit konstanter Geschwindigkeit nachgefüllt werden. Jede Anfrage entnimmt einen Token. Sind keine Token vorhanden, wird die Anfrage abgelehnt.

#include <chrono>#include <mutex>

class TokenBucket {private:    double tokens;    double maxTokens;    double refillRate; // Token pro Sekunde    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 (Leaky Bucket)

Anfragen gelangen in eine Warteschlange (Eimer), die mit einer festen Geschwindigkeit verarbeitet wird. Wenn der Eimer überläuft, werden Anfragen verworfen.

#include <queue>#include <chrono>

class LeakyBucket {private:    std::queue<int> bucket;    size_t capacity;    double leakRate; // Anfragen pro Sekunde    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;    }};