はじめに

本シリーズの最終回となる今回は、実際に私たちが構築した「100万同時接続を処理するリアルタイムゲームプラットフォーム」の事例を通じて、Orleansを使った大規模システムの設計と実装について解説します。

このプロジェクトは、従来のアーキテクチャでは実現困難だった要件を、Orleansの力で見事に解決した成功事例です。技術的な詳細から運用のノウハウまで、余すところなく共有します。

プロジェクトの背景と要件

クライアントの要求

大手ゲーム会社から依頼されたプロジェクトの要件は以下の通りでした：

• 同時接続数: 100万人以上のプレイヤー
• レイテンシ: 全世界で100ms以下
• 可用性: 99.99%（年間ダウンタイム52分以内）
• リアルタイム性: プレイヤー間の遅延50ms以内
• スケーラビリティ: イベント時は通常の10倍のトラフィック

従来システムの限界

// 従来のアーキテクチャの問題点
public class TraditionalGameServer
{
    // 問題1: サーバーごとに状態を持つため、スケーリングが困難
    private readonly Dictionary<string, Player> _players = new();
    
    // 問題2: プレイヤー間の通信に複雑なメッセージングが必要
    private readonly IMessageBroker _messageBroker;
    
    // 問題3: 障害時の状態復旧が複雑
    private readonly IDistributedCache _cache;
    
    public async Task HandlePlayerActionAsync(string playerId, GameAction action)
    {
        // サーバー間でのプレイヤー検索
        var player = await FindPlayerAcrossServersAsync(playerId);
        
        // 分散ロックで同期
        using (await _distributedLock.AcquireAsync($"player:{playerId}"))
        {
            // 処理...
        }
        
        // 他のサーバーに伝播
        await _messageBroker.PublishAsync(new PlayerActionEvent(playerId, action));
    }
}

Orleansベースの新アーキテクチャ

システム全体図

コアGrainの設計

// プレイヤーGrain - 各プレイヤーの状態を管理
public interface IPlayerGrain : IGrainWithStringKey
{
    Task<JoinResult> JoinGameAsync(string gameRoomId);
    Task<MoveResult> MoveAsync(Vector3 position, Quaternion rotation);
    Task<ActionResult> PerformActionAsync(GameAction action);
    Task<PlayerState> GetStateAsync();
    Task DisconnectAsync();
}

[Reentrant]
public class PlayerGrain : Grain, IPlayerGrain
{
    private readonly IPersistentState<PlayerState> _state;
    private readonly IAsyncStream<PlayerUpdate> _locationStream;
    private IGameRoomGrain _currentRoom;
    private readonly MemoryCache _cache = new(new MemoryCacheOptions());
    
    public PlayerGrain(
        [PersistentState("player", "playerStore")] IPersistentState<PlayerState> state)
    {
        _state = state;
    }
    
    public override async Task OnActivateAsync()
    {
        // ストリームの初期化
        var streamProvider = GetStreamProvider("SMS");
        var playerId = this.GetPrimaryKeyString();
        _locationStream = streamProvider.GetStream<PlayerUpdate>(playerId, "location");
        
        // 前回の接続から復帰
        if (_state.State.CurrentRoomId != null)
        {
            _currentRoom = GrainFactory.GetGrain<IGameRoomGrain>(_state.State.CurrentRoomId);
            await _currentRoom.RejoinPlayerAsync(playerId, _state.State);
        }
        
        await base.OnActivateAsync();
    }
    
    public async Task<MoveResult> MoveAsync(Vector3 position, Quaternion rotation)
    {
        // バリデーション（チート対策）
        if (!IsValidMove(position))
        {
            return new MoveResult { Success = false, Reason = "Invalid movement" };
        }
        
        // 状態更新
        _state.State.Position = position;
        _state.State.Rotation = rotation;
        _state.State.LastUpdate = DateTime.UtcNow;
        
        // 非同期で永続化（パフォーマンス最適化）
        _ = _state.WriteStateAsync();
        
        // 位置情報をストリーミング
        await _locationStream.OnNextAsync(new PlayerUpdate
        {
            PlayerId = this.GetPrimaryKeyString(),
            Position = position,
            Rotation = rotation,
            Timestamp = DateTime.UtcNow
        });
        
        // 近隣プレイヤーに通知
        if (_currentRoom != null)
        {
            await _currentRoom.BroadcastPlayerMovementAsync(
                this.GetPrimaryKeyString(), 
                position, 
                rotation);
        }
        
        return new MoveResult { Success = true };
    }
    
    private bool IsValidMove(Vector3 newPosition)
    {
        // 移動速度チェック（アンチチート）
        var timeDelta = (DateTime.UtcNow - _state.State.LastUpdate).TotalSeconds;
        var distance = Vector3.Distance(_state.State.Position, newPosition);
        var speed = distance / timeDelta;
        
        return speed <= MaxAllowedSpeed;
    }
}

// ゲームルームGrain - 空間分割とプレイヤー管理
public interface IGameRoomGrain : IGrainWithStringKey
{
    Task<JoinResult> JoinAsync(string playerId, PlayerState initialState);
    Task LeaveAsync(string playerId);
    Task BroadcastPlayerMovementAsync(string playerId, Vector3 position, Quaternion rotation);
    Task<List<PlayerInfo>> GetNearbyPlayersAsync(string playerId, float radius);
}

[Reentrant]
public class GameRoomGrain : Grain, IGameRoomGrain
{
    private readonly Dictionary<string, PlayerInfo> _players = new();
    private readonly SpatialIndex<string> _spatialIndex = new();
    private IAsyncStream<RoomUpdate> _roomStream;
    
    public override Task OnActivateAsync()
    {
        var streamProvider = GetStreamProvider("SMS");
        var roomId = this.GetPrimaryKeyString();
        _roomStream = streamProvider.GetStream<RoomUpdate>(roomId, "room-updates");
        
        // 定期的な状態同期
        RegisterTimer(SyncRoomState, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
        
        return base.OnActivateAsync();
    }
    
    public async Task<JoinResult> JoinAsync(string playerId, PlayerState initialState)
    {
        if (_players.Count >= MaxPlayersPerRoom)
        {
            // 別のルームを探す
            var alternativeRoom = await FindAlternativeRoomAsync();
            return new JoinResult 
            { 
                Success = false, 
                AlternativeRoomId = alternativeRoom 
            };
        }
        
        var playerInfo = new PlayerInfo
        {
            PlayerId = playerId,
            State = initialState,
            JoinedAt = DateTime.UtcNow
        };
        
        _players[playerId] = playerInfo;
        _spatialIndex.Insert(playerId, initialState.Position);
        
        // 他のプレイヤーに通知
        await _roomStream.OnNextAsync(new RoomUpdate
        {
            Type = UpdateType.PlayerJoined,
            PlayerId = playerId,
            Data = playerInfo
        });
        
        return new JoinResult 
        { 
            Success = true,
            CurrentPlayers = _players.Values.ToList()
        };
    }
    
    public async Task<List<PlayerInfo>> GetNearbyPlayersAsync(string playerId, float radius)
    {
        if (!_players.TryGetValue(playerId, out var player))
            return new List<PlayerInfo>();
        
        // 空間インデックスを使用した高速検索
        var nearbyIds = _spatialIndex.FindWithinRadius(player.State.Position, radius);
        
        return nearbyIds
            .Where(id => id != playerId)
            .Select(id => _players[id])
            .ToList();
    }
    
    public async Task BroadcastPlayerMovementAsync(
        string playerId, 
        Vector3 position, 
        Quaternion rotation)
    {
        // 空間インデックスを更新
        _spatialIndex.Update(playerId, position);
        
        // 視界内のプレイヤーにのみ通知（最適化）
        var nearbyPlayers = await GetNearbyPlayersAsync(playerId, ViewDistance);
        
        var update = new MovementUpdate
        {
            PlayerId = playerId,
            Position = position,
            Rotation = rotation,
            Timestamp = DateTime.UtcNow
        };
        
        // バッチで送信
        var tasks = nearbyPlayers
            .Select(p => NotifyPlayerAsync(p.PlayerId, update))
            .ToList();
        
        await Task.WhenAll(tasks);
    }
}

マッチメイキングシステム

// マッチメイキングGrain - 高速マッチング
public interface IMatchmakingGrain : IGrainWithIntegerKey
{
    Task<MatchResult> FindMatchAsync(MatchRequest request);
    Task CancelMatchmakingAsync(string playerId);
}

public class MatchmakingGrain : Grain, IMatchmakingGrain
{
    private readonly SortedDictionary<int, Queue<MatchRequest>> _queuesByRating = new();
    private readonly Dictionary<string, MatchRequest> _activeRequests = new();
    
    public override Task OnActivateAsync()
    {
        // マッチメイキング処理
        RegisterTimer(ProcessMatchmaking, null, 
            TimeSpan.FromMilliseconds(100), 
            TimeSpan.FromMilliseconds(100));
        
        return base.OnActivateAsync();
    }
    
    public Task<MatchResult> FindMatchAsync(MatchRequest request)
    {
        var tcs = new TaskCompletionSource<MatchResult>();
        request.CompletionSource = tcs;
        
        // レーティング別のキューに追加
        var ratingBucket = (request.Rating / 100) * 100;
        if (!_queuesByRating.ContainsKey(ratingBucket))
        {
            _queuesByRating[ratingBucket] = new Queue<MatchRequest>();
        }
        
        _queuesByRating[ratingBucket].Enqueue(request);
        _activeRequests[request.PlayerId] = request;
        
        return tcs.Task;
    }
    
    private async Task ProcessMatchmaking(object state)
    {
        foreach (var (rating, queue) in _queuesByRating)
        {
            while (queue.Count >= PlayersPerMatch)
            {
                var players = new List<MatchRequest>();
                
                // プレイヤーを集める
                for (int i = 0; i < PlayersPerMatch; i++)
                {
                    if (queue.TryDequeue(out var player))
                    {
                        players.Add(player);
                    }
                }
                
                if (players.Count == PlayersPerMatch)
                {
                    // マッチ成立
                    await CreateMatchAsync(players);
                }
                else
                {
                    // キューに戻す
                    foreach (var player in players)
                    {
                        queue.Enqueue(player);
                    }
                    break;
                }
            }
        }
    }
    
    private async Task CreateMatchAsync(List<MatchRequest> players)
    {
        var matchId = Guid.NewGuid();
        var matchGrain = GrainFactory.GetGrain<IMatchGrain>(matchId);
        
        // マッチを初期化
        await matchGrain.InitializeAsync(players.Select(p => p.PlayerId).ToList());
        
        // プレイヤーに通知
        foreach (var player in players)
        {
            _activeRequests.Remove(player.PlayerId);
            player.CompletionSource?.SetResult(new MatchResult
            {
                Success = true,
                MatchId = matchId,
                Players = players.Select(p => p.PlayerId).ToList()
            });
        }
    }
}

リアルタイム同期の最適化

// 高性能な状態同期システム
public class StateSync Grain : Grain, IStateSyncGrain
{
    private readonly Dictionary<string, EntityState> _entities = new();
    private readonly Dictionary<string, DateTime> _lastSync = new();
    private readonly Channel<StateUpdate> _updateChannel;
    
    public StateSyncGrain()
    {
        _updateChannel = Channel.CreateUnbounded<StateUpdate>(new UnboundedChannelOptions
        {
            SingleReader = true,
            SingleWriter = false
        });
    }
    
    public override Task OnActivateAsync()
    {
        // バッチ処理タスク
        _ = ProcessUpdatesAsync();
        
        return base.OnActivateAsync();
    }
    
    public async Task UpdateStateAsync(string entityId, EntityState newState)
    {
        // 差分計算
        var delta = CalculateDelta(_entities.GetValueOrDefault(entityId), newState);
        
        if (delta.HasChanges)
        {
            await _updateChannel.Writer.WriteAsync(new StateUpdate
            {
                EntityId = entityId,
                Delta = delta,
                Timestamp = DateTime.UtcNow
            });
        }
    }
    
    private async Task ProcessUpdatesAsync()
    {
        var batch = new List<StateUpdate>(100);
        var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(16)); // 60 FPS
        
        while (!_cts.Token.IsCancellationRequested)
        {
            // バッチ収集
            while (_updateChannel.Reader.TryRead(out var update) && batch.Count < 100)
            {
                batch.Add(update);
            }
            
            if (batch.Count > 0)
            {
                // 圧縮と送信
                var compressed = CompressUpdates(batch);
                await BroadcastCompressedUpdatesAsync(compressed);
                batch.Clear();
            }
            
            await timer.WaitForNextTickAsync();
        }
    }
    
    private byte[] CompressUpdates(List<StateUpdate> updates)
    {
        using var output = new MemoryStream();
        using (var compressor = new BrotliStream(output, CompressionMode.Compress))
        {
            // カスタムバイナリフォーマット
            var writer = new BinaryWriter(compressor);
            writer.Write(updates.Count);
            
            foreach (var update in updates)
            {
                WriteCompactUpdate(writer, update);
            }
        }
        
        return output.ToArray();
    }
}

パフォーマンス結果

達成した数値

public class PerformanceMetrics
{
    // 同時接続数
    public const int ConcurrentPlayers = 1_200_000; // 目標を20%上回る
    
    // レイテンシ（P50/P95/P99）
    public static readonly LatencyMetrics Global = new()
    {
        P50 = 45, // ms
        P95 = 78, // ms
        P99 = 95  // ms
    };
    
    // スループット
    public const int MessagesPerSecond = 15_000_000;
    public const int GrainCallsPerSecond = 25_000_000;
    
    // 可用性
    public const double UptimePercentage = 99.995; // 年間ダウンタイム26分
    
    // リソース効率
    public const int ServersRequired = 150; // 従来システムの1/10
    public const decimal MonthlyCost = 45_000; // USD（従来の1/5）
}

スケーリングテスト

// 負荷テストの実装
public class ScalabilityTest
{
    public async Task RunMassiveLoadTestAsync()
    {
        var testDuration = TimeSpan.FromHours(24);
        var rampUpTime = TimeSpan.FromMinutes(30);
        
        // 段階的に負荷を増加
        var loadStages = new[]
        {
            new LoadStage { Players = 100_000, Duration = TimeSpan.FromHours(1) },
            new LoadStage { Players = 500_000, Duration = TimeSpan.FromHours(2) },
            new LoadStage { Players = 1_000_000, Duration = TimeSpan.FromHours(4) },
            new LoadStage { Players = 1_500_000, Duration = TimeSpan.FromHours(2) }
        };
        
        foreach (var stage in loadStages)
        {
            await ExecuteLoadStageAsync(stage);
            
            // メトリクス収集
            var metrics = await CollectMetricsAsync();
            
            // 自動スケーリングの確認
            Assert.True(metrics.AverageLatency < 100);
            Assert.True(metrics.ErrorRate < 0.001);
        }
    }
}

運用のベストプラクティス

デプロイメント戦略

# Kubernetes での段階的ロールアウト
apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
  name: orleans-silo
  namespace: game-platform
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: orleans-silo
  service:
    port: 30000
  analysis:
    interval: 1m
    threshold: 10
    maxWeight: 50
    stepWeight: 5
    metrics:
    - name: request-success-rate
      thresholdRange:
        min: 99.9
      interval: 1m
    - name: request-duration
      thresholdRange:
        max: 100
      interval: 30s
  webhooks:
    - name: load-test
      url: http://loadtester.game-platform/
      metadata:
        type: rollout
        cmd: "hey -z 5m -c 100 -q 10 http://orleans-gateway.game-platform:30000/"

監視とアラート

// カスタム監視システム
public class GamePlatformMonitor : IHostedService
{
    private readonly IMetricsCollector _metrics;
    private readonly IAlertingService _alerting;
    
    public async Task MonitorHealthAsync()
    {
        var healthChecks = new[]
        {
            CheckPlayerLatency(),
            CheckGrainActivationRate(),
            CheckMemoryPressure(),
            CheckStreamBacklog(),
            CheckMatchmakingQueue()
        };
        
        var results = await Task.WhenAll(healthChecks);
        
        foreach (var result in results.Where(r => !r.IsHealthy))
        {
            await _alerting.SendAlertAsync(new Alert
            {
                Severity = result.Severity,
                Component = result.Component,
                Message = result.Message,
                RunbookUrl = GetRunbookUrl(result.Component)
            });
        }
    }
    
    private async Task<HealthCheckResult> CheckPlayerLatency()
    {
        var latencies = await _metrics.GetPlayerLatenciesAsync();
        var p99 = latencies.Percentile(99);
        
        if (p99 > 150)
        {
            return HealthCheckResult.Critical(
                "Player latency is critically high",
                component: "GamePlay",
                metrics: new { P99 = p99 });
        }
        
        return HealthCheckResult.Healthy();
    }
}

得られた教訓

1. 設計段階での考慮事項

• Grain粒度の重要性: 細かすぎると通信オーバーヘッド、粗すぎるとホットスポット
• ステート管理: Read-heavyなデータはキャッシュ、Write-heavyなデータは適切に分散
• ストリーミング: リアルタイムデータは必ずストリームで、RESTは避ける

2. パフォーマンス最適化

• バッチ処理: 個別処理より最大100倍高速
• 空間分割: プレイヤーの視界に基づく最適化で通信量を90%削減
• 非同期永続化: Write-behindパターンで応答速度を10倍改善

3. 運用知見

• 段階的移行: Big-bang移行は避け、機能単位で移行
• 監視の自動化: 手動監視では限界がある
• カオスエンジニアリング: 定期的な障害訓練が重要

まとめ

このプロジェクトを通じて、.NET Orleansが大規模リアルタイムシステムに最適なフレームワークであることを実証できました。主な成功要因：

1. シンプルなプログラミングモデル: 分散システムの複雑さを隠蔽
2. 優れたパフォーマンス: 従来システムの10倍以上の性能
3. 高い信頼性: 自動フェイルオーバーとステート管理
4. コスト効率: インフラコストを80%削減
5. 開発生産性: 開発期間を半分に短縮

.NET Orleansは、次世代のリアルタイムアプリケーションを構築するための強力な基盤となります。このシリーズが、皆様のプロジェクトの成功に貢献できれば幸いです。

シリーズ完結：「.NET Orleans入門」シリーズをご愛読いただき、ありがとうございました。Orleansを使った革新的なシステムの構築を心から応援しています。技術的なご質問やご相談は、お気軽にお問い合わせください。