マイクロサービスアーキテクチャ2025完全ガイド：モノリスからMSA、そしてモジュラーモノリスへ

+------------------------------------------+
|              Monolith                     |
|  +--------+ +--------+ +--------+        |
|  |  User  | | Order  | |Payment |        |
|  | Module | | Module | | Module |        |
|  +--------+ +--------+ +--------+        |
|  +----------------------------------+    |
|  |        Shared Database           |    |
|  +----------------------------------+    |
+------------------------------------------+

+--------+    +--------+    +--------+
| Service|    | Service|    | Service|
|   A    |    |   B    |    |   C    |
+---+----+    +---+----+    +---+----+
    |             |             |
+---v-------------v-------------v---+
|        Enterprise Service Bus     |
|    (SOAP, WSDL, XML, Routing)     |
+-----------------------------------+

+--------+     +--------+     +--------+
|  User  |     | Order  |     |Payment |
|Service |     |Service |     |Service |
|  DB-A  |     |  DB-B  |     |  DB-C  |
+---+----+     +---+----+     +---+----+
    |              |               |
    v              v               v
  [REST/gRPC]  [Kafka]        [REST/gRPC]

+------------------------------------------+
|           Modular Monolith               |
|  +----------+  +----------+  +--------+  |
|  |   User   |  |  Order   |  |Payment |  |
|  |  Module   |  |  Module  |  | Module |  |
|  | [Schema] |  | [Schema] |  |[Schema]|  |
|  | [API]    |  | [API]    |  | [API]  |  |
|  +----------+  +----------+  +--------+  |
|       |Internal API|   |Internal API|    |
|  +----------------------------------+    |
|  |     Shared Runtime (Single DB)   |    |
|  +----------------------------------+    |
+------------------------------------------+

従来の階層型:
Controllers/ -> Services/ -> Repositories/ -> Models/

Vertical Slice:
Features/
  CreateOrder/
    CreateOrderCommand.cs
    CreateOrderHandler.cs
    CreateOrderValidator.cs
    CreateOrderEndpoint.cs
  GetOrderById/
    GetOrderByIdQuery.cs
    GetOrderByIdHandler.cs
    GetOrderByIdEndpoint.cs

// Vertical Sliceの例 - MediatRパターン
public record CreateOrderCommand(
    string CustomerId,
    List<OrderItem> Items
) : IRequest<OrderResult>;

public class CreateOrderHandler
    : IRequestHandler<CreateOrderCommand, OrderResult>
{
    private readonly OrderDbContext _db;
    private readonly IEventBus _eventBus;

    public CreateOrderHandler(OrderDbContext db, IEventBus eventBus)
    {
        _db = db;
        _eventBus = eventBus;
    }

    public async Task<OrderResult> Handle(
        CreateOrderCommand cmd,
        CancellationToken ct)
    {
        var order = Order.Create(cmd.CustomerId, cmd.Items);
        _db.Orders.Add(order);
        await _db.SaveChangesAsync(ct);

        await _eventBus.Publish(new OrderCreatedEvent(order.Id));
        return new OrderResult(order.Id, order.TotalAmount);
    }
}

// モジュール間通信は必ず公開インターフェースを通じて
// order-module/src/main/java/com/app/order/api/
public interface OrderModuleApi {
    OrderDto getOrder(String orderId);
    OrderDto createOrder(CreateOrderRequest request);
    void cancelOrder(String orderId);
}

// order-module/src/main/java/com/app/order/internal/
// このパッケージのクラスは外部モジュールからアクセス不可
class OrderServiceImpl implements OrderModuleApi {
    private final OrderRepository repository;
    private final PaymentModuleApi paymentModule;

    @Override
    public OrderDto createOrder(CreateOrderRequest request) {
        Order order = Order.create(request);
        repository.save(order);
        paymentModule.initiatePayment(order.getId(), order.getTotal());
        return OrderDto.from(order);
    }
}

// モジュール構造
com.example.app/
  order/           // Orderモジュール（ルートパッケージ）
    OrderService.java
    Order.java
    internal/      // 外部アクセス不可
      OrderRepository.java
      OrderEventHandler.java
  payment/         // Paymentモジュール
    PaymentService.java
    internal/
      PaymentProcessor.java
  inventory/       // Inventoryモジュール
    InventoryService.java

// Spring Modulithイベントベースのモジュール間通信
@Service
@RequiredArgsConstructor
public class OrderService {

    private final ApplicationEventPublisher events;

    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        var order = new Order(request.customerId(), request.items());
        orderRepo.save(order);

        // イベント発行 — Paymentモジュールが非同期で受信
        events.publishEvent(new OrderCreated(order.getId(), order.getTotal()));
        return order;
    }
}

// Paymentモジュールのイベントハンドラー
@Service
public class PaymentEventHandler {

    @ApplicationModuleListener
    public void onOrderCreated(OrderCreated event) {
        paymentService.processPayment(event.orderId(), event.amount());
    }
}

// モジュール構造検証テスト
@Test
void verifyModularStructure() {
    ApplicationModules modules = ApplicationModules.of(Application.class);
    modules.verify(); // 循環依存性、パッケージアクセス違反を検証
}

+----------------+     +------------------+     +----------------+
|   Order BC     |     |   Payment BC     |     | Inventory BC   |
|                |     |                  |     |                |
| - Order        |     | - Payment        |     | - Product      |
| - OrderLine    |     | - Transaction    |     | - Stock        |
| - Customer(ref)|     | - Order(ref)     |     | - Warehouse    |
+-------+--------+     +--------+---------+     +-------+--------+
        |                       |                       |
        +----------- Events ---------------------+------+

[オレンジ] Domain Event: 「注文が作成された」
[青] Command: 「注文作成」
[黄] Aggregate: 「Order」
[ピンク] External System: 「決済ゲートウェイ」
[紫] Policy: 「注文作成時に在庫を減らす」
[赤] Hot Spot: 「決済失敗時の在庫復旧は？」

タイムライン:
注文作成 -> 在庫確認 -> 決済要求 -> 決済完了 -> 出荷開始
                                  -> 決済失敗 -> 在庫復旧 -> 注文キャンセル

// order_service.proto
syntax = "proto3";
package order;

service OrderService {
  // Unary RPC
  rpc CreateOrder(CreateOrderRequest) returns (OrderResponse);
  rpc GetOrder(GetOrderRequest) returns (OrderResponse);

  // Server Streaming
  rpc WatchOrderStatus(GetOrderRequest) returns (stream OrderStatusUpdate);

  // Bidirectional Streaming
  rpc ChatSupport(stream ChatMessage) returns (stream ChatMessage);
}

message CreateOrderRequest {
  string customer_id = 1;
  repeated OrderItem items = 2;
  ShippingAddress shipping_address = 3;
}

message OrderItem {
  string product_id = 1;
  int32 quantity = 2;
  double unit_price = 3;
}

message OrderResponse {
  string order_id = 1;
  OrderStatus status = 2;
  double total_amount = 3;
  google.protobuf.Timestamp created_at = 4;
}

enum OrderStatus {
  ORDER_STATUS_UNSPECIFIED = 0;
  ORDER_STATUS_PENDING = 1;
  ORDER_STATUS_CONFIRMED = 2;
  ORDER_STATUS_SHIPPED = 3;
  ORDER_STATUS_DELIVERED = 4;
  ORDER_STATUS_CANCELLED = 5;
}

// イベント定義
public record OrderCreatedEvent(
    String eventId,
    String orderId,
    String customerId,
    BigDecimal totalAmount,
    List<OrderItemDto> items,
    Instant occurredAt
) {}

// Producer (Order Service)
@Service
@RequiredArgsConstructor
public class OrderEventPublisher {

    private final KafkaTemplate<String, OrderCreatedEvent> kafkaTemplate;

    public void publishOrderCreated(Order order) {
        var event = new OrderCreatedEvent(
            UUID.randomUUID().toString(),
            order.getId(),
            order.getCustomerId(),
            order.getTotalAmount(),
            order.getItems().stream().map(OrderItemDto::from).toList(),
            Instant.now()
        );

        kafkaTemplate.send("order-events", order.getId(), event)
            .whenComplete((result, ex) -> {
                if (ex != null) {
                    log.error("Failed to publish event: {}", ex.getMessage());
                } else {
                    log.info("Event published to partition {} offset {}",
                        result.getRecordMetadata().partition(),
                        result.getRecordMetadata().offset());
                }
            });
    }
}

// Consumer (Payment Service)
@Service
public class PaymentEventConsumer {

    @KafkaListener(
        topics = "order-events",
        groupId = "payment-service",
        containerFactory = "kafkaListenerContainerFactory"
    )
    public void handleOrderCreated(
        @Payload OrderCreatedEvent event,
        @Header(KafkaHeaders.RECEIVED_PARTITION) int partition,
        @Header(KafkaHeaders.OFFSET) long offset
    ) {
        log.info("Received OrderCreated: orderId={}, partition={}, offset={}",
            event.orderId(), partition, offset);

        paymentService.processPayment(event.orderId(), event.totalAmount());
    }
}

+---------------------------------------------+
|                  Service A Pod               |
|  +-------------+     +------------------+   |
|  | Application | --> | Envoy Sidecar    |   |
|  | Container   | <-- | Proxy            |   |
|  +-------------+     +------------------+   |
+---------------------------------------------+
         |  mTLS   |
+---------------------------------------------+
|                  Service B Pod               |
|  +------------------+     +-------------+   |
|  | Envoy Sidecar    | --> | Application |   |
|  | Proxy            | <-- | Container   |   |
|  +------------------+     +-------------+   |
+---------------------------------------------+
         |
+---------------------------------------------+
|            Control Plane (Istiod)            |
| - Certificate Authority (mTLS)              |
| - Configuration Distribution                |
| - Service Discovery                         |
+---------------------------------------------+

# VirtualService - カナリーデプロイ
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
    - order-service
  http:
    - match:
        - headers:
            x-canary:
              exact: "true"
      route:
        - destination:
            host: order-service
            subset: canary
          weight: 100
    - route:
        - destination:
            host: order-service
            subset: stable
          weight: 90
        - destination:
            host: order-service
            subset: canary
          weight: 10
---
# DestinationRule - サブセット定義
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: order-service
spec:
  host: order-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100
      http:
        h2UpgradePolicy: UPGRADE
    outlierDetection:
      consecutive5xxErrors: 5
      interval: 30s
      baseEjectionTime: 30s
  subsets:
    - name: stable
      labels:
        version: v1
    - name: canary
      labels:
        version: v2

Order Service        Payment Service      Inventory Service
     |                      |                      |
     | OrderCreated         |                      |
     |--------------------->|                      |
     |                      | PaymentProcessed     |
     |                      |--------------------->|
     |                      |                      | InventoryReserved
     |                      |                      |----->
     |                      |                      |
     |         [失敗時の補償トランザクション]        |
     |                      |                      |
     |                      | PaymentFailed        |
     |                      |--------------------->|
     |                      |                      | InventoryReleased
     | OrderCancelled       |                      |
     |<---------------------|                      |

          Order Saga Orchestrator
                   |
    +--------------+--------------+
    |              |              |
    v              v              v
Order Service  Payment Service  Inventory Service
  create()     processPayment()  reserveStock()
  cancel()     refund()          releaseStock()

// Temporal Workflow定義
func OrderSagaWorkflow(ctx workflow.Context, input OrderInput) (OrderResult, error) {
    logger := workflow.GetLogger(ctx)
    var result OrderResult

    activityOpts := workflow.ActivityOptions{
        StartToCloseTimeout: 30 * time.Second,
        RetryPolicy: &temporal.RetryPolicy{
            InitialInterval:    time.Second,
            BackoffCoefficient: 2.0,
            MaximumInterval:    time.Minute,
            MaximumAttempts:    3,
        },
    }
    ctx = workflow.WithActivityOptions(ctx, activityOpts)

    // Step 1: 注文作成
    var orderID string
    err := workflow.ExecuteActivity(ctx, CreateOrderActivity, input).Get(ctx, &orderID)
    if err != nil {
        return result, fmt.Errorf("create order failed: %w", err)
    }

    // Step 2: 決済処理
    var paymentID string
    err = workflow.ExecuteActivity(ctx, ProcessPaymentActivity, orderID, input.Amount).Get(ctx, &paymentID)
    if err != nil {
        // 補償トランザクション: 注文キャンセル
        logger.Info("Payment failed, cancelling order", "orderID", orderID)
        _ = workflow.ExecuteActivity(ctx, CancelOrderActivity, orderID).Get(ctx, nil)
        return result, fmt.Errorf("payment failed: %w", err)
    }

    // Step 3: 在庫確保
    err = workflow.ExecuteActivity(ctx, ReserveInventoryActivity, orderID, input.Items).Get(ctx, nil)
    if err != nil {
        // 補償トランザクション: 返金 + 注文キャンセル
        logger.Info("Inventory reservation failed, compensating", "orderID", orderID)
        _ = workflow.ExecuteActivity(ctx, RefundPaymentActivity, paymentID).Get(ctx, nil)
        _ = workflow.ExecuteActivity(ctx, CancelOrderActivity, orderID).Get(ctx, nil)
        return result, fmt.Errorf("inventory reservation failed: %w", err)
    }

    result = OrderResult{
        OrderID:   orderID,
        PaymentID: paymentID,
        Status:    "CONFIRMED",
    }
    return result, nil
}

-- Outboxテーブル
CREATE TABLE outbox_events (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    aggregate_type VARCHAR(255) NOT NULL,
    aggregate_id VARCHAR(255) NOT NULL,
    event_type VARCHAR(255) NOT NULL,
    payload JSONB NOT NULL,
    created_at TIMESTAMP DEFAULT NOW(),
    published_at TIMESTAMP NULL
);

// Outboxパターン実装
@Service
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepo;
    private final OutboxRepository outboxRepo;

    @Transactional // 注文保存とイベント保存が一つのトランザクション
    public Order createOrder(CreateOrderRequest request) {
        Order order = Order.create(request);
        orderRepo.save(order);

        OutboxEvent event = OutboxEvent.builder()
            .aggregateType("Order")
            .aggregateId(order.getId())
            .eventType("OrderCreated")
            .payload(toJson(new OrderCreatedEvent(order)))
            .build();
        outboxRepo.save(event);

        return order;
    }
}

+---------------------------------------------------+
|                  Observability                    |
|                                                   |
|  +--------+    +---------+    +---------+         |
|  | Logs   |    | Metrics |    | Traces  |         |
|  | (What) |    | (How)   |    | (Where) |         |
|  +--------+    +---------+    +---------+         |
|                                                   |
|  「エラー発生」「遅延増加」 「どこで遅い？」         |
+---------------------------------------------------+

# otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:
    send_batch_size: 1024
    timeout: 5s

exporters:
  prometheusremotewrite:
    endpoint: "http://prometheus:9090/api/v1/write"
  otlp/jaeger:
    endpoint: "jaeger:4317"
    tls:
      insecure: true
  loki:
    endpoint: "http://loki:3100/loki/api/v1/push"

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp/jaeger]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheusremotewrite]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [loki]

// Spring Boot + OpenTelemetry自動計装
@Service
public class OrderService {

    private final Tracer tracer;

    public Order createOrder(CreateOrderRequest request) {
        Span span = tracer.spanBuilder("createOrder")
            .setAttribute("order.customer_id", request.getCustomerId())
            .setAttribute("order.item_count", request.getItems().size())
            .startSpan();

        try (Scope scope = span.makeCurrent()) {
            Order order = processOrder(request);
            span.setAttribute("order.id", order.getId());
            span.setStatus(StatusCode.OK);
            return order;
        } catch (Exception e) {
            span.setStatus(StatusCode.ERROR, e.getMessage());
            span.recordException(e);
            throw e;
        } finally {
            span.end();
        }
    }
}

RED Method（サービスレベルメトリクス）:
- Rate: 秒あたりのリクエスト数
- Errors: エラー率
- Duration: レイテンシパーセンタイル

USE Method（インフラレベルメトリクス）:
- Utilization: CPU/メモリ使用率
- Saturation: キュー深度、待機スレッド数
- Errors: システムエラー数

Client (Web/Mobile/Partner)
         |
         v
+---------------------+
|    API Gateway       |
| - ルーティング       |
| - 認証/認可          |
| - Rate Limiting      |
| - ロードバランシング |
| - キャッシング       |
| - リクエスト変換     |
| - Circuit Breaker    |
+---------------------+
    |       |       |
    v       v       v
  User   Order  Payment
 Service Service Service

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: order-service
spec:
  replicas: 10
  strategy:
    canary:
      steps:
        - setWeight: 5
        - pause:
            duration: 5m
        - analysis:
            templates:
              - templateName: success-rate
        - setWeight: 25
        - pause:
            duration: 10m
        - setWeight: 50
        - pause:
            duration: 10m
        - setWeight: 100
      canaryService: order-service-canary
      stableService: order-service-stable
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: registry.example.com/order-service:v2.1.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: 250m
              memory: 512Mi
            limits:
              cpu: 500m
              memory: 1Gi

Phase 1: プロキシ導入
+--------+     +-------+     +-----------+
| Client | --> | Proxy | --> | Monolith  |
+--------+     +-------+     +-----------+

Phase 2: 一部機能の抽出
+--------+     +-------+---> +-----------+
| Client | --> | Proxy |     | Monolith  |
+--------+     +---+---+     +-----------+
                   |
                   +--------> +-----------+
                              | New User  |
                              | Service   |
                              +-----------+

Phase 3: 段階的な移行完了
+--------+     +-------+---> +-----------+
| Client | --> | Proxy |     | Monolith  | (縮小)
+--------+     +---+---+     +-----------+
                   |
                   +--------> +-----------+
                   |          | User Svc  |
                   +--------> +-----------+
                   |          | Order Svc |
                   +--------> +-----------+
                              | Pay Svc   |
                              +-----------+

// Step 1: 抽象化レイヤー導入
public interface NotificationService {
    void sendEmail(String to, String subject, String body);
    void sendSms(String to, String message);
}

// Step 2: 既存実装のラッピング
public class LegacyNotificationService implements NotificationService {
    private final MonolithNotificationModule legacy;

    public void sendEmail(String to, String subject, String body) {
        legacy.email(to, subject, body);
    }
}

// Step 3: 新実装の開発
public class NewNotificationService implements NotificationService {
    private final EmailClient emailClient;
    private final SmsGateway smsGateway;

    public void sendEmail(String to, String subject, String body) {
        emailClient.send(to, subject, body);
    }
}

// Step 4: Feature Flagで切り替え
@Service
public class NotificationServiceRouter implements NotificationService {

    private final LegacyNotificationService legacy;
    private final NewNotificationService modern;
    private final FeatureFlags flags;

    public void sendEmail(String to, String subject, String body) {
        if (flags.isEnabled("use-new-notification-service")) {
            modern.sendEmail(to, subject, body);
        } else {
            legacy.sendEmail(to, subject, body);
        }
    }
}

悪い例:
Service A --sync--> Service B --sync--> Service C --sync--> Service D
   |                    |                    |
   +------------ 共有データベース -----------+

良い例:
Service A --event--> Service B --event--> Service C
   [DB-A]              [DB-B]              [DB-C]

悪い例:
- User Profile Service
- User Address Service
- User Preference Service
- User Avatar Service
- User Notification Settings Service
-> 5サービス + 5DB + 5CI/CD + 5モニタリング

良い例:
- User Service（Profile, Address, Preference, Avatar統合）
-> 1サービス、内部モジュールで分離

問題:
Client -> API GW -> Auth -> User -> Order -> Inventory -> Payment
全体遅延 = 各サービス遅延の合計
全体可用性 = 各サービス可用性の積
(99.9%)^6 = 99.4%（年間52時間のダウンタイム！）

解決策:
1. 非同期メッセージングに切り替え
2. CQRSで読み取りを最適化
3. 必須パスのみ同期、残りはイベント駆動

開発者1-5名:
  -> モノリス（Simple is best）

開発者5-20名:
  -> モジュラーモノリス（モジュール境界設定）

開発者20-50名:
  -> モジュラーモノリス + コアサービス2-3個分離

開発者50-200名:
  -> MSA（チーム単位のサービスオーナーシップ）

開発者200名+:
  -> MSA + Platform Engineering