모놀리스에서 마이크로서비스로: MSA 전환 실전 전략

// 주문 서비스 - 자체 DB 사용
@Configuration
public class OrderDataSourceConfig {

    @Bean
    @ConfigurationProperties("spring.datasource.order")
    public DataSource orderDataSource() {
        return DataSourceBuilder.create().build();
    }
}

// 공유 데이터가 필요한 경우 → API 호출로 해결
@Service
public class OrderService {

    private final ProductClient productClient;

    public Mono<OrderResponse> createOrder(OrderRequest request) {
        // 상품 정보는 Product 서비스에서 API로 조회
        return productClient.getProduct(request.getProductId())
                .flatMap(product -> {
                    Order order = Order.create(request, product.getPrice());
                    return orderRepository.save(order);
                })
                .map(OrderResponse::from);
    }
}

@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRoutes(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("order-service", r -> r
                        .path("/api/orders/**")
                        .filters(f -> f
                                .stripPrefix(1)
                                .addRequestHeader("X-Gateway", "true")
                                .retry(config -> config
                                        .setRetries(3)
                                        .setStatuses(HttpStatus.SERVICE_UNAVAILABLE))
                                .circuitBreaker(config -> config
                                        .setName("orderCircuitBreaker")
                                        .setFallbackUri("forward:/fallback/orders")))
                        .uri("lb://ORDER-SERVICE"))
                .route("payment-service", r -> r
                        .path("/api/payments/**")
                        .filters(f -> f
                                .stripPrefix(1)
                                .requestRateLimiter(config -> config
                                        .setRateLimiter(redisRateLimiter())))
                        .uri("lb://PAYMENT-SERVICE"))
                .build();
    }

    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20); // 초당 10건, 버스트 20건
    }
}

@Component
public class JwtAuthenticationFilter implements GatewayFilter {

    private final JwtTokenProvider tokenProvider;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = extractToken(exchange.getRequest());

        if (token == null) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }

        return tokenProvider.validateToken(token)
                .flatMap(claims -> {
                    exchange.getRequest().mutate()
                            .header("X-User-Id", claims.getUserId())
                            .header("X-User-Role", claims.getRole())
                            .build();
                    return chain.filter(exchange);
                })
                .onErrorResume(e -> {
                    exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                    return exchange.getResponse().setComplete();
                });
    }
}

// Spring Boot 3.x + Micrometer Tracing
// application.yml
management:
  tracing:
    sampling:
      probability: 1.0  # 개발 환경에서는 100%
  zipkin:
    tracing:
      endpoint: "https://YOUR_ZIPKIN_HOST/api/v2/spans"

// 커스텀 스팬 추가
@Service
public class OrderService {

    private final Tracer tracer;

    public Mono<Order> createOrder(OrderRequest request) {
        Span span = tracer.nextSpan().name("create-order").start();

        return Mono.defer(() -> {
            span.tag("order.type", request.getType());
            span.event("validation-start");

            return validateOrder(request)
                    .flatMap(this::processPayment)
                    .flatMap(this::saveOrder)
                    .doOnSuccess(order -> {
                        span.tag("order.id", order.getId().toString());
                        span.event("order-created");
                    })
                    .doOnError(e -> span.error(e))
                    .doFinally(signal -> span.end());
        }).contextWrite(Context.of(Span.class, span));
    }
}

@Configuration
public class CircuitBreakerConfig {

    @Bean
    public Customizer<Resilience4JCircuitBreakerFactory> defaultCustomizer() {
        return factory -> factory.configureDefault(id ->
                new Resilience4JConfigBuilder(id)
                        .circuitBreakerConfig(io.github.resilience4j.circuitbreaker.CircuitBreakerConfig
                                .custom()
                                .failureRateThreshold(50)        // 50% 실패 시 차단
                                .waitDurationInOpenState(Duration.ofSeconds(30))
                                .slidingWindowSize(10)            // 최근 10건 기준
                                .minimumNumberOfCalls(5)          // 최소 5건 이후 판단
                                .permittedNumberOfCallsInHalfOpenState(3)
                                .build())
                        .timeLimiterConfig(TimeLimiterConfig.custom()
                                .timeoutDuration(Duration.ofSeconds(3))
                                .build())
                        .build());
    }
}

@Service
public class PaymentService {

    private final CircuitBreakerFactory circuitBreakerFactory;
    private final PaymentClient paymentClient;

    public Mono<PaymentResponse> processPayment(PaymentRequest request) {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("payment");

        return Mono.fromCallable(() ->
                circuitBreaker.run(
                    () -> paymentClient.charge(request),
                    throwable -> fallbackPayment(request, throwable)
                ));
    }

    private PaymentResponse fallbackPayment(PaymentRequest request, Throwable t) {
        log.warn("Payment service unavailable, using fallback: {}", t.getMessage());
        return PaymentResponse.pending(request.getOrderId(),
                "결제 서비스 일시 장애. 잠시 후 재시도됩니다.");
    }
}

// 서비스별 스레드 풀 격리
@Bean
public Customizer<Resilience4JCircuitBreakerFactory> bulkheadCustomizer() {
    return factory -> factory.configure(builder ->
            builder.circuitBreakerConfig(CircuitBreakerConfig.ofDefaults()),
            "payment", "inventory");
}

// 세마포어 기반 Bulkhead
BulkheadConfig bulkheadConfig = BulkheadConfig.custom()
        .maxConcurrentCalls(25)           // 최대 동시 호출 25건
        .maxWaitDuration(Duration.ofMillis(500))
        .build();

Bulkhead paymentBulkhead = Bulkhead.of("payment", bulkheadConfig);