浅析hystrix断路器

断路器&&hystrix简介

• 断路器代理了服务调用方对提供方的请求。监控最近请求的失败和超时次数，在下游服务因为过载或者故障无法提供响应时，断路器中请求失败率会大大提升，超过一定阈值后，断路器会打开，切断服务调用方和提供方的联系，此时调用者会执行失败逻辑或者直接返回异常。同时断路器还有检测恢复机制，允许服务调用者尝试调用服务提供者以检测它是否恢复正常，若恢复正常则关闭断路器，恢复正常调用。
• 断路器的三态
  • 关闭状态：程序正常运行时，大多数都处于此状态，服务调用者正常访问服务提供者。断路器会统计周期时间内的请求总次数和失败数的比例。
  • 打开状态：最近失败频率超过了预设的阈值以后，断路器进入打开状态，服务调用者对服务提供者的调用失效，服务调用进入失败逻辑或者返回异常。
  • 半开状态：断路器在进入打开状态时候会启动一个超时定时器，在定时器到达时，它会进入到半开状态，此时执行“恢复检测机制”，即调用者尝试对服务提供者发起少量调用请求。如果这些请求都成功执行，那么断路器就认为服务提供者已恢复正常，断路器则关闭，失败计数器复位。如果这些请求失败，断路器返回到打开状态，并重新启动超时定时器，重新进行检测恢复。
• hystrix
  • hystrix是一个延迟和容错的库。作用于隔离三方系统，服务，第三方库之间的调用，防止级联故障。并且在分布式系统中实现故障出现后的复原能力。git地址：https://pkg.go.dev/github.com/afex/hystrix-go/hystrix

　　hystrix执行流程

　　

 

hystrix使用实例

1. 准备两个http server的 service
2. 通过配置hystrix的命令，验证断路器的熔断，检测恢复功能
3. 示例代码中demo1，配置service1的请求并发数量大于100时，触发断路器打开，配置service2的并发请求数量大于5时，触发断路器打开。两个服务同时用50个goroutine去并发请求，可以看到，请求service2会打印“”失败回滚日志；
4. 示例代码demo2中，service1 先正常执行，然后关闭五秒后，让hystrix因为服务请求失败进入到打开状态；因为配置了5秒的超时窗口时间，继而在五秒窗口时间后进入到半开状态，此时service1保持关闭，hystrix将会重新打开；最后，等再过五秒窗口时间，hystrix进入到半开状态，此时service1打开，使所有请求正常，hystrix检测所有请求正常，断路器进入关闭状态；

 

// Service1代码
package main

import (
   "github.com/gin-gonic/gin"
)

func main() {
   r := gin.Default()
   r.GET("/ping", func(c *gin.Context) {
      c.JSON(200, gin.H{
         "message": "this is service1",
      })
   })
   r.Run("127.0.0.1:11012")
}
// Service2代码
package main

import (
   "github.com/gin-gonic/gin"
)

func main() {
   r := gin.Default()
   r.GET("/ping", func(c *gin.Context) {
      c.JSON(200, gin.H{
         "message": "this is service2",
      })
   })
   r.Run("127.0.0.1:11013") 
}

// hystrix使用示例代码
package main

import (
   "fmt"
   "io/ioutil"
   "net/http"
   "sync"
   "time"

   "github.com/afex/hystrix-go/hystrix"
)

const (
   service1Command = "service1_command"
   service2Command = "service2_command"
   service1Url     = "http://127.0.0.1:11012/ping"
   service2Url     = "http://127.0.0.1:11013/ping"
)

func main() {
   //demo1()
   demo2()
}

// 并发数超过配置最大请求数，hystrix直接打开进入失败逻辑
func demo1() {

   //hystrix 基础配置
   hystrix.ConfigureCommand(service1Command, hystrix.CommandConfig{
      Timeout:                1000, //命令执行超时时间
      MaxConcurrentRequests:  100,  //最大并发请求数量，命令最大执行的并发goroutine，同种hystrix命令超出该值后，请求直接进入失败回滚逻辑
      RequestVolumeThreshold: 1,    //最小请求阈值，只有窗口时间内请求数量超过该值，断路器才执行对应的判断逻辑
      SleepWindow:            5000, //超时窗口时间，断路器打开多久时长后进入半开状态，重新允许远程调用发生，试探下游服务是否正常。如果接下来请求都成功，断路器将关闭
      ErrorPercentThreshold:  25,   //错误比例阈值，当滑动窗口时间内的错误请求频率超过该值时，断路器将打开
   })

   hystrix.ConfigureCommand(service2Command, hystrix.CommandConfig{
      Timeout:                1000,
      MaxConcurrentRequests:  5,
      RequestVolumeThreshold: 1,
      SleepWindow:            5000,
      ErrorPercentThreshold:  25,
   })
   wg1 := sync.WaitGroup{}
   wg1.Add(50)
   wg2 := sync.WaitGroup{}
   wg2.Add(50)
   //开50个goroutine去跑
   for i := 0; i < 50; i++ {
      go RequestService1(&wg1)
      go RequestService2(&wg2)
   }
   wg1.Wait()
   wg2.Wait()
   fmt.Println("main process done")
}

// service1 正常执行五秒后关闭，让hystrix进入到打开状态
//继而在五秒窗口时间进入到半开状态，此时service1保持关闭，hystrix重新打开。
//再过五秒窗口时间，hystrix进入到半开状态，此时service1打开，使所有请求正常，hystrix检测所有请求正常，进入关闭状态
func demo2() {
   //hystrix 基础配置
   hystrix.ConfigureCommand(service1Command, hystrix.CommandConfig{
      Timeout:                1000, //命令执行超时时间
      MaxConcurrentRequests:  100,  //最大并发请求数量，命令最大执行的并发goroutine，同种hystrix命令超出该值后，请求直接进入失败回滚逻辑
      RequestVolumeThreshold: 1,    //最小请求阈值，只有窗口时间内请求数量超过该值，断路器才执行对应的判断逻辑
      SleepWindow:            5000, //超时窗口时间，断路器打开多久时长后进入半开状态，重新允许远程调用发生，试探下游服务是否正常。如果接下来请求都成功，断路器将关闭
      ErrorPercentThreshold:  10,   //错误比例阈值，当滑动窗口时间内的错误请求频率超过该值时，断路器将打开
   })
   wg1 := sync.WaitGroup{}
   wg1.Add(5000)
   start := time.Now() // 获取当前时间
   for i := 0; i < 5000; i++ {
      time.Sleep(time.Second)
      RequestService1(&wg1)
   }
   wg1.Wait()
   elapsed := time.Since(start)
   fmt.Println("该函数执行完成耗时：", elapsed)
   fmt.Println("main process done")
}

func RequestService1(wg *sync.WaitGroup) {
   // 请求service1
   defer wg.Done()
   err := hystrix.Do(service1Command, func() error {
      client := http.Client{}
      resp, err := client.Get(service1Url)
      if err != nil {
         return err
      }
      defer resp.Body.Close()
      if resp.StatusCode != 200 {
         return fmt.Errorf("request err status code is %v \n", resp.StatusCode)
      }
      connect, err := ioutil.ReadAll(resp.Body)
      if err != nil {
         return fmt.Errorf("connect err  %v \n", err)
      }
      fmt.Printf("service1 resp : %s \n", string(connect))
      return nil
   }, func(err error) error {
      // 失败回滚方法
      fmt.Printf("service1_command exec err : %v \n", err)
      return nil
   })
   if err != nil {
      fmt.Printf("hystrix do service1_command fail : %v \n", err)
   }
}

func RequestService2(wg *sync.WaitGroup) {
   // 请求service2
   defer wg.Done()
   err := hystrix.Do(service2Command, func() error {
      client := http.Client{}
      resp, err := client.Get(service2Url)
      if err != nil {
         return err
      }
      defer resp.Body.Close()
      if resp.StatusCode != 200 {
         return fmt.Errorf("request err status code is %v \n", resp.StatusCode)
      }
      connect, err := ioutil.ReadAll(resp.Body)
      if err != nil {
         return fmt.Errorf("connect err  %v \n", err)
      }
      fmt.Printf("service2 resp : %s \n", string(connect))
      return nil
   }, func(err error) error {
      // 失败回滚方法
      fmt.Printf("service2_command exec err : %v \n", err)
      return nil
   })
   if err != nil {
      fmt.Printf("hystrix do service2_command fail : %v \n", err)
   }
}

 

　　demo1执行响应图，请求sevice2因为并发量超过hystrix配置断路器打开，请求service1正常

 

 

 　　demo2执行响应图

 

 

 

hystrix集成到项目（网关）

　　断路器一般会作用在BFF层或者一些网关服务，在针对某些下游服务的请求并发量过大时做熔断处理，下面代码，示例如何将hystrix集成到具体的项目。

package main

import (
   "errors"
   "fmt"
   "log"
   "net/http"
   "net/http/httputil"
   "strings"
   "sync"

   "github.com/afex/hystrix-go/hystrix"
)

// HystrixHandler  Hystrix的实际应用
type HystrixHandler struct {

   // 记录hystrix是否已配置
   hystrixs      map[string]bool
   hystrixsMutex *sync.Mutex
   // 服务的名称或者域名
   serviceName string
   // 服务的端口
   serviceHost int
   logger      *log.Logger
}

func NewHystrixHandler(serviceName string, serviceHost int, logger *log.Logger) *HystrixHandler {

   return &HystrixHandler{
      logger:        logger,
      hystrixs:      make(map[string]bool),
      hystrixsMutex: &sync.Mutex{},
      serviceName:   serviceName,
      serviceHost:   serviceHost,
   }

}

func (hystrixHandler *HystrixHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {

   // 假设服务请求路径约定为 http://localhost:10098/oauth/token?grant_type=password
   reqPath := req.URL.Path
   if reqPath == "" {
      return
   }
   //按照分隔符'/'对路径进行分解，获取服务名称serviceName
   pathArray := strings.Split(reqPath, "/")
   serviceName := pathArray[1]

   if serviceName == "" {
      // 路径不存在
      rw.WriteHeader(404)
      return
   }

   if _, ok := hystrixHandler.hystrixs[serviceName]; !ok {
      hystrixHandler.hystrixsMutex.Lock()
      if _, ok := hystrixHandler.hystrixs[serviceName]; !ok {
         //把serviceName作为 hystrix 命令命名
         hystrix.ConfigureCommand(serviceName, hystrix.CommandConfig{
            // 进行 hystrix 命令自定义
         })
         hystrixHandler.hystrixs[serviceName] = true
      }
      hystrixHandler.hystrixsMutex.Unlock()
   }

   err := hystrix.Do(serviceName, func() error {
      //创建Director
      director := func(req *http.Request) {

         //重新组织请求路径，去掉服务名称部分
         destPath := strings.Join(pathArray[2:], "/")

         hystrixHandler.logger.Println("service name ", hystrixHandler.serviceName)

         //设置代理服务地址信息
         req.URL.Scheme = "http"
         req.URL.Host = fmt.Sprintf("%s:%d", hystrixHandler.serviceName, hystrixHandler.serviceHost)
         req.URL.Path = "/" + destPath
      }
      var proxyError error
      // 返回代理异常，用于记录 hystrix.Do 执行失败
      errorHandler := func(ew http.ResponseWriter, er *http.Request, err error) {
         proxyError = err
      }
      proxy := &httputil.ReverseProxy{
         Director:     director,
         ErrorHandler: errorHandler,
      }

      proxy.ServeHTTP(rw, req)
      // 将执行异常反馈 hystrix
      return proxyError

   }, func(e error) error {
      hystrixHandler.logger.Println("proxy error ", e)
      return errors.New("fallback excute")
   })

   // hystrix.Do 返回执行异常
   if err != nil {
      rw.WriteHeader(500)
      rw.Write([]byte(err.Error()))
   }

}

启用 Metrics dashboard

• hystrix可以添加Metrics控制器，上报hystrix命令的状态信息。步骤如下：

1. 下载docker镜像hystrix-dashboard：docker pull mlabouardy/hystrix-dashboard
2. 启动hystrix-dashboard：docker run -d -p 8080:9002 --name hystrix-dashboard mlabouardy/hystrix-dashboard:latest
3. 填写断路器数据上报指标的地址（局域网ip和端口以及路由）

?

1 2 3 4 5 6 7 8 9

func main() {    //...    //添加Metrics控制器 上报hystrix命令的状态信息    hystrixStreamHandler := hystrix.NewStreamHandler()    hystrixStreamHandler.Start()    go http.ListenAndServe(net.JoinHostPort("", "81"), hystrixStreamHandler)    demo2()    //.... }

• 命令执行情况截图