Resilience4j — 서킷 브레이커, 리트라이, 벌크헤드로 장애를 격리하는 방법

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

         실패율 ≥ 임계값
  CLOSED ──────────────→ OPEN
    ↑                      │
    │ 성공률 ≥ 임계값      │ 대기 시간 경과
    │                      ↓
    └──────────────── HALF_OPEN
         실패율 ≥ 임계값 → OPEN

resilience4j:
  circuitbreaker:
    instances:
      paymentService:
        slidingWindowType: COUNT_BASED
        slidingWindowSize: 10           # 최근 10개 요청 기준
        failureRateThreshold: 50         # 실패율 50% 이상이면 OPEN
        waitDurationInOpenState: 30s     # OPEN 상태 유지 시간
        permittedNumberOfCallsInHalfOpenState: 5  # HALF_OPEN에서 허용할 요청 수
        minimumNumberOfCalls: 5          # 최소 5번은 호출해야 판단
        recordExceptions:
          - java.io.IOException
          - java.util.concurrent.TimeoutException
        ignoreExceptions:
          - com.example.BusinessException  # 비즈니스 예외는 실패로 카운트하지 않음

@Service
public class PaymentService {

    private final PaymentClient paymentClient;

    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    public PaymentResult processPayment(PaymentRequest request) {
        return paymentClient.pay(request);
    }

    // Fallback 메서드 — 파라미터 + Throwable
    private PaymentResult paymentFallback(PaymentRequest request, Throwable t) {
        log.warn("결제 서비스 장애로 Fallback 실행: {}", t.getMessage());
        return PaymentResult.pending(request.getOrderId(),
                "결제 서비스가 일시적으로 이용 불가합니다. 잠시 후 자동으로 재시도됩니다.");
    }
}

resilience4j:
  retry:
    instances:
      paymentService:
        maxAttempts: 3                # 최대 3번 시도
        waitDuration: 1s               # 재시도 간격
        exponentialBackoffMultiplier: 2 # 지수 백오프 (1s → 2s → 4s)
        retryExceptions:
          - java.io.IOException
          - java.util.concurrent.TimeoutException
        ignoreExceptions:
          - com.example.BusinessException

@Retry(name = "paymentService", fallbackMethod = "retryFallback")
public PaymentResult processPayment(PaymentRequest request) {
    return paymentClient.pay(request);
}

@CircuitBreaker(name = "paymentService", fallbackMethod = "fallback")
@Retry(name = "paymentService")
public PaymentResult processPayment(PaymentRequest request) {
    return paymentClient.pay(request);
}

resilience4j:
  ratelimiter:
    instances:
      externalApi:
        limitForPeriod: 100           # 주기당 허용 요청 수
        limitRefreshPeriod: 1s         # 갱신 주기
        timeoutDuration: 500ms         # 허용 대기 시간

@RateLimiter(name = "externalApi")
public ExternalData callExternalApi() {
    return externalClient.getData();
}

resilience4j:
  bulkhead:
    instances:
      paymentService:
        maxConcurrentCalls: 20        # 최대 동시 호출 20개
        maxWaitDuration: 500ms         # 대기 시간

@Bulkhead(name = "paymentService")
public PaymentResult processPayment(PaymentRequest request) {
    return paymentClient.pay(request);
}

resilience4j:
  thread-pool-bulkhead:
    instances:
      paymentService:
        maxThreadPoolSize: 10
        coreThreadPoolSize: 5
        queueCapacity: 20

resilience4j:
  timelimiter:
    instances:
      paymentService:
        timeoutDuration: 3s            # 3초 타임아웃
        cancelRunningFuture: true      # 타임아웃 시 실행 중인 Future 취소

@TimeLimiter(name = "paymentService")
@CircuitBreaker(name = "paymentService", fallbackMethod = "fallback")
public CompletableFuture<PaymentResult> processPaymentAsync(PaymentRequest request) {
    return CompletableFuture.supplyAsync(() -> paymentClient.pay(request));
}

management:
  endpoints:
    web:
      exposure:
        include: health, circuitbreakers, retries
  health:
    circuitbreakers:
      enabled: true

GET /actuator/circuitbreakers
GET /actuator/circuitbreakerevents

@Service
public class OrderService {

    // 결제: 재시도 → 서킷 브레이커 → 타임아웃
    @TimeLimiter(name = "payment")
    @CircuitBreaker(name = "payment", fallbackMethod = "paymentFallback")
    @Retry(name = "payment")
    @Bulkhead(name = "payment")
    public CompletableFuture<PaymentResult> processPayment(PaymentRequest request) {
        return CompletableFuture.supplyAsync(() -> paymentClient.pay(request));
    }

    // Fallback
    private CompletableFuture<PaymentResult> paymentFallback(
            PaymentRequest request, Throwable t) {
        log.warn("결제 Fallback: {}", t.getMessage());
        return CompletableFuture.completedFuture(
                PaymentResult.pending(request.getOrderId()));
    }
}