golang框架的限流和熔断机制的最佳实践是什么？

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

    "github.com/juju/ratelimit"
)

func main() {
    // 创建一个限流器，每秒允许 10 个请求。
    limiter := ratelimit.NewBucket(time.Second, 10)

    // 使用限流中间件确保每个请求都经过限流。
    limitedHandler := ratelimit.NewMiddleware(limiter, func(w http.ResponseWriter, r *http.Request) error {
        _, err := limiter.Take(context.Background(), 1)
        return err
    })

    // 创建一个 HTTP 处理程序，并应用限流中间件。
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
    })
    limitedHandler.Handler = handler

    // 启动 HTTP 服务器，端口 8080。
    http.ListenAndServe(":8080", limitedHandler.Handler)
}

import (
    "errors"
    "sync"

    "github.com/sony/gobreaker"
)

func main() {
    // 创建一个熔断器，失败次数为 5，失败率为 50%。
    cb := gobreaker.NewCircuitBreaker(
        gobreaker.Settings{
            Name:        "my-circuit-breaker",
            MaxRequests: 5,
            Interval:    time.Second,
            Timeout:     time.Second,
            ReadyToTrip: func(counts gobreaker.Counts) bool {
                return counts.TotalFailures > 2
            },
        },
    )

    var mu sync.Mutex

    // 使用熔断器保护包含故障的函数。
    var counter int
    cb.Execute(func() (interface{}, error) {
        mu.Lock()
        defer mu.Unlock()

        counter++
        if counter%2 == 0 {
            return nil, errors.New("simulated failure")
        }
        return nil, nil
    })
}