Ratenbegrenzung ASP.NET Core: Einrichtung und Algorithmen

# Ratenbegrenzung in ASP.NET Core einrichten: Ein Schritt-für-Schritt-Leitfaden für Entwickler

Die Ratenbegrenzungsfunktion in ASP.NET Core ermöglicht es Ihnen, die Serverlast zu kontrollieren, vor DoS-Angriffen zu schützen und eine faire Verteilung der Ressourcen zu gewährleisten. Die Einrichtung erfordert zwei Schritte: Registrieren der Dienste und Hinzufügen der Middleware zur Pipeline. Alle Abhängigkeiten sind im SDK enthalten – keine zusätzlichen Pakete erforderlich.

In Program.cs rufen Sie AddRateLimiter auf WebApplicationBuilder.Services auf:

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

Fügen Sie dann die Middleware hinzu:

app.UseRateLimiter();

Dies ist die grundlegende Integration. Als Nächstes: Details zu Algorithmen und Richtlinien.

Algorithmen und selektive Begrenzung

ASP.NET Core unterstützt mehrere Ratenbegrenzungsalgorithmen:

• Fixed Window – festes Zeitfenster, einfach, aber anfällig für Lastspitzen.
• Sliding Window – gleitendes Fenster, verteilt Limits gleichmäßiger.
• Token Bucket – Token-Eimer, erlaubt Burst-Verkehr.
• Concurrency Limiter – begrenzt gleichzeitige Anfragen.

Die Selektivität bestimmt, welche Anfragen begrenzt werden. Der globale Begrenzer gilt für alle Anfragen, selektive verwenden Schlüssel (IP, Benutzer-ID).

Beispiel für einen globalen Begrenzer (100 Anfragen pro 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)
        }));
);

Gruppierung und Kombinieren von Begrenzern

Die Gruppierung nach Schlüssel ist die Grundlage der Selektivität. Verwenden Sie AddFixedWindowLimiter oder benutzerdefinierte Richtlinien.

Szenarien für Schlüsselgruppierung:

• Nach IP: partitionKey: httpContext.Connection.RemoteIpAddress?.ToString()
• Nach Client: partitionKey: httpContext.User.Identity?.Name
• Nach API-Endpunkt: partitionKey: httpContext.Request.Path
• Kombinierter Schlüssel: IP + User-Agent

Kombinieren selektiver Begrenzer über AddPolicy:

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

Neue Funktion: Kombinieren nicht-selektiver Begrenzer – mehrere globale Begrenzer mit Warteschlangen.

Warteschlangen und Ablehnungsbehandlung

Aktivieren Sie Warteschlangen, um Spitzen auszugleichen:

• QueueLimit – Maximum in der Warteschlange.
• QueueProcessingOrder – Reihenfolge (OldestFirst / NewestFirst).

Ablehnungsaktionen können global oder pro Richtlinie festgelegt werden:

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

Benannte und anonyme Richtlinien

Benannte Richtlinien werden über Attribute auf Controller/Aktionen angewendet:

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

Einfache Registrierung:

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

Anonyme Richtlinien – ein Bonus, der nicht in der Microsoft-Dokumentation behandelt wird. Umgesetzt über IRateLimiter direkt in Selektoren.

Beispiel:

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

public class CustomRateLimiter : FixedWindowRateLimiter
{
    // Kastomnaya logic
}

Verknüpfung mit Routen: [EnableRateLimiting("api")] oder deaktivieren mit [DisableRateLimiting].

Wichtige Punkte

• Die Ratenbegrenzung arbeitet auf Middleware-Ebene, vor den Controllern.
• Konfigurieren Sie immer OnRejected für 429 Zu viele Anfragen.
• Verwenden Sie Warteschlangen für Szenarien mit hoher Last.
• Kombinieren Sie Richtlinien für granulare Kontrolle (IP + Endpunkt).
• Anonyme Richtlinien erweitern die Möglichkeiten über die Standard-API hinaus.

— Editorial Team