모놀리식에서 MSA로: 전환 여정과 교훈

-- Before: 모놀리식 DB
CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    user_id BIGINT,
    product_id BIGINT,
    FOREIGN KEY (user_id) REFERENCES users(id),
    FOREIGN KEY (product_id) REFERENCES products(id)
);
 
-- After: 마이크로서비스 DB
-- Order Service DB
CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    user_id BIGINT,  -- 외래 키 제약 없음
    product_id BIGINT  -- 외래 키 제약 없음
);

@Configuration
public class GatewayConfig {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user-service", r -> r
                .path("/api/users/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .circuitBreaker(c -> c
                        .setName("userServiceCircuitBreaker")
                        .setFallbackUri("forward:/fallback/users")))
                .uri("lb://user-service"))
            
            .route("product-service", r -> r
                .path("/api/products/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .addRequestHeader("X-Gateway", "true"))
                .uri("lb://product-service"))
            
            .route("order-service", r -> r
                .path("/api/orders/**")
                .filters(f -> f.stripPrefix(1))
                .uri("lb://order-service"))
            
            .build();
    }
}

@FeignClient(name = "product-service")
public interface ProductClient {
    
    @GetMapping("/products/{id}")
    ProductResponse getProduct(@PathVariable Long id);
    
    @PostMapping("/products/{id}/stock/decrease")
    void decreaseStock(@PathVariable Long id, @RequestParam int quantity);
}
 
@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final ProductClient productClient;
    
    public Order createOrder(CreateOrderRequest request) {
        // 상품 정보 조회
        ProductResponse product = productClient.getProduct(request.getProductId());
        
        // 재고 감소
        productClient.decreaseStock(request.getProductId(), request.getQuantity());
        
        // 주문 생성
        return orderRepository.save(new Order(request));
    }
}

@Configuration
public class KafkaConfig {
    
    @Bean
    public NewTopic orderCreatedTopic() {
        return TopicBuilder.name("order-created")
            .partitions(3)
            .replicas(2)
            .build();
    }
}
 
// Producer (Order Service)
@Service
@RequiredArgsConstructor
public class OrderEventPublisher {
    
    private final KafkaTemplate<String, OrderCreatedEvent> kafkaTemplate;
    
    public void publishOrderCreated(Order order) {
        OrderCreatedEvent event = new OrderCreatedEvent(
            order.getId(),
            order.getUserId(),
            order.getTotalAmount()
        );
        
        kafkaTemplate.send("order-created", event);
    }
}
 
// Consumer (Payment Service)
@Service
public class OrderEventConsumer {
    
    @KafkaListener(topics = "order-created", groupId = "payment-service")
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 결제 처리 로직
        processPayment(event);
    }
}

// Order Service
@Service
@RequiredArgsConstructor
public class OrderSagaOrchestrator {
    
    private final KafkaTemplate<String, Object> kafkaTemplate;
    
    @Transactional
    public void createOrder(CreateOrderRequest request) {
        // 1. 주문 생성 (Pending 상태)
        Order order = orderRepository.save(Order.pending(request));
        
        // 2. 재고 확인 이벤트 발행
        kafkaTemplate.send("check-inventory", new CheckInventoryEvent(order));
    }
    
    @KafkaListener(topics = "inventory-checked")
    public void handleInventoryChecked(InventoryCheckedEvent event) {
        if (event.isAvailable()) {
            // 3. 결제 요청 이벤트 발행
            kafkaTemplate.send("process-payment", new ProcessPaymentEvent(event.getOrderId()));
        } else {
            // 재고 부족 - 주문 취소
            cancelOrder(event.getOrderId());
        }
    }
    
    @KafkaListener(topics = "payment-processed")
    public void handlePaymentProcessed(PaymentProcessedEvent event) {
        if (event.isSuccess()) {
            // 4. 주문 확정
            confirmOrder(event.getOrderId());
        } else {
            // 결제 실패 - 보상 트랜잭션
            compensateOrder(event.getOrderId());
        }
    }
}

# order-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
      - name: order-service
        image: myregistry/order-service:1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        - name: SPRING_DATASOURCE_URL
          valueFrom:
            secretKeyRef:
              name: order-db-secret
              key: url
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 20
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  selector:
    app: order-service
  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP