Redis 기반 Global Rate Limiter로 업스트림 서비스 보호하기

func GetUserTrustScore(ctx context.Context, req *TrustScoreRequest) (*TrustScoreResponse, error) {
    // [Stage 1] 기본 사용자 정보 조회
    userId, err := authService.GetUserId(ctx, req.Token)
    if err != nil {
        return nil, err
    }

    // [Stage 2] 병렬로 여러 신뢰도 계산 방법 수행
    scoreCandidates := make(chan *ScoreCandidate, 5)
    
    go func() {
        // 우선순위 1: 거래 히스토리 기반 점수 (Transaction Service) -> [처리 용량이 상대적으로 작음]
        if score := transactionService.GetTrustScoreFromHistory(ctx, userId); score != nil {
            scoreCandidates <- &ScoreCandidate{Source: "transaction", Score: score, Priority: 1}
        }
    }()
    
    go func() {
        // 우선순위 2: 리뷰/평점 기반 점수 (Review Service)
        if score := reviewService.GetTrustScoreFromReviews(ctx, userId); score != nil {
            scoreCandidates <- &ScoreCandidate{Source: "review", Score: score, Priority: 2}
        }
    }()
    
    go func() {
        // 우선순위 3: 소셜 연결 기반 점수 (Social Service)
        if score := socialService.GetTrustScoreFromConnections(ctx, userId); score != nil {
            scoreCandidates <- &ScoreCandidate{Source: "social", Score: score, Priority: 3}
        }
    }()
    
    go func() {
        // 우선순위 4: 행동 패턴 기반 점수 (Behavior Service)
        if score := behaviorService.GetTrustScoreFromBehavior(ctx, userId); score != nil {
            scoreCandidates <- &ScoreCandidate{Source: "behavior", Score: score, Priority: 4}
        }
    }()
    
    go func() {
        // 우선순위 5: 기본 점수 (Default Service)
        if score := defaultService.GetDefaultTrustScore(ctx); score != nil {
            scoreCandidates <- &ScoreCandidate{Source: "default", Score: score, Priority: 5}
        }
    }()

    // [Stage 3] 우선순위에 따라 최적의 신뢰도 점수 선택
    return selectOptimalTrustScore(ctx, scoreCandidates)
}

package utils

import (
    "context"
    "time"
    
    "github.com/ulule/limiter/v3"
    limiterRedis "github.com/ulule/limiter/v3/drivers/store/redis"
)

type RateLimiter struct {
    limiter  *limiter.Limiter
    key      string
    failOpen bool // true: Redis 장애 시 통과(가용성 우선), false: 차단(보호 우선)
}

func NewRateLimiterWithFailOpen(redisClient limiterRedis.Client, key string, rps int, failOpen bool) (*RateLimiter, error) {
    // 1초 단위로 요청 제한(RPS) 설정
    rate := limiter.Rate{
        Period: 1 * time.Second,
        Limit:  int64(rps),
    }

    // Redis를 스토어로 사용하며 'ratelimit' 접두사로 키 관리
    store, err := limiterRedis.NewStoreWithOptions(redisClient, limiter.StoreOptions{
        Prefix:          "ratelimit",
        CleanUpInterval: 0, // Redis TTL에 의존하여 클린업 비활성화
    })
    if err != nil {
        return nil, err
    }

    return &RateLimiter{
        limiter:  limiter.New(store, rate),
        key:      key,
        failOpen: failOpen,
    }, nil
}

func (l *RateLimiter) Allow(ctx context.Context) (bool, error) {
    // Redis Lua 스크립트를 호출하여 원자적(Atomic)으로 토큰 차감
    limiterCtx, err := l.limiter.Get(ctx, l.key)
    if err != nil {
        // [Fail-Open 전략] Redis 연결 오류 시 서비스 지속 여부 결정
        return l.failOpen, err
    }
    return !limiterCtx.Reached, nil
}

package client

import (
    "context"
    "encoding/json"
    "time"
    
    "your-project/metrics"
    "your-project/ratelimiter"
)

type cachedTransactionServiceClient struct {
    client      TransactionServiceClient
    redis       *redis.Client
    rateLimiter *ratelimiter.RateLimiter
}

func NewCachedTransactionServiceClient(
    client TransactionServiceClient,
    redis *redis.Client,
    redisForRateLimit *redis.Client,
) *cachedTransactionServiceClient {
    // failOpen=false로 설정하여, Redis 문제 시 업스트림 서버를 엄격히 보호
    rateLimiter, _ := ratelimiter.NewRateLimiterWithFailOpen(
        redisForRateLimit,
        "transaction_service",
        50, // 초당 50개 요청으로 제한
        false, // Redis 장애 시 차단 (보호 우선)
    )
    
    return &cachedTransactionServiceClient{
        client:      client,
        redis:       redis,
        rateLimiter: rateLimiter,
    }
}

func (c *cachedTransactionServiceClient) GetTrustScoreFromHistory(ctx context.Context, userId int64) (*TrustScore, error) {
    cacheKey := fmt.Sprintf("transaction_trust_score:%d", userId)
    
    // 1. 캐시 우선 조회 (캐시 히트 시 Rate Limit 소모 없음 - 업스트림 서비스 보호)
    val, err := c.redis.Get(ctx, cacheKey).Result()
    if err == nil {
        var trustScore TrustScore
        if json.Unmarshal([]byte(val), &trustScore) == nil {
            metrics.RecordCacheHit("transaction_service_client")
            return &trustScore, nil
        }
    }

    // 2. 캐시 미스 시 Rate Limiter 작동
    allowed, err := c.rateLimiter.Allow(ctx)
    if !allowed {
        // 차단된 요청은 메트릭으로 기록하여 모니터링
        metrics.RecordRateLimitExceeded("transaction_service_client")
        return nil, status.Error(codes.ResourceExhausted, "rate limit exceeded")
    }

    // 3. 실제 업스트림 서비스 호출
    result, err := c.client.GetTrustScoreFromHistory(ctx, userId)
    if err != nil {
        return nil, err
    }
    
    // 4. 호출 성공 시 결과를 비동기로 캐시에 저장
    go func() {
        if data, err := json.Marshal(result); err == nil {
            c.redis.Set(context.Background(), cacheKey, data, 5*time.Minute)
        }
    }()
    
    return result, nil
}

// Transaction Service: 장애 시 차단 (보호 우선)
rateLimiter := ratelimiter.NewRateLimiterWithFailOpen(
    redis,
    "transaction_service", 
    50,    // RPS
    false, // Redis 장애 시 차단
)

// Network Service: 장애 시 통과 (가용성 우선)  
rateLimiter := ratelimiter.NewRateLimiterWithFailOpen(
    redis,
    "network_service",
    200,  // RPS
    true, // Redis 장애 시 통과
)

package metrics

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    rateLimitExceededCounter = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "rate_limit_exceeded_total",
            Help: "Total number of requests that were rate limited",
        },
        []string{"service"},
    )
    
    failOpenCounter = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "rate_limit_fail_open_total", 
            Help: "Total number of requests that passed due to Redis failure",
        },
        []string{"service"},
    )
)

func RecordRateLimitExceeded(service string) {
    rateLimitExceededCounter.WithLabelValues(service).Inc()
}

func RecordFailOpen(service string) {
    failOpenCounter.WithLabelValues(service).Inc()
}