【Dnc.Api.Throttle】适用于.Net Core WebApi接口限流框架

Dnc.Api.Throttle

  

适用于Dot Net Core的WebApi接口限流框架

使用Dnc.Api.Throttle可以使您轻松实现WebApi接口的限流管理。Dnc.Api.Throttle支持IP、用户身份、Request Header、Request QueryString等多种限流策略，支持黑名单和白名单功能，支持全局拦截和单独Api拦截。

Dnc.Api.Throttle暂时只支持Redis作为缓存和存储库，后续会进行扩展。

开始使用

  • 安装Dnc.Api.Throttle

    NuGet：PM> Install-Package Dnc.Api.Throttle

  • 基本配置

    Startup.cs:

        public void ConfigureServices(IServiceCollection services)
    {
        //Api限流
        services.AddApiThrottle(options => {
            //配置redis
            //如果Cache和Storage使用同一个redis，则可以按如下配置
            options.UseRedisCacheAndStorage(opts => {
                opts.ConnectionString = "localhost,connectTimeout=5000,allowAdmin=false,defaultDatabase=0";
                //opts.KeyPrefix = "apithrottle"; //指定给所有key加上前缀，默认为apithrottle
            });
            //如果Cache和Storage使用不同redis库，可以按如下配置
            //options.UseRedisCache(opts => {
            //    opts.ConnectionString = "localhost,connectTimeout=5000,allowAdmin=false,defaultDatabase=0";
            //});
            //options.UseRedisStorage(opts => {
            //    opts.ConnectionString = "localhost,connectTimeout=5000,allowAdmin=false,defaultDatabase=1";
            //});
        });

        services.AddMvc(opts => {
            //这里添加ApiThrottleActionFilter拦截器
            opts.Filters.Add(typeof(ApiThrottleActionFilter));
        }).SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        ...

        //Api限流
        app.UseApiThrottle();

        app.UseMvc();
    }
  • 给Api添加一个限流阀门（Valve）

    ValuesController.cs:

        // GET api/values
    [HttpGet]
    [RateValve(Policy = Policy.Ip, Limit = 10, Duration = 30)]
    public ActionResult<IEnumerable<string>> Get()
    {
        return new string[] { "value1", "value2" };
    }

    以上特性代表给Get接口添加一个速率阀门，指定每个IP，30秒内最多调用10次该接口。

  • 通过以上配置，最简单的一个接口限流就完成了。

    当Api被拦截时，接口不会执行，context.Result会返回一个 new ApiThrottleResult { Content = "访问过于频繁，请稍后重试！" }， ApiThrottleResult继承于ContentResult，你可以不继续处理，也可以在自己的ResultFilter中拦截ApiThrottleResult并处理。

更多Valve范例

  • [RateValve(Policy = Policy.UserIdentity, Limit = 1, Duration = 60)]

    代表根据用户身份，每60秒可访问1次该接口。关于用户身份，默认是如下取得的：

        return context.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;

    如果需要自定义，则可以在Startup.cs中如下配置：

           //Api限流
        services.AddApiThrottle(options => {
            ...
            options.OnUserIdentity = (httpContext) =>
            {
                //这里根据自己需求返回用户唯一身份
                return httpContext.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
            };
            ...
        });
  • [RateValve(Policy = Policy.Header, PolicyKey = "hkey", Limit = 1, Duration = 30, WhenNull = WhenNull.Intercept)]

    代表根据Request Header中hkey对应的值，每30秒可访问1次该接口。如果无法取得Header中的值或取得的值为空，则进行拦截。

    关于WhenNull：

    WhenNull = WhenNull.Pass：对应策略取得的识别值为空时，不进行拦截。

    WhenNull = WhenNull.Intercept：对应策略取得的识别值为空时，进行拦截。

  • [RateValve(Policy = Policy.Query, PolicyKey = "mobile", Limit = 1, Duration = 30, WhenNull = WhenNull.Pass)]

    代表根据Request Query中mobile对应的值，每30秒可访问1次该接口。如果无法取得识别值或取得的值为空，则不进行拦截。

  • [BlackListValve(Policy = Policy.Query, PolicyKey = "mobile")]

    黑名单拦截，代表根据Request Query中mobile对应的值，如果在黑名单中，则进行拦截。关于如何添加黑名单，请参照后面关于IApiThrottleService部分。

  • [WhiteListValve(Policy = Policy.Ip)]

    白名单拦截，代表根据客户端IP地址，如果在白名单中，则不进行拦截（如果同一个Api上有多个Valve，按序当检查到白名单符合时，则代表检查通过，不进行后续Valve的拦截检查）。关于如何添加白名单，请参照后面关于IApiThrottleService部分。

  • 一个Api多个Valve 
        // POST api/values
    [HttpPost]
    [WhiteListValve(Policy = Policy.Ip, Priority = 3)]
    [BlackListValve(Policy = Policy.UserIdentity, Priority = 2)]
    [RateValve(Policy = Policy.Header, PolicyKey = "hkey", Limit = 1, Duration = 30, WhenNull = WhenNull.Pass)]
    public void Post([FromBody] string value)
    {
    }

    多个Valve根据Priority值从大到小进行拦截，如果被拦截，则不进行后续Valve拦截检查。

全局限流配置

以上都是对单个Api进行限流管理的，如果需要对全局进行限流管理，可在`Startup.cs`中进行如下配置：
       //Api限流
        services.AddApiThrottle(options => {
            ...
            options.Global.AddValves(new BlackListValve
            {
                Policy = Policy.Ip,
                Priority = 99
            }, new WhiteListValve
            {
                Policy = Policy.UserIdentity,
                Priority = 88
            },
            new BlackListValve
            {
                Policy = Policy.Header,
                PolicyKey = "throttle"
            }, new RateValve
            {
                Policy = Policy.Ip,
                Limit = 5,
                Duration = 10,
                WhenNull = WhenNull.Pass
            });
            ...
        });
以上代表给全局添加了4个Valve进行拦截，如果被拦截，则不进行后续操作。

白名单检查通过时，代表全局拦截通过，不进行后续全局Valve检查（后续单独Api的检查还会进行）。

相同识别策略（Policy+PolicyKey）的Valve只能添加一个，重复不会添加。

全局限流拦截在Middlewarez中进行，单独Api限流拦截在IAsyncActionFilter中进行，当然也支持Razor Page，在IAsyncPageFilterz中进行限流。

其他自定义配置项

  • 自定义IP地址取得方法：

    //Api限流
        services.AddApiThrottle(options => {
            ...
            //以下是 Dnc.Api.Throttle 默认取得Ip地址的方法，可进行自定义
            options.OnIpAddress = (context) => {
                var ip = context.Request.Headers["X-Forwarded-For"].FirstOrDefault();
                if (string.IsNullOrEmpty(ip))
                {
                    ip = context.Connection.RemoteIpAddress.ToString();
                }
                return ip;
            };
            ...
        });
  • 自定义拦截后处理： 
           //Api限流
        services.AddApiThrottle(options => {
            ...
            options.onIntercepted = (context, valve, where) =>
            {
                //valve：引发拦截的valve
                //where：拦截发生的地方，有ActionFilter,PageFilter,Middleware(全局)
                if (where == IntercepteWhere.Middleware)
                {
                    //注意：Middleware中返回的ActionResult无法在ResultFilter中拦截处理。
                    return new JsonResult(new { code = 99, message = "访问过于频繁，请稍后重试！" });
                }
                else
                {
                    return new ApiThrottleResult { Content = "访问过于频繁，请稍后重试！" };
                }
            };
            ...
        });

    IApiThrottleService

    使用IApiThrottleService接口可实现黑名单、白名单的管理维护等其他功能。

    使用范例：

        /// <summary>
    /// Api限流管理服务
    /// </summary>
    private readonly IApiThrottleService _service;

    public ValuesController(IApiThrottleService service)
    {
        _service = service;
    }

    [HttpPost]
    [BlackListValve(Policy = Policy.Ip)]
    public async Task AddBlackList()
    {
        var ip = GetIpAddress(HttpContext);
        //添加IP黑名单
        await _service.AddRosterAsync(RosterType.BlackList,
            "WebApiTest.Controllers.ValuesController.AddBlackList",
            Policy.Ip, null, TimeSpan.FromSeconds(60), ip);
    }

    /// <summary>
    /// 取得客户端IP地址
    /// </summary>
    private static string GetIpAddress(HttpContext context)
    {
        var ip = context.Request.Headers["X-Forwarded-For"].FirstOrDefault();
        if (string.IsNullOrEmpty(ip))
        {
            ip = context.Connection.RemoteIpAddress.ToString();
        }
        return ip;
    }
    AddBlackList中针对WebApiTest.Controllers.ValuesController.AddBlackList方法添加了一个有效期60的IP黑名单，当前IP调用该接口会被IP黑名单拦截。


    IApiThrottleService 现有接口：
        #region 黑名单 & 白名单

    /// <summary>
    /// 添加名单
    /// </summary>
    /// <param name="rosterType">名单类型</param>
    /// <param name="api">Api</param>
    /// <param name="policy">策略</param>
    /// <param name="policyKey">策略Key</param>
    /// <param name="expiry">过期时间</param>
    /// <param name="item">项目</param>
    Task AddRosterAsync(RosterType rosterType, string api, Policy policy, string policyKey, TimeSpan? expiry, params string[] item);

    /// <summary>
    /// 删除名单中数据
    /// </summary>
    /// <param name="rosterType">名单类型</param>
    /// <param name="api">API</param>
    /// <param name="policy">策略</param>
    /// <param name="policyKey">策略Key</param>
    /// <param name="expiry">过期时间</param>
    /// <param name="item">项目</param>
    Task RemoveRosterAsync(RosterType rosterType, string api, Policy policy, string policyKey, params string[] item);

    /// <summary>
    /// 取得名单列表（分页）
    /// </summary>
    /// <param name="rosterType">名单类型</param>
    /// <param name="api">API</param>
    /// <param name="policy">策略</param>
    /// <param name="policyKey">策略Key</param>
    Task<(long count, IEnumerable<ListItem> items)> GetRosterListAsync(RosterType rosterType, string api, Policy policy, string policyKey, long skip, long take);

    /// <summary>
    /// 取得名单列表
    /// </summary>
    /// <param name="rosterType">名单类型</param>
    /// <param name="api">API</param>
    /// <param name="policy">策略</param>
    /// <param name="policyKey">策略Key</param>
    Task<IEnumerable<ListItem>> GetRosterListAsync(RosterType rosterType, string api, Policy policy, string policyKey);

    /// <summary>
    /// 添加全局名单
    /// </summary>
    /// <param name="rosterType">名单类型</param>
    /// <param name="policy">策略</param>
    /// <param name="policyKey">策略Key</param>
    /// <param name="expiry">过期时间</param>
    /// <param name="item">项目</param>
    Task AddGlobalRosterAsync(RosterType rosterType, Policy policy, string policyKey, TimeSpan? expiry, params string[] item);

    /// <summary>
    /// 移除全局名单
    /// </summary>
    /// <param name="policy">策略</param>
    /// <param name="item">项目</param>
    Task RemoveGlobalRosterAsync(RosterType rosterType, Policy policy, string policyKey, params string[] item);

    /// <summary>
    /// 取得全局名单列表（分页）
    /// </summary>
    /// <param name="rosterType">名单类型</param>
    /// <param name="policy">策略</param>
    /// <param name="policyKey">策略Key</param>
    Task<(long count, IEnumerable<ListItem> items)> GetGlobalRosterListAsync(RosterType rosterType, Policy policy, string policyKey, long skip, long take);

    /// <summary>
    /// 取得全局名单列表
    /// </summary>
    /// <param name="rosterType">名单类型</param>
    /// <param name="policy">策略</param>
    /// <param name="policyKey">策略Key</param>
    Task<IEnumerable<ListItem>> GetGlobalRosterListAsync(RosterType rosterType, Policy policy, string policyKey);

    #endregion
    Github：https://github.com/kulend/Dnc.Api.ThrottleNuGet：https://www.nuget.org/packages/Dnc.Api.Throttle
     

原文地址：https://www.cnblogs.com/kulend/p/9435095.html

时间： 2024-11-05 22:53:55

【Dnc.Api.Throttle】适用于.Net Core WebApi接口限流框架的相关文章

ASP.NET Core WebApi AspNetCoreRateLimit 限流中间件学习

原文:ASP.NET Core WebApi AspNetCoreRateLimit 限流中间件学习 AspNetCoreRateLimit介绍: AspNetCoreRateLimit是ASP.NET核心速率限制框架,能够对WebApi,Mvc中控制限流,AspNetCoreRateLimit包包含IpRateLimit中间件和ClientRateLimit中间件,每个中间件都可以为不同的场景设置多个限,该框架的作者是stefanprodan,项目nuget地址是https://github.

.Net Core的API网关Ocelot的使用(二)[负载,限流,熔断,Header转换]

网关的负载均衡 当下游拥有多个节点的时候,我们可以用DownstreamHostAndPorts来配置 { "UpstreamPathTemplate": "/Api_A/{controller}/{action}", "DownstreamPathTemplate": "/api/{controller}/{action}", "DownstreamScheme": "https",

使用google的guova开发高并发下的接口限流

使用google的guova进行限流 1.guova的限流方式,在定时产生定量的令牌,令牌的数量限制了流量 2.增加一个订单接口限流类OrderRateFilter,继承ZuulFilter,并重载方法:filterType.filterOrder.shouldFilter.run ????filterType中return PRE_TYPE; ????fileterOrder中应该优先级最高,设为-4 ????shouldFilter中设置限流的方法(类似于鉴权) ???? RequestCo

SpringCloud(8)----zuul权限校验、接口限流

项目代码GitHub地址:https://github.com/yudiandemingzi/spring-cloud-study 一.权限校验搭建 正常项目开发时,权限校验可以考虑JWT和springSecurity结合进行权限校验,这个后期会总结,这里做个基于ZuulFilter过滤器进行一个简单的权限校验过滤. 对于组件zuul中,其实带有权限认证的功能,那就是ZuulFilter过滤器.ZuulFilter是Zuul中核心组件,通过继承该抽象类,覆写几个关键方法达到自定义调度请求的作用

Guava的RateLimiter实现接口限流

最近开发需求中有需要对后台接口进行限流处理,整理了一下基本使用方法. 首先添加guava依赖: <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>23.0</version> </dependency> 然后封装RateLimiter适用对多接口的限制: import com.goog

java接口限流算法

0. 前言 常见的限流算法有:令牌桶.漏桶.计数器也可以进行粗暴限流实现. 1. 算法介绍 1.1 令牌桶算法 令牌桶算法是一个存放固定容量令牌的桶,按照固定速率往桶里添加令牌.令牌桶算法的描述如下: 假设限制2r/s,则按照500毫秒的固定速率往桶中添加令牌: 桶中最多存放b个令牌,当桶满时,新添加的令牌被丢弃或拒绝: 当一个n个字节大小的数据包到达,将从桶中删除n个令牌,接着数据包被发送到网络上: 如果桶中的令牌不足n个,则不会删除令牌,且该数据包将被限流(要么丢弃,要么缓冲区等待). 1.

接口限流实践

一.问题描述 某天A君突然发现自己的接口请求量突然涨到之前的10倍,没多久该接口几乎不可使用,并引发连锁反应导致整个系统崩溃.如何应对这种情况呢?生活给了我们答案:比如老式电闸都安装了保险丝,一旦有人使用超大功率的设备,保险丝就会烧断以保护各个电器不被强电流给烧坏.同理我们的接口也需要安装上“保险丝”,以防止非预期的请求对系统压力过大而引起的系统瘫痪,当流量过大时,可以采取拒绝或者引流等机制. 二.常用的限流算法 常用的限流算法有两种:漏桶算法和令牌桶算法,这篇博文介绍得比较清晰(过载保护算法浅

接口限流算法总结

背景 曾经在一个大神的博客里看到这样一句话:在开发高并发系统时,有三把利器用来保护系统:缓存.降级和限流.那么何为限流呢?顾名思义,限流就是限制流量,就像你宽带包了1个G的流量,用完了就没了.通过限流,我们可以很好地控制系统的qps,从而达到保护系统的目的.本篇文章将会介绍一下常用的限流算法以及他们各自的特点. 算法介绍 计数器法 计 数器法是限流算法里最简单也是最容易实现的一种算法.比如我们规定,对于A接口来说,我们1分钟的访问次数不能超过100个.那么我们可以这么做:在一开 始的时候,我们可

限流(二)接口限流

如果某个接口可能出现突发情况,比如"秒杀"活动,那么很有可能因为突然爆发的访问量造成系统奔溃,我们需要最这样的接口进行限流. 在上一篇"限流算法"中,我们简单提到了两种限流方式: 1)(令牌桶.漏桶算法)限速率,例如:每 5r/1s = 1r/200ms 即一个请求以200毫秒的速率来执行: 2)(计数器方式)限制总数.或者单位时间内的总数,例如:设定总并发数的阀值,单位时间总并发数的阀值. 一.限制总并发数 我们可以采用java提供的atomicLong类来实现