Rate Limiting in C++: Bibliotheken und Implementierung zum Schutz von APIs

Rate Limiting in C++: Überblick über Werkzeuge und Implementierung

Rate Limiting (Begrenzung der Anfragenrate) ist ein kritisch wichtiger Mechanismus zum Schutz von Webdiensten, APIs und Microservices vor Überlastung, DDoS-Angriffen und ineffizienter Ressourcennutzung. Im C++-Ökosystem gibt es mehrere ausgereifte Bibliotheken und Ansätze zur Implementierung von Rate Limiting. In diesem Artikel betrachten wir die wichtigsten Algorithmen, beliebte Bibliotheken und schreiben Codebeispiele.

Beliebte Rate-Limiting-Algorithmen

Bevor Sie eine Bibliothek auswählen, ist es hilfreich zu verstehen, welche Algorithmen zugrunde liegen:

\n
• Token Bucket (Token-Eimer) — Token werden mit einer festen Rate hinzugefügt, eine Anfrage verbraucht ein Token. Sind keine Token vorhanden, wird die Anfrage abgelehnt. Einfach und effizient.
\n
• Sliding Window (Gleitendes Fenster) — Berücksichtigt die Anzahl der Anfragen im letzten Zeitintervall (z. B. 10 Anfragen pro Sekunde).
\n
• Fixed Window (Festes Fenster) — Ein einfacher Zähler für Anfragen in einem festen Zeitraum (z. B. wird der Zähler jede Minute zurückgesetzt).
\n
• Leaky Bucket (Leckender Eimer) — Anfragen werden in eine Warteschlange gestellt und mit konstanter Geschwindigkeit verarbeitet, Überschuss wird verworfen.
\n

Bibliotheken für Rate Limiting in C++

1. Boost.Token Bucket (Boost.Timer + manuelle Implementierung)

Boost bietet keine fertige Token-Bucket-Implementierung, aber diese lässt sich leicht mit boost::timer oder std::chrono erstellen. Für Produktionslösungen sind jedoch vollwertige Bibliotheken besser geeignet.

2. libcppa (C++ Actor Framework)

Die Bibliothek libcppa (jetzt Teil von CAF — C++ Actor Framework) bietet integrierte Rate-Limiting-Mechanismen für Aktoren. Sie ermöglicht die Begrenzung der Anzahl von Nachrichten pro Zeiteinheit.

#include <caf/all.hpp>\n\nusing namespace caf;\n\nbehavior rate_limited_actor(event_based_actor* self, int max_requests, duration period) {\n    auto limiter = self->make_rate_limiter(max_requests, period);\n    return {\n        [=](const std::string& msg) {\n            if (limiter->try_acquire()) {\n                aout(self) << "Processed: " << msg << endl;\n            } else {\n                aout(self) << "Rate limit exceeded for: " << msg << endl;\n            }\n        }\n    };\n}\n

3. userver (von Yandex)

Das Framework userver von Yandex ist eine leistungsstarke Lösung für hochlastige Dienste in C++. Es enthält integrierte Unterstützung für Rate Limiting über components::RateLimiter und utils::TokenBucket.

#include <userver/utils/token_bucket.hpp>\n\nusing namespace userver;\n\nint main() {\n    utils::TokenBucket limiter(10, std::chrono::seconds(1)); // 10 Anfragen pro Sekunde\n    for (int i = 0; i < 20; ++i) {\n        if (limiter.TryObtain()) {\n            std::cout << "Request " << i << " allowed\\n";\n        } else {\n            std::cout << "Request " << i << " blocked\\n";\n        }\n        std::this_thread::sleep_for(std::chrono::milliseconds(50));\n    }\n    return 0;\n}\n

4. Pistache (HTTP-Framework mit Rate Limiting)

Die Bibliothek Pistache zum Erstellen von HTTP-Servern verfügt über eine integrierte Middleware für Rate Limiting. Beispiel:

#include <pistache/endpoint.h>\n#include <pistache/router.h>\n#include <pistache/http.h>\n\nusing namespace Pistache;\n\nint main() {\n    Http::Endpoint server(Address(Ipv4::any(), Port(9080)));\n    auto router = std::make_shared<Rest::Router>();\n    \n    // Integrierter Rate Limiter: 5 Anfragen pro Sekunde\n    router->addMiddleware(Http::Middleware::RateLimit(5, std::chrono::seconds(1)));\n    \n    Rest::Routes::Get(*router, "/api/resource", [](const Rest::Request& req, Http::ResponseWri