熔断器hystrix、sentinel

hstrix:

// 超时代码
// import github.com/afex/hystrix-go/hystrix
// 1.配置config
configA := hystrix.CommandConfig{
		Timeout:                1000,
		MaxConcurrentRequests:  50,   // 最大并发数
		RequestVolumeThreshold: 3,    // 触发最小请求数
		SleepWindow:            1000, // 熔断状态保持时间
		ErrorPercentThreshold:  50,   // 错误比例
	}
// 2.配置command
hystrix.ConfigureCommand("getProds", configA)
// 3.执行Do方法
var prodRes *models.ProdListResponse
err := hystrix.Do("getProds", func() error {
	prodRes, err = prodService.GetProdList(context.Background(), &prodReq)
	return err
}, func(e error) error {
	// 降级 显示默认产品
	prodRes, err = defaultProds()
	return err
})

sentinel

// import sentinel "github.com/alibaba/sentinel-golang/api"

// 初始化sentinel
sentinel.InitWithConfigFile("../config/sentinel.yaml")


// 配置熔断规则
_, err = circuitbreaker.LoadRules([]*circuitbreaker.Rule{
		// Statistic time span=5s, recoveryTimeout=3s, maxErrorCount=50
		{
			Resource:                     "abc",
			Strategy:                     circuitbreaker.ErrorCount,
			RetryTimeoutMs:               3000,
			MinRequestAmount:             10,
			StatIntervalMs:               5000,
			StatSlidingWindowBucketCount: 10,
			Threshold:                    50,
		},
	})
	if err != nil {
		log.Fatal(err)
	}

// 埋点，使用规则
e, b := sentinel.Entry("abc")
if b != nil {
	// 熔断
	return b
} else {
	defer e.Exit() // 这个一定要写
	// TODO 正常业务代码
}

// 初始化sentinel
func initSentinel() error {
	return sentinel.InitWithConfigFile("../config/sentinel.yaml")
}

// 限流规则
func loadRuleSentinel() error {
	_, err := flow.LoadRules([]*flow.Rule{
		{
			Resource:               "res1",
			TokenCalculateStrategy: flow.Direct,
			ControlBehavior:        flow.Reject,
			Threshold:              2,
			StatIntervalInMs:       1000 * 10,
		},
		{
			Resource:               "res2",
			TokenCalculateStrategy: flow.Direct,
			ControlBehavior:        flow.Throttling,
			Threshold:              2,

			StatIntervalInMs: 1000 * 10,
		},
	})
	return err
}

// 熔断规则
func loadBreaker() error {
	_, err := circuitbreaker.LoadRules([]*circuitbreaker.Rule{
		{
			Resource:         "breakRes1",                     // 埋点资源名称
			Strategy:         circuitbreaker.SlowRequestRatio, // 熔断策略,慢调用比例、错误比例、错误数量
			RetryTimeoutMs:   3000,                            // 熔断触发后持续的时间
			MinRequestAmount: 10,                              // 统计周期内的静默数量
			StatIntervalMs:   5000,                            // 统计的时间窗口长度
			MaxAllowedRtMs:   500,                             // 如果response time大于MaxAllowedRtMs，那么当前请求就属于慢调用。
			Threshold:        0.5,                             //阈值
		},
	})
	return err
}

// 并发隔离规则
func loadConcurrency() error {
	_, err := isolation.LoadRules([]*isolation.Rule{
		{
			Resource:   "conRes1",
			MetricType: isolation.Concurrency, // 并发数作为统计指标
			Threshold:  12,                    // 资源当前的并发数高于阈值 (Threshold)，那么资源将不可访问。
		},
	})

	return err
}