API 레이트 리밋과 백프레셔 심화

Client → [Rate Limit] → API Gateway → Application → DB

API Gateway → Application → [Backpressure/Bulkhead] → DB/External API

버스트를 허용해야 하는가?
├── Yes → Token Bucket
│     └── 다운스트림을 일정 속도로 보호해야 하는가?
│           └── Yes → Leaky Bucket (출력 평탄화)
└── No (공정성 우선)
      └── 과금/정밀 추적이 필요한가?
            ├── Yes → Sliding Window Log
            └── No → Sliding Window Counter

윈도우 1 (0:00~1:00): 마지막 1초에 100건 → 허용
윈도우 2 (1:00~2:00): 첫 1초에 100건 → 허용
→ 실제로는 2초 동안 200건이 통과 (제한 100건/분인데)

-- rate_limit_sliding_window.lua
-- KEYS[1] = rate limit key (e.g., "rl:user:123")
-- ARGV[1] = window size (ms)
-- ARGV[2] = max requests
-- ARGV[3] = current timestamp (ms)

local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

-- 만료된 엔트리 제거
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

-- 현재 윈도우 내 요청 수
local count = redis.call('ZCARD', key)

if count < limit then
    -- 허용: 현재 타임스탬프를 score와 member로 추가
    redis.call('ZADD', key, now, now .. ':' .. math.random(1000000))
    redis.call('PEXPIRE', key, window)
    return {1, limit - count - 1}  -- {허용, 남은 횟수}
else
    -- 거부
    return {0, 0}
end

-- rate_limit_token_bucket.lua
-- KEYS[1] = bucket key
-- ARGV[1] = max tokens (burst capacity)
-- ARGV[2] = refill rate (tokens per second)
-- ARGV[3] = current timestamp (seconds, float)
-- ARGV[4] = tokens to consume

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

local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
local tokens = tonumber(bucket[1]) or max_tokens
local last_refill = tonumber(bucket[2]) or now

-- 경과 시간에 따른 토큰 충전
local elapsed = math.max(0, now - last_refill)
tokens = math.min(max_tokens, tokens + elapsed * refill_rate)

if tokens >= requested then
    tokens = tokens - requested
    redis.call('HMSET', key, 'tokens', tokens, 'last_refill', now)
    redis.call('EXPIRE', key, math.ceil(max_tokens / refill_rate) * 2)
    return {1, math.floor(tokens)}  -- {허용, 남은 토큰}
else
    redis.call('HMSET', key, 'tokens', tokens, 'last_refill', now)
    redis.call('EXPIRE', key, math.ceil(max_tokens / refill_rate) * 2)
    return {0, math.floor(tokens)}  -- {거부, 남은 토큰}
end

@Component
@RequiredArgsConstructor
public class RedisRateLimiter {

    private final StringRedisTemplate redisTemplate;
    private final RedisScript<List<Long>> slidingWindowScript;

    /**
     * @return true if allowed, false if rate limited
     */
    public RateLimitResult tryAcquire(String clientId, int windowMs, int maxRequests) {
        String key = "rl:" + clientId;
        long now = System.currentTimeMillis();

        List<Long> result = redisTemplate.execute(
            slidingWindowScript,
            List.of(key),
            String.valueOf(windowMs),
            String.valueOf(maxRequests),
            String.valueOf(now)
        );

        boolean allowed = result.get(0) == 1L;
        long remaining = result.get(1);

        return new RateLimitResult(allowed, remaining, windowMs);
    }
}

public record RateLimitResult(boolean allowed, long remaining, int windowMs) {
    public Map<String, String> toHeaders() {
        return Map.of(
            "X-RateLimit-Remaining", String.valueOf(remaining),
            "X-RateLimit-Reset", String.valueOf(
                System.currentTimeMillis() + windowMs
            )
        );
    }
}

# application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: api-route
          uri: lb://api-service
          predicates:
            - Path=/api/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10      # 초당 10개
                redis-rate-limiter.burstCapacity: 20       # 최대 버스트 20개
                redis-rate-limiter.requestedTokens: 1      # 요청당 1토큰
                key-resolver: "#{@userKeyResolver}"

@Configuration
public class RateLimiterConfig {

    // 인증된 사용자 기준
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> Mono.justOrEmpty(
            exchange.getRequest().getHeaders().getFirst("X-User-Id")
        ).defaultIfEmpty("anonymous");
    }

    // IP 기준 (비인증 API)
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
            Objects.requireNonNull(
                exchange.getRequest().getRemoteAddress()
            ).getAddress().getHostAddress()
        );
    }

    // API 키 기준 (테넌트별)
    @Bean
    public KeyResolver apiKeyResolver() {
        return exchange -> Mono.justOrEmpty(
            exchange.getRequest().getHeaders().getFirst("X-API-Key")
        ).defaultIfEmpty("no-key");
    }
}

spring:
  cloud:
    gateway:
      routes:
        # 일반 조회: 1토큰
        - id: read-api
          uri: lb://api-service
          predicates:
            - Path=/api/products/**
            - Method=GET
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100
                redis-rate-limiter.burstCapacity: 200
                redis-rate-limiter.requestedTokens: 1

        # 파일 업로드: 10토큰 (비용 높음)
        - id: upload-api
          uri: lb://api-service
          predicates:
            - Path=/api/upload/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100
                redis-rate-limiter.burstCapacity: 200
                redis-rate-limiter.requestedTokens: 10

        # 검색: 5토큰
        - id: search-api
          uri: lb://api-service
          predicates:
            - Path=/api/search/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100
                redis-rate-limiter.burstCapacity: 200
                redis-rate-limiter.requestedTokens: 5

// Tomcat 스레드 풀 대기열 제한
@Configuration
public class TomcatConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> customizer() {
        return factory -> factory.addConnectorCustomizers(connector -> {
            var executor = new org.apache.tomcat.util.threads.ThreadPoolExecutor(
                10,    // core
                200,   // max
                60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(100)  // 대기열 100으로 제한
            );
            var protocolHandler = (AbstractProtocol<?>) connector.getProtocolHandler();
            protocolHandler.setExecutor(executor);
        });
    }
}

@Configuration
public class BulkheadConfig {

    @Bean
    public BulkheadRegistry bulkheadRegistry() {
        BulkheadConfig config = BulkheadConfig.custom()
            .maxConcurrentCalls(20)          // 동시 처리 최대 20개
            .maxWaitDuration(Duration.ZERO)  // 대기 없이 즉시 실패
            .build();

        return BulkheadRegistry.of(config);
    }
}

@Service
@RequiredArgsConstructor
public class SearchService {

    private final BulkheadRegistry bulkheadRegistry;

    public SearchResult search(String query) {
        Bulkhead bulkhead = bulkheadRegistry.bulkhead("search");

        return Bulkhead.decorateSupplier(bulkhead, () -> {
            // 실제 검색 로직 (DB/Elasticsearch)
            return doSearch(query);
        }).get();
        // 동시 호출 20개 초과 시 BulkheadFullException → 503
    }
}

@Component
public class PriorityLoadShedder implements HandlerInterceptor {

    private final AtomicInteger activeRequests = new AtomicInteger(0);
    private static final int MAX_CONCURRENT = 500;

    // 우선순위: 결제 > 주문 > 조회 > 추천
    private static final Map<String, Integer> PRIORITY = Map.of(
        "/api/payment", 100,
        "/api/orders",  80,
        "/api/products", 50,
        "/api/recommendations", 20
    );

    @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res,
                             Object handler) throws Exception {
        int current = activeRequests.incrementAndGet();
        int priority = getPriority(req.getRequestURI());

        // 부하 높을 때 낮은 우선순위부터 드롭
        double loadRatio = (double) current / MAX_CONCURRENT;
        int threshold = (int) (100 * (1 - loadRatio));  // 부하 높을수록 임계 상승

        if (priority < threshold) {
            activeRequests.decrementAndGet();
            res.setStatus(503);
            res.setHeader("Retry-After", "5");
            res.getWriter().write("{\"error\":\"Service overloaded\"}");
            return false;
        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest req, HttpServletResponse res,
                                Object handler, Exception ex) {
        activeRequests.decrementAndGet();
    }

    private int getPriority(String uri) {
        return PRIORITY.entrySet().stream()
            .filter(e -> uri.startsWith(e.getKey()))
            .map(Map.Entry::getValue)
            .findFirst()
            .orElse(50);
    }
}

HTTP/1.1 429 Too Many Requests
Retry-After: 30
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1679616000

{
  "error": "rate_limit_exceeded",
  "message": "API rate limit exceeded. Try again in 30 seconds.",
  "retry_after": 30
}

서버 느려짐 → 타임아웃 증가
  → 클라이언트 재시도 → 트래픽 증가
    → 서버 더 느려짐 → 더 많은 재시도
      → 연쇄 붕괴 (Retry Storm)

public class RetryWithBackoff {

    public <T> T execute(Supplier<T> action, int maxRetries) {
        int attempt = 0;
        while (true) {
            try {
                return action.get();
            } catch (RetryableException e) {
                if (++attempt > maxRetries) throw e;

                long baseDelay = 100;  // ms
                long maxDelay = 30_000; // ms
                long delay = Math.min(baseDelay * (1L << attempt), maxDelay);
                long jitter = ThreadLocalRandom.current().nextLong(0, delay);

                try {
                    Thread.sleep(delay + jitter);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException(ie);
                }
            }
        }
    }
}

# Prometheus 메트릭 예시
# Rate limit 차단율
- name: rate_limit_rejected_total
  type: counter
  labels: [client_id, endpoint, reason]

# 동시 처리 수 (Bulkhead)
- name: bulkhead_active_calls
  type: gauge
  labels: [service, method]

# 대기열 상태
- name: request_queue_size
  type: gauge
  labels: [service]