详解Go可用性(六)熔断

在前面的几篇文章当中，无论是令牌桶、漏桶还是自适应限流的方法，总的来说都是服务端的单机限流方式。虽然服务端限流虽然可以帮助我们抗住一定的压力，但是拒绝请求毕竟还是有成本的。如果我们的本来流量可以支撑 1w rps，加了限流可以支撑在 10w rps 的情况下仍然可以提供 1w rps 的有效请求，但是流量突然再翻了 10 倍，来到 100w rps 那么服务该挂还是得挂。

创新互联建站主要从事网站设计、网站制作、网页设计、企业做网站、公司建网站等业务。立足成都服务河源,10余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:13518219792

所以我们的可用性建设不仅仅是服务端做建设就可以万事大吉了，得在整个链路上的每个组件都做好自己的事情才行，今天我们就来一起看一下客户端上的限流措施：熔断。

熔断器

熔断器[^2]

如上图[^2]所示，熔断器存在三个状态:

关闭(closed): 关闭状态下没有触发断路保护，所有的请求都正常通行

打开(open): 当错误阈值触发之后，就进入开启状态，这个时候所有的流量都会被节流，不运行通行

半打开(half-open): 处于打开状态一段时间之后，会尝试尝试放行一个流量来探测当前 server 端是否可以接收新流量，如果这个没有问题就会进入关闭状态，如果有问题又会回到打开状态

hystrix-go

熔断器中比较典型的实现就是 hystrix，Golang 也有对应的版本，我们先来看一下 hystrix-go 是怎么实现的

案例

先看一个使用案例，首先我们使用 gin 启动一个服务端，这个服务端主要是前 200ms 的请求都会返回 500，之后的请求都会返回 200

 
 
 
 
    
  
  
  
  
  1. func server() { 
    2.   
  
  
  
  2.  e := gin.Default() 
    3.   
  
  
  
  3.  e.GET("/ping", func(ctx *gin.Context) { 
    4.   
  
  
  
  4.   if time.Since(start) < 201*time.Millisecond { 
    5.   
  
  
  
  5.    ctx.String(http.StatusInternalServerError, "pong") 
    6.   
  
  
  
  6.    return 
    7.   
  
  
  
  7.   } 
    8.   
  
  
  
  8.   ctx.String(http.StatusOK, "pong") 
    9.   
  
  
  
  9.  }) 
    10.   
  
  
  
  10.  e.Run(":8080") 
    11.   
  
  
  
  11. } 
    12.

然后配置 hystrix，hystrix.ConfigureCommand(command name, config) hystrix 的配置是按照每个 command 进行配置，使用的时候我们也需要传递一个 command，下面的配置就是我们的请求数量大于等于 10 个并且错误率大于等于 20% 的时候就会触发熔断器开关，熔断器打开 500ms 之后会进入半打开的状态，尝试放一部分请求去访问

 
 
 
 
    
  
  
  
  
  1. func main(){ 
    2.   
  
  
  
  2.  hystrix.ConfigureCommand("test", hystrix.CommandConfig{ 
    3.   
  
  
  
  3.   // 执行 command 的超时时间 
    4.   
  
  
  
  4.   Timeout: 10, 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.   // 最大并发量 
    7.   
  
  
  
  7.   MaxConcurrentRequests: 100, 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.   // 一个统计窗口 10 秒内请求数量 
    10.   
  
  
  
  10.   // 达到这个请求数量后才去判断是否要开启熔断 
    11.   
  
  
  
  11.   RequestVolumeThreshold: 10, 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.   // 熔断器被打开后 
    14.   
  
  
  
  14.   // SleepWindow 的时间就是控制过多久后去尝试服务是否可用了 
    15.   
  
  
  
  15.     // 单位为毫秒 
    16.   
  
  
  
  16.   SleepWindow: 500, 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.   // 错误百分比 
    19.   
  
  
  
  19.   // 请求数量大于等于 RequestVolumeThreshold 并且错误率到达这个百分比后就会启动熔断 
    20.   
  
  
  
  20.   ErrorPercentThreshold: 20, 
    21.   
  
  
  
  21.  }) 
    22.   
  
  
  
  22. } 
    23.

然后我们使用一个循环当做客户端代码，会请求 20 次，每一个请求消耗 100ms

 
 
 
 
    
  
  
  
  
  1. func main() { 
    2.   
  
  
  
  2.  go server() 
    3.   
  
  
  
  3.   
    4.   
  
  
  
  4.   // 这里是 config 代码 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.  for i := 0; i < 20; i++ { 
    7.   
  
  
  
  7.   _ = hystrix.Do("test", func() error { 
    8.   
  
  
  
  8.    resp, _ := resty.New().R().Get("http://localhost:8080/ping") 
    9.   
  
  
  
  9.    if resp.IsError() { 
    10.   
  
  
  
  10.     return fmt.Errorf("err code: %s", resp.Status()) 
    11.   
  
  
  
  11.    } 
    12.   
  
  
  
  12.    return nil 
    13.   
  
  
  
  13.   }, func(err error) error { 
    14.   
  
  
  
  14.    fmt.Println("fallback err: ", err) 
    15.   
  
  
  
  15.    return err 
    16.   
  
  
  
  16.   }) 
    17.   
  
  
  
  17.   time.Sleep(100 * time.Millisecond) 
    18.   
  
  
  
  18.  } 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20. } 
    21.

所以我们执行的结果就是，前面 2 个请求报 500，等到发起了 10 个请求之后就会进入熔断， 500ms 也就是发出 5 个请求之后就会重新去请求服务端

image-20210504164650024

hystrix-go 核心实现

核心实现的方法是 AllowRequest，IsOpen判断当前是否处于熔断状态，allowSingleTest就是去看是否过了一段时间需要重新进行尝试

 
 
 
 
    
  
  
  
  
  1. func (circuit *CircuitBreaker) AllowRequest() bool { 
    2.   
  
  
  
  2.  return !circuit.IsOpen() || circuit.allowSingleTest() 
    3.   
  
  
  
  3. } 
    4.

IsOpen先看当前是否已经打开了，如果已经打开了就直接返回就行了，如果还没打开就去判断

请求数量是否满足要求

请求的错误率是否过高，如果两个都满足就会打开熔断器

 
 
 
 
    
  
  
  
  
  1. func (circuit *CircuitBreaker) IsOpen() bool { 
    2.   
  
  
  
  2.  circuit.mutex.RLock() 
    3.   
  
  
  
  3.  o := circuit.forceOpen || circuit.open 
    4.   
  
  
  
  4.  circuit.mutex.RUnlock() 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.  if o { 
    7.   
  
  
  
  7.   return true 
    8.   
  
  
  
  8.  } 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.  if uint64(circuit.metrics.Requests().Sum(time.Now())) < getSettings(circuit.Name).RequestVolumeThreshold { 
    11.   
  
  
  
  11.   return false 
    12.   
  
  
  
  12.  } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.  if !circuit.metrics.IsHealthy(time.Now()) { 
    15.   
  
  
  
  15.   // too many failures, open the circuit 
    16.   
  
  
  
  16.   circuit.setOpen() 
    17.   
  
  
  
  17.   return true 
    18.   
  
  
  
  18.  } 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.  return false 
    21.   
  
  
  
  21. } 
    22.

hystrix-go已经可以比较好的满足我们的需求，但是存在一个问题就是一旦触发了熔断，在一段时间之类就会被一刀切的拦截请求，所以我们来看看 google sre 的一个实现

Google SRE 过载保护算法

算法如上所示，这个公式计算的是请求被丢弃的概率[^3]

  • requests: 一段时间的请求数量
  • accepts: 成功的请求数量
  • K: 倍率，K 越小表示越激进，越小表示越容易被丢弃请求

这个算法的好处是不会直接一刀切的丢弃所有请求，而是计算出一个概率来进行判断，当成功的请求数量越少，K越小的时候的值就越大，计算出的概率也就越大，表示这个请求被丢弃的概率越大

Kratos 实现分析

 
 
 
 
    
  
  
  
  
  1. func (b *sreBreaker) Allow() error { 
    2.   
  
  
  
  2.  // 统计成功的请求，和总的请求 
    3.   
  
  
  
  3.  success, total := b.summary() 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.  // 计算当前的成功率 
    6.   
  
  
  
  6.  k := b.k * float64(success) 
    7.   
  
  
  
  7.  if log.V(5) { 
    8.   
  
  
  
  8.   log.Info("breaker: request: %d, succee: %d, fail: %d", total, success, total-success) 
    9.   
  
  
  
  9.  } 
    10.   
  
  
  
  10.  // 统计请求量和成功率 
    11.   
  
  
  
  11.  // 如果 rps 比较小，不触发熔断 
    12.   
  
  
  
  12.  // 如果成功率比较高，不触发熔断，如果 k = 2，那么就是成功率 >= 50% 的时候就不熔断 
    13.   
  
  
  
  13.  if total < b.request || float64(total) < k { 
    14.   
  
  
  
  14.   if atomic.LoadInt32(&b.state) == StateOpen { 
    15.   
  
  
  
  15.    atomic.CompareAndSwapInt32(&b.state, StateOpen, StateClosed) 
    16.   
  
  
  
  16.   } 
    17.   
  
  
  
  17.   return nil 
    18.   
  
  
  
  18.  } 
    19.   
  
  
  
  19.  if atomic.LoadInt32(&b.state) == StateClosed { 
    20.   
  
  
  
  20.   atomic.CompareAndSwapInt32(&b.state, StateClosed, StateOpen) 
    21.   
  
  
  
  21.  } 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.  // 计算一个概率，当 dr 值越大，那么被丢弃的概率也就越大 
    24.   
  
  
  
  24.  // dr 值是，如果失败率越高或者是 k 值越小，那么它越大 
    25.   
  
  
  
  25.  dr := math.Max(0, (float64(total)-k)/float64(total+1)) 
    26.   
  
  
  
  26.  drop := b.trueOnProba(dr) 
    27.   
  
  
  
  27.  if log.V(5) { 
    28.   
  
  
  
  28.   log.Info("breaker: drop ratio: %f, drop: %t", dr, drop) 
    29.   
  
  
  
  29.  } 
    30.   
  
  
  
  30.  if drop { 
    31.   
  
  
  
  31.   return ecode.ServiceUnavailable 
    32.   
  
  
  
  32.  } 
    33.   
  
  
  
  33.  return nil 
    34.   
  
  
  
  34. } 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36. // 通过随机来判断是否需要进行熔断 
    37.   
  
  
  
  37. func (b *sreBreaker) trueOnProba(proba float64) (truth bool) { 
    38.   
  
  
  
  38.  b.randLock.Lock() 
    39.   
  
  
  
  39.  truth = b.r.Float64() < proba 
    40.   
  
  
  
  40.  b.randLock.Unlock() 
    41.   
  
  
  
  41.  return 
    42.   
  
  
  
  42. } 
    43.

总结

可用性仅靠服务端来保证是不靠谱的，只有整条链路上的所有服务都做好了自己可用性相关的建设我们的服务 SLA 最后才能够有保证。今天我们讲了 hystrix-go 和 kratos 两种熔断的实现方式，kratos采用 Google SRE 的实现的好处就是没有半开的状态，也没有完全开启的状态，而是通过一个概率来进行判断我们的流量是否应该通过，这样没有那么死板，也可以保证我们错误率比较高的时候不会大量请求服务端，给服务端喘息恢复的时间。

参考文献

[^1]: 极客时间: Go 进阶训练营 https://u.geekbang.org/subject/go?utm_source=lailin.xyz&utm_medium=lailin.xyz

[^2]: 熔断原理与实现Golang版 https://www.jianshu.com/p/0ee350cde543

[^3]: Google SRE https://sre.google/sre-book/handling-overload/#eq2101

[^4]: hystrix-go https://github.com/afex/hystrix-go/

[^5]: kratos 实现 https://github.com/go-kratos/kratos/blob/v1.0.x/pkg/net/netutil/breaker/sre_breaker.go

本文转载自微信公众号「mohuishou」，可以通过以下二维码关注。转载本文请联系mohuishou公众号。

网页标题：详解Go可用性(六)熔断
链接地址：http://www.shufengxianlan.com/qtweb/news41/151941.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

商城网站知识

同城分类信息

成都网站推广　　 　全网整合营销推广　　 　成都网站优化　　 　成都小谭网创广告　　 　重庆花箱　　 　绵阳梓潼网站建设　　 　郫县门窗定制　　 　成都网站SEO优化公司　　 　成都SEO优化公司　　 　服务器托管　　 　甘孜州博瑞斯　　 　成都酒店服定制　　 　成都高电机柜租用　　 　网站建设公司　　 　网络推广外包　　 　成都西信服务器托管　　 　网站制作　　 　二枢服务器托管　　 　高端定制网站设计　　 　堡垒主机