AspNetCore添加API限流

　　最近发现有客户在大量的请求我们的接口，出于性能考虑遂添加了请求频率限制。

　　由于我们接口请求的是.Net Core写的API网关，所以可以直接添加一个中间件，中间件中使用请求的地址当key，通过配置中心读取对应的请求频率参数设置，然后通过设置redis的过期时间就能实现了。

　　添加一个中间件ApiThrottleMiddleware，使用httpContext.Request.Path获取请求的接口，然后以次为key去读取配置中心设置的请求频率设置。（Ps：使用_configuration.GetSection(apiUrl).Get<ApiThrottleConfig>()不知为何返回值为null，这个还在查）

public class ApiThrottleMiddleware
    {
        private readonly RequestDelegate _next;
        private IConfiguration _configuration;
        private readonly IRedisRunConfigDatabaseProvider _redisRunConfigDatabaseProvider;
        private readonly IDatabase _database;

        public ApiThrottleMiddleware(RequestDelegate next,
            IConfiguration configuration,
            IRedisRunConfigDatabaseProvider redisRunConfigDatabaseProvider)
        {
            _next = next;
            _configuration = configuration;
            _redisRunConfigDatabaseProvider = redisRunConfigDatabaseProvider;
            _database = _redisRunConfigDatabaseProvider.GetDatabase();
        }

        public async Task Invoke(HttpContext httpContext)
        {
            var middlewareContext = httpContext.GetOrCreateMiddlewareContext();
            var apiUrl = httpContext.Request.Path.ToString();

            var jsonValue= _configuration.GetSection(apiUrl).Value;
            var apiThrottleConfig=JsonConvert.DeserializeObject<ApiThrottleConfig>(jsonValue);
            //var apiThrottleConfig = _configuration.GetSection(apiUrl).Get<ApiThrottleConfig>();

            await _next.Invoke(httpContext);
        }
}

　我们使用的配置中心是Apollo，设置的格式如下，其中Duration为请求间隔/秒，Limit为调用次数。（下图设置为每分钟允许请求10次）

（Ps： 由于在API限流中间件前我们已经通过了一个接口签名验证的中间件了，所以我们可以拿到调用客户的具体信息）

如果请求地址没有配置请求频率控制，则直接跳过。否则先通过SortedSetLengthAsync获取对应key的记录数，其中key我们使用了 $"{客户Id}:{插件编码}:{请求地址}"，以此来限制每个客户，每个插件对应的某个接口来控制请求频率。获取key对应集合，当前时间-配置的时间段到当前时间的记录。

 1         /// <summary>
 2         /// 获取key
 3         /// </summary>
 4         /// <param name="signInfo"></param>
 5         /// <param name="apiUrl">接口地址</param>
 6         /// <returns></returns>
 7         private string GetApiRecordKey(InterfaceSignInfo signInfo,string apiUrl)
 8         {
 9             var key = $"{signInfo.LicNo}:{signInfo.PluginCode}:{apiUrl}";
10             return key;
11         }
12
13         /// <summary>
14         /// 获取接口调用次数
15         /// </summary>
16         /// <param name="signInfo"></param>
17         /// <param name="apiUrl">接口地址</param>
18         /// <param name="duration">超时时间</param>
19         /// <returns></returns>
20         public async Task<long> GetApiRecordCountAsync(InterfaceSignInfo signInfo, string apiUrl, int duration)
21         {
22             var key = GetApiRecordKey(signInfo, apiUrl);
23             var nowTicks = DateTime.Now.Ticks;
24             return await _database.SortedSetLengthAsync(key, nowTicks - TimeSpan.FromSeconds(duration).Ticks, nowTicks);
25         }        

如果请求次数大于等于我们设置的频率就直接返回接口调用频率超过限制错误，否则则在key对应的集合中添加一条记录，同时将对应key的过期时间设置为我们配置的限制时间。

        /// <summary>
        /// 获取接口调用次数
        /// </summary>
        /// <param name="signInfo"></param>
        /// <param name="apiUrl">接口地址</param>
        /// <param name="duration">超时时间</param>
        /// <returns></returns>
        public async Task<long> GetApiRecordCountAsync(InterfaceSignInfo signInfo, string apiUrl, int duration)
        {
            var key = GetApiRecordKey(signInfo, apiUrl);
            var nowTicks = DateTime.Now.Ticks;
            return await _database.SortedSetLengthAsync(key, nowTicks - TimeSpan.FromSeconds(duration).Ticks, nowTicks);
        }

　然后只需要在Startup中，在API签名验证中间件后调用我们这个API限流中间件就行了。

　　以下为完整的代码

 1 using ApiGateway.Core.Configuration;
 2 using ApiGateway.Core.Domain.Authentication;
 3 using ApiGateway.Core.Domain.Configuration;
 4 using ApiGateway.Core.Domain.Errors;
 5 using Microsoft.AspNetCore.Http;
 6 using Microsoft.Extensions.Configuration;
 7 using Newtonsoft.Json;
 8 using StackExchange.Redis;
 9 using System;
10 using System.Threading.Tasks;
11
12 namespace ApiGateway.Core.Middleware.Api
13 {
14     /// <summary>
15     /// API限流中间件
16     /// </summary>
17     public class ApiThrottleMiddleware
18     {
19         private readonly RequestDelegate _next;
20         private IConfiguration _configuration;
21         private readonly IRedisRunConfigDatabaseProvider _redisRunConfigDatabaseProvider;
22         private readonly IDatabase _database;
23
24         public ApiThrottleMiddleware(RequestDelegate next,
25             IConfiguration configuration,
26             IRedisRunConfigDatabaseProvider redisRunConfigDatabaseProvider)
27         {
28             _next = next;
29             _configuration = configuration;
30             _redisRunConfigDatabaseProvider = redisRunConfigDatabaseProvider;
31             _database = _redisRunConfigDatabaseProvider.GetDatabase();
32         }
33
34         public async Task Invoke(HttpContext httpContext)
35         {
36             var middlewareContext = httpContext.GetOrCreateMiddlewareContext();
37             var apiUrl = httpContext.Request.Path.ToString();
38
39             var jsonValue= _configuration.GetSection(apiUrl).Value;
40             var apiThrottleConfig=JsonConvert.DeserializeObject<ApiThrottleConfig>(jsonValue);
41             //var apiThrottleConfig = _configuration.GetSection(apiUrl).Get<ApiThrottleConfig>();
42             if (apiThrottleConfig!=null)
43             {
44                 var count = await GetApiRecordCountAsync(middlewareContext.InterfaceSignInfo, apiUrl, apiThrottleConfig.Duration);
45                 if (count >= apiThrottleConfig.Limit)
46                 {
47                     middlewareContext.Errors.Add(new Error("接口调用频率超过限制", GatewayErrorCode.OverThrottleError));
48                 }
49                 else
50                 {
51                     await AddApiRecordCountAsync(middlewareContext.InterfaceSignInfo, apiUrl, apiThrottleConfig.Duration);
52                 }
53             }
54
55             await _next.Invoke(httpContext);
56         }
57
58         /// <summary>
59         /// 获取接口调用次数
60         /// </summary>
61         /// <param name="signInfo"></param>
62         /// <param name="apiUrl">接口地址</param>
63         /// <param name="duration">超时时间</param>
64         /// <returns></returns>
65         public async Task<long> GetApiRecordCountAsync(InterfaceSignInfo signInfo, string apiUrl, int duration)
66         {
67             var key = GetApiRecordKey(signInfo, apiUrl);
68             var nowTicks = DateTime.Now.Ticks;
69             return await _database.SortedSetLengthAsync(key, nowTicks - TimeSpan.FromSeconds(duration).Ticks, nowTicks);
70         }
71
72         /// <summary>
73         /// 添加调用次数
74         /// </summary>
75         /// <param name="signInfo"></param>
76         /// <param name="apiUrl">接口地址</param>
77         /// <param name="duration">超时时间</param>
78         /// <returns></returns>
79         public async Task AddApiRecordCountAsync(InterfaceSignInfo signInfo, string apiUrl, int duration)
80         {
81             var key = GetApiRecordKey(signInfo, apiUrl);
82             var nowTicks = DateTime.Now.Ticks;
83             await _database.SortedSetAddAsync(key, nowTicks.ToString(), nowTicks);
84             await _database.KeyExpireAsync(key, TimeSpan.FromSeconds(duration));
85         }
86
87         /// <summary>
88         /// 获取key
89         /// </summary>
90         /// <param name="signInfo"></param>
91         /// <param name="apiUrl">接口地址</param>
92         /// <returns></returns>
93         private string GetApiRecordKey(InterfaceSignInfo signInfo,string apiUrl)
94         {
95             var key = $"{signInfo.LicNo}:{signInfo.PluginCode}:{apiUrl}";
96             return key;
97         }
98     }
99 }