社区编辑申请
注册/登录
Go 分布式令牌桶限流 + 兜底保障
开发 后端 分布式
单位时间按照一定速率匀速的生产 token 放入桶内,直到达到桶容量上限。处理请求,每次尝试获取一个或多个令牌,如果拿到则处理请求,失败则拒绝请求。

 

本文转载自微信公众号「微服务实践」,作者欧阳安。转载本文请联系微服务实践公众号。

上篇文章提到固定时间窗口限流无法处理突然请求洪峰情况,本文讲述的令牌桶线路算法则可以比较好的处理此场景。

工作原理

单位时间按照一定速率匀速的生产 token 放入桶内,直到达到桶容量上限。

处理请求,每次尝试获取一个或多个令牌,如果拿到则处理请求,失败则拒绝请求。

优缺点

优点

可以有效处理瞬间的突发流量,桶内存量 token 即可作为流量缓冲区平滑处理突发流量。

缺点

实现较为复杂。

代码实现

  1. core/limit/tokenlimit.go 

分布式环境下考虑使用 redis 作为桶和令牌的存储容器,采用 lua 脚本实现整个算法流程。

redis lua 脚本

  1. -- 每秒生成token数量即token生成速度 
  2. local rate = tonumber(ARGV[1]) 
  3. -- 桶容量 
  4. local capacity = tonumber(ARGV[2]) 
  5. -- 当前时间戳 
  6. local now = tonumber(ARGV[3]) 
  7. -- 当前请求token数量 
  8. local requested = tonumber(ARGV[4]) 
  9. -- 需要多少秒才能填满桶 
  10. local fill_time = capacity/rate 
  11. -- 向下取整,ttl为填满时间的2倍 
  12. local ttl = math.floor(fill_time*2) 
  13. -- 当前时间桶容量 
  14. local last_tokens = tonumber(redis.call("get", KEYS[1])) 
  15. -- 如果当前桶容量为0,说明是第一次进入,则默认容量为桶的最大容量 
  16. if last_tokens == nil then 
  17. last_tokens = capacity 
  18. end 
  19. -- 上一次刷新的时间 
  20. local last_refreshed = tonumber(redis.call("get", KEYS[2])) 
  21. -- 第一次进入则设置刷新时间为0 
  22. if last_refreshed == nil then 
  23. last_refreshed = 0 
  24. end 
  25. -- 距离上次请求的时间跨度 
  26. local delta = math.max(0, now-last_refreshed) 
  27. -- 距离上次请求的时间跨度,总共能生产token的数量,如果超多最大容量则丢弃多余的token 
  28. local filled_tokens = math.min(capacity, last_tokens+(delta*rate)) 
  29. -- 本次请求token数量是否足够 
  30. local allowed = filled_tokens >= requested 
  31. -- 桶剩余数量 
  32. local new_tokens = filled_tokens 
  33. -- 允许本次token申请,计算剩余数量 
  34. if allowed then 
  35. new_tokens = filled_tokens - requested 
  36. end 
  37. -- 设置剩余token数量 
  38. redis.call("setex", KEYS[1], ttl, new_tokens) 
  39. -- 设置刷新时间 
  40. redis.call("setex", KEYS[2], ttl, now) 
  41.  
  42. return allowed 

令牌桶限流器定义

  1. type TokenLimiter struct { 
  2.     // 每秒生产速率 
  3.     rate int 
  4.     // 桶容量 
  5.     burst int 
  6.     // 存储容器 
  7.     store *redis.Redis 
  8.     // redis key 
  9.     tokenKey       string 
  10.     // 桶刷新时间key 
  11.     timestampKey   string 
  12.     // lock 
  13.     rescueLock     sync.Mutex 
  14.     // redis健康标识 
  15.     redisAlive     uint32 
  16.     // redis故障时采用进程内 令牌桶限流器 
  17.     rescueLimiter  *xrate.Limiter 
  18.     // redis监控探测任务标识 
  19.     monitorStarted bool 
  20.  
  21. func NewTokenLimiter(rate, burst int, store *redis.Redis, key string) *TokenLimiter { 
  22.     tokenKey := fmt.Sprintf(tokenFormat, key
  23.     timestampKey := fmt.Sprintf(timestampFormat, key
  24.  
  25.     return &TokenLimiter{ 
  26.         rate:          rate, 
  27.         burst:         burst, 
  28.         store:         store, 
  29.         tokenKey:      tokenKey, 
  30.         timestampKey:  timestampKey, 
  31.         redisAlive:    1, 
  32.         rescueLimiter: xrate.NewLimiter(xrate.Every(time.Second/time.Duration(rate)), burst), 
  33.     } 

获取令牌

  1. func (lim *TokenLimiter) reserveN(now time.Time, n int) bool { 
  2.     // 判断redis是否健康 
  3.     // redis故障时采用进程内限流器 
  4.     // 兜底保障 
  5.     if atomic.LoadUint32(&lim.redisAlive) == 0 { 
  6.         return lim.rescueLimiter.AllowN(now, n) 
  7.     } 
  8.     // 执行脚本获取令牌 
  9.     resp, err := lim.store.Eval( 
  10.         script, 
  11.         []string{ 
  12.             lim.tokenKey, 
  13.             lim.timestampKey, 
  14.         }, 
  15.         []string{ 
  16.             strconv.Itoa(lim.rate), 
  17.             strconv.Itoa(lim.burst), 
  18.             strconv.FormatInt(now.Unix(), 10), 
  19.             strconv.Itoa(n), 
  20.         }) 
  21.     // redis allowed == false 
  22.     // Lua boolean false -> r Nil bulk reply 
  23.     // 特殊处理key不存在的情况 
  24.     if err == redis.Nil { 
  25.         return false 
  26.     } else if err != nil { 
  27.         logx.Errorf("fail to use rate limiter: %s, use in-process limiter for rescue", err) 
  28.         // 执行异常,开启redis健康探测任务 
  29.         // 同时采用进程内限流器作为兜底 
  30.         lim.startMonitor() 
  31.         return lim.rescueLimiter.AllowN(now, n) 
  32.     } 
  33.  
  34.     code, ok := resp.(int64) 
  35.     if !ok { 
  36.         logx.Errorf("fail to eval redis script: %v, use in-process limiter for rescue", resp) 
  37.         lim.startMonitor() 
  38.         return lim.rescueLimiter.AllowN(now, n) 
  39.     } 
  40.  
  41.     // redis allowed == true 
  42.     // Lua boolean true -> r integer reply with value of 1 
  43.     return code == 1 

redis 故障时兜底策略

兜底策略的设计考虑得非常细节,当 redis 不可用的时候,启动单机版的 ratelimit 做备用限流,确保基本的限流可用,服务不会被冲垮。

  1. // 开启redis健康探测 
  2. func (lim *TokenLimiter) startMonitor() { 
  3.     lim.rescueLock.Lock() 
  4.     defer lim.rescueLock.Unlock() 
  5.     // 防止重复开启 
  6.     if lim.monitorStarted { 
  7.         return 
  8.     } 
  9.  
  10.     // 设置任务和健康标识 
  11.     lim.monitorStarted = true 
  12.     atomic.StoreUint32(&lim.redisAlive, 0) 
  13.     // 健康探测 
  14.     go lim.waitForRedis() 
  15.  
  16. // redis健康探测定时任务 
  17. func (lim *TokenLimiter) waitForRedis() { 
  18.     ticker := time.NewTicker(pingInterval) 
  19.     // 健康探测成功时回调此函数 
  20.     defer func() { 
  21.         ticker.Stop() 
  22.         lim.rescueLock.Lock() 
  23.         lim.monitorStarted = false 
  24.         lim.rescueLock.Unlock() 
  25.     }() 
  26.  
  27.     for range ticker.C { 
  28.         // ping属于redis内置健康探测命令 
  29.         if lim.store.Ping() { 
  30.             // 健康探测成功,设置健康标识 
  31.             atomic.StoreUint32(&lim.redisAlive, 1) 
  32.             return 
  33.         } 
  34.     } 

项目地址

https://github.com/zeromicro/go-zero

欢迎使用 go-zero 并 star 支持我们!

 

责任编辑:武晓燕 来源: 微服务实践
相关推荐

2022-04-02 20:45:04

Hi3516开发板操作系统鸿蒙

2022-05-09 15:08:56

存储厂商NFV领域华为

2022-05-18 23:42:08

网络安全安全分析工具

2022-04-08 11:08:17

分布式数据接口同步机制

2022-04-26 23:42:08

Windows 10微软升级

2022-05-09 11:57:39

云原生实践安全

2022-04-14 09:00:22

开源数据存储Ignite

2022-05-17 16:56:33

开发工具前端

2022-03-22 15:04:20

中间件分布式软件鸿蒙

2022-04-14 15:56:54

峰会存储

2022-03-24 07:51:27

seata分布式事务Java

2022-04-21 09:26:41

FastDFS开源分布式文件系统

2022-04-15 09:23:29

Kubernetes面试题

2022-03-31 06:13:24

DDoS网络攻击漏洞

2022-03-23 10:28:08

分布式架构代码评审

2022-04-25 14:55:31

数据管理数据驱动架构

2022-05-11 14:48:33

腾讯云寿险民生保险

2022-04-30 09:09:55

SecureFXSecureCRT

2022-05-16 15:35:00

漏洞黑客

2022-03-24 09:44:09

曙光

同话题下的热门内容

Python 字符串总结,建议收藏!这份Java日志格式规范,拿走不谢!Mybatis-Plus官方发布分库分表神器,一个依赖轻松搞定!后端思维篇:如何应用设计模式优化代码改变 Python 对象规则的黑魔法 Metaclass几种限流算法的Go语言实现JMeter关联之正则表达式提取器在 Go 中实现一个支持并发的 TCP 服务端

编辑推荐

使用Kotlin做开发一个月后的感想面试官问你什么是消息队列?把这篇甩给他!五大自动化测试的Python框架图文详解两种算法:深度优先遍历(DFS)和广度优先遍历(BFS)2018年最流行的十大编程语言,其中包括你用的语言吗?
我收藏的内容
点赞
收藏

51CTO技术栈公众号