C# / .NET Kompendium PLEN
.NET / C# / Web API, Blazor

Rate Limiting w ASP.NET Core

Wbudowany middleware (od .NET 7) - Microsoft.AspNetCore.RateLimiting

Wcześniej rate limiting wymagał zewnętrznych bibliotek (AspNetCoreRateLimit) albo własnej implementacji - od .NET 7 jest wbudowany w framework.

using System.Threading.RateLimiting;

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("fixed", opt =>
    {
        opt.Window = TimeSpan.FromSeconds(10);
        opt.PermitLimit = 5; // maksymalnie 5 requestów na 10 sekund
        opt.QueueLimit = 2;  // dodatkowo, 2 requesty mogą czekać w kolejce
    });
});

var app = builder.Build();
app.UseRateLimiter();

app.MapGet("/api/data", () => "wynik").RequireRateLimiting("fixed");

Cztery wbudowane algorytmy - kiedy który

1. Fixed Window - najprostszy

Limit resetuje się co N sekund w stałych odstępach.

options.AddFixedWindowLimiter("fixed", opt =>
{
    opt.Window = TimeSpan.FromMinutes(1);
    opt.PermitLimit = 100;
});

Wada: możliwy "burst" na granicy okna - 100 requestów na końcu jednej minuty + 100 na początku następnej = 200 w krótkim czasie.

2. Sliding Window

Jak Fixed Window, ale okno "przesuwa się" płynnie, dzielone na segmenty - eliminuje problem burstów na granicy.

options.AddSlidingWindowLimiter("sliding", opt =>
{
    opt.Window = TimeSpan.FromMinutes(1);
    opt.PermitLimit = 100;
    opt.SegmentsPerWindow = 6; // dzieli minutę na 6 segmentów po 10s
});

3. Token Bucket

"Wiadro tokenów", uzupełniane w stałym tempie; każdy request zabiera token. Pozwala na kontrolowany burst (jeśli wiadro było pełne), ale ogranicza średnie tempo w długim okresie.

options.AddTokenBucketLimiter("token", opt =>
{
    opt.TokenLimit = 50;                              // maks. rozmiar "wiadra"
    opt.TokensPerPeriod = 10;                          // ile tokenów dodaje co okres
    opt.ReplenishmentPeriod = TimeSpan.FromSeconds(10); // jak często uzupełnia
});

4. Concurrency Limiter

Limituje równoczesne requesty (nie w czasie, tylko "w danym momencie"), przydatne dla endpointów kosztownych zasobowo (np. generowanie raportu PDF).

options.AddConcurrencyLimiter("concurrency", opt =>
{
    opt.PermitLimit = 10; // max 10 requestów wykonuje się RÓWNOCZEŚNIE
    opt.QueueLimit = 20;
});

Partycjonowanie - limit PER klient, nie globalnie

To jest kluczowa, praktyczna funkcja - bez partycjonowania limit jest wspólny dla wszystkich użytkowników naraz (jeden zły klient zajmuje cały limit). Partycjonowanie daje osobny licznik per klucz (np. per IP, per użytkownik, per API key):

options.AddPolicy("per-user", context =>
    RateLimitPartition.GetFixedWindowLimiter(
        partitionKey: context.User.Identity?.Name ?? context.Connection.RemoteIpAddress?.ToString() ?? "anonymous",
        factory: _ => new FixedWindowRateLimiterOptions
        {
            Window = TimeSpan.FromMinutes(1),
            PermitLimit = 20
        }));

Każdy zalogowany użytkownik (albo, dla anonimowych, każdy adres IP) dostaje własny, niezależny licznik 20 requestów/minutę - jeden nadaktywny klient nie zjada limitu innych.

Reakcja na przekroczenie limitu - status 429

options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;

options.OnRejected = async (context, token) =>
{
    context.HttpContext.Response.Headers["Retry-After"] = "10";
    await context.HttpContext.Response.WriteAsync("Zbyt wiele requestów, spróbuj później.", token);
};

Standard HTTP dla rate limitingu to kod 429 Too Many Requests, opcjonalnie z nagłówkiem Retry-After mówiącym klientowi, po ilu sekundach spróbować ponownie.

Pełny przykład w Web API - kontroler + globalna i per-endpoint polityka

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();

builder.Services.AddRateLimiter(options =>
{
    options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;

    // Polityka GLOBALNA - per adres IP, stosowana domyślnie do WSZYSTKICH endpointów
    options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(context =>
        RateLimitPartition.GetFixedWindowLimiter(
            partitionKey: context.Connection.RemoteIpAddress?.ToString() ?? "unknown",
            factory: _ => new FixedWindowRateLimiterOptions
            {
                Window = TimeSpan.FromMinutes(1),
                PermitLimit = 100
            }));

    // Polityka DODATKOWA, bardziej restrykcyjna - dla konkretnego, kosztownego endpointu
    options.AddTokenBucketLimiter("expensive-operation", opt =>
    {
        opt.TokenLimit = 5;
        opt.TokensPerPeriod = 1;
        opt.ReplenishmentPeriod = TimeSpan.FromSeconds(30);
    });
});

var app = builder.Build();
app.UseRateLimiter(); // MUSI być po UseRouting(), przed MapControllers/endpointami

app.MapControllers();
app.Run();
[ApiController]
[Route("api/reports")]
public class ReportsController : ControllerBase
{
    [HttpGet]
    [EnableRateLimiting("expensive-operation")] // NADPISUJE globalną politykę TYLKO dla tej akcji
    public async Task<IActionResult> GenerateReport()
    {
        await Task.Delay(2000); // symulacja kosztownej operacji
        return Ok(new { generated = true });
    }

    [HttpGet("summary")]
    [DisableRateLimiting] // WYŁĄCZA rate limiting dla tej JEDNEJ akcji (np. health-check)
    public IActionResult GetSummary() => Ok("lekki endpoint, bez limitu");
}

Ten przykład pokazuje typową, warstwową konfigurację: globalny limiter (per IP, 100/min) chroniący całe API, plus bardziej restrykcyjna polityka (token bucket, 1 token/30s) nałożona na jeden, kosztowny endpoint przez [EnableRateLimiting], oraz [DisableRateLimiting] jako wentyl bezpieczeństwa dla endpointów, które muszą być zawsze dostępne (np. /health).

Podsumowanie - kiedy który algorytm

Algorytm Kiedy używać
Fixed Window Prosty limit, akceptowalny mały burst na granicy okna
Sliding Window Potrzebujesz gładszego rozkładu, bez burstów na granicy
Token Bucket Chcesz pozwolić na chwilowy burst, ale ograniczyć średnie tempo
Concurrency Ochrona zasobożernych endpointów przed zbyt wieloma równoczesnymi wywołaniami

Podsumowanie

Rate limiting w ASP.NET Core (od .NET 7, Microsoft.AspNetCore.RateLimiting) chroni API przed nadmiernym obciążeniem przez cztery algorytmy (Fixed/Sliding Window, Token Bucket, Concurrency), konfigurowane globalnie albo per-endpoint ([EnableRateLimiting]/[DisableRateLimiting]). Partycjonowanie (RateLimitPartition) daje niezależny licznik per klient (IP, użytkownik, API key), a przekroczenie limitu standardowo zwraca 429 Too Many Requests, opcjonalnie z nagłówkiem Retry-After.

Postaw mi kawę