初学者的速率限制：它是什么以及如何在 Go 中构建速率限制

速率限制是 Web 开发和 API 设计中的一个关键概念。它确保用户或系统在特定时间范围内只能向服务器发出有限数量的请求。在这篇博文中，我们将探讨什么是速率限制、为什么它很重要，以及如何在 Go 中实现一个简单的速率限制器。

什么是速率限制？

想象一个主题公园，里面有过山车，每 10 分钟只能容纳 10 人。如果超过 10 人试图在该时间内上车，他们将不得不等待。这个类比反映了软件系统中速率限制的原理。

用技术术语来说，速率限制限制客户端（例如用户、设备或 IP 地址）在预定义时间内可以发送到服务器的请求数量。它有帮助：

1. 防止滥用并确保公平使用资源。
2. 保护服务器不被过多的流量淹没。
3. 避免过度使用第三方 API 或服务，造成高昂代价。

例如，API 可能允许每个用户每分钟 100 个请求。如果用户超出此限制，服务器将拒绝进一步的请求，直到限制重置。

速率限制如何运作？

实现速率限制的一种常见方法是通过令牌桶算法。其工作原理如下：

1. 存储桶以固定数量的令牌（例如 10）开始。
2. 每个请求都会从存储桶中删除一个令牌。
3. 如果桶中没有剩余令牌，则请求被拒绝。
4. 代币会以稳定的速度（例如每秒 1 个代币）补充，直到桶装满。

在 Go 中构建一个简单的速率限制器

让我们深入研究在 Go 中构建一个速率限制器，将每个客户端限制为每分钟 3 个请求。

第 1 步：定义速率限制器结构

我们将使用sync.Mutex来确保线程安全并存储令牌数量、最大容量和填充率等信息。

package main

import (
    "sync"
    "time"
)

type RateLimiter struct {
    tokens         float64   // Current number of tokens
    maxTokens      float64   // Maximum tokens allowed
    refillRate     float64   // Tokens added per second
    lastRefillTime time.Time // Last time tokens were refilled
    mutex          sync.Mutex
}

func NewRateLimiter(maxTokens, refillRate float64) *RateLimiter {
    return &RateLimiter{
        tokens:         maxTokens,
        maxTokens:      maxTokens,
        refillRate:     refillRate,
        lastRefillTime: time.Now(),
    }
}

第 2 步：实施令牌补充逻辑

代币应根据上次充值以来的经过时间定期补充。

func (r *RateLimiter) refillTokens() {
    now := time.Now()
    duration := now.Sub(r.lastRefillTime).Seconds()
    tokensToAdd := duration * r.refillRate

    r.tokens += tokensToAdd
    if r.tokens > r.maxTokens {
        r.tokens = r.maxTokens
    }
    r.lastRefillTime = now
}

第 3 步：检查请求是否被允许

Allow 方法将根据可用令牌确定请求是否可以继续。

func (r *RateLimiter) Allow() bool {
    r.mutex.Lock()
    defer r.mutex.Unlock()

    r.refillTokens()

    if r.tokens >= 1 {
        r.tokens--
        return true
    }
    return false
}

第 4 步：对每个 IP 应用速率限制

为了限制每个客户端的请求，我们将创建 IP 地址到各自速率限制器的映射。

type IPRateLimiter struct {
    limiters map[string]*RateLimiter
    mutex    sync.Mutex
}

func NewIPRateLimiter() *IPRateLimiter {
    return &IPRateLimiter{
        limiters: make(map[string]*RateLimiter),
    }
}

func (i *IPRateLimiter) GetLimiter(ip string) *RateLimiter {
    i.mutex.Lock()
    defer i.mutex.Unlock()

    limiter, exists := i.limiters[ip]
    if !exists {
        // Allow 3 requests per minute
        limiter = NewRateLimiter(3, 0.05)
        i.limiters[ip] = limiter
    }

    return limiter
}

第 5 步：创建用于速率限制的中间件

最后，我们将创建一个 HTTP 中间件，对每个客户端实施速率限制。

package main

import (
    "sync"
    "time"
)

type RateLimiter struct {
    tokens         float64   // Current number of tokens
    maxTokens      float64   // Maximum tokens allowed
    refillRate     float64   // Tokens added per second
    lastRefillTime time.Time // Last time tokens were refilled
    mutex          sync.Mutex
}

func NewRateLimiter(maxTokens, refillRate float64) *RateLimiter {
    return &RateLimiter{
        tokens:         maxTokens,
        maxTokens:      maxTokens,
        refillRate:     refillRate,
        lastRefillTime: time.Now(),
    }
}

第 6 步：设置服务器

以下是如何将它们连接在一起并测试速率限制器。

func (r *RateLimiter) refillTokens() {
    now := time.Now()
    duration := now.Sub(r.lastRefillTime).Seconds()
    tokensToAdd := duration * r.refillRate

    r.tokens += tokensToAdd
    if r.tokens > r.maxTokens {
        r.tokens = r.maxTokens
    }
    r.lastRefillTime = now
}

测试速率限制器

启动服务器并使用curl或浏览器进行测试：

func (r *RateLimiter) Allow() bool {
    r.mutex.Lock()
    defer r.mutex.Unlock()

    r.refillTokens()

    if r.tokens >= 1 {
        r.tokens--
        return true
    }
    return false
}

• 快速发送 3 个请求：全部都应该成功。
• 在同一分钟内发送第四个请求：您应该看到“超出速率限制”消息。
• 等待 20 秒，然后重试：存储桶重新装满，请求应该会成功。

源代码

GitHub 存储库

以上是初学者的速率限制：它是什么以及如何在 Go 中构建速率限制的详细内容。更多信息请关注PHP中文网其他相关文章！