Golang微服务限流与熔断机制实践

golang.org/x/time/rate

rate.Limiter

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "time"

    "golang.org/x/time/rate"
)

// 创建一个每秒最多允许1个事件，桶容量为5的限流器
var limiter = rate.NewLimiter(rate.Limit(1), 5) 

func handler(w http.ResponseWriter, r *http.Request) {
    // 尝试获取一个令牌，如果获取不到，等待直到超时或获取到
    // 这里的WithContext可以让你在Context取消时停止等待
    if err := limiter.Wait(r.Context()); err != nil {
        http.Error(w, "Too many requests, please try again later.", http.StatusTooManyRequests)
        log.Printf("Request rejected due to rate limiting: %v", err)
        return
    }

    // 模拟一些业务处理
    time.Sleep(100 * time.Millisecond) 
    fmt.Fprintln(w, "Hello, you got through!")
}

func main() {
    http.HandleFunc("/", handler)
    log.Println("Server starting on port 8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

github.com/sony/gobreaker

package main

import (
    "errors"
    "fmt"
    "log"
    "net/http"
    "time"

    "github.com/sony/gobreaker"
)

// 模拟一个可能会失败的外部服务调用
func callExternalService() (string, error) {
    // 模拟服务不稳定，大约50%的几率失败
    if time.Now().UnixNano()%2 == 0 {
        return "Data from external service", nil
    }
    return "", errors.New("external service is temporarily unavailable")
}

// 创建一个熔断器实例
var cb *gobreaker.CircuitBreaker

func init() {
    // 配置熔断器
    // MaxRequests: 半开状态下允许通过的最大请求数
    // Interval: 统计失败率的周期
    // Timeout: 熔断器从打开状态切换到半开状态的等待时间
    // ReadyToTrip: 自定义熔断条件，这里是连续失败5次或失败率超过60%
    settings := gobreaker.Settings{
        MaxRequests: 1, // 半开状态下只允许一个请求尝试
        Interval:    5 * time.Second, // 统计窗口
        Timeout:     10 * time.Second, // 熔断后10秒进入半开状态
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            // 只有当总请求数超过5个时才开始判断
            if counts.Requests < 5 {
                return false
            }
            failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
            return failureRatio >= 0.6 // 失败率超过60%就熔断
        },
        OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
            log.Printf("Circuit Breaker '%s' changed from %s to %s", name, from, to)
        },
    }
    cb = gobreaker.NewCircuitBreaker(settings)
}

func serviceHandler(w http.ResponseWriter, r *http.Request) {
    // 使用熔断器执行服务调用
    result, err := cb.Execute(func() (interface{}, error) {
        return callExternalService()
    })

    if err != nil {
        if errors.Is(err, gobreaker.ErrOpenState) {
            http.Error(w, "Service is currently unavailable (circuit breaker is open).", http.StatusServiceUnavailable)
            log.Printf("Request rejected by circuit breaker: %v", err)
        } else {
            http.Error(w, fmt.Sprintf("Service error: %v", err), http.StatusInternalServerError)
            log.Printf("Service call failed: %v", err)
        }
        return
    }
    fmt.Fprintln(w, result)
}

func main() {
    http.HandleFunc("/service", serviceHandler)
    log.Println("Service server starting on port 8081...")
    log.Fatal(http.ListenAndServe(":8081", nil))
}

golang.org/x/time/rate

rate.NewLimiter(rate.Limit(r), b)

r

b

rate.NewLimiter(rate.Limit(200), 300)

github.com/sony/gobreaker

gobreaker

OnStateChange