Rate Limiting em C++: bibliotecas e implementação para proteção de API

Rate Limiting em C++: visão geral de ferramentas e implementação

Rate limiting (limitação de velocidade de requisições) é um mecanismo criticamente importante para proteger serviços web, APIs e microsserviços contra sobrecargas, ataques DDoS e uso irracional de recursos. No ecossistema C++, existem várias bibliotecas maduras e abordagens para implementar rate limiting. Neste artigo, veremos os principais algoritmos, bibliotecas populares e escreveremos exemplos de código.

Algoritmos populares de rate limiting

Antes de escolher uma biblioteca, é útil entender quais algoritmos estão na base:

\n
• Token Bucket (Balde de Tokens) — tokens são adicionados a uma velocidade fixa, a requisição consome um token. Se não houver tokens, a requisição é rejeitada. Simples e eficiente.
\n
• Sliding Window (Janela Deslizante) — considera o número de requisições no último intervalo de tempo (por exemplo, 10 requisições por 1 segundo).
\n
• Fixed Window (Janela Fixa) — um contador simples de requisições por um período fixo (por exemplo, a cada minuto o contador é zerado).
\n
• Leaky Bucket (Balde Furado) — as requisições são colocadas em uma fila e processadas a uma velocidade constante, o excesso é descartado.
\n

Bibliotecas para rate limiting em C++

1. Boost.Token Bucket (Boost.Timer + implementação manual)

No Boost não há uma implementação pronta de token bucket, mas é fácil escrever uma usando boost::timer ou std::chrono. No entanto, para soluções de produção, é melhor usar bibliotecas completas.

2. libcppa (C++ Actor Framework)

A biblioteca libcppa (agora parte do CAF — C++ Actor Framework) fornece mecanismos integrados de rate limiting para atores. Permite limitar o número de mensagens por unidade de tempo.

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

O framework userver da Yandex é uma solução poderosa para serviços de alta carga em C++. Inclui suporte integrado para rate limiting através de components::RateLimiter e 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 requisições 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 (HTTP-framework com rate limiting)

A biblioteca Pistache para criação de servidores HTTP possui middleware integrado para rate limiting. Exemplo:

#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    // Rate limiter integrado: 5 requisições 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