• Français

      • Limitation de Débit

      Middleware fournissant une fonctionnalité de limitation de débit.

      Fonctionnalités Clés

      • RateIssuer fournit une abstraction pour identifier les clés des visiteurs. RemoteIpIssuer est l'une de ses implémentations, qui détermine les visiteurs en fonction de leurs adresses IP. Les clés ne sont pas nécessairement des chaînes de caractères ; tout type satisfaisant les contraintes Hash + Eq + Send + Sync + 'static peut servir de clé.

      • RateGuard offre une abstraction pour les algorithmes de limitation de débit. Les implémentations par défaut incluent la fenêtre fixe (FixedGuard) et la fenêtre glissante (SlidingGuard).

      • RateStore fournit des opérations de stockage de données. MokaStore est une implémentation de cache en mémoire intégrée basée sur moka. Vous pouvez également définir votre propre implémentation.

      • RateLimiter est une structure implémentant Handler, qui inclut un champ skipper pour spécifier les requêtes qui doivent contourner la limitation de débit. Par défaut, none_skipper est utilisé, ce qui signifie qu'aucune requête n'est ignorée.

      • QuotaGetter fournit une abstraction pour récupérer les quotas. Il récupère un objet de quota en fonction de la Key du visiteur, permettant aux quotas utilisateurs et autres configurations d'être stockés dans des bases de données et modifiés ou récupérés dynamiquement.

      Exemple de Code

      Exemple de Quota Statique

      main.rs
      Cargo.toml
      use salvo::prelude::*;
use salvo::rate_limiter::{BasicQuota, FixedGuard, MokaStore, RateLimiter, RemoteIpIssuer};

#[handler]
async fn hello() -> &'static str {
    "Hello World"
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();

    let limiter = RateLimiter::new(
        FixedGuard::new(),
        MokaStore::new(),
        RemoteIpIssuer,
        BasicQuota::per_second(1),
    );
    let router = Router::with_hoop(limiter).get(hello);
    let acceptor = TcpListener::new("0.0.0.0:8698").bind().await;
    Server::new(acceptor).serve(router).await;
}

      Exemple de Quota Dynamique

      main.rs
      Cargo.toml
      use std::borrow::Borrow;
use std::collections::HashMap;
use std::hash::Hash;
use std::sync::LazyLock;

use salvo::Error;
use salvo::prelude::*;
use salvo::rate_limiter::{
    CelledQuota, MokaStore, QuotaGetter, RateIssuer, RateLimiter, SlidingGuard,
};

static USER_QUOTAS: LazyLock<HashMap<String, CelledQuota>> = LazyLock::new(|| {
    let mut map = HashMap::new();
    map.insert("user1".into(), CelledQuota::per_second(1, 1));
    map.insert("user2".into(), CelledQuota::set_seconds(1, 1, 5));
    map.insert("user3".into(), CelledQuota::set_seconds(1, 1, 10));
    map
});

struct UserIssuer;
impl RateIssuer for UserIssuer {
    type Key = String;
    async fn issue(&self, req: &mut Request, _depot: &Depot) -> Option<Self::Key> {
        req.query::<Self::Key>("user")
    }
}

struct CustomQuotaGetter;
impl QuotaGetter<String> for CustomQuotaGetter {
    type Quota = CelledQuota;
    type Error = Error;

    async fn get<Q>(&self, key: &Q) -> Result<Self::Quota, Self::Error>
    where
        String: Borrow<Q>,
        Q: Hash + Eq + Sync,
    {
        USER_QUOTAS
            .get(key)
            .cloned()
            .ok_or_else(|| Error::other("user not found"))
    }
}

#[handler]
async fn limited() -> &'static str {
    "Limited page"
}
#[handler]
async fn home() -> Text<&'static str> {
    Text::Html(HOME_HTML)
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();

    let limiter = RateLimiter::new(
        SlidingGuard::new(),
        MokaStore::new(),
        UserIssuer,
        CustomQuotaGetter,
    );
    let router = Router::new()
        .get(home)
        .push(Router::with_path("limited").hoop(limiter).get(limited));
    let acceptor = TcpListener::new("0.0.0.0:8698").bind().await;
    Server::new(acceptor).serve(router).await;
}

static HOME_HTML: &str = r#"
<!DOCTYPE html>
<html>
    <head>
        <title>Rate Limiter Dynamic</title>
    </head>
    <body>
        <h2>Rate Limiter Dynamic</h2>
        <p>
            This example shows how to set limit for different users.
        </p>
        <p>
            <a href="/limited?user=user1" target="_blank">Limited page for user1: 1/second</a>
        </p>
        <p>
            <a href="/limited?user=user2" target="_blank">Limited page for user2: 1/5seconds</a>
        </p>
        <p>
            <a href="/limited?user=user3" target="_blank">Limited page for user3: 1/10seconds</a>
        </p>
    </body>
</html>
"#;