Redis로 구현하는 Rate Limiting — Token Bucket과 Sliding Window

윈도우: 12:00:00 ~ 12:00:59 → 카운터 키: rate:user123:202603281200
윈도우: 12:01:00 ~ 12:01:59 → 카운터 키: rate:user123:202603281201

-- fixed_window.lua
-- KEYS[1]: 카운터 키 (예: rate:user123:202603281200)
-- ARGV[1]: 최대 허용 횟수
-- ARGV[2]: 윈도우 크기(초)

local current = redis.call('INCR', KEYS[1])

-- 첫 번째 요청이면 TTL 설정
if current == 1 then
    redis.call('EXPIRE', KEYS[1], ARGV[2])
end

-- 제한 초과 여부 확인
if current > tonumber(ARGV[1]) then
    return 0  -- 거부
else
    return 1  -- 허용
end

  윈도우 1 (12:00~12:01)     윈도우 2 (12:01~12:02)
  ─────────────────────────  ─────────────────────────
                   ▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓
                   100건       100건
                   ◄──2초──►

  제한: 1분에 100건인데, 2초 사이에 200건이 허용됨!

-- sliding_window_log.lua
-- KEYS[1]: Sorted Set 키 (예: rate:user123)
-- ARGV[1]: 최대 허용 횟수
-- ARGV[2]: 윈도우 크기(밀리초)
-- ARGV[3]: 현재 타임스탬프(밀리초)

local window_start = tonumber(ARGV[3]) - tonumber(ARGV[2])

-- 1. 윈도우 밖의 오래된 요청 제거
redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', window_start)

-- 2. 현재 윈도우 내 요청 수 확인
local count = redis.call('ZCARD', KEYS[1])

if count >= tonumber(ARGV[1]) then
    return 0  -- 거부
end

-- 3. 현재 요청 추가 (타임스탬프를 score와 member 모두에 사용)
redis.call('ZADD', KEYS[1], ARGV[3], ARGV[3])

-- 4. TTL 설정 (윈도우 크기 + 여유 시간)
redis.call('PEXPIRE', KEYS[1], ARGV[2])

return 1  -- 허용

이전 윈도우 (12:00~12:01): 84건
현재 윈도우 (12:01~12:02): 36건
현재 시각: 12:01:15 (현재 윈도우의 25% 경과)

가중 합산 = 이전 윈도우 × (1 - 경과 비율) + 현재 윈도우
         = 84 × 0.75 + 36
         = 63 + 36 = 99건

-- sliding_window_counter.lua
-- KEYS[1]: 이전 윈도우 카운터 키
-- KEYS[2]: 현재 윈도우 카운터 키
-- ARGV[1]: 최대 허용 횟수
-- ARGV[2]: 윈도우 크기(초)
-- ARGV[3]: 현재 윈도우 시작 시각(Unix 초)
-- ARGV[4]: 현재 시각(Unix 초)

local prev_count = tonumber(redis.call('GET', KEYS[1]) or '0')
local curr_count = tonumber(redis.call('GET', KEYS[2]) or '0')

-- 현재 윈도우에서 경과한 비율 계산
local window_size = tonumber(ARGV[2])
local elapsed = tonumber(ARGV[4]) - tonumber(ARGV[3])
local weight = math.max(0, (window_size - elapsed) / window_size)

-- 가중 합산
local total = math.floor(prev_count * weight) + curr_count

if total >= tonumber(ARGV[1]) then
    return 0  -- 거부
end

-- 현재 윈도우 카운터 증가
redis.call('INCR', KEYS[2])
redis.call('EXPIRE', KEYS[2], window_size * 2)  -- 다음 윈도우에서도 참조하므로 2배

return 1  -- 허용

  버킷 용량: 10개   충전 속도: 2개/초

  ┌──────────┐
  │ ● ● ● ●  │  ← 현재 4개 토큰
  │ ● ● ●    │
  │          │
  └──────────┘
       ↑
    2개/초 충전

  → 요청 1건 = 토큰 1개 소비
  → 요청 없으면 최대 10개까지 누적
  → 누적된 토큰으로 버스트 처리 가능

-- token_bucket.lua
-- KEYS[1]: 버킷 키 (예: bucket:user123)
-- ARGV[1]: 버킷 최대 용량
-- ARGV[2]: 초당 충전 토큰 수
-- ARGV[3]: 현재 타임스탬프(밀리초)
-- ARGV[4]: 소비할 토큰 수 (보통 1)

local bucket_key = KEYS[1]
local capacity = tonumber(ARGV[1])
local refill_rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local requested = tonumber(ARGV[4])

-- 현재 버킷 상태 조회
local bucket = redis.call('HMGET', bucket_key, 'tokens', 'last_refill')
local tokens = tonumber(bucket[1])
local last_refill = tonumber(bucket[2])

-- 최초 요청이면 버킷을 가득 채움
if tokens == nil then
    tokens = capacity
    last_refill = now
end

-- 마지막 충전 이후 경과 시간 기반으로 토큰 충전
local elapsed = (now - last_refill) / 1000  -- 밀리초 → 초
local new_tokens = math.min(capacity, tokens + (elapsed * refill_rate))

-- 토큰 소비 시도
if new_tokens >= requested then
    new_tokens = new_tokens - requested
    -- 버킷 상태 갱신
    redis.call('HSET', bucket_key, 'tokens', new_tokens, 'last_refill', now)
    redis.call('EXPIRE', bucket_key, math.ceil(capacity / refill_rate) * 2)
    return 1  -- 허용
else
    -- 토큰 부족 — 충전 상태는 갱신하되 소비하지 않음
    redis.call('HSET', bucket_key, 'tokens', new_tokens, 'last_refill', now)
    redis.call('EXPIRE', bucket_key, math.ceil(capacity / refill_rate) * 2)
    return 0  -- 거부
end

spring:
  cloud:
    gateway:
      routes:
        - id: api-route
          uri: http://localhost:8080
          predicates:
            - Path=/api/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10  # 초당 충전 토큰
                redis-rate-limiter.burstCapacity: 20  # 버킷 최대 용량
                key-resolver: "#{@userKeyResolver}"   # 사용자 식별 기준

@Bean
public KeyResolver userKeyResolver() {
    // IP 주소 기준으로 Rate Limiting 적용
    return exchange -> Mono.just(
        exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
    );
}

@Bean
public ProxyManager<String> proxyManager(RedissonClient redissonClient) {
    // Redisson 기반 Redis 연동
    return RedissonBasedProxyManager.builderFor(redissonClient)
        .build();
}

public boolean tryConsume(String userId) {
    BucketConfiguration config = BucketConfiguration.builder()
        // 분당 100건, 최대 버스트 20건
        .addLimit(Bandwidth.builder()
            .capacity(20)
            .refillGreedy(100, Duration.ofMinutes(1))
            .build())
        .build();

    Bucket bucket = proxyManager.builder()
        .build("rate:" + userId, () -> config);

    return bucket.tryConsume(1);  // 토큰 1개 소비 시도
}

-- Redis 서버 시각 사용
local time = redis.call('TIME')
local now_ms = tonumber(time[1]) * 1000 + math.floor(tonumber(time[2]) / 1000)

# 해시 태그 사용 — {user123} 부분만 해싱
rate:{user123}:prev
rate:{user123}:curr

# 이렇게 하면 두 키가 반드시 같은 슬롯에 위치