# 限流方式
- 验证：IP黑名单、验证码
- 容器：IIS/Nginx的负载均衡
- 服务端：固定时间窗口、漏斗、令牌
# 固定时间窗口
固定时间内只允许通过一定数据量请求，超出的请求数则会被拦截
//第一步 Services 添加服务
// needed to store rate limit counters and ip rules
services.AddMemoryCache();
//load general configuration from appsettings.json
services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
// inject counter and rules stores
services.AddSingleton<IIpPolicyStore, MemoryCacheIpPolicyStore>();
services.AddSingleton<IRateLimitCounterStore, MemoryCacheRateLimitCounterStore>();
// inject counter and rules distributed cache stores
//services.AddSingleton<IIpPolicyStore, DistributedCacheIpPolicyStore>();
//services.AddSingleton<IRateLimitCounterStore, DistributedCacheRateLimitCounterStore>();
// the clientId/clientIp resolvers use it.
services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
// configuration (resolvers, counter key builders)
services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
//第二步 添加中间件
app.UseIpRateLimiting();//放到最前面
//第三步 AppSetting.json 添加配置
"IpRateLimiting": {
//是否启用节点限流，默认False：API限制规则针对所有接口共同访问的数量
//True：API限制规则针对单个接口访问的数量
"EnableEndpointRateLimiting": true,
//错误的数量是否记录到另外一个计数器上
"StackBlockedRequests": false,
"RealIpHeader": "X-Real-IP",
"ClientIdHeader": "X-ClientId",
"IpWhitelist": [], //白名单
"EndpointWhitelist": [ "get:/api/xxx", "*:/api/yyy" ], //API的白名单
"ClientWhitelist": [ "dev-client-1", "dev-client-2" ], //客户端的白名单
"QuotaExceededResponse": {
"Content": "{{\"status\":429,\"msg\":\"访问过于频繁，请稍后重试\",\"success\":false}}",
"ContentType": "application/json",
"StatusCode": 429
},
"HttpStatusCode": 429, //返回状态码
"GeneralRules": [ //api规则,结尾一定要带*
{
"Endpoint": "*:/api/blog*",
"Period": "1m",
"Limit": 20
},
{
"Endpoint": "*/api/*",
"Period": "1s",
"Limit": 3
},
{
"Endpoint": "*/api/*",
"Period": "1m",
"Limit": 30
},
{
"Endpoint": "*/api/*",
"Period": "12h",
"Limit": 500
}
]
}
# 漏斗和令牌
# 漏斗
声明一个固定容量的桶，每接受到一个请求向桶中添加一个令牌，当令牌桶达到上线后请求丢弃或等待，具体算法如下：
创建一个固定容量的漏桶，请求到达时向漏桶添加一个令牌 如果请求添加令牌不成功，请求丢弃或等待 另一个线程以固定的速率消费桶里的令牌 工作过程也包括3个阶段：产生令牌、消耗令牌和判断数据包是否通过。其中涉及到2个参数：令牌自动消费的速率和令牌桶的大小，个过程的具体工作如下。
产生令牌：业务程序根据具体业务情况申请令牌。申请一次，令牌桶令牌加一。如果桶中令牌数已到达上限，则挂起业务后等待令牌。 消费令牌：周期性的以固定速率消费令牌桶中令牌，桶中的令牌不断较少。 判断是否通过：判断是否已有令牌桶是否存在有效令牌，当桶中的令牌数量可以满足需求时，则继续业务处理，否则将挂起业务，等待令牌。
class LeakageBucketLimitingService: ILimitingService
{
private LimitedQueue<object> limitedQueue = null;
private CancellationTokenSource cancelToken;
private Task task = null;
private int maxTPS;
private int limitSize;
private object lckObj = new object();
public LeakageBucketLimitingService(int maxTPS, int limitSize)
{
this.limitSize = limitSize;
this.maxTPS = maxTPS;
if (this.limitSize <= 0)
this.limitSize = 100;
if (this.maxTPS <= 0)
this.maxTPS = 1;
limitedQueue = new LimitedQueue<object>(limitSize);
cancelToken = new CancellationTokenSource();
task = Task.Factory.StartNew(new Action(TokenProcess), cancelToken.Token);
}
private void TokenProcess()
{
int sleep = 1000 / maxTPS;
if (sleep == 0)
sleep = 1;
DateTime start = DateTime.Now;
while (cancelToken.Token.IsCancellationRequested == false)
{
try
{
if (limitedQueue.Count > 0)
{
lock (lckObj)
{
if (limitedQueue.Count > 0)
limitedQueue.Dequeue();
}
}
}
catch
{
}
finally
{
if (DateTime.Now - start < TimeSpan.FromMilliseconds(sleep))
{
int newSleep = sleep - (int)(DateTime.Now - start).TotalMilliseconds;
if (newSleep > 1)
Thread.Sleep(newSleep - 1); //做一下时间上的补偿
}
start = DateTime.Now;
}
}
}
public void Dispose()
{
cancelToken.Cancel();
}
public bool Request()
{
if (limitedQueue.Count >= limitSize)
return false;
lock (lckObj)
{
if (limitedQueue.Count >= limitSize)
return false;
return limitedQueue.Enqueue(new object());
}
}
}
//调用方法
var service = LimitingFactory.Build(LimitingType.LeakageBucket, 500, 200);
while (true)
{
var result = service.Request();
//如果返回true，说明可以进行业务处理，否则需要继续等待
if (result)
{
//业务处理......
}
else
Thread.Sleep(1);
}
# 令牌
令牌桶算法的基本过程如下：
假如用户配置的平均发送速率为r，则每隔1/r秒速率将一个令牌被加入到桶中； 假设桶最多可以存发b个令牌。当桶中的令牌达到上限后，丢弃令牌。 当一个有请求到达时，首先去令牌桶获取令牌，能够取到，则处理这个请求 如果桶中没有令牌，那么请求排队或者丢弃 工作过程包括3个阶段：产生令牌、消耗令牌和判断数据包是否通过。其中涉及到2个参数：令牌产生的速率和令牌桶的大小，这个过程的具体工作如下。
产生令牌：周期性的以固定速率向令牌桶中增加令牌，桶中的令牌不断增多。如果桶中令牌数已到达上限，则丢弃多余令牌。 消费 令牌：业务程序根据具体业务情况消耗桶中的令牌。消费一次，令牌桶令牌减少一个。 判断是否通过：判断是否已有令牌桶是否存在有效令牌，当桶中的令牌数量可以满足需求时，则继续业务处理，否则将挂起业务，等待令牌。
class TokenBucketLimitingService: ILimitingService
{
private LimitedQueue<object> limitedQueue = null;
private CancellationTokenSource cancelToken;
private Task task = null;
private int maxTPS;
private int limitSize;
private object lckObj = new object();
public TokenBucketLimitingService(int maxTPS, int limitSize)
{
this.limitSize = limitSize;
this.maxTPS = maxTPS;
if (this.limitSize <= 0)
this.limitSize = 100;
if(this.maxTPS <=0)
this.maxTPS = 1;
limitedQueue = new LimitedQueue<object>(limitSize);
for (int i = 0; i < limitSize; i++)
{
limitedQueue.Enqueue(new object());
}
cancelToken = new CancellationTokenSource();
task = Task.Factory.StartNew(new Action(TokenProcess), cancelToken.Token);
}
/// <summary>
/// 定时消息令牌
/// </summary>
private void TokenProcess()
{
int sleep = 1000 / maxTPS;
if (sleep == 0)
sleep = 1;
DateTime start = DateTime.Now;
while (cancelToken.Token.IsCancellationRequested ==false)
{
try
{
lock (lckObj)
{
limitedQueue.Enqueue(new object());
}
}
catch
{
}
finally
{
if (DateTime.Now - start < TimeSpan.FromMilliseconds(sleep))
{
int newSleep = sleep - (int)(DateTime.Now - start).TotalMilliseconds;
if (newSleep > 1)
Thread.Sleep(newSleep - 1); //做一下时间上的补偿
}
start = DateTime.Now;
}
}
}
public void Dispose()
{
cancelToken.Cancel();
}
/// <summary>
/// 请求令牌
/// </summary>
/// <returns>true：获取成功，false：获取失败</returns>
public bool Request()
{
if (limitedQueue.Count <= 0)
return false;
lock (lckObj)
{
if (limitedQueue.Count <= 0)
return false;
object data = limitedQueue.Dequeue();
if (data == null)
return false;
}
return true;
}
}
public interface ILimitingService:IDisposable
{
/// <summary>
/// 申请流量处理
/// </summary>
/// <returns>true：获取成功，false：获取失败</returns>
bool Request();
}
public class LimitingFactory
{
/// <summary>
/// 创建限流服务对象
/// </summary>
/// <param name="limitingType">限流模型</param>
/// <param name="maxQPS">最大QPS</param>
/// <param name="limitSize">最大可用票据数</param>
public static ILimitingService Build(LimitingType limitingType = LimitingType.TokenBucket,
int maxQPS = 100, int limitSize = 100)
{
switch (limitingType)
{
case LimitingType.TokenBucket:
default:
return new TokenBucketLimitingService(maxQPS, limitSize);
case LimitingType.LeakageBucket:
return new LeakageBucketLimitingService(maxQPS, limitSize);
}
}
}
/// <summary>
/// 限流模式
/// </summary>
public enum LimitingType
{
TokenBucket,//令牌桶模式
LeakageBucket//漏桶模式
}
public class LimitedQueue<T> : Queue<T>
{
private int limit = 0;
public const string QueueFulled = "TTP-StreamLimiting-1001";
public int Limit
{
get { return limit; }
set { limit = value; }
}
public LimitedQueue()
: this(0)
{ }
public LimitedQueue(int limit)
: base(limit)
{
this.Limit = limit;
}
public new bool Enqueue(T item)
{
if (limit > 0 && this.Count >= this.Limit)
{
return false;
}
base.Enqueue(item);
return true;
}
}
//调用方法
var service = LimitingFactory.Build(LimitingType.TokenBucket, 500, 200);
while (true)
{
var result = service.Request();
//如果返回true，说明可以进行业务处理，否则需要继续等待
if (result)
{
//业务处理......
}
else
Thread.Sleep(1);
}
# 漏斗和令牌的区别
- 漏桶算法能够强行限制数据的传输速率。在某些情况下，漏桶算法不能够有效地使用网络资源。因为漏桶的漏出速率是固定的
- 令牌桶算法能够在限制数据的平均传输速率的同时还允许某种程度的突发传输
← MiniProfiler 工作单元 →