使用Golang实现微服务限流，核心是通过令牌桶、漏桶等算法控制请求频率。单机场景可使用golang.org/x/time/rate包，基于令牌桶实现高效限流；分布式环境推荐结合Redis与Lua脚本，利用原子操作实现IP级滑动窗口限流；复杂流量治理可集成sentinel-go，支持限流、熔断、降级；在Gin等框架中可通过中间件统一接入，确保业务解耦。关键细节包括过期键清理、时钟漂移处理，方案选择应根据部署规模和系统复杂度决定。

在Golang中实现微服务限流，核心是控制单位时间内接口的访问频率，防止系统因突发流量而崩溃。常见的做法包括令牌桶、漏桶算法，结合中间件或独立组件来实现。以下是几种实用且高效的限流方案。

使用golang.org/x/time/rate实现限流

rate 是 Go 官方提供的限流工具包，基于令牌桶算法，简单高效，适合单机服务限流。

示例：为HTTP接口添加每秒最多10次请求的限制

package main
import (
"net/http"
"time"
"golang.org/x/time/rate"
)
var limiter = rate.NewLimiter(10, 5) // 每秒10个令牌，最大允许5个突发
func limit(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !limiter.Allow() {
http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
return
}
next.ServeHTTP(w, r)
})
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello, limited world!"))
})
http.ListenAndServe(":8080", limit(mux))
}
基于Redis的分布式限流
在微服务架构中，多个实例共享限流状态，需使用Redis等集中存储。常用方法是利用Redis的原子操作实现滑动窗口或固定窗口计数器。
示例：使用Redis+Lua脚本实现IP级限流
-- rate_limit.lua
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local current = redis.call("INCR", key)
if current == 1 then
    redis.call("EXPIRE", key, window)
end
return current <= limit
Go中调用：
import (
    "github.com/go-redis/redis/v8"
    "context"
)
var redisClient = redis.NewClient(&redis.Options{Addr: "localhost:6379"})
var luaScript = redis.NewScript(luaSrc) // luaSrc为上面的脚本内容
func isAllowed(ip string) bool {
ctx := context.Background()
result, err := luaScript.Run(ctx, redisClient, []string{"rate:" + ip}, 10, 60).Result()
if err != nil {
return false
}
return result.(int64) == 1
}
集成第三方库如sentinel-go
sentinel-go 是阿里巴巴开源的流量治理组件，支持限流、熔断、降级，适合复杂的微服务场景。
安装：
go get github.com/alibaba/sentinel-golang/core/flow
配置限流规则：
import (
    "github.com/alibaba/sentinel-golang/core/flow"
    "github.com/alibaba/sentinel-golang/core/base"
)
func init() {
_, err := flow.LoadRules([]*flow.Rule{
{
Resource:               "api_login",
TokenCalculateStrategy: flow.Direct,
ControlBehavior:        flow.Reject,
Threshold:              10, // 每秒最多10次
StatIntervalInMs:       1000,
},
})
if err != nil {
panic(err)
}
}
func loginHandler(w http.ResponseWriter, r *http.Request) {
entry, blockErr := sentinel.Entry("api_login")
if blockErr != nil {
http.Error(w, "Blocked by Sentinel", http.StatusTooManyRequests)
return
}
defer entry.Exit()
// 实际业务逻辑
w.Write([]byte("Login success"))
}
在服务框架中统一接入
若使用Go微服务框架（如Go-kit、Gin），可将限流封装成中间件，在路由层统一处理。
Gin 示例：
func RateLimit() gin.HandlerFunc {
    store := make(map[string]time.Time)
    return func(c *gin.Context) {
        ip := c.ClientIP()
        last, exists := store[ip]
        now := time.Now()
        if exists && now.Sub(last) < time.Second {
            c.JSON(429, gin.H{"error": "Too many requests"})
            c.Abort()
            return
        }
        store[ip] = now
        c.Next()
    }
}
r := gin.Default()
r.GET("/api", RateLimit(), handler)
注意：该方式仅适用于单机，生产环境建议结合Redis存储时间戳。
基本上就这些。根据部署规模选择合适方案：单机用 rate，分布式用Redis脚本，复杂场景上 sentinel-go。关键是把限流逻辑与业务解耦，通过中间件统一管理。不复杂但容易忽略细节，比如清空过期键、应对时钟漂移等。