AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

利用中间件限流

2024-10-11 34
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 利用中间件限流

限流（Rate Limiting）是一种控制系统中请求速率的技术，用于防止过多的请求涌入系统，从而保护服务器资源，防止滥用或恶意攻击。实现限流中间件可以确保你的应用在高并发情况下依然稳定运行。

在 Go 语言中，结合 Gin 框架实现限流中间件是一种常见的做法。下面，我将详细介绍如何在 Gin 框架中手动实现限流中间件，采用令牌桶（Token Bucket）算法作为限流策略。

  1. 令牌桶算法概述
    令牌桶算法是一种常用的限流算法，其基本原理如下：

令牌桶：桶中有一定数量的令牌，代表可以处理的请求数。
生成令牌：按照固定的速率向桶中添加令牌，直到达到桶的容量。
处理请求：每当一个请求到达时，从桶中取出一个令牌，如果成功，允许请求继续处理；否则，拒绝请求。
这种算法允许突发请求，但在长时间内保持请求速率的稳定。

  1. 实现步骤
    2.1. 定义限流中间件
    我们将创建一个 Gin 中间件，该中间件使用令牌桶算法来限制每个客户端（基于 IP 地址）的请求速率。

2.2. 实现令牌桶
我们需要一个结构来表示每个客户端的令牌桶，包括：

速率：每秒生成的令牌数。
容量：令牌桶的最大容量。
剩余令牌：当前桶中剩余的令牌数。
最后更新时间：上一次令牌生成的时间。
2.3. 实现限流逻辑
在每个请求到达时：

根据客户端的标识（如 IP 地址）获取对应的令牌桶。
根据时间间隔生成新的令牌，确保令牌数量不超过桶的容量。
尝试获取一个令牌：
成功：允许请求继续处理。
失败：返回 429 状态码（Too Many Requests）。

  1. 代码实现
    下面是一个完整的示例代码，展示如何在 Gin 框架中实现基于 IP 地址的限流中间件。

package main

import (
"net/http"
"sync"
"time"

"github.com/gin-gonic/gin"

)

// TokenBucket 定义令牌桶结构
type TokenBucket struct {
rate float64 // 令牌生成速率（每秒生成的令牌数）
capacity float64 // 令牌桶容量
tokens float64 // 当前令牌数
lastRefill time.Time // 上次填充令牌的时间
mutex sync.Mutex // 保护令牌桶的互斥锁
}

// NewTokenBucket 创建一个新的令牌桶
func NewTokenBucket(rate float64, capacity float64) *TokenBucket {
return &TokenBucket{
rate: rate,
capacity: capacity,
tokens: capacity,
lastRefill: time.Now(),
}
}

// Allow 尝试获取一个令牌，返回是否允许
func (tb *TokenBucket) Allow() bool {
tb.mutex.Lock()
defer tb.mutex.Unlock()

now := time.Now()
elapsed := now.Sub(tb.lastRefill).Seconds()
tb.lastRefill = now

// 计算新增的令牌数
tb.tokens += elapsed * tb.rate
if tb.tokens > tb.capacity {
    tb.tokens = tb.capacity
}

if tb.tokens >= 1 {
    tb.tokens -= 1
    return true
}

return false

}

// RateLimiter 定义限流器结构
type RateLimiter struct {
clients map[string]*TokenBucket
mutex sync.Mutex
rate float64
capacity float64
}

// NewRateLimiter 创建一个新的限流器
func NewRateLimiter(rate float64, capacity float64) RateLimiter {
return &RateLimiter{
clients: make(map[string]TokenBucket),
rate: rate,
capacity: capacity,
}
}

// GetTokenBucket 获取或创建客户端的令牌桶
func (rl RateLimiter) GetTokenBucket(clientID string) TokenBucket {
rl.mutex.Lock()
defer rl.mutex.Unlock()

tb, exists := rl.clients[clientID]
if !exists {
    tb = NewTokenBucket(rl.rate, rl.capacity)
    rl.clients[clientID] = tb
}

return tb

}

// Cleanup 定期清理不活跃的客户端（可选）
func (rl *RateLimiter) Cleanup(timeout time.Duration) {
for {
time.Sleep(timeout)
rl.mutex.Lock()
for clientID, tb := range rl.clients {
tb.mutex.Lock()
if time.Since(tb.lastRefill) > timeout {
delete(rl.clients, clientID)
}
tb.mutex.Unlock()
}
rl.mutex.Unlock()
}
}

// RateLimitMiddleware 返回一个 Gin 中间件，用于限流
func RateLimitMiddleware(rl RateLimiter) gin.HandlerFunc {
return func(c gin.Context) {
clientIP := c.ClientIP()
tb := rl.GetTokenBucket(clientIP)

    if tb.Allow() {
        c.Next()
    } else {
        c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
            "error": "Too Many Requests",
        })
        return
    }
}

}

func main() {
router := gin.Default()

// 创建限流器，例：每秒5个请求，令牌桶容量为10
rateLimiter := NewRateLimiter(5, 10)

// 可选：启动清理协程，清理1分钟内不活跃的客户端
go rateLimiter.Cleanup(1 * time.Minute)

// 应用限流中间件
router.Use(RateLimitMiddleware(rateLimiter))

// 定义路由
router.GET("/", func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello, World!",
    })
})

router.GET("/user/:name", func(c *gin.Context) {
    name := c.Param("name")
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello, " + name + "!",
    })
})

// 启动服务器
router.Run(":8080")

}

  1. 代码详解
    4.1. 令牌桶结构
    type TokenBucket struct {
    rate float64
    capacity float64
    tokens float64
    lastRefill time.Time
    mutex sync.Mutex
    }
    rate：令牌生成速率，例如每秒生成5个令牌。
    capacity：令牌桶的最大容量，防止令牌数过多。
    tokens：当前令牌数。
    lastRefill：上次令牌生成的时间，用于计算新增的令牌数。
    mutex：互斥锁，确保并发安全。
    4.2. 令牌桶方法
    func (tb *TokenBucket) Allow() bool {
    tb.mutex.Lock()
    defer tb.mutex.Unlock()

    now := time.Now()
    elapsed := now.Sub(tb.lastRefill).Seconds()
    tb.lastRefill = now

    // 计算新增的令牌数
    tb.tokens += elapsed * tb.rate
    if tb.tokens > tb.capacity { 

     tb.tokens = tb.capacity

    }

    if tb.tokens >= 1 { 

     tb.tokens -= 1
 return true

    }

    return false
    }
    Allow()：尝试获取一个令牌。
    计算自上次填充以来经过的时间，生成相应数量的令牌。
    如果令牌数超过容量，则设为容量。
    如果有足够的令牌，扣除一个并允许请求。
    否则，拒绝请求。
    4.3. 限流器结构
    type RateLimiter struct {
    clients map[string]TokenBucket
    mutex sync.Mutex
    rate float64
    capacity float64
    }
    clients：存储每个客户端（如 IP 地址）的令牌桶。
    mutex：互斥锁，确保并发安全。
    rate 和 capacity：全局的令牌生成速率和容量。
    4.4. 限流器方法
    func (rl     RateLimiter) GetTokenBucket(clientID string) *TokenBucket {
    rl.mutex.Lock()
    defer rl.mutex.Unlock()

    tb, exists := rl.clients[clientID]
    if !exists { 

     tb = NewTokenBucket(rl.rate, rl.capacity)
 rl.clients[clientID] = tb

    }

    return tb
    }
    GetTokenBucket()：根据客户端标识（如 IP 地址）获取或创建令牌桶。
    func (rl *RateLimiter) Cleanup(timeout time.Duration) {
    for { 

     time.Sleep(timeout)
 rl.mutex.Lock()
 for clientID, tb := range rl.clients {
     tb.mutex.Lock()
     if time.Since(tb.lastRefill) > timeout {
         delete(rl.clients, clientID)
     }
     tb.mutex.Unlock()
 }
 rl.mutex.Unlock()

    }
    }
    Cleanup()：定期清理不活跃的客户端，防止内存泄漏。这个函数在一个独立的 goroutine 中运行。
    4.5. 限流中间件
    func RateLimitMiddleware(rl RateLimiter) gin.HandlerFunc {
    return func(c     gin.Context) { 

     clientIP := c.ClientIP()
 tb := rl.GetTokenBucket(clientIP)

 if tb.Allow() {
     c.Next()
 } else {
     c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
         "error": "Too Many Requests",
     })
     return
 }

    }
    }
    RateLimitMiddleware：Gin 中间件，获取客户端 IP，检查是否允许请求，允许则继续处理，不允许则返回 429 状态码。
    4.6. 主函数
    func main() {
    router := gin.Default()

    // 创建限流器，例：每秒5个请求，令牌桶容量为10
    rateLimiter := NewRateLimiter(5, 10)

    // 可选：启动清理协程，清理1分钟内不活跃的客户端
    go rateLimiter.Cleanup(1 * time.Minute)

    // 应用限流中间件
    router.Use(RateLimitMiddleware(rateLimiter))

    // 定义路由
    router.GET("/", func(c *gin.Context) { 

     c.JSON(http.StatusOK, gin.H{
     "message": "Hello, World!",
 })

    })

    router.GET("/user/:name", func(c *gin.Context) { 

     name := c.Param("name")
 c.JSON(http.StatusOK, gin.H{
     "message": "Hello, " + name + "!",
 })

    })

    // 启动服务器
    router.Run(":8080")
    }
    创建限流器：设置令牌生成速率为每秒5个，令牌桶容量为10个。
    启动清理协程：定期清理不活跃的客户端，防止内存泄漏。
    应用中间件：将限流中间件应用到 Gin 路由器上。
    定义路由：定义几个简单的路由进行测试。
    启动服务器：在端口8080上启动 Gin 服务器。

  2. 测试限流效果
    启动服务器后，可以使用 curl 或者其他 HTTP 客户端工具进行测试。

5.1. 正常请求
curl http://localhost:8080/
响应：

{
"message": "Hello, World!"
}
5.2. 超过限流
快速连续发送多个请求，超过令牌桶容量后，后续请求将被拒绝。

for i in {1..15}; do curl -i http://localhost:8080/; done
部分响应：

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
...

HTTP/1.1 429 Too Many Requests
Content-Type: application/json; charset=utf-8
...

{
"error": "Too Many Requests"
}

  1. 进一步优化
    6.1. 限制不同的客户端
    当前实现基于 IP 地址进行限流。如果需要更精细的控制，可以基于用户身份、API 密钥等进行限流。

6.2. 分布式限流
上面的实现适用于单实例应用。如果你的应用部署在多个实例上，可以考虑使用分布式存储（如 Redis）来同步令牌桶状态，实现全局限流。

6.3. 使用第三方库
虽然手动实现限流中间件有助于理解其原理，但在生产环境中，使用成熟的第三方库更为可靠和高效。例如：

golang.org/x/time/rate：Go 官方提供的限流包，基于令牌桶算法。
uber-go/ratelimit：Uber 提供的高性能限流库。
示例：使用 golang.org/x/time/rate 实现限流中间件
package main

import (
"net/http"
"sync"
"time"

"github.com/gin-gonic/gin"
"golang.org/x/time/rate"

)

// Client 定义每个客户端的限流器
type Client struct {
limiter *rate.Limiter
lastSeen time.Time
}

// RateLimiter 使用 golang.org/x/time/rate 实现限流器
type RateLimiter struct {
clients map[string]*Client
mutex sync.Mutex
r rate.Limit
b int
}

// NewRateLimiter 创建一个新的限流器
func NewRateLimiter(r rate.Limit, b int) RateLimiter {
rl := &RateLimiter{
clients: make(map[string]Client),
r: r,
b: b,
}

// 启动清理协程
go rl.cleanupClients()

return rl

}

// GetLimiter 获取或创建客户端的限流器
func (rl RateLimiter) GetLimiter(clientID string) rate.Limiter {
rl.mutex.Lock()
defer rl.mutex.Unlock()

client, exists := rl.clients[clientID]
if !exists {
    limiter := rate.NewLimiter(rl.r, rl.b)
    rl.clients[clientID] = &Client{
        limiter:  limiter,
        lastSeen: time.Now(),
    }
    return limiter
}

client.lastSeen = time.Now()
return client.limiter

}

// cleanupClients 定期清理不活跃的客户端
func (rl RateLimiter) cleanupClients() {
for {
time.Sleep(time.Minute)
rl.mutex.Lock()
for clientID, client := range rl.clients {
if time.Since(client.lastSeen) > 3time.Minute {
delete(rl.clients, clientID)
}
}
rl.mutex.Unlock()
}
}

// RateLimitMiddleware 返回一个 Gin 中间件，使用 golang.org/x/time/rate 进行限流
func RateLimitMiddleware(rl RateLimiter) gin.HandlerFunc {
return func(c gin.Context) {
clientIP := c.ClientIP()
limiter := rl.GetLimiter(clientIP)

    if limiter.Allow() {
        c.Next()
    } else {
        c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
            "error": "Too Many Requests",
        })
        return
    }
}

}

func main() {
router := gin.Default()

// 使用 golang.org/x/time/rate，每秒5个请求，桶容量10
rl := NewRateLimiter(5, 10)

// 应用限流中间件
router.Use(RateLimitMiddleware(rl))

// 定义路由
router.GET("/", func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello, World!",
    })
})

[kod.w3c4.net）
[kod.wgooo.net）
[kod.willawen.com）
[kod.xyzytv.com）
[kod.wqcycpms.com）
[kod.wnear.com）
[kod.xinceshi.net）
router.GET("/user/:name", func(c *gin.Context) {
name := c.Param("name")
c.JSON(http.StatusOK, gin.H{
"message": "Hello, " + name + "!",
})
})

// 启动服务器
router.Run(":8080")

}
分类: 从问题出发深入理解Gin框架

文章标签：
中间件
Go
算法
存储
JSON
游客cxtb2yf2r55as
目录
相关文章
Sunny_yiyi
|
6月前
|
应用服务中间件 nginx
分布式限流
分布式限流
Sunny_yiyi
54 1
萝卜丝丸子
|
4月前
|
应用服务中间件 nginx 缓存
高并发架构设计三大利器：缓存、限流和降级问题之Nginx作为前置网关进行限流问题如何解决
高并发架构设计三大利器：缓存、限流和降级问题之Nginx作为前置网关进行限流问题如何解决
萝卜丝丸子
64 0
阿兵云原生
|
11月前
|
Cloud Native 算法 安全
简单理解微服务限流、降级、熔断
简单理解微服务限流、降级、熔断
阿兵云原生
167 0
阿兵云原生
|
数据采集 缓存 算法
最常用的限流算法以及如何在http中间件中加入流控
最常用的限流算法以及如何在http中间件中加入流控
阿兵云原生
114 0
数据与后端架构提升之路
|
算法 NoSQL Java
单机限流和分布式应用限流
单机限流和分布式应用限流
数据与后端架构提升之路
329 0
杨宸杨
|
Java API Sentinel
微服务 过滤器 集成Sentinel实现网关限流
微服务 过滤器 集成Sentinel实现网关限流
杨宸杨
331 0
Masters
|
算法 NoSQL API
限流功能的实现
限流功能的实现
Masters
188 0
云课程笔记
|
Java 开发者 Spring
服务保护、服务限流、服务降级的概念|学习笔记
快速学习服务保护、服务限流、服务降级的概念
云课程笔记
195 0
游客gybmahbtqgs6y
|
NoSQL 算法 Java
分布式限流（中）
本文接着上文应用限流进行讨论。 之前谈到的限流方案只能针对于单个 JVM 有效，也就是单机应用。而对于现在普遍的分布式应用也得有一个分布式限流的方案。
游客gybmahbtqgs6y
197 0
平凡人笔记
熔断和限流原理和使用（4）
熔断和限流原理和使用（4）
平凡人笔记
127 0
熔断和限流原理和使用（4）

热门文章

最新文章

  • 1
    Flutter之禅 内存优化篇
  • 2
    《Cadence 16.6电路设计与仿真从入门到精通》——2.4 Design Entry CIS原理图图形界面　
  • 3
    记一次对网络抖动经典案例的分析
  • 4
    国外成人网站xHamster大量用户信息黑市变卖，部分账号涉及英美政府官员
  • 5
    用户密码以BCrypt加密的方式来防范被破解
  • 6
    带你理清CPU，cache和存储器之间的逻辑运作
  • 7
    Git设置代理服务器
  • 8
    【DSW Gallery】PAI-DSW开通及授权
  • 9
    吐血整理：机器学习的30个基本概念，都在这里了（手绘图解）
  • 10
    MOSS站点的迁移(备份还原)
  • 1
    设计模式之 5 大创建型模式，万字长文深剖 ，近 30 张图解！
    49
  • 2
    《C++新特性：为多线程数据竞争检测与预防保驾护航》
    41
  • 3
    Kotlin - 区间与数组
    41
  • 4
    Kotlin - 参数与异常
    39
  • 5
    Kotlin - 运算符与中缀表达式
    34
  • 6
    Kotlin - 函数与Lambda表达式
    23
  • 7
    Kotlin - 分支与循环
    19
  • 8
    天气预报1天-中国气象局-地址查询版免费API接口教程
    20
  • 9
    《C++智能合约与区块链底层交互全解析：构建坚实的去中心化应用桥梁》
    19

    • 相关课程

    更多
  • 微服务实战-服务熔断 - Sentinel

    • 相关电子书

    更多
  • Sentinel-Sentinel :保障微服务高可用的利器
  • 阿里云容器 AHAS Sentinel 网关流控揭秘
  • 微服务架构演进与挑战-API网关，分布式事务

    • 相关实验场景

    更多
  • 快速玩转Dubbo生态之限流降级篇（Sentinel）
    • 下一篇
    阿里云OSS设置跨域访问