淺析如何在?ASP.NET?Core中實現速率限制

更新時間：2025年01月15日 10:12:20 作者：代碼拾光

在?ASP.NET?Core?中實現速率限制（Rate?Limiting）中間件可以幫助你控制客戶端對?API?的請求頻率,防止濫用和過載,下面我們就來看看具體實現方法吧

1. 使用自定義中間件實現速率限制

你可以通過自定義中間件來實現速率限制。以下是一個簡單的實現示例：

1.1 實現速率限制中間件

using Microsoft.AspNetCore.Http;
using System.Collections.Concurrent;
using System.Threading.Tasks;

public class RateLimitingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly int _maxRequests; // 每分鐘允許的最大請求數
    private readonly ConcurrentDictionary<string, RateLimiter> _rateLimiters;

    public RateLimitingMiddleware(RequestDelegate next, int maxRequests)
    {
        _next = next;
        _maxRequests = maxRequests;
        _rateLimiters = new ConcurrentDictionary<string, RateLimiter>();
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 獲取客戶端的唯一標識（例如 IP 地址）
        var clientId = context.Connection.RemoteIpAddress.ToString();

        // 獲取或創(chuàng)建速率限制器
        var rateLimiter = _rateLimiters.GetOrAdd(clientId, _ => new RateLimiter(_maxRequests));

        if (rateLimiter.AllowRequest())
        {
            await _next(context);
        }
        else
        {
            context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
            await context.Response.WriteAsync("請求太多。請稍后再試.");
        }
    }
}

public class RateLimiter
{
    private readonly int _maxRequests;
    private int _requestCount;
    private DateTime _windowStart;

    public RateLimiter(int maxRequests)
    {
        _maxRequests = maxRequests;
        _requestCount = 0;
        _windowStart = DateTime.UtcNow;
    }

    public bool AllowRequest()
    {
        var now = DateTime.UtcNow;

        // 如果當前時間窗口已過期，重置計數器
        if ((now - _windowStart).TotalSeconds > 60)
        {
            _requestCount = 0;
            _windowStart = now;
        }

        // 檢查請求是否超出限制
        if (_requestCount < _maxRequests)
        {
            _requestCount++;
            return true;
        }

        return false;
    }
}

1.2 注冊中間件

在 Startup.cs 中注冊中間件：

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<RateLimitingMiddleware>(10); // 每分鐘最多 10個請求

    app.UseRouting();

    app.UseEndpoints(endpoints =>
                     {
                         endpoints.MapControllers();
                     });
}

2. 使用第三方庫實現速率限制

如果你不想自己實現速率限制邏輯，可以使用一些現成的第三方庫，例如：

AspNetCoreRateLimit

AspNetCoreRateLimit 是一個流行的 ASP.NET Core 速率限制庫，支持 IP 地址、客戶端 ID 和端點級別的速率限制。

安裝

通過 NuGet 安裝：

dotnet add package AspNetCoreRateLimit

配置

在 Startup.cs 中配置速率限制：

public void ConfigureServices(IServiceCollection services)
{
    // 添加內存緩存
    services.AddMemoryCache();

    // 配置速率限制
    services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
    services.AddSingleton<IIpPolicyStore, MemoryCacheIpPolicyStore>();
    services.AddSingleton<IRateLimitCounterStore, MemoryCacheRateLimitCounterStore>();
    services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
    services.AddSingleton<IProcessingStrategy, AsyncKeyLockProcessingStrategy>();
    services.AddInMemoryRateLimiting();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseIpRateLimiting();

    app.UseRouting();

    app.UseEndpoints(endpoints =>
                     {
                         endpoints.MapControllers();
                     });
}

配置文件

在 appsettings.json 中添加速率限制配置：

{
    "IpRateLimiting": {
        "EnableEndpointRateLimiting": true,
        "StackBlockedRequests": false,
        "RealIpHeader": "X-Real-IP",
        "ClientIdHeader": "X-ClientId",
        "GeneralRules": [
            {
                "Endpoint": "*",
                "Period": "1m",
                "Limit": 10
                }
        ]
    }
}

3. 使用分布式緩存實現速率限制

如果你的應用是分布式的（例如部署在 Kubernetes 或多個服務器上），可以使用分布式緩存（如 Redis）來實現速率限制。

3.1 使用 Redis 實現速率限制

你可以使用 Redis 來存儲每個客戶端的請求計數。以下是一個簡單的示例：

using Microsoft.AspNetCore.Http;
using StackExchange.Redis;
using System.Threading.Tasks;

public class RedisRateLimitingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly int _maxRequests;
    private readonly ConnectionMultiplexer _redis;

    public RedisRateLimitingMiddleware(RequestDelegate next, int maxRequests, ConnectionMultiplexer redis)
    {
        _next = next;
        _maxRequests = maxRequests;
        _redis = redis;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var clientId = context.Connection.RemoteIpAddress.ToString();
        var db = _redis.GetDatabase();

        var key = $"rate_limit:{clientId}";
        var requestCount = await db.StringIncrementAsync(key);

        if (requestCount == 1)
        {
            await db.KeyExpireAsync(key, TimeSpan.FromMinutes(1));
        }

        if (requestCount > _maxRequests)
        {
            context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
            await context.Response.WriteAsync("請求太多。請稍后再試.");
        }
        else
        {
            await _next(context);
        }
    }
}

3.2 注冊中間件

在 Startup.cs 中注冊中間件：

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<ConnectionMultiplexer>(ConnectionMultiplexer.Connect("localhost:6379"));
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<RedisRateLimitingMiddleware>(10); // 每分鐘最多 10個請求

    app.UseRouting();

    app.UseEndpoints(endpoints =>
                     {
                         endpoints.MapControllers();
                     });
}