如何在 ASP.NET Core 中实现速率限定？

在 ASP.NET Core 中实现速率限定（Rate Limiting）中间件可以帮助你控制客户端对 API 的请求频率，防止滥用和过载。速率限定通常用于保护服务器资源，确保服务的稳定性和可用性。
ASP.NET Core 本身并没有内置的速率限定中间件，但你可以通过自定义中间件或使用第三方库来实现速率限定。以下是实现速率限定的几种常见方法：
1. 使用自定义中间件实现速率限定

你可以通过自定义中间件来实现速率限定。以下是一个简单的实现示例：
1.1 实现速率限定中间件

1. using Microsoft.AspNetCore.Http;
2. using System.Collections.Concurrent;
3. using System.Threading.Tasks;
5. public class RateLimitingMiddleware
6. {
7.     private readonly RequestDelegate _next;
8.     private readonly int _maxRequests; // 每分钟允许的最大请求数
9.     private readonly ConcurrentDictionary<string, RateLimiter> _rateLimiters;
11.     public RateLimitingMiddleware(RequestDelegate next, int maxRequests)
12.     {
13.         _next = next;
14.         _maxRequests = maxRequests;
15.         _rateLimiters = new ConcurrentDictionary<string, RateLimiter>();
16.     }
18.     public async Task InvokeAsync(HttpContext context)
19.     {
20.         // 获取客户端的唯一标识（例如 IP 地址）
21.         var clientId = context.Connection.RemoteIpAddress.ToString();
23.         // 获取或创建速率限制器
24.         var rateLimiter = _rateLimiters.GetOrAdd(clientId, _ => new RateLimiter(_maxRequests));
26.         if (rateLimiter.AllowRequest())
27.         {
28.             await _next(context);
29.         }
30.         else
31.         {
32.             context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
33.             await context.Response.WriteAsync("请求太多。请稍后再试.");
34.         }
35.     }
36. }
38. public class RateLimiter
39. {
40.     private readonly int _maxRequests;
41.     private int _requestCount;
42.     private DateTime _windowStart;
44.     public RateLimiter(int maxRequests)
45.     {
46.         _maxRequests = maxRequests;
47.         _requestCount = 0;
48.         _windowStart = DateTime.UtcNow;
49.     }
51.     public bool AllowRequest()
52.     {
53.         var now = DateTime.UtcNow;
55.         // 如果当前时间窗口已过期，重置计数器
56.         if ((now - _windowStart).TotalSeconds > 60)
57.         {
58.             _requestCount = 0;
59.             _windowStart = now;
60.         }
62.         // 检查请求是否超出限制
63.         if (_requestCount < _maxRequests)
64.         {
65.             _requestCount++;
66.             return true;
67.         }
69.         return false;
70.     }
71. }

复制代码

2. 使用第三方库实现速率限定

假如你不想自己实现速率限定逻辑，可以使用一些现成的第三方库，例如：
2.1 AspNetCoreRateLimit

AspNetCoreRateLimit 是一个流行的 ASP.NET Core 速率限定库，支持 IP 地点、客户端 ID 和端点级别的速率限定。
安装

通过 NuGet 安装：

1. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
2. {
3.     app.UseMiddleware<RateLimitingMiddleware>(10); // 每分钟最多 10个请求
5.     app.UseRouting();
7.     app.UseEndpoints(endpoints =>
8.                      {
9.                          endpoints.MapControllers();
10.                      });
11. }

复制代码

配置

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

1. dotnet add package AspNetCoreRateLimit

复制代码

配置文件

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

1. public void ConfigureServices(IServiceCollection services)
2. {
3.     // 添加内存缓存
4.     services.AddMemoryCache();
6.     // 配置速率限制
7.     services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
8.     services.AddSingleton<IIpPolicyStore, MemoryCacheIpPolicyStore>();
9.     services.AddSingleton<IRateLimitCounterStore, MemoryCacheRateLimitCounterStore>();
10.     services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
11.     services.AddSingleton<IProcessingStrategy, AsyncKeyLockProcessingStrategy>();
12.     services.AddInMemoryRateLimiting();
13. }
15. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
16. {
17.     app.UseIpRateLimiting();
19.     app.UseRouting();
21.     app.UseEndpoints(endpoints =>
22.                      {
23.                          endpoints.MapControllers();
24.                      });
25. }

复制代码

3. 使用分布式缓存实现速率限定

假如你的应用是分布式的（例如部署在 Kubernetes 或多个服务器上），可以使用分布式缓存（如 Redis）来实现速率限定。
3.1 使用 Redis 实现速率限定

你可以使用 Redis 来存储每个客户端的请求计数。以下是一个简单的示例：

1. {
2.     "IpRateLimiting": {
3.         "EnableEndpointRateLimiting": true,
4.         "StackBlockedRequests": false,
5.         "RealIpHeader": "X-Real-IP",
6.         "ClientIdHeader": "X-ClientId",
7.         "GeneralRules": [
8.             {
9.                 "Endpoint": "*",
10.                 "Period": "1m",
11.                 "Limit": 10
12.                 }
13.         ]
14.     }
15. }

复制代码

3.2 注册中间件

在 Startup.cs 中注册中间件：

1. using Microsoft.AspNetCore.Http;
2. using StackExchange.Redis;
3. using System.Threading.Tasks;
5. public class RedisRateLimitingMiddleware
6. {
7.     private readonly RequestDelegate _next;
8.     private readonly int _maxRequests;
9.     private readonly ConnectionMultiplexer _redis;
11.     public RedisRateLimitingMiddleware(RequestDelegate next, int maxRequests, ConnectionMultiplexer redis)
12.     {
13.         _next = next;
14.         _maxRequests = maxRequests;
15.         _redis = redis;
16.     }
18.     public async Task InvokeAsync(HttpContext context)
19.     {
20.         var clientId = context.Connection.RemoteIpAddress.ToString();
21.         var db = _redis.GetDatabase();
23.         var key = $"rate_limit:{clientId}";
24.         var requestCount = await db.StringIncrementAsync(key);
26.         if (requestCount == 1)
27.         {
28.             await db.KeyExpireAsync(key, TimeSpan.FromMinutes(1));
29.         }
31.         if (requestCount > _maxRequests)
32.         {
33.             context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
34.             await context.Response.WriteAsync("请求太多。请稍后再试.");
35.         }
36.         else
37.         {
38.             await _next(context);
39.         }
40.     }
41. }

复制代码

4. 总结

在 ASP.NET Core 中实现速率限定有多种方式：

• 自定义中间件：得当简单的场景，但需要自己实现逻辑。
  
• 第三方库：如 AspNetCoreRateLimit，提供了更强大的功能和灵活性。
  
• 分布式缓存：如 Redis，得当分布式环境。
  

根据你的需求选择合适的方式，确保你的 API 可以大概有效防止滥用和过载。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。