Limitation de débit ASP.NET Core : configuration et algorithmes

# Configurer la limitation de débit dans ASP.NET Core : Guide étape par étape pour les développeurs

La fonctionnalité de limitation de débit dans ASP.NET Core vous permet de contrôler la charge du serveur, de vous protéger contre les attaques DoS et d'assurer une distribution équitable des ressources. La configuration nécessite deux étapes : l'enregistrement des services et l'ajout du middleware au pipeline. Toutes les dépendances sont incluses dans le SDK — aucun package supplémentaire n'est nécessaire.

Dans Program.cs, appelez AddRateLimiter sur WebApplicationBuilder.Services :

builder.Services.AddRateLimiter(options =>
{
    // Konfiguratsiya politik
});

Ajoutez ensuite le middleware :

app.UseRateLimiter();

Ceci est l'intégration de base. Prochainement : détails sur les algorithmes et les politiques.

Algorithmes et limitation sélective

ASP.NET Core prend en charge plusieurs algorithmes de limitation de débit :

• Fixed Window — fenêtre temporelle fixe, simple mais sujette à des pics de charge.
• Sliding Window — fenêtre glissante, distribue les limites de manière plus uniforme.
• Token Bucket — seau de jetons, autorise le trafic en rafale.
• Concurrency Limiter — limite les requêtes concurrentes.

La sélectivité détermine quelles requêtes limiter. Le limiteur global s'applique à toutes les requêtes, tandis que les limiteurs sélectifs utilisent des clés (IP, ID utilisateur).

Exemple d'un limiteur global (100 requêtes par minute) :

options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(
    httpContext => RateLimitPartition.GetFixedWindowLimiter(
        partitionKey: httpContext.Request.Headers.Host.ToString(),
        factory: partition => new FixedWindowRateLimiterOptions
        {
            AutoReplenishment = true,
            PermitLimit = 100,
            Window = TimeSpan.FromMinutes(1)
        }));
);

Regroupement et combinaison des limiteurs

Le regroupement par clé est la base de la sélectivité. Utilisez AddFixedWindowLimiter ou des politiques personnalisées.

Scénarios de regroupement par clé :

• Par IP : partitionKey: httpContext.Connection.RemoteIpAddress?.ToString()
• Par client : partitionKey: httpContext.User.Identity?.Name
• Par point de terminaison API : partitionKey: httpContext.Request.Path
• Clé combinée : IP + User-Agent

Combinaison de limiteurs sélectifs via AddPolicy :

options.AddPolicy("ip", httpContext =>
{
    var ip = httpContext.Connection.RemoteIpAddress;
    return new FixedWindowRateLimiterOptions
    {
        PermitLimit = 50,
        Window = TimeSpan.FromMinutes(1),
        QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
        QueueLimit = 10
    };
});

Nouvelle fonctionnalité : combinaison de limiteurs non sélectifs — plusieurs limiteurs globaux avec files d'attente.

Files d'attente et gestion des rejets

Activez les files d'attente pour lisser les pics :

• QueueLimit — maximum dans la file d'attente.
• QueueProcessingOrder — ordre (OldestFirst / NewestFirst).

Les actions de rejet peuvent être définies globalement ou par politique :

options.OnRejected = (context, token) =>
{
    context.HttpContext.Response.StatusCode = 429;
    context.HttpContext.Response.ContentType = "application/json";
    return context.HttpContext.Response.WriteAsync(
        "{"too many requests. try again later.", token);
};

Politiques nommées et anonymes

Politiques nommées s'appliquent via des attributs aux contrôleurs/actions :

[EnableRateLimiting("policy1")]
public class ApiController : ControllerBase { }

Enregistrement simple :

options.AddPolicy("policy1", httpContext =>
    new TokenBucketRateLimiterOptions
    {
        TokenLimit = 100,
        QueueLimit = 20,
        ReplenishmentPeriod = TimeSpan.FromMinutes(1),
        TokensPerPeriod = 100,
        AutoReplenishment = true
    });

Politiques anonymes — un bonus non couvert dans la documentation MS. Implémentées via IRateLimiter directement dans les sélecteurs.

Exemple :

options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext>(
    context => new CustomRateLimiter(context));

public class CustomRateLimiter : FixedWindowRateLimiter
{
    // Kastomnaya logic
}

Liaison aux routes : [EnableRateLimiting("api")] ou désactivation avec [DisableRateLimiting].

Points clés

• La limitation de débit opère au niveau du middleware, avant les contrôleurs.
• Configurez toujours OnRejected pour 429 Too Many Requests.
• Utilisez les files d'attente pour les scénarios à forte charge.
• Combinez les politiques pour un contrôle granulaire (IP + point de terminaison).
• Les politiques anonymes étendent les capacités au-delà de l'API standard.

— Editorial Team