https://sentinelguard.io/zh-cn/docs/golang/basic-api-usage.html

	Sentinel	Hystrix
隔离策略	信号量隔离	线程池隔离/信号量隔离
熔断降级策略	基于响应时间或失败比率	基于失败比率
实时指标实现	滑动窗口	滑动窗口（基于 RxJava）
规则配置	支持多种数据源	支持多种数据源
扩展性	多个扩展点	插件的形式
基于注解的支持	支持	支持
限流	基于 QPS，支持基于调用关系的限流	有限的支持
流量整形	支持慢启动、匀速器模式	不支持
系统负载保护	支持	不支持
控制台	开箱即用，可配置规则、查看秒级监控、机器发现等	不完善
常见框架的适配	Servlet、Spring Cloud、Dubbo、gRPC 等	Servlet、Spring Cloud Netflix

sentinel的qps限流

https://github.com/alibaba/sentinel-golang/blob/master/example/flow/qps/qps_limit_example.go

package main
import (
    "fmt"
    "log"
    "time"
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/base"
    "github.com/alibaba/sentinel-golang/core/flow"
)
func main() {
    //先初始化sentinel
    err := sentinel.InitDefault()
    if err != nil {
        log.Fatalf("初始化sentinel 异常: %v", err)
    }
    //配置限流规则
    _, err = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "some-test",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Reject, //直接拒绝
            Threshold:              1000,             //100ms只能就已经来了1W的并发， 1s就是10W的并发
            StatIntervalInMs:       100,
        },
        {
            Resource:               "some-test2",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Reject, //直接拒绝
            Threshold:              1000,
            StatIntervalInMs:       100,
        },
    })
    if err != nil {
        log.Fatalf("加载规则失败: %v", err)
    }
    for i := 0; i < 12; i++ {
        e, b := sentinel.Entry("some-test", sentinel.WithTrafficType(base.Inbound))
        if b != nil {
            fmt.Println("限流了")
        } else {
            fmt.Println("检查通过")
            e.Exit()
        }
    }
}

sentinel的预热和冷启动(WarmUp)

package main
import (
    "fmt"
    "log"
    "math/rand"
    "time"
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/base"
    "github.com/alibaba/sentinel-golang/core/flow"
)
func main() {
    //先初始化sentinel
    err := sentinel.InitDefault()
    if err != nil {
        log.Fatalf("初始化sentinel 异常: %v", err)
    }
    var globalTotal int
    var passTotal int
    var blockTotal int
    ch := make(chan struct{})
    //配置限流规则
    _, err = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "some-test",
            TokenCalculateStrategy: flow.WarmUp, //冷启动策略
            ControlBehavior:        flow.Reject, //直接拒绝
            Threshold:              1000,
            WarmUpPeriodSec:        30,
        },
    })
    if err != nil {
        log.Fatalf("加载规则失败: %v", err)
    }
    //我会在每一秒统计一次，这一秒只能 你通过了多少，总共有多少， block了多少, 每一秒会产生很多的block
    for i := 0; i < 100; i++ {
        go func() {
            for {
                globalTotal++
                e, b := sentinel.Entry("some-test", sentinel.WithTrafficType(base.Inbound))
                if b != nil {
                    //fmt.Println("限流了")
                    blockTotal++
                    time.Sleep(time.Duration(rand.Uint64()%10) * time.Millisecond)
                } else {
                    passTotal++
                    time.Sleep(time.Duration(rand.Uint64()%10) * time.Millisecond)
                    e.Exit()
                }
            }
        }()
    }
    go func() {
        var oldTotal int //过去1s总共有多少个
        var oldPass int  //过去1s总共pass多少个
        var oldBlock int //过去1s总共block多少个
        for {
            oneSecondTotal := globalTotal - oldTotal
            oldTotal = globalTotal
            oneSecondPass := passTotal - oldPass
            oldPass = passTotal
            oneSecondBlock := blockTotal - oldBlock
            oldBlock = blockTotal
            time.Sleep(time.Second)
            fmt.Printf("total:%d, pass:%d, block:%d\n", oneSecondTotal, oneSecondPass, oneSecondBlock)
        }
    }()
    <-ch
}

sentinel的Throttling配置策略

package main
import (
    "fmt"
    "log"
    "time"
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/base"
    "github.com/alibaba/sentinel-golang/core/flow"
)
func main() {
    //先初始化sentinel
    err := sentinel.InitDefault()
    if err != nil {
        log.Fatalf("初始化sentinel 异常: %v", err)
    }
    //配置限流规则
    _, err = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "some-test",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Throttling, //匀速通过
            Threshold:              10,          
            StatIntervalInMs:       1000,
        },
        {
            Resource:               "some-test2",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Reject, //直接拒绝
            Threshold:              10,
            StatIntervalInMs:       1000,
        },
    })
    if err != nil {
        log.Fatalf("加载规则失败: %v", err)
    }
    for i := 0; i < 12; i++ {
        e, b := sentinel.Entry("some-test", sentinel.WithTrafficType(base.Inbound))
        if b != nil {
            fmt.Println("限流了")
        } else {
            fmt.Println("检查通过")
            e.Exit()
        }
        //匀速通过
        time.Sleep(11 * time.Millisecond)
    }
}

sentinel的熔断接口-基于错误数—基于错误率和慢请求

基于错误数

https://github.com/alibaba/sentinel-golang/tree/master/example/circuitbreaker/error_count

package main
import (
    "errors"
    "fmt"
    "log"
    "math/rand"
    "time"
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/circuitbreaker"
    "github.com/alibaba/sentinel-golang/core/config"
    "github.com/alibaba/sentinel-golang/logging"
    "github.com/alibaba/sentinel-golang/util"
)
type stateChangeTestListener struct {
}
func (s *stateChangeTestListener) OnTransformToClosed(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Closed, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}
func (s *stateChangeTestListener) OnTransformToOpen(prev circuitbreaker.State, rule circuitbreaker.Rule, snapshot interface{}) {
    fmt.Printf("rule.steategy: %+v, From %s to Open, snapshot: %d, time: %d\n", rule.Strategy, prev.String(), snapshot, util.CurrentTimeMillis())
}
func (s *stateChangeTestListener) OnTransformToHalfOpen(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Half-Open, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}
func main() {
    total := 0
    totalPass := 0
    totalBlock := 0
    totalErr := 0
    conf := config.NewDefaultConfig()
    // for testing, logging output to console
    conf.Sentinel.Log.Logger = logging.NewConsoleLogger()
    err := sentinel.InitWithConfig(conf)
    if err != nil {
        log.Fatal(err)
    }
    ch := make(chan struct{})
    // Register a state change listener so that we could observer the state change of the internal circuit breaker.
    circuitbreaker.RegisterStateChangeListeners(&stateChangeTestListener{})
    _, err = circuitbreaker.LoadRules([]*circuitbreaker.Rule{
        // Statistic time span=10s, recoveryTimeout=3s, maxErrorCount=50
        {
            Resource:         "abc",
            Strategy:         circuitbreaker.ErrorCount,
            RetryTimeoutMs:   3000, //3s只有尝试回复
            MinRequestAmount: 10,   //静默数
            StatIntervalMs:   5000,
            Threshold:        50,
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    logging.Info("[CircuitBreaker ErrorCount] Sentinel Go circuit breaking demo is running. You may see the pass/block metric in the metric log.")
    go func() {
        for {
            total++
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g1 blocked
                totalBlock++
                fmt.Println("协程熔断了")
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                totalPass++
                if rand.Uint64()%20 > 9 {
                    totalErr++
                    // Record current invocation as error.
                    sentinel.TraceError(e, errors.New("biz error"))
                }
                // g1 passed
                time.Sleep(time.Duration(rand.Uint64()%20+10) * time.Millisecond)
                e.Exit()
            }
        }
    }()
    go func() {
        for {
            total++
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g2 blocked
                totalBlock++
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                // g2 passed
                totalPass++
                time.Sleep(time.Duration(rand.Uint64()%80) * time.Millisecond)
                e.Exit()
            }
        }
    }()
    go func() {
        for {
            time.Sleep(time.Second)
            fmt.Println(totalErr)
        }
    }()
    <-ch
}

错误率

https://github.com/alibaba/sentinel-golang/tree/master/example/circuitbreaker/error_ratio

package main
import (
    "errors"
    "fmt"
    "log"
    "math/rand"
    "time"
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/circuitbreaker"
    "github.com/alibaba/sentinel-golang/core/config"
    "github.com/alibaba/sentinel-golang/logging"
    "github.com/alibaba/sentinel-golang/util"
)
type stateChangeTestListener struct {
}
func (s *stateChangeTestListener) OnTransformToClosed(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Closed, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}
func (s *stateChangeTestListener) OnTransformToOpen(prev circuitbreaker.State, rule circuitbreaker.Rule, snapshot interface{}) {
    fmt.Printf("rule.steategy: %+v, From %s to Open, snapshot: %.2f, time: %d\n", rule.Strategy, prev.String(), snapshot, util.CurrentTimeMillis())
}
func (s *stateChangeTestListener) OnTransformToHalfOpen(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Half-Open, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}
func main() {
    total := 0
    totalPass := 0
    totalBlock := 0
    totalErr := 0
    conf := config.NewDefaultConfig()
    // for testing, logging output to console
    conf.Sentinel.Log.Logger = logging.NewConsoleLogger()
    err := sentinel.InitWithConfig(conf)
    if err != nil {
        log.Fatal(err)
    }
    ch := make(chan struct{})
    // Register a state change listener so that we could observer the state change of the internal circuit breaker.
    circuitbreaker.RegisterStateChangeListeners(&stateChangeTestListener{})
    _, err = circuitbreaker.LoadRules([]*circuitbreaker.Rule{
        // Statistic time span=10s, recoveryTimeout=3s, maxErrorCount=50
        {
            Resource:         "abc",
            Strategy:         circuitbreaker.ErrorRatio,
            RetryTimeoutMs:   3000, //3s只有尝试回复
            MinRequestAmount: 10,   //静默数
            StatIntervalMs:   5000,
            Threshold:        0.4,
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    logging.Info("[CircuitBreaker ErrorCount] Sentinel Go circuit breaking demo is running. You may see the pass/block metric in the metric log.")
    go func() {
        for {
            total++
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g1 blocked
                totalBlock++
                fmt.Println("协程熔断了")
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                totalPass++
                if rand.Uint64()%20 > 9 {
                    totalErr++
                    // Record current invocation as error.
                    sentinel.TraceError(e, errors.New("biz error"))
                }
                // g1 passed
                time.Sleep(time.Duration(rand.Uint64()%40+10) * time.Millisecond)
                e.Exit()
            }
        }
    }()
    go func() {
        for {
            total++
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g2 blocked
                totalBlock++
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                // g2 passed
                totalPass++
                time.Sleep(time.Duration(rand.Uint64()%80) * time.Millisecond)
                e.Exit()
            }
        }
    }()
    go func() {
        for {
            time.Sleep(time.Second)
            fmt.Println(float64(totalErr) / float64(total))
        }
    }()
    <-ch
}

慢请求

package main
import (
    "errors"
    "fmt"
    "log"
    "math/rand"
    "time"
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/circuitbreaker"
    "github.com/alibaba/sentinel-golang/core/config"
    "github.com/alibaba/sentinel-golang/logging"
    "github.com/alibaba/sentinel-golang/util"
)
type stateChangeTestListener struct {
}
func (s *stateChangeTestListener) OnTransformToClosed(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Closed, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}
func (s *stateChangeTestListener) OnTransformToOpen(prev circuitbreaker.State, rule circuitbreaker.Rule, snapshot interface{}) {
    fmt.Printf("rule.steategy: %+v, From %s to Open, snapshot: %.2f, time: %d\n", rule.Strategy, prev.String(), snapshot, util.CurrentTimeMillis())
}
func (s *stateChangeTestListener) OnTransformToHalfOpen(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Half-Open, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}
func main() {
    conf := config.NewDefaultConfig()
    // for testing, logging output to console
    conf.Sentinel.Log.Logger = logging.NewConsoleLogger()
    err := sentinel.InitWithConfig(conf)
    if err != nil {
        log.Fatal(err)
    }
    ch := make(chan struct{})
    // Register a state change listener so that we could observer the state change of the internal circuit breaker.
    circuitbreaker.RegisterStateChangeListeners(&stateChangeTestListener{})
    _, err = circuitbreaker.LoadRules([]*circuitbreaker.Rule{
        // Statistic time span=10s, recoveryTimeout=3s, slowRtUpperBound=50ms, maxSlowRequestRatio=50%
        {
            Resource:         "abc",
            Strategy:         circuitbreaker.SlowRequestRatio,
            RetryTimeoutMs:   3000,
            MinRequestAmount: 10,
            StatIntervalMs:   5000,
            MaxAllowedRtMs:   50,
            Threshold:        0.5,
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    logging.Info("[CircuitBreaker SlowRtRatio] Sentinel Go circuit breaking demo is running. You may see the pass/block metric in the metric log.")
    go func() {
        for {
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g1 blocked
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                if rand.Uint64()%20 > 9 {
                    // Record current invocation as error.
                    sentinel.TraceError(e, errors.New("biz error"))
                }
                // g1 passed
                time.Sleep(time.Duration(rand.Uint64()%80+10) * time.Millisecond)
                e.Exit()
            }
        }
    }()
    go func() {
        for {
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g2 blocked
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                // g2 passed
                time.Sleep(time.Duration(rand.Uint64()%80) * time.Millisecond)
                e.Exit()
            }
        }
    }()
    <-ch
}

gin集成sentinel实现限流

商品列表页

package initialize
import (
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/flow"
    "go.uber.org/zap"
)
func InitSentinel(){
    err := sentinel.InitDefault()
    if err != nil {
        zap.S().Fatalf("初始化sentinel 异常: %v", err)
    }
    //配置限流规则
    //这种配置应该从nacos中读取
    _, err = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "goods-list",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Reject, //匀速通过
            Threshold:              20,             //100ms只能就已经来了1W的并发， 1s就是10W的并发
            StatIntervalInMs:       6000,
        },
    })
    if err != nil {
        zap.S().Fatalf("加载规则失败: %v", err)
    }
}

6.熔断、限流技术选型

sentinel的qps限流

sentinel的预热和冷启动(WarmUp)

sentinel的Throttling配置策略

sentinel的熔断接口-基于错误数—基于错误率和慢请求

基于错误数

错误率

慢请求

gin集成sentinel实现限流