Go语言中进行API限流的实战详解_Golang

为什么要进行 api 限流

api 限流是控制和管理应用程序访问量的重要手段，旨在防止恶意滥用、保护后端服务的稳定性和可用性，并确保系统能够有效处理请求。api 限流不仅能提高系统的性能，还能优化用户体验。下面是为什么要进行 api 限流的一些原因：

1.防止服务过载

当 api 接口的访问量过大时，后端服务可能无法处理所有请求，导致服务崩溃或响应迟缓。

限流能够保证后端服务不会因为高并发请求而被击垮，从而提升系统的可靠性。

2.保护资源

api 服务通常需要访问数据库、缓存、第三方 api 等资源。通过限流，可以控制这些资源的访问频率，防止它们被过度消耗。

防止用户发送大量无效请求或重复请求，避免不必要的资源浪费。

3.提高用户体验

api 限流能够确保每个用户公平地获得访问权限，避免某些用户发送过多请求从而影响其他用户的体验。

4.防止恶意攻击

限流是抵御 ddos（分布式拒绝服务）攻击的一种手段，可以有效减缓大量请求的冲击。

防止暴力破解（如密码暴力破解、账户滥用等）攻击，限制某些频繁请求的行为。

5.成本控制

许多服务（如云服务、第三方 api）基于请求量计费。通过限流，能够在一定程度上减少不必要的成本。

常用的 api 限流算法

以下是一些常见的 api 限流算法，每种算法有不同的优缺点和适用场景：

1. 令牌桶算法（token bucket）

原理：令牌桶算法维护一个桶，每个请求需要获取一个令牌。令牌会以固定速率放入桶中，桶有最大容量。如果桶满了，新的令牌将会丢弃。当请求到达时，若桶中有令牌，说明可以处理该请求，令牌被取走；若桶中没有令牌，则拒绝请求。

特点：

能够处理突发流量，因为桶中可以积累一定数量的令牌。
适用于允许请求量有一定波动的场景。

适用场景：适用于限流场景中需要允许短时间内的流量突增，例如某些高并发的 api 服务。

2. 漏桶算法（leaky bucket）

原理：漏桶算法也使用一个桶来存储请求，当请求到达时，它们会依次进入桶中。如果桶没有满，水会以恒定的速率流出。如果桶已满，则新请求会被丢弃。

特点：

平滑的流量控制，能确保请求按照固定速率流出。
不允许短时间内出现突发流量，所有的请求流量必须按固定速率流出。

适用场景：适用于需要平滑流量、避免短时间内的突发请求影响系统的场景。

3. 固定窗口计数算法（fixed window counter）

原理：在固定的时间窗口内（如每分钟或每小时），允许一定数量的请求通过。每当时间窗口结束时，计数器会重置。超出最大请求数的请求将被拒绝。

特点：

简单易实现，但容易受到时间窗口边界问题的影响（即在窗口切换时，可能会允许过多的请求通过）。

适用场景：适用于流量相对平稳的场景，通常在请求量较低的应用中使用。

4. 滑动窗口计数算法（sliding window counter）

原理：与固定窗口计数算法类似，但是它不是固定的时间窗口，而是以滑动的方式进行计数。每次请求都会在时间轴上记录，滑动窗口会随着时间的推移进行更新。

特点：

能够更加平滑地控制请求速率，避免固定窗口切换时的突发流量。
适用场景：适用于需要精确限流的场景，减少边界效应。

5. 基于 redis 的限流

原理：使用 redis 的键值存储特性，可以结合 redis 的过期时间来实现限流。例如，在 redis 中记录每个用户或 ip 的请求次数，并设置过期时间，来实现请求的限制。

特点：

分布式限流，非常适合分布式系统。
高效、易扩展。

适用场景：适用于分布式系统，尤其是微服务架构中的 api 限流。

使用 go 实现 api 限流

以下是如何在 go 中实现 api 限流的几种常见方式：

1. 基于 token bucket 算法实现限流

package main

import (
	"fmt"
	"time"
)

type tokenbucket struct {
	capacity int           // 桶的最大容量
	tokens   int           // 当前桶中令牌数量
	rate     time.duration // 令牌生成速率
	lasttime time.time     // 上次令牌生成时间
}

func newtokenbucket(capacity int, rate time.duration) *tokenbucket {
	return &tokenbucket{
		capacity: capacity,
		tokens:   capacity,
		rate:     rate,
		lasttime: time.now(),
	}
}

func (tb *tokenbucket) allow() bool {
	// 计算令牌的生成数量
	now := time.now()
	elapsed := now.sub(tb.lasttime)
	tokenstoadd := int(elapsed / tb.rate)
	tb.lasttime = now

	// 如果有令牌生成，更新桶中的令牌数量
	if tokenstoadd > 0 {
		tb.tokens = min(tb.capacity, tb.tokens+tokenstoadd)
	}

	// 如果有令牌，则消费一个令牌并返回 true
	if tb.tokens > 0 {
		tb.tokens--
		return true
	}
	// 否则返回 false，拒绝请求
	return false
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func main() {
	tb := newtokenbucket(5, time.second)

	// 模拟请求
	for i := 0; i < 10; i++ {
		if tb.allow() {
			fmt.println("request", i, "allowed")
		} else {
			fmt.println("request", i, "denied")
		}
		time.sleep(200 * time.millisecond)
	}
}

2. 基于 redis 实现限流（使用 go redis 客户端）

使用 redis 进行限流实现时，常用的是 setnx（设置一个键值对，如果键不存在则设置，防止重复计数）和 expire（设置过期时间）来控制访问频率。

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/go-redis/redis/v8"
	"golang.org/x/net/context"
)

var rdb *redis.client
var ctx = context.background()

func init() {
	// 初始化 redis 客户端
	rdb = redis.newclient(&redis.options{
		addr: "localhost:6379", // redis 地址
	})
}

func limitrequest(userid string) bool {
	// 使用 redis 来存储访问记录
	key := fmt.sprintf("rate_limit:%s", userid)
	// 设置每个用户的最大请求次数限制
	maxrequests := 5
	// 设置过期时间为 60 秒
	expiration := 60 * time.second

	// 获取当前用户的请求次数
	count, err := rdb.get(ctx, key).int()
	if err != nil && err != redis.nil {
		log.fatalf("error retrieving count from redis: %v", err)
	}

	// 如果请求次数超过限制，拒绝请求
	if count >= maxrequests {
		return false
	}

	// 增加请求次数
	err = rdb.incr(ctx, key).err()
	if err != nil {
		log.fatalf("error incrementing count: %v", err)
	}

	// 设置过期时间，避免无限制的请求
	rdb.expire(ctx, key, expiration)

	return true
}

func main() {
	userid := "user123"
	for i := 0; i < 10; i++ {
		if limitrequest(userid) {
			fmt.println("request allowed")
		} else {
			fmt.println("request denied due to rate limit")
		}
		time.sleep(5 * time.second)
	}
}