Limitación de velocidad ASP.NET Core: configuración y algoritmos

# Configuración de limitación de tasa en ASP.NET Core: Guía paso a paso para desarrolladores

La característica de limitación de tasa en ASP.NET Core te permite controlar la carga del servidor, proteger contra ataques DoS y garantizar una distribución justa de recursos. La configuración requiere dos pasos: registrar los servicios y agregar el middleware al pipeline. Todas las dependencias están incluidas en el SDK; no se necesitan paquetes adicionales.

En Program.cs, llama a AddRateLimiter en WebApplicationBuilder.Services:

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

Luego agrega el middleware:

app.UseRateLimiter();

Esta es la integración básica. A continuación: detalles sobre algoritmos y políticas.

Algoritmos y limitación selectiva

ASP.NET Core soporta varios algoritmos de limitación de tasa:

• Fixed Window — ventana de tiempo fija, simple pero propensa a picos de carga.
• Sliding Window — ventana deslizante, distribuye los límites de forma más uniforme.
• Token Bucket — cubo de tokens, permite tráfico en ráfagas.
• Concurrency Limiter — limita las solicitudes concurrentes.

La selectividad determina qué solicitudes limitar. El limitador global se aplica a todas las solicitudes, mientras que los selectivos usan claves (IP, ID de usuario).

Ejemplo de un limitador global (100 solicitudes por minuto):

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)
        }));
);

Agrupación y combinación de limitadores

La agrupación por clave es la base de la selectividad. Usa AddFixedWindowLimiter o políticas personalizadas.

Escenarios de agrupación por clave:

• Por IP: partitionKey: httpContext.Connection.RemoteIpAddress?.ToString()
• Por cliente: partitionKey: httpContext.User.Identity?.Name
• Por punto de enlace de API: partitionKey: httpContext.Request.Path
• Clave combinada: IP + User-Agent

Combinación de limitadores selectivos mediante AddPolicy:

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

Nueva característica: combinación de limitadores no selectivos — múltiples limitadores globales con colas.

Colas y manejo de rechazos

Habilita colas para suavizar los picos:

• QueueLimit — máximo en cola.
• QueueProcessingOrder — orden (OldestFirst / NewestFirst).

Las acciones de rechazo se pueden configurar de forma global o por política:

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);
};

Políticas nombradas y anónimas

Las políticas nombradas se aplican mediante atributos a controladores/acciones:

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

Registro simple:

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

Políticas anónimas — un extra no cubierto en la documentación de MS. Se implementan mediante IRateLimiter directamente en los selectores.

Ejemplo:

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

public class CustomRateLimiter : FixedWindowRateLimiter
{
    // Kastomnaya logic
}

Vinculación a rutas: [EnableRateLimiting("api")] o deshabilitar con [DisableRateLimiting].

Puntos clave

• La limitación de tasa opera a nivel de middleware, antes de los controladores.
• Siempre configura OnRejected para 429 Too Many Requests.
• Usa colas en escenarios de alta carga.
• Combina políticas para un control granular (IP + punto de enlace).
• Las políticas anónimas extienden las capacidades más allá de la API estándar.

— Editorial Team