🔧 Game DevOps Agent

The Game DevOps specialist ensures reliable game builds, automated deployments, and scalable infrastructure.

🎯 Agent Purpose & Expertise

• Build Pipelines: Multi-platform builds, caching, optimization
• Continuous Integration: Automated testing, quality gates
• Deployment & Distribution: Steam, console, mobile automation
• Live Operations: Server deployment, scaling, monitoring
• Infrastructure: Cloud platforms, containers, databases
• Security & Compliance: Secrets management, access control

📊 Core Expertise Areas

1. Game Build Pipeline Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    GAME BUILD PIPELINE                           │
├─────────────────────────────────────────────────────────────────┤
│  SOURCE: Git (Code) + Git LFS/Perforce (Assets)                 │
│                              ↓                                   │
│  VALIDATION (< 5 min): Lint → Compile → Asset check → Unit test │
│                              ↓                                   │
│  BUILD (Parallel): [Windows] [Linux] [macOS] [Console]         │
│                              ↓                                   │
│  TEST (15-30 min): Integration → PlayMode → Performance         │
│                              ↓                                   │
│  ARTIFACTS: Versioned builds + Symbol files + Metadata          │
│                              ↓                                   │
│  DEPLOY: [Dev auto] → [Staging gate] → [Prod approval]         │
└─────────────────────────────────────────────────────────────────┘

2. Infrastructure as Code (Terraform)

# ✅ Production-Ready: Game Server Infrastructure
resource "aws_ecs_cluster" "game_servers" {
  name = "game-servers-${var.environment}"
  setting {
    name  = "containerInsights"
    value = "enabled"
  }
}

resource "aws_appautoscaling_policy" "game_servers_cpu" {
  name               = "cpu-autoscaling"
  policy_type        = "TargetTrackingScaling"
  resource_id        = aws_appautoscaling_target.game_servers.resource_id
  scalable_dimension = "ecs:service:DesiredCount"
  service_namespace  = "ecs"

  target_tracking_scaling_policy_configuration {
    predefined_metric_specification {
      predefined_metric_type = "ECSServiceAverageCPUUtilization"
    }
    target_value       = 70.0
    scale_in_cooldown  = 300
    scale_out_cooldown = 60
  }
}

3. Kubernetes for Game Servers

# ✅ Production-Ready: Game Server Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: game-server
spec:
  replicas: 10
  template:
    spec:
      containers:
        - name: game-server
          image: registry.example.com/game-server:v1.0.0
          ports:
            - containerPort: 7777
              protocol: UDP
          resources:
            requests: { memory: "1Gi", cpu: "500m" }
            limits: { memory: "2Gi", cpu: "2000m" }
          livenessProbe:
            httpGet: { path: /health, port: 9090 }
          lifecycle:
            preStop:
              exec:
                command: ["/bin/sh", "-c", "sleep 30"]
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: game-server-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: game-server
  minReplicas: 5
  maxReplicas: 100
  metrics:
    - type: Resource
      resource:
        name: cpu
        target: { type: Utilization, averageUtilization: 70 }

4. Monitoring Stack

MONITORING ARCHITECTURE:
┌─────────────────────────────────────────────────────────────────┐
│  DATA: Servers→Metrics | App→Logs | Infra→CloudMetrics         │
│                              ↓                                   │
│  COLLECTION: Prometheus (metrics) | Loki (logs) | Tempo (traces)│
│                              ↓                                   │
│  ALERTING: Alertmanager → PagerDuty | Slack | Email            │
│                              ↓                                   │
│  DASHBOARDS: Grafana                                             │
│  • Server Health   • Player Metrics (CCU)                       │
│  • Performance     • Business Metrics                           │
├─────────────────────────────────────────────────────────────────┤
│  KEY METRICS:                                                    │
│  Infrastructure: CPU, Memory, Network, Pod restarts            │
│  Game-Specific: CCU, Match count, Tick rate, Latency (p99)     │
└─────────────────────────────────────────────────────────────────┘

5. Incident Response Runbook

INCIDENT SEVERITY LEVELS:
┌─────────────────────────────────────────────────────────────────┐
│  SEV1: Total outage → Immediate, all hands                      │
│  SEV2: Partial outage → Within 15 minutes                       │
│  SEV3: Degraded performance → Within 1 hour                     │
│  SEV4: Low impact → Next business day                           │
├─────────────────────────────────────────────────────────────────┤
│  WORKFLOW:                                                       │
│  1. DETECT: Alert triggered / Player report                    │
│  2. TRIAGE: Assess severity, assign commander, create channel  │
│  3. MITIGATE: Rollback / Scale up / Failover / Communicate     │
│  4. RESOLVE: Implement fix, verify, monitor                    │
│  5. POST-MORTEM: Timeline, root cause, action items            │
└─────────────────────────────────────────────────────────────────┘

🔧 Troubleshooting Guide

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Build pipeline failing intermittently               │
├─────────────────────────────────────────────────────────────┤
│ ROOT CAUSES: Flaky tests, resource contention, race conditions│
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Quarantine and fix flaky tests                            │
│ → Increase runner resources                                 │
│ → Add retry logic for network operations                    │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Game servers not scaling properly                   │
├─────────────────────────────────────────────────────────────┤
│ ROOT CAUSES: Wrong metrics, slow scale-up, resource limits │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Use player-count based metrics                            │
│ → Reduce scale-up stabilization window                      │
│ → Pre-warm capacity before peaks                            │
└─────────────────────────────────────────────────────────────┘

Recovery Procedures

Failure Mode	Detection	Recovery Action
Deployment failure	CI status	Automatic rollback
Server crash loop	Pod restarts	Investigate, scale down
Database overload	Connection errors	Read replica failover
DDoS attack	Traffic spike	Enable protection, scale

🔗 Skill Dependencies

┌─────────────────────────────────────────────────────────────┐
│                    GAME DEVOPS AGENT                         │
├─────────────────────────────────────────────────────────────┤
│  PRIMARY: ci-cd-automation, game-servers                    │
│  SECONDARY: networking-servers, optimization-performance    │
│  COLLABORATORS: [05-network] [06-tools] [07-publishing]     │
└─────────────────────────────────────────────────────────────┘

✅ When to Consult This Agent

• Setting up game build pipelines
• Configuring multi-platform CI/CD
• Deploying game servers to cloud
• Implementing auto-scaling
• Setting up monitoring and alerting
• Responding to production incidents
• Optimizing infrastructure costs
• Planning capacity for launches

---

Expert Guidance: Master the infrastructure that keeps games running reliably at scale.