適用条件:
✅ 開発チーム規模: 20名以上
✅ 複数チームでの並行開発
✅ 異なる技術スタックの需要
✅ 独立したリリースサイクルの必要性
✅ 高い可用性要件

適用条件:
✅ アプリケーションの複雑性が高い
✅ 異なるスケーリング要件
✅ 明確なドメイン境界が存在
✅ データの独立性が保てる
✅ 分散システムの運用能力

// 現在のモノリシックアプリケーション例
const express = require('express');
const app = express();
// ❌ 問題：全機能が一つのアプリケーションに集約
app.use('/api/users', require('./routes/users'));
app.use('/api/products', require('./routes/products'));
app.use('/api/orders', require('./routes/orders'));
app.use('/api/payments', require('./routes/payments'));
app.use('/api/notifications', require('./routes/notifications'));
app.use('/api/analytics', require('./routes/analytics'));
// 問題点:
// - 一つの変更が全体に影響
// - 技術スタックが固定
// - スケーリングが非効率
// - デプロイリスクが高い

ドメイン分析例（ECサイト）:
1. ユーザー管理ドメイン
- ユーザー登録・認証
- プロフィール管理
- 権限管理
2. 商品管理ドメイン
- 商品情報管理
- 在庫管理
- カテゴリ管理
3. 注文管理ドメイン
- 注文処理
- 注文履歴
- 注文状態管理
4. 決済ドメイン
- 決済処理
- 決済履歴
- 返金処理
5. 通知ドメイン
- メール通知
- プッシュ通知
- SMS通知

// ユーザーサービスの境界コンテキスト
class UserService {
  // ユーザードメインの責務のみ
  async createUser(userData) {
    // ユーザー作成ロジック
    const user = new User(userData);
    await this.userRepository.save(user);
    // 他のサービスへのイベント発行
    await this.eventBus.publish('UserCreated', {
      userId: user.id,
      email: user.email
    });
    return user;
  }
  async getUserById(userId) {
    return await this.userRepository.findById(userId);
  }
  async updateUserProfile(userId, profileData) {
    const user = await this.userRepository.findById(userId);
    user.updateProfile(profileData);
    await this.userRepository.save(user);
    await this.eventBus.publish('UserProfileUpdated', {
      userId: user.id,
      changes: profileData
    });
    return user;
  }
}

-- ユーザーサービス専用データベース
CREATE DATABASE user_service;
USE user_service;
CREATE TABLE users (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    status ENUM('active', 'inactive', 'suspended') DEFAULT 'active',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE user_profiles (
    user_id INT UNSIGNED PRIMARY KEY,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    phone VARCHAR(20),
    FOREIGN KEY (user_id) REFERENCES users(id)
);
-- 商品サービス専用データベース
CREATE DATABASE product_service;
USE product_service;
CREATE TABLE products (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(200) NOT NULL,
    description TEXT,
    price DECIMAL(10,2) NOT NULL,
    stock_quantity INT UNSIGNED DEFAULT 0,
    category_id INT UNSIGNED,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

// 商品サービスのAPI
class ProductController {
  async getProduct(req, res) {
    try {
      const product = await this.productService.getById(req.params.id);
      if (!product) {
        return res.status(404).json({ error: 'Product not found' });
      }
      res.json({ data: product });
    } catch (error) {
      res.status(500).json({ error: 'Internal server error' });
    }
  }
  async updateStock(req, res) {
    try {
      const { productId, quantity } = req.body;
      const result = await this.productService.updateStock(productId, quantity);
      res.json({ data: result });
    } catch (error) {
      if (error.name === 'InsufficientStockError') {
        return res.status(400).json({ error: error.message });
      }
      res.status(500).json({ error: 'Internal server error' });
    }
  }
}

// イベントバスの実装
class EventBus {
  constructor() {
    this.subscribers = new Map();
  }
  subscribe(eventType, handler) {
    if (!this.subscribers.has(eventType)) {
      this.subscribers.set(eventType, []);
    }
    this.subscribers.get(eventType).push(handler);
  }
  async publish(eventType, eventData) {
    const handlers = this.subscribers.get(eventType) || [];
    // 並列実行でパフォーマンス向上
    await Promise.all(
      handlers.map(handler => 
        handler(eventData).catch(error => 
          console.error(`Event handler error for ${eventType}:`, error)
        )
      )
    );
  }
}
// 注文サービスでのイベント処理
class OrderService {
  constructor(eventBus, productServiceClient) {
    this.eventBus = eventBus;
    this.productServiceClient = productServiceClient;
    // イベント購読
    this.eventBus.subscribe('OrderCreated', this.handleOrderCreated.bind(this));
  }
  async createOrder(orderData) {
    // 在庫確認（同期通信）
    const stockCheck = await this.productServiceClient.checkStock(
      orderData.items
    );
    if (!stockCheck.available) {
      throw new Error('Insufficient stock');
    }
    // 注文作成
    const order = new Order(orderData);
    await this.orderRepository.save(order);
    // イベント発行（非同期通信）
    await this.eventBus.publish('OrderCreated', {
      orderId: order.id,
      userId: order.userId,
      items: order.items,
      totalAmount: order.totalAmount
    });
    return order;
  }
  async handleOrderCreated(eventData) {
    // 在庫減算処理
    await this.productServiceClient.reserveStock(eventData.items);
  }
}

// API Gateway / プロキシの実装
const express = require('express');
const httpProxy = require('http-proxy-middleware');
const app = express();
// 新しいマイクロサービスへのルーティング
app.use('/api/users', httpProxy({
  target: 'http://user-service:3001',
  changeOrigin: true,
  pathRewrite: {
    '^/api/users': '/api/v1/users'
  }
}));
// まだ移行していない機能は既存のモノリスへ
app.use('/api/products', httpProxy({
  target: 'http://monolith:3000',
  changeOrigin: true
}));
app.use('/api/orders', httpProxy({
  target: 'http://monolith:3000',
  changeOrigin: true
}));
app.listen(8080, () => {
  console.log('API Gateway running on port 8080');
});

// 移行フェーズ管理
class MigrationManager {
  constructor() {
    this.migrationFlags = {
      userService: true,      // 移行完了
      productService: false,  // 移行中
      orderService: false     // 未移行
    };
  }
  async routeRequest(service, request) {
    if (this.migrationFlags[service]) {
      // 新しいマイクロサービスへ
      return await this.callMicroservice(service, request);
    } else {
      // 既存のモノリスへ
      return await this.callMonolith(service, request);
    }
  }
  async callMicroservice(service, request) {
    const serviceUrls = {
      userService: 'http://user-service:3001',
      productService: 'http://product-service:3002',
      orderService: 'http://order-service:3003'
    };
    // マイクロサービスへのAPI呼び出し
    return await fetch(`${serviceUrls[service]}/api/v1${request.path}`, {
      method: request.method,
      headers: request.headers,
      body: request.body
    });
  }
  async callMonolith(service, request) {
    // モノリスへのAPI呼び出し
    return await fetch(`http://monolith:3000${request.path}`, {
      method: request.method,
      headers: request.headers,
      body: request.body
    });
  }
}

// データ同期ツール
class DataMigrationTool {
  constructor(sourceDb, targetDb) {
    this.sourceDb = sourceDb;
    this.targetDb = targetDb;
  }
  async migrateUsers() {
    console.log('Starting user data migration...');
    const batchSize = 1000;
    let offset = 0;
    let totalMigrated = 0;
    while (true) {
      // バッチ単位でデータ取得
      const users = await this.sourceDb.query(`
        SELECT * FROM users 
        ORDER BY id 
        LIMIT ${batchSize} OFFSET ${offset}
      `);
      if (users.length === 0) break;
      // 新しいデータベースに挿入
      for (const user of users) {
        await this.targetDb.query(`
          INSERT INTO users (id, email, password_hash, status, created_at)
          VALUES (?, ?, ?, ?, ?)
          ON DUPLICATE KEY UPDATE
          email = VALUES(email),
          status = VALUES(status)
        `, [user.id, user.email, user.password_hash, user.status, user.created_at]);
      }
      totalMigrated += users.length;
      offset += batchSize;
      console.log(`Migrated ${totalMigrated} users...`);
    }
    console.log(`Migration completed. Total: ${totalMigrated} users`);
  }
  async setupReplication() {
    // リアルタイム同期の設定
    // CDC (Change Data Capture) やトリガーを使用
  }
}

// OpenTelemetry を使用した分散トレーシング
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');
// トレーシング設定
const sdk = new NodeSDK({
  traceExporter: new JaegerExporter({
    endpoint: 'http://jaeger:14268/api/traces',
  }),
  instrumentations: [getNodeAutoInstrumentations()]
});
sdk.start();
// カスタムスパンの作成
const { trace } = require('@opentelemetry/api');
class OrderService {
  async createOrder(orderData) {
    const tracer = trace.getTracer('order-service');
    return tracer.startActiveSpan('create-order', async (span) => {
      try {
        span.setAttributes({
          'order.user_id': orderData.userId,
          'order.item_count': orderData.items.length,
          'order.total_amount': orderData.totalAmount
        });
        // 在庫確認
        await tracer.startActiveSpan('check-stock', async (stockSpan) => {
          const stockResult = await this.productService.checkStock(orderData.items);
          stockSpan.setAttributes({
            'stock.available': stockResult.available
          });
          stockSpan.end();
          return stockResult;
        });
        // 注文作成処理
        const order = await this.createOrderRecord(orderData);
        span.setAttributes({
          'order.id': order.id,
          'order.status': order.status
        });
        return order;
      } catch (error) {
        span.recordException(error);
        span.setStatus({ code: 2, message: error.message });
        throw error;
      } finally {
        span.end();
      }
    });
  }
}

// ヘルスチェック実装
class HealthCheckService {
  constructor() {
    this.checks = new Map();
  }
  addCheck(name, checkFunction) {
    this.checks.set(name, checkFunction);
  }
  async runHealthChecks() {
    const results = {};
    let overallStatus = 'healthy';
    for (const [name, checkFn] of this.checks) {
      try {
        const startTime = Date.now();
        await checkFn();
        results[name] = {
          status: 'healthy',
          responseTime: Date.now() - startTime
        };
      } catch (error) {
        results[name] = {
          status: 'unhealthy',
          error: error.message
        };
        overallStatus = 'unhealthy';
      }
    }
    return {
      status: overallStatus,
      timestamp: new Date().toISOString(),
      checks: results
    };
  }
}
// サーキットブレーカー実装
class CircuitBreaker {
  constructor(options = {}) {
    this.failureThreshold = options.failureThreshold || 5;
    this.resetTimeout = options.resetTimeout || 60000;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.failureCount = 0;
    this.lastFailureTime = null;
  }
  async call(fn) {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
        this.state = 'HALF_OPEN';
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }
    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  onSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }
  onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    if (this.failureCount >= this.failureThreshold) {
      this.state = 'OPEN';
    }
  }
}
// 使用例
const productServiceBreaker = new CircuitBreaker({
  failureThreshold: 3,
  resetTimeout: 30000
});
class OrderService {
  async getProductInfo(productId) {
    return await productServiceBreaker.call(async () => {
      return await this.productServiceClient.getProduct(productId);
    });
  }
}

// メトリクス収集
const prometheus = require('prom-client');
// カスタムメトリクス定義
const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.1, 0.3, 0.5, 0.7, 1, 3, 5, 7, 10]
});
const httpRequestTotal = new prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status_code']
});
// ミドルウェアでメトリクス収集
const metricsMiddleware = (req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    const labels = {
      method: req.method,
      route: req.route?.path || req.path,
      status_code: res.statusCode
    };
    httpRequestDuration.observe(labels, duration);
    httpRequestTotal.inc(labels);
  });
  next();
};
// メトリクス公開エンドポイント
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', prometheus.register.contentType);
  res.end(await prometheus.register.metrics());
});

# Kubernetes HPA設定
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: user-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: user-service
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
      - type: Percent
        value: 100
        periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60

問題点:
- モノリス: 50万行のコード
- デプロイ時間: 2時間
- 障害影響: 全機能停止
- 開発チーム: 25名が同一コードベース
- 技術負債: 累積した複雑性

Phase 1 (1-3ヶ月): 分析・設計
- ドメイン境界の特定
- サービス分割戦略策定
- インフラ基盤構築
Phase 2 (4-8ヶ月): 段階的移行
- ユーザーサービス分離
- 商品サービス分離
- 注文サービス分離
Phase 3 (9-12ヶ月): 最適化
- パフォーマンス調整
- 監視システム強化
- 運用プロセス確立

改善効果:
- デプロイ時間: 2時間 → 5分（96%短縮）
- 開発速度: 300%向上
- 障害影響: 局所化（全体停止なし）
- チーム自律性: 各チーム独立開発
- 技術選択: サービス毎に最適化

経験レベル別年収:
- 初級（1-2年）: 800-1,100万円
- 中級（3-5年）: 1,100-1,600万円
- 上級（5年以上）: 1,600-2,300万円
フリーランス単価:
- アーキテクチャ設計: 月額150-200万円
- 移行プロジェクト支援: プロジェクト1,000-3,000万円
- 技術コンサルティング: 日額10-20万円

最高単価パターン:
マイクロサービス + Kubernetes + クラウド + DDD
→ 年収2,000-2,500万円
高単価パターン:
分散システム + API設計 + DevOps + 運用
→ 年収1,600-2,000万円
安定単価パターン:
基本的なマイクロサービス + Docker + 監視
→ 年収1,100-1,600万円