actix-rl is a RateLimit middleware for the actix-web library. It supports asynchronous processing and currently provides two storage options: in-memory storage (MemStore) and Redis storage (RedisStore).

If you have other storage options, feel free to submit a Pull Request. PR is welcome.

Usage:

1. Define a Store where the program stores information and sets timeouts.
2. Define a Controller. The Controller is used to define middleware response behaviors, such as how to return HTTP information during exceptions. You can also use the library's provided default functions, but in most cases, you will need to customize the response to return necessary limit information to the client.
3. Finally, add a Middleware to your HTTP Server using the wrap function (from actix-web).

You can find examples in examples folder.

The Store is used to store caching information.

Let's take MemCache as an example:

// data timeout for each key is 10 seconds, with 1024 init capacity.
let store = actix_rl::store::MemCache::new(1024, chrono::Duration::seconds(10));

Controller is a set of functions. To create a default one:

let controller = controller::Controller::new();

You can determine which requests should be checked, by modifying Controller:

let controller = controller.with_do_rate_limit(|req| !req.path().start_with("/healthz"));

In this case, only those requests without prefix /healthz will be checked by RateLimiter.

For more functions, please check the doc of Controller.

Define a RateLimiter and wrap to HTTP server:

let rate_limiter = actix_rl::middleware::RateLimitMiddleware::new(
    store,
    10, // max count is 10, which means max 10 hits per 10 seconds.
    controller,
);

Then, add it to actix-web HTTP server wrap:

App::new()
   .wrap(rate_limiter)
    // ...