PHP处理高并发下的限流：API Gateway层面的令牌桶与漏桶算法实现 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，下面我们就开始探讨PHP在高并发下API Gateway层面的限流实现，重点介绍令牌桶和漏桶算法，并提供相应的代码示例。

引言：高并发与限流的必要性

在高并发场景下，我们的API服务面临着巨大的访问压力。如果不加以控制，突发的流量高峰可能会导致服务宕机、数据库崩溃，最终影响用户体验。因此，限流是保障系统稳定性的重要手段。限流旨在限制单位时间内API的请求数量，防止恶意攻击和流量洪峰对系统造成冲击。

API Gateway作为所有请求的入口，是实施限流的最佳位置。在API Gateway层进行限流，可以有效地保护后端服务，避免不必要的资源消耗。

限流算法：令牌桶 vs 漏桶

令牌桶和漏桶是两种常见的限流算法，它们各有优缺点，适用于不同的场景。

令牌桶（Token Bucket）：
- 想象一个固定容量的桶，系统以恒定速率向桶中放入令牌。
- 每个请求需要从桶中获取一个令牌，只有拿到令牌才能通过。
- 如果桶中没有令牌，请求将被拒绝或等待。
- 特点： 允许一定程度的突发流量，因为桶中可以积累令牌。更适合处理突发流量，平均速率限制。
- 适用场景： 允许一定程度的burst，比如用户点击按钮后的快速连续请求，或者短时间内的活动推广。
漏桶（Leaky Bucket）：
- 想象一个固定容量的桶，请求就像水一样注入桶中。
- 桶以恒定速率漏水（处理请求）。
- 如果请求注入速度过快，导致桶满，则新的请求将被丢弃。
- 特点： 强制限制请求的速率，使得请求以恒定速率处理。更适合平滑流量，保证服务质量。
- 适用场景： 对请求速率有严格要求的场景，比如视频直播、实时音视频通信等，需要保证流量的平稳性。

特性	令牌桶	漏桶
突发流量处理	允许，桶中可以积累令牌	不允许，桶满后直接丢弃请求
流量平滑性	相对较差，允许一定程度的burst	较好，强制以恒定速率处理请求
适用场景	允许一定程度突发流量，平均速率限制场景	严格限制请求速率，保证流量平稳性，例如流媒体

PHP实现令牌桶算法

以下是一个简单的PHP令牌桶算法实现，使用Redis作为令牌桶的存储介质：

<?php

class TokenBucketLimiter
{
    private $redis;
    private $bucketKey;
    private $capacity;
    private $rate;

    public function __construct(Redis $redis, string $bucketKey, int $capacity, float $rate)
    {
        $this->redis = $redis;
        $this->bucketKey = $bucketKey;
        $this->capacity = $capacity;
        $this->rate = $rate; // 令牌生成速率，单位：令牌/秒
    }

    /**
     * 尝试获取令牌
     *
     * @return bool
     */
    public function tryConsume(): bool
    {
        $now = microtime(true); // 获取当前时间，精确到微秒

        $this->redis->watch($this->bucketKey); // 监听 key 的变化

        $bucket = $this->redis->hGetAll($this->bucketKey);

        $lastRefillTimestamp = $bucket['last_refill_timestamp'] ?? 0; // 上次填充令牌的时间戳
        $tokens = $bucket['tokens'] ?? $this->capacity;                // 当前令牌数量

        // 计算应该填充的令牌数量
        $refillAmount = ($now - $lastRefillTimestamp) * $this->rate;
        $tokens = min($this->capacity, $tokens + $refillAmount); // 令牌数量不能超过桶的容量

        if ($tokens >= 1) { // 桶中有令牌
            $tokens -= 1; // 消费一个令牌
            $multi = $this->redis->multi(); // 开启事务
            $multi->hMSet($this->bucketKey, [
                'tokens' => $tokens,
                'last_refill_timestamp' => $now,
            ]);
            if($multi->exec()){
              return true;
            } else {
              return false;
            }

        } else { // 桶中没有令牌
            $this->redis->unwatch(); // 取消监听
            return false;
        }
    }

    /**
     * 初始化令牌桶
     */
    public function initBucket(): void
    {
        $this->redis->hMSet($this->bucketKey, [
            'tokens' => $this->capacity,
            'last_refill_timestamp' => microtime(true),
        ]);
    }
}

// 示例用法
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

$bucketKey = 'api_token_bucket';
$capacity = 100; // 令牌桶容量
$rate = 10;    // 每秒生成 10 个令牌

$limiter = new TokenBucketLimiter($redis, $bucketKey, $capacity, $rate);

// 初始化令牌桶（仅在第一次使用时执行）
// $limiter->initBucket();

if ($limiter->tryConsume()) {
    // 处理请求
    echo "请求成功！n";
} else {
    // 拒绝请求
    echo "请求被限流！n";
}

代码解释：

TokenBucketLimiter 类： 封装了令牌桶算法的逻辑。
构造函数： 接收 Redis 实例、令牌桶的 key、桶的容量和令牌生成速率作为参数。
tryConsume() 方法： 尝试从令牌桶中获取一个令牌。
- 使用 microtime(true) 获取当前时间戳，精确到微秒。
- 使用 Redis 的 watch 命令监听令牌桶 key 的变化，防止并发问题。
- 从 Redis 中获取令牌桶的信息（令牌数量和上次填充时间戳）。
- 计算应该填充的令牌数量，并更新令牌数量。
- 如果令牌数量大于等于 1，则消费一个令牌，并更新 Redis 中的令牌桶信息。
- 如果令牌数量小于 1，则拒绝请求。
- 使用了 Redis 的事务 (multi 和 exec) 来保证操作的原子性。
initBucket() 方法： 初始化令牌桶，设置初始令牌数量和上次填充时间戳。
示例用法： 创建 TokenBucketLimiter 实例，并调用 tryConsume() 方法来尝试获取令牌。

PHP实现漏桶算法

以下是一个简单的PHP漏桶算法实现，同样使用Redis：

<?php

class LeakyBucketLimiter
{
    private $redis;
    private $bucketKey;
    private $capacity;
    private $rate;

    public function __construct(Redis $redis, string $bucketKey, int $capacity, float $rate)
    {
        $this->redis = $redis;
        $this->bucketKey = $bucketKey;
        $this->capacity = $capacity;
        $this->rate = $rate; // 漏水速率，单位：请求/秒
    }

    /**
     * 尝试添加请求到桶中
     *
     * @return bool
     */
    public function tryAdd(): bool
    {
        $now = microtime(true);

        $this->redis->watch($this->bucketKey);

        $bucket = $this->redis->hGetAll($this->bucketKey);

        $lastLeakTimestamp = $bucket['last_leak_timestamp'] ?? 0; // 上次漏水的时间戳
        $water = $bucket['water'] ?? 0;                      // 当前水量

        // 计算应该漏掉的水量
        $leakAmount = ($now - $lastLeakTimestamp) * $this->rate;
        $water = max(0, $water - $leakAmount); // 水量不能小于 0

        if ($water < $this->capacity) { // 桶未满
            $water += 1; // 添加一个请求（水）
            $multi = $this->redis->multi();
            $multi->hMSet($this->bucketKey, [
                'water' => $water,
                'last_leak_timestamp' => $now,
            ]);
            if($multi->exec()){
                return true;
            } else {
                return false;
            }
        } else { // 桶已满
            $this->redis->unwatch();
            return false;
        }
    }

    /**
     * 初始化漏桶
     */
    public function initBucket(): void
    {
        $this->redis->hMSet($this->bucketKey, [
            'water' => 0,
            'last_leak_timestamp' => microtime(true),
        ]);
    }
}

// 示例用法
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

$bucketKey = 'api_leaky_bucket';
$capacity = 50;   // 漏桶容量
$rate = 5;      // 每秒漏掉 5 个请求

$limiter = new LeakyBucketLimiter($redis, $bucketKey, $capacity, $rate);

// 初始化漏桶（仅在第一次使用时执行）
// $limiter->initBucket();

if ($limiter->tryAdd()) {
    // 处理请求
    echo "请求成功！n";
} else {
    // 拒绝请求
    echo "请求被限流！n";
}

代码解释：

LeakyBucketLimiter 类： 封装了漏桶算法的逻辑。
构造函数： 接收 Redis 实例、漏桶的 key、桶的容量和漏水速率作为参数。
tryAdd() 方法： 尝试向漏桶中添加一个请求。
- 使用 microtime(true) 获取当前时间戳，精确到微秒。
- 使用 Redis 的 watch 命令监听漏桶 key 的变化，防止并发问题。
- 从 Redis 中获取漏桶的信息（当前水量和上次漏水时间戳）。
- 计算应该漏掉的水量，并更新水量。
- 如果桶未满，则添加一个请求（水），并更新 Redis 中的漏桶信息。
- 如果桶已满，则拒绝请求。
- 使用了 Redis 的事务 (multi 和 exec) 来保证操作的原子性。
initBucket() 方法： 初始化漏桶，设置初始水量和上次漏水时间戳。
示例用法： 创建 LeakyBucketLimiter 实例，并调用 tryAdd() 方法来尝试添加请求。

API Gateway集成：中间件实现

为了将限流逻辑集成到API Gateway中，我们可以使用PHP的中间件来实现。以下是一个简单的示例，使用Slim框架：

<?php

require 'vendor/autoload.php';

use SlimFactoryAppFactory;
use PsrHttpMessageServerRequestInterface as Request;
use PsrHttpMessageResponseInterface as Response;

// 引入上面定义的 TokenBucketLimiter 或 LeakyBucketLimiter 类

$app = AppFactory::create();

// 创建 Redis 实例
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

// 定义限流参数
$bucketKey = 'api_token_bucket'; // 或者 'api_leaky_bucket'
$capacity = 100;
$rate = 10;

// 创建限流器实例
$limiter = new TokenBucketLimiter($redis, $bucketKey, $capacity, $rate); // 或者 LeakyBucketLimiter

// 创建限流中间件
$limitMiddleware = function (Request $request, Response $response, callable $next) use ($limiter) {
    if ($limiter->tryConsume()) { // 或者 $limiter->tryAdd()
        $response = $next($request, $response);
        return $response;
    } else {
        $response->getBody()->write('请求被限流！');
        return $response->withStatus(429) // HTTP 429 Too Many Requests
                        ->withHeader('Content-Type', 'text/plain');
    }
};

// 注册中间件
$app->add($limitMiddleware);

// 定义路由
$app->get('/api/resource', function (Request $request, Response $response) {
    $response->getBody()->write('API Resource');
    return $response;
});

$app->run();

代码解释：

引入依赖： 使用 Composer 安装 Slim 框架。
创建 Slim 应用： 使用 AppFactory::create() 创建 Slim 应用实例。
创建 Redis 实例： 连接到 Redis 服务器。
定义限流参数： 设置令牌桶（或漏桶）的 key、容量和速率。
创建限流器实例： 创建 TokenBucketLimiter（或 LeakyBucketLimiter）实例。
创建限流中间件： 定义一个匿名函数作为中间件。
- 在中间件中调用 tryConsume()（或 tryAdd()）方法来尝试获取令牌（或添加请求）。
- 如果获取令牌成功（或添加请求成功），则调用 $next() 方法将请求传递给下一个中间件或路由处理函数。
- 如果获取令牌失败（或添加请求失败），则返回一个 HTTP 429 Too Many Requests 错误响应。
注册中间件： 使用 $app->add() 方法注册限流中间件。
定义路由： 定义一个简单的路由 /api/resource。
运行应用： 使用 $app->run() 方法运行 Slim 应用。

其他考虑因素：

动态配置： 可以将令牌桶的容量和速率存储在数据库或配置文件中，并提供管理界面，以便动态调整限流策略。
分布式限流： 在分布式系统中，需要使用分布式锁（例如 Redis 的 SETNX 命令）来保证限流的准确性。可以使用 Redlock 算法来实现更可靠的分布式锁。
监控和告警： 监控限流器的状态（例如令牌桶的令牌数量、漏桶的水量），并设置告警阈值，以便及时发现并解决问题。可以使用 Prometheus 和 Grafana 等工具来进行监控和告警。
熔断机制： 除了限流，还可以考虑使用熔断机制来防止后端服务雪崩。当后端服务出现故障时，熔断器会阻止所有请求访问该服务，直到服务恢复正常。
IP 白名单/黑名单： 可以根据 IP 地址来允许或阻止某些请求。
用户级别限流： 可以根据用户 ID 来进行限流，防止单个用户占用过多资源。
更复杂的算法： 除了令牌桶和漏桶，还有其他的限流算法，例如滑动窗口、固定窗口等。可以根据实际需求选择合适的算法。

总结：选择合适的限流策略，保障系统稳定

通过以上的讲解和代码示例，我们了解了如何在PHP的API Gateway层实现令牌桶和漏桶算法。选择合适的限流算法，并根据实际情况进行配置和优化，是保障系统在高并发环境下稳定运行的关键。同时，结合其他技术手段，例如动态配置、分布式限流、监控告警和熔断机制，可以构建更加健壮和可靠的API服务。

最后几句话：持续学习，持续优化

限流策略并非一成不变，需要根据实际业务场景和系统运行状况进行持续的调整和优化。通过不断学习和实践，我们可以更好地应对高并发带来的挑战，打造更加稳定、高效的API服务。

发表回复 取消回复

发表回复取消回复