Kubernetes para servidores de jogo: escalar com Agones (guia avançado)

Aviso franco

Kubernetes para servidor de jogo é overkill em 95% dos casos.

Se você tem:

• 1-3 servidores fixos
• < 500 players total
• Foco em custo mínimo

Não use Kubernetes. Docker Compose (nosso tutorial) resolve.

Kubernetes faz sentido se você:

• Roda dezenas de servidores dinamicamente
• Precisa spawn on-demand (novo server ao encher outro)
• Tem network gigante (Hypixel, Mineplex scale)
• Quer multi-região com failover
• É negócio SaaS de hosting

Se você reconhece um desses cenários, continue lendo.

O que Kubernetes faz por você

• Orquestra containers em cluster de VMs
• Auto-scale (spawn/destruir com base em load)
• Load balance entre servers
• Rolling updates sem downtime
• Self-healing (nó cai → move workload)
• Secret management (senhas, tokens)

Por que jogo é difícil no K8s

Jogos são stateful. Um player está conectado a 1 server específico por horas. Se K8s decide mover o pod, player desconecta.

K8s puro foi pensado para HTTP stateless. Jogo precisa de tooling extra.

Agones — a solução

Agones é framework do Google para game servers em K8s. Open-source, usado por gigantes (Ubisoft, Roblox, etc).

O que Agones adiciona:

• GameServer CRD — recurso K8s pra game server específico
• Fleet CRD — pool de game servers prontos
• Allocation — pega um GameServer livre para player
• Health check integrado com o game
• Scaling automático baseado em jogadores

Arquitetura básica

[Player] → [Matchmaker / API]
              ↓
[Agones Allocator]
              ↓
[Fleet: 10 GameServers "Ready"]
              ↓ (1 vai pra "Allocated")
[GameServer específico → PodIP:Port]
              ↓
Player conecta

Quando fleet esvazia (poucos "Ready"), auto-scaler cria novos GameServers.

Setup mínimo (dev)

1. Cluster K8s

Local: minikube ou kind. Cloud: EKS, GKE, AKS, DigitalOcean K8s.

minikube start --cpus=4 --memory=8g

2. Instalar Agones

kubectl create namespace agones-system
helm repo add agones https://agones.dev/chart/stable
helm install my-release agones/agones --namespace agones-system

3. Deploy GameServer example

gameserver.yaml:

apiVersion: agones.dev/v1
kind: GameServer
metadata:
  name: mc-example
spec:
  container: mc
  ports:
    - name: default
      portPolicy: Dynamic
      containerPort: 25565
      protocol: TCP
  template:
    spec:
      containers:
        - name: mc
          image: itzg/minecraft-server:latest
          env:
            - name: EULA
              value: "TRUE"
            - name: TYPE
              value: "PAPER"

kubectl apply -f gameserver.yaml
kubectl get gameservers

Agones cria o pod, expõe porta dinâmica, marca "Ready".

4. Fleet (pool de servers)

fleet.yaml:

apiVersion: agones.dev/v1
kind: Fleet
metadata:
  name: mc-fleet
spec:
  replicas: 5     # 5 servers prontos
  template:
    spec:
      container: mc
      ports:
        - name: default
          portPolicy: Dynamic
          containerPort: 25565
          protocol: TCP
      template:
        spec:
          containers:
            - name: mc
              image: itzg/minecraft-server:latest
              env: [{name: EULA, value: "TRUE"}, {name: TYPE, value: "PAPER"}]

kubectl apply -f fleet.yaml
kubectl get gameservers    # 5 "Ready"

5. Allocation (player pede server)

kubectl create -f - <<EOF
apiVersion: allocation.agones.dev/v1
kind: GameServerAllocation
spec:
  required:
    matchLabels:
      agones.dev/fleet: mc-fleet
EOF

Retorna o GameServer alocado (nome, IP, porta). Frontend passa ao player.

Auto-scaling

apiVersion: autoscaling.agones.dev/v1
kind: FleetAutoscaler
metadata:
  name: mc-autoscaler
spec:
  fleetName: mc-fleet
  policy:
    type: Buffer
    buffer:
      bufferSize: 3      # sempre 3 "Ready" prontos
      minReplicas: 1
      maxReplicas: 100

Quando players entram (Allocated), Agones cria novos automaticamente.

Real cost analysis

Cluster K8s básico rodando (GKE, DigitalOcean K8s):

• Control plane: US$ 70+/mês (managed) ou grátis (self-managed)
• 3 worker nodes 4 vCPU 8 GB: US$ 60/mês cada = US$ 180
• Total mínimo: US$ 250-350/mês

Comparado a 10 VPS separadas rodando servers:

• 10 × US$ 20 = US$ 200/mês

Kubernetes só compensa em larga escala (30+ servers, elasticidade real).

Alternativas mais leves

Docker Swarm

Docker Swarm é K8s "light". Setup em 5 min, orquestração básica.

docker swarm init
docker stack deploy mc-stack docker-compose.yml

Bom para 5-20 servers sem complexidade K8s.

Nomad (HashiCorp)

Nomad é outro orquestrador, mais simples que K8s. Usado por Cloudflare, Netflix.

Managed services

Se fim é ter game servers rodando dinamicamente sem manter cluster:

• PlayFab Multiplayer Servers (Microsoft)
• AccelByte
• Multiplay (Unity)

Todos cobram premium mas eliminam complexidade K8s.

Quando usar K8s + Agones

✅ Sim:

• Você é gigante (Hypixel-scale)
• Multi-região (SP + Miami + EU)
• Elasticidade crítica (Battle Royale que sobe/desce servers a cada minuto)
• Time DevOps dedicado

❌ Não:

• Servidor único
• Small hosting (10-30 servers)
• Sem experiência K8s
• Quer minimizar custo

Conclusão

Kubernetes + Agones é poderoso e overkill ao mesmo tempo. Só use se souber por quê.

Para 99% dos servidores brasileiros, Docker Compose em VPS dedicated é suficiente. Nossos VPS-BR rodam containers sem restrição.

Se você opera hosting de jogos em escala, Kubernetes vale o investimento — mas o time DevOps precisa ser sólido.

Links

• Agones
• Agones Docs
• Kubernetes
• Casos reais — Ubisoft, MojoLive, etc