AspNetCore添加API限流

本文轉載自查看原文 2021-08-13 10:00 551

最近發現有客戶在大量的請求我們的接口，出於性能考慮遂添加了請求頻率限制。

由於我們接口請求的是.Net Core寫的API網關，所以可以直接添加一個中間件，中間件中使用請求的地址當key，通過配置中心讀取對應的請求頻率參數設置，然后通過設置redis的過期時間就能實現了。

添加一個中間件ApiThrottleMiddleware，使用httpContext.Request.Path獲取請求的接口，然后以次為key去讀取配置中心設置的請求頻率設置。（Ps：使用_configuration.GetSection(apiUrl).Get<ApiThrottleConfig>()不知為何返回值為null，這個還在查）

 1     public class ApiThrottleMiddleware
 2     {
 3         private readonly RequestDelegate _next;
 4         private IConfiguration _configuration;
 5         private readonly IRedisRunConfigDatabaseProvider _redisRunConfigDatabaseProvider;
 6         private readonly IDatabase _database;
 7 
 8         public ApiThrottleMiddleware(RequestDelegate next,
 9             IConfiguration configuration,
10             IRedisRunConfigDatabaseProvider redisRunConfigDatabaseProvider)
11         {
12             _next = next;
13             _configuration = configuration;
14             _redisRunConfigDatabaseProvider = redisRunConfigDatabaseProvider;
15             _database = _redisRunConfigDatabaseProvider.GetDatabase();
16         }
17 
18         public async Task Invoke(HttpContext httpContext)
19         {
20             var middlewareContext = httpContext.GetOrCreateMiddlewareContext();
21             var apiUrl = httpContext.Request.Path.ToString();
22 
23             var jsonValue= _configuration.GetSection(apiUrl).Value;
24             var apiThrottleConfig=JsonConvert.DeserializeObject<ApiThrottleConfig>(jsonValue);
25             //var apiThrottleConfig = _configuration.GetSection(apiUrl).Get<ApiThrottleConfig>();
26             
27             await _next.Invoke(httpContext);
28         }
29 }

我們使用的配置中心是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限流中間件就行了。

　　以下為完整的代碼

using ApiGateway.Core.Configuration;
using ApiGateway.Core.Domain.Authentication;
using ApiGateway.Core.Domain.Configuration;
using ApiGateway.Core.Domain.Errors;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Threading.Tasks;

namespace ApiGateway.Core.Middleware.Api
{
    /// <summary>
    /// API限流中間件
    /// </summary>
    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;
            if (!string.IsNullOrEmpty(jsonValue))
            {
                var apiThrottleConfig = JsonConvert.DeserializeObject<ApiThrottleConfig>(jsonValue);
                //var apiThrottleConfig = _configuration.GetSection(apiUrl).Get<ApiThrottleConfig>();
                var count = await GetApiRecordCountAsync(middlewareContext.InterfaceSignInfo, apiUrl, apiThrottleConfig.Duration);
                if (count >= apiThrottleConfig.Limit)
                {
                    middlewareContext.Errors.Add(new Error("接口調用頻率超過限制", GatewayErrorCode.OverThrottleError));
                }
                else
                {
                    await AddApiRecordCountAsync(middlewareContext.InterfaceSignInfo, apiUrl, apiThrottleConfig.Duration);
                }
            }
            
            await _next.Invoke(httpContext);
        }

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

        /// <summary>
        /// 添加調用次數
        /// </summary>
        /// <param name="signInfo"></param>
        /// <param name="apiUrl">接口地址</param>
        /// <param name="duration">超時時間</param>
        /// <returns></returns>
        public async Task AddApiRecordCountAsync(InterfaceSignInfo signInfo, string apiUrl, int duration)
        {
            var key = GetApiRecordKey(signInfo, apiUrl);
            var nowTicks = DateTime.Now.Ticks;
            await _database.SortedSetAddAsync(key, nowTicks.ToString(), nowTicks);
            await _database.KeyExpireAsync(key, TimeSpan.FromSeconds(duration));
        }

        /// <summary>
        /// 獲取key
        /// </summary>
        /// <param name="signInfo"></param>
        /// <param name="apiUrl">接口地址</param>
        /// <returns></returns>
        private string GetApiRecordKey(InterfaceSignInfo signInfo,string apiUrl)
        {
            var key = $"_api_throttle:{signInfo.LicNo}:{signInfo.PluginCode}:{apiUrl}";
            return key;
        }
    }
}

View Code

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 AspNetCore 限流中間件IpRateLimitMiddleware 介紹 PHP API接口限流高並發之API接口限流在Windows 下如何使用 AspNetCore Api 和 consul 服務接口API限流 RateLimit 【5min+】美化API，包裝AspNetCore的返回結果 AspNetCore打造一個“最安全”的api接口服務接口API限流 Rate Limit 令牌桶算法實現API限流 Guava RateLimiter實現接口API限流