Limitación de Tasa en C++: bibliotecas e implementación para proteger API

Limitación de Tasa en C++: resumen de herramientas e implementación

La limitación de tasa (rate limiting) es un mecanismo crítico para proteger servicios web, API y microservicios contra sobrecargas, ataques DDoS y uso irracional de recursos. En el ecosistema de C++ existen varias bibliotecas maduras y enfoques para implementar la limitación de tasa. En este artículo revisaremos los algoritmos principales, las bibliotecas populares y escribiremos ejemplos de código.

Algoritmos populares de limitación de tasa

Antes de elegir una biblioteca, es útil comprender qué algoritmos están en la base:

\n
• Token Bucket (Cubo de fichas) — las fichas se agregan a una velocidad fija, una solicitud consume una ficha. Si no hay fichas, la solicitud es rechazada. Simple y eficiente.
\n
• Sliding Window (Ventana deslizante) — considera la cantidad de solicitudes en el último intervalo de tiempo (por ejemplo, 10 solicitudes por 1 segundo).
\n
• Fixed Window (Ventana fija) — un contador simple de solicitudes en un período fijo (por ejemplo, cada minuto el contador se reinicia).
\n
• Leaky Bucket (Cubo con fugas) — las solicitudes se colocan en una cola y se procesan a una velocidad constante, el exceso se descarta.
\n

Bibliotecas para limitación de tasa en C++

1. Boost.Token Bucket (Boost.Timer + implementación manual)

Boost no tiene una implementación lista de token bucket, pero es fácil escribirla sobre boost::timer o std::chrono. Sin embargo, para soluciones de producción es mejor usar bibliotecas completas.

2. libcppa (C++ Actor Framework)

La biblioteca libcppa (ahora parte de CAF — C++ Actor Framework) proporciona mecanismos integrados de limitación de tasa para actores. Permite limitar la cantidad de mensajes por unidad de tiempo.

#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 (de Yandex)

El framework userver de Yandex es una solución potente para servicios de alta carga en C++. Incluye soporte integrado para limitación de tasa a través de components::RateLimiter y 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 solicitudes por segundo\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 (framework HTTP con limitación de tasa)

La biblioteca Pistache para crear servidores HTTP tiene un middleware integrado para limitación de tasa. Ejemplo:

#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    // Limitador de tasa integrado: 5 solicitudes por segundo\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