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 zwraca429 Too Many Requests, opcjonalnie z nagłówkiemRetry-After.