import redis
import time

r = redis.Redis()

def is_rate_limited_fixed_window(user_id: str, limit: int, window: int) -> bool:
    key = f"rate_limit:{user_id}"
    current_requests = r.get(key)

    if current_requests is None:
        # 使用 pipeline 保證原子性
        pipe = r.pipeline()
        pipe.incr(key)
        pipe.expire(key, window)
        pipe.execute()
        return False

    if int(current_requests) >= limit:
        return True

    r.incr(key)
    return False

# 示例: 每位用戶每60秒最多10個請求
for i in range(15):
    if is_rate_limited_fixed_window("user123", 10, 60):
        print("請求被限制")
    else:
        print("請求成功")
    time.sleep(1)

-- rate_limiter.lua
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])

local current = tonumber(redis.call("GET", key) or "0")

if current >= limit then
    return 1 -- 1 表示被限制
end

if current == 0 then
    redis.call("INCR", key)
    redis.call("EXPIRE", key, window)
else
    redis.call("INCR", key)
end

return 0 -- 0 表示未被限制

import redis.clients.jedis.Jedis;

public class RateLimiter {
    private final Jedis jedis;
    private final String script;

    public RateLimiter(Jedis jedis) {
        this.jedis = jedis;
        // 實際項目中應(yīng)從文件加載
        this.script = "local key = KEYS[1]..."
    }

    public boolean isRateLimited(String key, int limit, int window) {
        Object result = jedis.eval(this.script, 1, key, String.valueOf(limit), String.valueOf(window));
        return "1".equals(result.toString());
    }
}

import redis
import time

r = redis.Redis()

def is_rate_limited_sliding_log(user_id: str, limit: int, window: int) -> bool:
    key = f"rate_limit_log:{user_id}"
    now = int(time.time() * 1000)
    window_start = now - window * 1000

    # 使用 pipeline 保證原子性
    pipe = r.pipeline()
    # 移除窗口外的數(shù)據(jù)
    pipe.zremrangebyscore(key, 0, window_start)
    # 添加當前請求
    pipe.zadd(key, {f"{now}:{int(time.time()*1000000)}": now}) # 保證 member 唯一
    # 獲取窗口內(nèi)的請求數(shù)
    pipe.zcard(key)
    # 設(shè)置過期時間，防止冷數(shù)據(jù)占用內(nèi)存
    pipe.expire(key, window)
    results = pipe.execute()

    current_requests = results[2]
    return current_requests > limit

-- sliding_window.lua
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local now = redis.call("TIME")
local now_ms = (now[1] * 1000) + math.floor(now[2] / 1000)
local window_start = now_ms - window * 1000

-- 移除過期的請求記錄
redis.call("ZREMRANGEBYSCORE", key, 0, window_start)

-- 獲取當前窗口內(nèi)的請求數(shù)
local count = redis.call("ZCARD", key)

if count >= limit then
    return 1 -- 被限制
end

-- 添加當前請求
redis.call("ZADD", key, now_ms, now_ms .. "-" .. count) -- member 保證唯一性
redis.call("EXPIRE", key, window)

return 0 -- 未被限制

// 依賴: bucket4j-core, jcache-api, redisson
// 配置 RedissonClient...

// 創(chuàng)建一個基于 Redis 的代理管理器
ProxyManager<String> proxyManager = new JCacheProxyManager<>(jcache);

// 定義令牌桶配置：每分鐘補充10個令牌，桶容量為10
BucketConfiguration configuration = BucketConfiguration.builder()
        .addLimit(Bandwidth.simple(10, Duration.ofMinutes(1)))
        .build();

// 獲取或創(chuàng)建令牌桶
Bucket bucket = proxyManager.getProxy("rate-limit-bucket:user123", configuration);

// 嘗試消費一個令牌
if (bucket.tryConsume(1)) {
    // 請求成功
} else {
    // 請求被限制
}

spring:
  cloud:
    gateway:
      routes:
      - id: my_route
        uri: lb://my-service
        predicates:
        - Path=/my-api/**
        filters:
        - name: RequestRateLimiter
          args:
            redis-rate-limiter.replenishRate: 10      # 令牌桶每秒填充速率
            redis-rate-limiter.burstCapacity: 20     # 令牌桶容量
            redis-rate-limiter.requestedTokens: 1  # 每次請求消耗的令牌數(shù)
            key-resolver: "#{@ipKeyResolver}"     # 使用 IP 地址作為限流的 key

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import redis

app = FastAPI()
r = redis.Redis()

@app.middleware("http")
async def rate_limit_middleware(request: Request, call_next):
    # 簡單示例：使用固定窗口計數(shù)器
    ip = request.client.host
    key = f"rate_limit:{ip}"
    limit = 5
    window = 60

    # 此處應(yīng)使用 Lua 腳本保證原子性
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)

    if current > limit:
        return JSONResponse(status_code=429, content={"message": "Too Many Requests"})

    response = await call_next(request)
    return response