如何在Kubernetes中共享Microsoft.AspNetCore.RateLimiting中间件的限流状态

默认的Microsoft.AspNetCore.RateLimiting中间件依赖内存存储限流状态，在K8s多Pod部署场景下，每个Pod会独立维护计数器，无法实现全局统一的限流效果。要解决这个问题，核心是替换内存存储为分布式共享存储（如Redis），通过自定义符合AspNetCore RateLimiting规范的组件，实现跨Pod的状态同步。

核心实现思路 #

1. 选择支持原子操作的分布式存储（Redis是最常用方案，能保证计数更新的准确性）；
2. 实现自定义IRateLimiter接口，将状态读写逻辑委托给分布式存储；
3. 注册自定义限流器到依赖注入容器，替换默认的内存实现。

自定义Redis分布式限流器示例 #

以下以固定窗口限流策略为例，提供完整的跨Pod共享状态实现：

1. 实现Redis限流器核心逻辑 #

通过IRateLimiter接口封装Redis的原子操作，处理限流计数：

using System.Threading.RateLimiting;
using StackExchange.Redis;

public class RedisFixedWindowRateLimiter : IRateLimiter
{
    private readonly IConnectionMultiplexer _redis;
    private readonly string _policyName;
    private readonly TimeSpan _window;
    private readonly int _permitLimit;

    public RedisFixedWindowRateLimiter(IConnectionMultiplexer redis, string policyName, TimeSpan window, int permitLimit)
    {
        _redis = redis;
        _policyName = policyName;
        _window = window;
        _permitLimit = permitLimit;
    }

    public RateLimiterStatistics? GetStatistics() => null; // 按需扩展统计逻辑

    public async ValueTask<RateLimitLease> AcquireAsync(int permitCount = 1, CancellationToken cancellationToken = default)
    {
        if (permitCount < 1) throw new ArgumentOutOfRangeException(nameof(permitCount));

        var db = _redis.GetDatabase();
        var key = $"rate-limit:{_policyName}:{GetWindowTimestamp()}";

        // Lua脚本：原子性检查并更新限流计数
        var luaScript = @"
            local current = redis.call('GET', KEYS[1])
            if current == false then
                redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[2])
                return 1
            elseif tonumber(current) < tonumber(ARGV[3]) then
                redis.call('INCRBY', KEYS[1], ARGV[1])
                return 1
            else
                return 0
            end
        ";

        var result = await db.ScriptEvaluateAsync(luaScript, 
            new RedisKey[] { key }, 
            new RedisValue[] { permitCount, _window.TotalSeconds, _permitLimit });

        return (long)result == 1 
            ? new RedisRateLimitLease(true) 
            : new RedisRateLimitLease(false);
    }

    // 生成当前窗口的时间戳键，保证每个窗口计数独立
    private string GetWindowTimestamp()
    {
        var now = DateTimeOffset.UtcNow;
        var windowStart = now - now.TimeOfDay % _window;
        return windowStart.ToUnixTimeSeconds().ToString();
    }

    // 自定义限流租赁实现
    private class RedisRateLimitLease : RateLimitLease
    {
        private readonly bool _isAcquired;

        public RedisRateLimitLease(bool isAcquired) => _isAcquired = isAcquired;

        public override bool IsAcquired => _isAcquired;

        public override IEnumerable<string> MetadataNames => Enumerable.Empty<string>();

        public override bool TryGetMetadata(string metadataName, out object? metadata)
        {
            metadata = null;
            return false;
        }
    }
}

2. 实现自定义限流策略提供器 #

让中间件能够识别并使用自定义限流器，需要实现IRateLimiterPolicy接口：

using System.Threading.RateLimiting;

public class RedisFixedWindowPolicy : IRateLimiterPolicy<string>
{
    private readonly IConnectionMultiplexer _redis;

    public RedisFixedWindowPolicy(IConnectionMultiplexer redis) => _redis = redis;

    public IRateLimiter GetRateLimiter(string partitionKey, RateLimitPartition<string> partition)
    {
        var policyOptions = partition.Policy as FixedWindowRateLimiterOptions;
        if (policyOptions == null)
            throw new InvalidOperationException("当前仅支持固定窗口限流策略");

        return new RedisFixedWindowRateLimiter(
            _redis, 
            partitionKey, 
            policyOptions.Window, 
            policyOptions.PermitLimit);
    }
}

3. 注册组件到DI容器 #

在Program.cs中替换默认内存限流器，注册Redis连接和自定义策略：

var builder = WebApplication.CreateBuilder(args);

// 注册Redis连接
builder.Services.AddSingleton<IConnectionMultiplexer>(_ => 
    ConnectionMultiplexer.Connect(builder.Configuration["Redis:ConnectionString"]));

// 注册自定义限流策略
builder.Services.AddSingleton<IRateLimiterPolicy<string>, RedisFixedWindowPolicy>();

// 配置限流中间件
builder.Services.AddRateLimiter(options =>
{
    options.AddPolicy("global-api", context =>
        RateLimitPartition.Create<string>("global", _ =>
            new FixedWindowRateLimiterOptions
            {
                Window = TimeSpan.FromMinutes(1),
                PermitLimit = 100,
                QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
                QueueLimit = 10
            }));
});

var app = builder.Build();

// 启用限流中间件
app.UseRateLimiter();

// 其他中间件配置...

app.Run();

4. 配置文件示例（appsettings.json） #

{
  "Redis": {
    "ConnectionString": "your-redis-service:6379"
  }
}

关键注意事项 #

• 原子性保障：必须使用Redis Lua脚本或原子命令，避免多Pod并发更新时的计数不一致；
• 键设计合理性：通过窗口时间戳生成唯一键，确保不同窗口的计数相互隔离；
• 异常处理：生产环境需添加Redis连接重试、降级逻辑，避免存储不可用时导致服务雪崩；
• 策略扩展：若需令牌桶、滑动窗口等其他限流策略，可按照相同模式实现对应的Redis限流器。

内容的提问来源于stack exchange，提问作者kalitsov