浅析如何在 ASP.NET Core中实现速率限制_Asp.net

在 asp.net core 中实现速率限制（rate limiting）中间件可以帮助你控制客户端对 api 的请求频率，防止滥用和过载。速率限制通常用于保护服务器资源，确保服务的稳定性和可用性。

asp.net core 本身并没有内置的速率限制中间件，但你可以通过自定义中间件或使用第三方库来实现速率限制。以下是实现速率限制的几种常见方法：

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

        // 获取或创建速率限制器
        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();
                     });
}