分散システム完全ガイド

分散システム完全ガイド

分散システムの実践的な実装方法を、実務で使える実装例とベストプラクティスとともに詳しく解説します。

1. 分散システムとは

分散システムの定義

分散システムは、複数の独立したコンピュータがネットワークを通じて協調して動作するシステムです。

分散システムの特徴
   ├─ スケーラビリティ
   ├─ 可用性
   ├─ パフォーマンス
   └─ 障害耐性

2. CAP定理

CAP定理の説明

CAP定理:
- Consistency（一貫性）: すべてのノードが同じデータを見る
- Availability（可用性）: すべてのリクエストが応答を受ける
- Partition tolerance（分断耐性）: ネットワーク分断に耐える

3つのうち2つまでしか同時に満たせない

CAP定理の選択

## CAP定理の選択

### CP（一貫性 + 分断耐性）
- 例: 金融システム、決済システム
- 一貫性を優先

### AP（可用性 + 分断耐性）
- 例: SNS、ECサイト
- 可用性を優先

### CA（一貫性 + 可用性）
- 分断が発生しない環境でのみ可能
- 実用的ではない

3. 一貫性モデル

強一貫性

// 強一貫性: すべてのノードが同じデータを見る
class StronglyConsistentStore {
  async write(key: string, value: any): Promise<void> {
    // すべてのノードに書き込み
    await Promise.all([
      this.node1.write(key, value),
      this.node2.write(key, value),
      this.node3.write(key, value)
    ]);
  }

  async read(key: string): Promise<any> {
    // どのノードから読んでも同じ値
    return await this.node1.read(key);
  }
}

結果整合性

// 結果整合性: 最終的に一貫性が保証される
class EventuallyConsistentStore {
  async write(key: string, value: any): Promise<void> {
    // 1つのノードに書き込み
    await this.node1.write(key, value);
    // 非同期で他のノードに複製
    this.replicate(key, value);
  }

  async read(key: string): Promise<any> {
    // 最も新しい値を返す
    const values = await Promise.all([
      this.node1.read(key),
      this.node2.read(key),
      this.node3.read(key)
    ]);
    return this.getLatestValue(values);
  }
}

4. 分散トランザクション

2フェーズコミット（2PC）

// 2フェーズコミット
class TwoPhaseCommit {
  async commit(transaction: Transaction): Promise<void> {
    // Phase 1: Prepare
    const prepared = await Promise.all(
      transaction.participants.map(p => p.prepare(transaction))
    );

    if (prepared.every(p => p === 'OK')) {
      // Phase 2: Commit
      await Promise.all(
        transaction.participants.map(p => p.commit(transaction))
      );
    } else {
      // Rollback
      await Promise.all(
        transaction.participants.map(p => p.rollback(transaction))
      );
    }
  }
}

Sagaパターン

// Sagaパターン
class Saga {
  async execute(transactions: Transaction[]): Promise<void> {
    const compensations: Compensation[] = [];

    try {
      for (const transaction of transactions) {
        await transaction.execute();
        compensations.push(transaction.getCompensation());
      }
    } catch (error) {
      // 補償トランザクションを実行
      for (const compensation of compensations.reverse()) {
        await compensation.execute();
      }
      throw error;
    }
  }
}

5. サービスディスカバリー

サービスレジストリ

// サービスレジストリ
class ServiceRegistry {
  private services = new Map<string, Service[]>();

  register(service: Service): void {
    const services = this.services.get(service.name) || [];
    services.push(service);
    this.services.set(service.name, services);
  }

  discover(serviceName: string): Service | null {
    const services = this.services.get(serviceName);
    if (!services || services.length === 0) {
      return null;
    }
    // ロードバランシング
    return this.loadBalance(services);
  }
}

6. 実践的なベストプラクティス

分散トレーシング

// 分散トレーシング
class DistributedTracing {
  startSpan(operation: string): Span {
    const span = {
      traceId: this.generateTraceId(),
      spanId: this.generateSpanId(),
      operation,
      startTime: Date.now()
    };
    return span;
  }

  finishSpan(span: Span): void {
    span.endTime = Date.now();
    span.duration = span.endTime - span.startTime;
    this.sendSpan(span);
  }
}

まとめ

分散システム完全ガイドのポイント：

• CAP定理: 一貫性、可用性、分断耐性のトレードオフ
• 一貫性モデル: 強一貫性、結果整合性
• 分散トランザクション: 2PC、Sagaパターン
• サービスディスカバリー: サービスレジストリ
• 分散トレーシング: リクエストの追跡

適切な分散システムにより、スケーラブルで可用性の高いシステムを構築できます。