マイクロサービスアーキテクチャ：DXを成功に導く設計パターンとアンチパターン

開始
 |
 ↓
[ビジネス要件の評価]
 | 高速イテレーションやスケール要求が高いか？
 |    Yes ↓        No → モノリスを検討
 |
[組織評価]
 | DevOps文化や自律的チーム構造があるか？
 |    Yes ↓        No → 組織変革と並行または段階的導入を検討
 |
[技術評価]
 | 分散システム管理の知識・ツールはあるか？
 |    Yes ↓        No → 技術的負債を考慮し能力構築を計画
 |
[既存システム評価]
 | レガシーシステムからの移行が必要か？
 |    Yes → ストラングラーパターンを検討
 |    No ↓        
 |
マイクロサービスアーキテクチャの採用を推奨

// 注文サービスと商品サービスの境界コンテキスト分離例
// 注文サービス内での商品表現
public class OrderItemDto {
    private String productId;
    private String productName;
    private BigDecimal price;
    private int quantity;
    // 注文コンテキストで必要な最小限の商品情報
}

// 商品サービス内での商品表現
public class Product {
    private String id;
    private String name;
    private String description;
    private BigDecimal price;
    private int stockLevel;
    private String manufacturer;
    private List<String> categories;
    private Map<String, String> attributes;
    // 商品コンテキストでの完全な商品情報
}

# Kongゲートウェイ設定例
services:
  - name: customer-service
    url: http://customer-service:8080
    routes:
      - paths: ["/api/customers"]
  - name: order-service
    url: http://order-service:8080
    routes:
      - paths: ["/api/orders"]
  - name: product-service
    url: http://product-service:8080
    routes:
      - paths: ["/api/products"]
    plugins:
      - name: rate-limiting
        config:
          minute: 100
      - name: jwt

// Spring Cloudを使用したサーキットブレーカー実装例
@Service
public class ProductService {
    @CircuitBreaker(name = "inventoryService", fallbackMethod = "getDefaultInventory")
    public InventoryStatus getInventoryStatus(String productId) {
        // 在庫サービスへの呼び出し
        return inventoryClient.checkInventory(productId);
    }
    
    public InventoryStatus getDefaultInventory(String productId, Exception e) {
        // フォールバック：デフォルト値か過去にキャッシュした値を返す
        log.warn("Inventory service failed, using fallback for product: {}", productId);
        return new InventoryStatus(productId, InventoryState.UNKNOWN);
    }
}

// オーケストレーション型サガの例（擬似コード）
class OrderSaga {
  async process(orderId: string) {
    try {
      // 1. 在庫確保
      await this.inventoryService.reserve(orderId);
      
      // 2. 支払い処理
      await this.paymentService.process(orderId);
      
      // 3. 配送準備
      await this.shippingService.prepare(orderId);
      
      // 4. 注文確定
      await this.orderService.confirm(orderId);
      
    } catch (error) {
      // 補償トランザクション（補償処理）を実行
      await this.compensate(orderId, error.step);
      throw error;
    }
  }
  
  async compensate(orderId: string, failedStep: string) {
    switch(failedStep) {
      case 'payment':
        await this.inventoryService.release(orderId);
        break;
      case 'shipping':
        await this.paymentService.refund(orderId);
        await this.inventoryService.release(orderId);
        break;
      // その他の補償処理
    }
  }
}

// CQRS実装例（C#）
// コマンド側（書き込みモデル）
public class CreateOrderCommand : ICommand
{
    public string CustomerId { get; set; }
    public List<OrderItem> Items { get; set; }
    public string ShippingAddress { get; set; }
}

public class CreateOrderHandler : ICommandHandler<CreateOrderCommand>
{
    private readonly IOrderRepository _repository;
    
    public async Task Handle(CreateOrderCommand command)
    {
        var order = new Order(
            Guid.NewGuid(),
            command.CustomerId,
            command.Items,
            command.ShippingAddress);
            
        await _repository.Save(order);
        
        // イベントの発行
        await _eventBus.Publish(new OrderCreatedEvent(order.Id));
    }
}

// クエリ側（読み取りモデル）
public class OrderSummaryQuery : IQuery<List<OrderSummaryDto>>
{
    public string CustomerId { get; set; }
}

public class OrderSummaryHandler : IQueryHandler<OrderSummaryQuery, List<OrderSummaryDto>>
{
    private readonly IOrderReadDbContext _readDb;
    
    public async Task<List<OrderSummaryDto>> Handle(OrderSummaryQuery query)
    {
        // 最適化された読み取り専用モデルからクエリ
        return await _readDb.OrderSummaries
            .Where(o => o.CustomerId == query.CustomerId)
            .OrderByDescending(o => o.OrderDate)
            .ToListAsync();
    }
}

// イベント駆動アーキテクチャの実装例（Kotlin + Spring Cloud Stream）
// イベント発行側
@Service
class OrderService(private val orderStreamSource: OrderStreamSource) {
    
    fun placeOrder(order: Order): OrderResult {
        // 注文処理ロジック
        val savedOrder = orderRepository.save(order)
        
        // イベント発行
        val orderPlacedEvent = OrderPlacedEvent(
            orderId = savedOrder.id,
            customerId = savedOrder.customerId,
            items = savedOrder.items,
            totalAmount = savedOrder.totalAmount,
            timestamp = Instant.now()
        )
        
        orderStreamSource.orderPlacedChannel().send(MessageBuilder.withPayload(orderPlacedEvent).build())
        
        return OrderResult(savedOrder.id, "処理完了")
    }
}

// イベント購読側
@Service
class InventoryService {
    
    @StreamListener(InventoryStreamSink.ORDER_PLACED_INPUT)
    fun handleOrderPlaced(orderPlacedEvent: OrderPlacedEvent) {
        // 在庫更新処理
        orderPlacedEvent.items.forEach { item ->
            inventoryRepository.reduceStock(item.productId, item.quantity)
        }
        
        // 在庫不足の場合は別イベントを発行して処理
    }
}

// Akkaを使用したバックプレッシャー実装例（Scala）
val orderProcessingFlow = Flow[Order]
  .throttle(
    elements = 100,
    per = 1.minute,
    maximumBurst = 20,
    mode = ThrottleMode.shaping
  )
  .mapAsync(parallelism = 10) { order =>
    orderProcessor.process(order)
  }
  .buffer(size = 1000, overflowStrategy = OverflowStrategy.backpressure)

Source(orders)
  .via(orderProcessingFlow)
  .to(Sink.foreach(result => logger.info(s"Processed order: ${result.orderId}")))
  .run()

// ストラングラーパターンを実装するAPIゲートウェイの設定例（Node.js/Express）
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const app = express();

// 新しいマイクロサービスに移行済みの機能へのルーティング
app.use('/api/customers', createProxyMiddleware({ 
  target: 'http://customer-microservice', 
  changeOrigin: true 
}));

app.use('/api/products', createProxyMiddleware({ 
  target: 'http://product-microservice', 
  changeOrigin: true 
}));

// まだ移行していない機能はレガシーシステムへルーティング
app.use('/', createProxyMiddleware({ 
  target: 'http://legacy-monolith', 
  changeOrigin: true 
}));

app.listen(3000);

<!-- マイクロフロントエンド実装例（Web Componentsを使用） -->
<!DOCTYPE html>
<html>
<head>
  <title>ECサイト</title>
  <script src="/js/web-components-loader.js"></script>
</head>
<body>
  <header>
    <!-- Team A担当 -->
    <nav-bar user-id="1234"></nav-bar>
  </header>
  
  <main>
    <!-- Team B担当 -->
    <product-catalog category="electronics"></product-catalog>
    
    <!-- Team C担当 -->
    <shopping-cart id="main-cart"></shopping-cart>
    
    <!-- Team D担当 -->
    <recommendation-panel user-id="1234"></recommendation-panel>
  </main>
  
  <footer>
    <!-- Team E担当 -->
    <company-footer></company-footer>
  </footer>
  
  <script>
    // 各マイクロフロントエンドモジュールの独立したローディングと統合
    MicroFrontends.register('nav-bar', '/team-a/navbar.js');
    MicroFrontends.register('product-catalog', '/team-b/catalog.js');
    MicroFrontends.register('shopping-cart', '/team-c/cart.js');
    MicroFrontends.register('recommendation-panel', '/team-d/recommendations.js');
    MicroFrontends.register('company-footer', '/team-e/footer.js');
  </script>
</body>
</html>

# Kubernetesにおけるサイドカーパターン実装例
apiVersion: v1
kind: Pod
metadata:
  name: order-service
spec:
  containers:
  - name: order-app
    image: mycompany/order-service:1.0
    ports:
    - containerPort: 8080
  - name: log-collector
    image: mycompany/log-collector:1.0
    volumeMounts:
    - name: log-volume
      mountPath: /var/log/app
  - name: metrics-sidecar
    image: mycompany/metrics-exporter:1.0
    ports:
    - containerPort: 9090
  - name: security-scanner
    image: security/vulnerability-scanner:1.0
    volumeMounts:
    - name: app-volume
      mountPath: /app
      readOnly: true
  volumes:
  - name: log-volume
    emptyDir: {}
  - name: app-volume
    emptyDir: {}

// 分散モノリス化した例
// ユーザーサービス内
public class User {
    private Long id;
    private String name;
    private String email;
    // ユーザー情報
    
    @OneToMany(cascade = CascadeType.ALL)
    private List<Order> orders; // 直接的な結合関係
}

// 注文サービスでの参照
@Service
public class OrderService {
    private final UserServiceClient userClient;
    
    public Order placeOrder(Long userId, List<OrderItem> items) {
        // 毎回ユーザーサービスの呼び出しが必要
        User user = userClient.getUserById(userId);
        if (!user.isActive()) {
            throw new UserInactiveException();
        }
        
        // ユーザーと注文が強く結合している
        Order order = new Order(userId, items, user.getAddress());
        return orderRepository.save(order);
    }
}

// ネットワーク過信の例（Node.js）
async function processOrder(orderId) {
  // 複数の同期APIコールが連鎖しており、どれかが失敗すると全体が失敗
  const order = await orderService.getOrder(orderId);
  const customer = await customerService.getCustomer(order.customerId);
  const inventory = await inventoryService.checkAvailability(order.items);
  const payment = await paymentService.processPayment(order.totalAmount, customer.paymentInfo);
  const shipping = await shippingService.createShipment(order, customer.address);
  
  return {
    orderConfirmation: order.confirmationCode,
    paymentConfirmation: payment.transactionId,
    shipmentTracking: shipping.trackingNumber
  };
}

-- シェアードデータベースアンチパターンの例
-- 複数サービスが同じデータベースのテーブルにアクセス

-- ユーザーサービスのクエリ
SELECT * FROM users WHERE id = 123;

-- 注文サービスのクエリ
SELECT o.*, u.name, u.email, u.shipping_address 
FROM orders o 
JOIN users u ON o.user_id = u.id
WHERE o.id = 456;

-- 支払いサービスのクエリ
SELECT p.*, u.name, u.email
FROM payments p
JOIN users u ON p.user_id = u.id
WHERE p.transaction_id = 'txn_789';