サーキットブレーカーとレジリエンスパターン実践ガイド — Resilience4j、Istio、障害分離戦略

              失敗率 >= 閾値 (failureRateThreshold)
    +---------------------------------------------+
    |                                             |
    v                                             |
+----------+                                 +----------+
|          |     試行呼び出し成功率 >= 閾値     |          |
|   OPEN   | <- - - - - - - - - - - - - - -- |  CLOSED  |
|  (遮断)   |                                 |  (正常)   |
+----------+                                 +----------+
     |                                            ^
     | waitDurationInOpenState 経過                |
     v                                            |
+--------------+    試行呼び出し成功               |
|  HALF-OPEN   | ---------------------------------+
|  (試行許可)  |
+--------------+
     |
     | 試行呼び出し失敗
     v
+----------+
|   OPEN   |  (再び遮断)
+----------+

// build.gradle (Spring Boot 3.x)
dependencies {
    implementation 'io.github.resilience4j:resilience4j-spring-boot3:2.2.0'
    implementation 'io.github.resilience4j:resilience4j-micrometer:2.2.0'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-aop'
}

resilience4j:
  circuitbreaker:
    instances:
      paymentService:
        registerHealthIndicator: true
        slidingWindowType: COUNT_BASED
        slidingWindowSize: 10
        minimumNumberOfCalls: 5
        failureRateThreshold: 50
        waitDurationInOpenState: 10s
        permittedNumberOfCallsInHalfOpenState: 3
        slowCallDurationThreshold: 2s
        slowCallRateThreshold: 80
        recordExceptions:
          - java.io.IOException
          - java.util.concurrent.TimeoutException
          - org.springframework.web.client.HttpServerErrorException
        ignoreExceptions:
          - com.example.BusinessException

  retry:
    instances:
      paymentService:
        maxAttempts: 3
        waitDuration: 500ms
        enableExponentialBackoff: true
        exponentialBackoffMultiplier: 2
        retryExceptions:
          - java.io.IOException
          - java.util.concurrent.TimeoutException

  bulkhead:
    instances:
      paymentService:
        maxConcurrentCalls: 20
        maxWaitDuration: 500ms

  timelimiter:
    instances:
      paymentService:
        timeoutDuration: 3s
        cancelRunningFuture: true

  ratelimiter:
    instances:
      paymentService:
        limitRefreshPeriod: 1s
        limitForPeriod: 50
        timeoutDuration: 0s

@Service
@Slf4j
public class PaymentService {

    private final PaymentGatewayClient paymentGatewayClient;
    private final PaymentCacheService paymentCacheService;

    public PaymentService(PaymentGatewayClient paymentGatewayClient,
                          PaymentCacheService paymentCacheService) {
        this.paymentGatewayClient = paymentGatewayClient;
        this.paymentCacheService = paymentCacheService;
    }

    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    @Bulkhead(name = "paymentService")
    @Retry(name = "paymentService")
    @TimeLimiter(name = "paymentService")
    public CompletableFuture<PaymentResponse> processPayment(PaymentRequest request) {
        return CompletableFuture.supplyAsync(() -> {
            log.info("決済リクエスト処理中: orderId={}", request.getOrderId());
            return paymentGatewayClient.charge(request);
        });
    }

    // フォールバックメソッド：サーキットがOPENまたは例外発生時に呼び出し
    private CompletableFuture<PaymentResponse> paymentFallback(
            PaymentRequest request, Throwable throwable) {
        log.warn("決済サービスフォールバック実行: orderId={}, reason={}",
                request.getOrderId(), throwable.getMessage());

        if (throwable instanceof CallNotPermittedException) {
            // サーキットが開いた状態 - キューに保存して非同期処理
            return CompletableFuture.completedFuture(
                PaymentResponse.queued(request.getOrderId(),
                    "決済サービス一時障害。注文がキューに登録されました。")
            );
        }

        // その他の例外 - キャッシュされた結果を返却試行
        return CompletableFuture.completedFuture(
            paymentCacheService.getCachedResponse(request.getOrderId())
                .orElse(PaymentResponse.error(request.getOrderId(),
                    "決済処理中にエラーが発生しました。しばらく後に再度お試しください。"))
        );
    }
}

Retry ( CircuitBreaker ( RateLimiter ( TimeLimiter ( Bulkhead ( Function ) ) ) ) )

apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: payment-service-circuit-breaker
  namespace: production
spec:
  host: payment-service.production.svc.cluster.local
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100 # 最大TCP接続数
        connectTimeout: 3s # TCP接続タイムアウト
      http:
        h2UpgradePolicy: DEFAULT
        http1MaxPendingRequests: 50 # 待機中のHTTPリクエスト最大数
        http2MaxRequests: 100 # アクティブHTTP/2リクエスト最大数
        maxRequestsPerConnection: 10 # 接続あたり最大リクエスト数
        maxRetries: 3 # 最大リトライ回数
    outlierDetection:
      consecutive5xxErrors: 5 # 連続5xxエラー5回で除去
      interval: 10s # 分析間隔
      baseEjectionTime: 30s # 最小除去時間
      maxEjectionPercent: 50 # 最大除去比率（50%）
      minHealthPercent: 30 # 最小正常インスタンス比率

# ThreadPool Bulkhead設定
resilience4j:
  thread-pool-bulkhead:
    instances:
      inventoryService:
        maxThreadPoolSize: 10
        coreThreadPoolSize: 5
        queueCapacity: 20
        keepAliveDuration: 100ms
        writableStackTraceEnabled: true

@Service
public class OrderOrchestrator {

    @Bulkhead(name = "paymentService", type = Bulkhead.Type.SEMAPHORE)
    public PaymentResult processPayment(Order order) {
        return paymentClient.charge(order.getPaymentInfo());
    }

    @Bulkhead(name = "inventoryService", type = Bulkhead.Type.THREADPOOL)
    public CompletableFuture<InventoryResult> reserveInventory(Order order) {
        return CompletableFuture.supplyAsync(() ->
            inventoryClient.reserve(order.getItems()));
    }

    @Bulkhead(name = "notificationService", type = Bulkhead.Type.SEMAPHORE)
    public void sendNotification(Order order) {
        notificationClient.send(order.getUserId(), "ご注文を承りました。");
    }
}

@Configuration
public class ResilienceConfig {

    @Bean
    public Supplier<String> resilientSupplier(
            CircuitBreakerRegistry circuitBreakerRegistry,
            RetryRegistry retryRegistry,
            BulkheadRegistry bulkheadRegistry,
            RateLimiterRegistry rateLimiterRegistry) {

        CircuitBreaker circuitBreaker = circuitBreakerRegistry
                .circuitBreaker("externalApi");
        Retry retry = retryRegistry.retry("externalApi");
        Bulkhead bulkhead = bulkheadRegistry.bulkhead("externalApi");
        RateLimiter rateLimiter = rateLimiterRegistry
                .rateLimiter("externalApi");

        // デコレーターチェーニング：内側から外側に適用
        Supplier<String> decoratedSupplier = Decorators
                .ofSupplier(() -> externalApiClient.call())
                .withBulkhead(bulkhead)           // 1. 同時呼び出し制限
                .withRateLimiter(rateLimiter)      // 2. レート制限
                .withCircuitBreaker(circuitBreaker) // 3. 失敗検知/遮断
                .withRetry(retry)                   // 4. リトライ
                .withFallback(Arrays.asList(
                    CallNotPermittedException.class,
                    BulkheadFullException.class,
                    RequestNotPermitted.class),
                    throwable -> "Fallback Response")
                .decorate();

        return decoratedSupplier;
    }
}

@Service
@Slf4j
public class ProductRecommendationService {

    private final RecommendationEngine primaryEngine;
    private final RecommendationEngine secondaryEngine;
    private final RedisTemplate<String, List<Product>> cache;

    @CircuitBreaker(name = "recommendation",
                    fallbackMethod = "secondaryRecommendation")
    public List<Product> getRecommendations(String userId) {
        return primaryEngine.recommend(userId);
    }

    // 1次フォールバック：補助レコメンドエンジンを使用
    private List<Product> secondaryRecommendation(
            String userId, Throwable t) {
        log.warn("1次レコメンドエンジン障害、補助エンジンに切替: {}", t.getMessage());
        try {
            return secondaryEngine.recommend(userId);
        } catch (Exception e) {
            return cachedRecommendation(userId, e);
        }
    }

    // 2次フォールバック：キャッシュされたレコメンド結果を返却
    private List<Product> cachedRecommendation(
            String userId, Throwable t) {
        log.warn("補助レコメンドエンジンも障害、キャッシュ参照: {}", t.getMessage());
        List<Product> cached = cache.opsForValue()
                .get("recommendation:" + userId);
        if (cached != null && !cached.isEmpty()) {
            return cached;
        }
        return defaultRecommendation(userId, t);
    }

    // 3次フォールバック：人気商品デフォルトリストを返却
    private List<Product> defaultRecommendation(
            String userId, Throwable t) {
        log.warn("キャッシュもなし、デフォルト人気商品を返却");
        return List.of(
            Product.popular("BEST-001", "ベストセラー商品A"),
            Product.popular("BEST-002", "ベストセラー商品B"),
            Product.popular("BEST-003", "ベストセラー商品C")
        );
    }
}

// 削除
// implementation 'org.springframework.cloud:spring-cloud-starter-netflix-hystrix'

// 追加
implementation 'io.github.resilience4j:resilience4j-spring-boot3:2.2.0'
implementation 'io.github.resilience4j:resilience4j-micrometer:2.2.0'

resilience4j:
  retry:
    instances:
      paymentGateway:
        maxAttempts: 3
        waitDuration: 1s
        enableExponentialBackoff: true
        exponentialBackoffMultiplier: 2
        enableRandomizedWait: true # jitter有効化
        randomizedWaitFactor: 0.5 # 50%範囲内でランダム化

#!/bin/bash
# circuit-breaker-recovery.sh
# サーキットブレーカー障害復旧手順スクリプト

echo "===== サーキットブレーカー状態確認 ====="
# Actuatorエンドポイントでサーキットブレーカー状態確認
curl -s http://localhost:8080/actuator/circuitbreakers | jq '.circuitBreakers'

echo ""
echo "===== ダウンストリームサービスヘルスチェック ====="
curl -s http://payment-service:8080/actuator/health | jq '.status'
curl -s http://inventory-service:8080/actuator/health | jq '.status'

echo ""
echo "===== サーキットブレーカー強制クローズ（ダウンストリーム復旧確認後） ====="
# 注意：ダウンストリームサービスが完全に復旧した後にのみ実行
# curl -X POST http://localhost:8080/actuator/circuitbreakers/paymentService/close

echo ""
echo "===== 現在のメトリクス確認 ====="
curl -s http://localhost:8080/actuator/metrics/resilience4j.circuitbreaker.state | jq '.'
curl -s http://localhost:8080/actuator/metrics/resilience4j.circuitbreaker.failure.rate | jq '.'

echo ""
echo "===== Istio Outlier Detection状態確認 ====="
kubectl get destinationrules -n production
kubectl describe destinationrule payment-service-circuit-breaker -n production

# Prometheusスクレイプ設定
scrape_configs:
  - job_name: 'spring-boot-resilience4j'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['payment-service:8080']
        labels:
          application: 'payment-service'

# Grafana Alert Rule（プロビジョニング）
groups:
  - name: circuit-breaker-alerts
    rules:
      - alert: CircuitBreakerOpen
        expr: resilience4j_circuitbreaker_state{state="open"} == 1
        for: 10s
        labels:
          severity: critical
        annotations:
          summary: 'サーキットブレーカーOPEN - {{ $labels.name }}'
          description: >
            {{ $labels.application }}の{{ $labels.name }}
            サーキットブレーカーがOPEN状態です。
            直ちにダウンストリームサービスの状態を確認してください。

      - alert: HighFailureRate
        expr: resilience4j_circuitbreaker_failure_rate > 40
        for: 30s
        labels:
          severity: warning
        annotations:
          summary: '高い失敗率を検知 - {{ $labels.name }}'
          description: >
            {{ $labels.name }}の失敗率が{{ $value }}%です。
            サーキットが開く前に原因を特定してください。

# Istioメッシュ内のサービス状態確認
istioctl proxy-config cluster <pod-name> -n production | grep outlier

# Envoy統計確認
kubectl exec -it <pod-name> -n production -c istio-proxy -- \
  curl localhost:15000/stats | grep outlier_detection

# Kialiダッシュボードアクセス
istioctl dashboard kiali