Agones im Heimlabor: Multiplayer-Game-Server auf Kubernetes

Moin zusammen! Als langjähriger Linux-Admin und leidenschaftlicher Heimlaborant habe ich schon so einige Herausforderungen gemeistert, wenn es um das Hosting von Diensten geht. Besonders knifflig wird es, wenn man Multiplayer-Game-Server betreiben will. Wer kennt es nicht? Man will mit ein paar Freunden eine Runde zocken, aber der eigene Server muss manuell gestartet, Ports freigeschaltet und bei Bedarf skaliert werden. Das ist mühsam und fehleranfällig.

In meiner Erfahrung ist die manuelle Verwaltung von Game-Servern ein echter Zeitfresser. Wenn der Server abstürzt, muss man ihn neu starten. Wenn mehr Spieler kommen, braucht man eventuell eine zweite Instanz. Und das alles, während man eigentlich zocken will! Genau hier kommt Agones ins Spiel. Agones ist ein Open-Source-Projekt von Google, das speziell dafür entwickelt wurde, Game-Server in einem Kubernetes-Cluster zu verwalten. Und wie wir aus den News wissen, hat Google Agones nun der Cloud Native Computing Foundation (CNCF) übergeben – ein klares Zeichen für die Reife und Bedeutung des Projekts.

Für uns im Heimlabor ist das eine fantastische Nachricht. Agones bringt die Vorteile von Kubernetes – Skalierbarkeit, Resilienz, automatisches Deployment – direkt in die Welt der Game-Server. Es ist ein Game-Changer (im wahrsten Sinne des Wortes!), weil es uns erlaubt, unsere Game-Server wie jede andere Cloud-native Anwendung zu behandeln. Ich habe Agones in meinem eigenen Heimlabor auf meinem Proxmox-Cluster (der natürlich K3s-VMs für Kubernetes hostet) eingerichtet und bin begeistert, wie reibungslos das läuft. In diesem Guide zeige ich dir, wie du Agones in deinem eigenen Lab zum Laufen bringst und deinen ersten Game-Server deployst.

Voraussetzungen für Agones im Heimlabor

Bevor wir uns ins Getümmel stürzen, lass uns kurz klären, was du an Bord haben solltest. Wer das zum ersten Mal einrichtet, sollte sich nicht scheuen, bei den Basics nochmal genauer hinzuschauen. Eine solide Basis ist hier Gold wert.

• Ein laufender Kubernetes-Cluster: Das ist das Herzstück. Ob du einen vollwertigen Kubeadm-Cluster, K3s auf Raspberry Pis oder VMs (wie ich auf Proxmox), oder MicroK8s verwendest, ist im Prinzip egal. Wichtig ist, dass er stabil läuft und du Admin-Zugriff hast. Mein Tipp: Für den Anfang reicht ein kleiner K3s-Cluster auf einer oder zwei VMs völlig aus.
• kubectl installiert und konfiguriert: Das Kommandozeilen-Tool für Kubernetes muss auf deinem Admin-Rechner installiert sein und Zugriff auf deinen Cluster haben. Teste das am besten mit einem einfachen kubectl get nodes.
• Helm installiert: Agones wird über Helm, den Paketmanager für Kubernetes, installiert. Stell sicher, dass Helm v3 auf deinem System verfügbar ist. Ein helm version sollte dir die Version anzeigen.
• Grundlegende Netzwerkkenntnisse: Du solltest wissen, wie Port-Weiterleitungen (NAT) und Firewalls in deinem Netzwerk funktionieren, falls du deine Game-Server von außerhalb deines Heimnetzes erreichbar machen willst.
• Docker-Grundlagen: Agones verwaltet Docker-Container. Ein grundlegendes Verständnis von Docker-Images und Containern ist hilfreich.
• Optional, aber empfehlenswert: Eine Container Registry: Wenn du eigene Game-Server-Images bauen und deployen willst, ist eine private oder öffentliche Container Registry (z.B. Docker Hub, GitLab Container Registry, oder eine lokale Registry wie Harbor) sehr nützlich.

Sind diese Punkte abgehakt? Wunderbar, dann legen wir los!

Schritt-für-Schritt-Anleitung: Agones installieren und Game-Server deployen

Wir gehen das Ganze jetzt Schritt für Schritt durch. Ich habe diese Reihenfolge selbst mehrfach durchgespielt, und sie hat sich bewährt.

1. Agones mit Helm installieren

Der erste Schritt ist die Installation von Agones selbst. Das geht am einfachsten über Helm. Agones wird als sogenannter Operator in deinem Kubernetes-Cluster installiert. Dieser Operator überwacht dann deine Game-Server-Ressourcen.

Helm Repository hinzufügen

Zuerst fügen wir das Agones Helm Repository hinzu, damit Helm weiß, wo es die Agones-Pakete finden kann.

helm repo add agones https://agones.dev/chart/stable
helm repo update

Agones Namespace erstellen

Es ist gute Praxis, Agones in einem eigenen Namespace zu installieren. Das hält deinen Cluster sauber und übersichtlich.

kubectl create namespace agones-system

Agones installieren

Jetzt installieren wir Agones. Ich verwende hier die Standardkonfiguration, die für die meisten Heimlabor-Szenarien ausreicht.

helm install agones --namespace agones-system agones/agones

Die Installation kann ein paar Minuten dauern, da Kubernetes die notwendigen Pods herunterlädt und startet. Du kannst den Status der Pods im agones-system Namespace überprüfen:

kubectl get pods --namespace agones-system

Du solltest mehrere Pods sehen, die alle den Status Running haben, wie zum Beispiel agones-controller-manager-..., agones-allocator-... und so weiter. Wenn alles grün ist, ist Agones bereit!

2. Ersten Game-Server bereitstellen (Beispiel)

Agones verwendet eine Custom Resource Definition (CRD) namens GameServer. Das bedeutet, du definierst deine Game-Server als Kubernetes-Ressourcen, genau wie Pods oder Deployments. Agones kümmert sich dann um den Rest.

Für den Anfang verwenden wir ein einfaches Test-Game-Server-Image, das von Agones selbst bereitgestellt wird. Dieses Image implementiert das Agones SDK, was wichtig ist, damit Agones den Status des Game-Servers überwachen und steuern kann.

GameServer YAML erstellen

Erstelle eine Datei namens simple-gameserver.yaml mit folgendem Inhalt. Achte genau auf die Einrückungen, bei YAML ist das essenziell!

apiVersion: agones.dev/v1
kind: GameServer
metadata:
  generateName: simple-gameserver-
spec:
  # Der Port, auf dem dein Game-Server im Container lauscht
  ports:
  - name: default
    portPolicy: Dynamic # Agones wählt einen freien Port auf dem Node
    containerPort: 7654 # Der Port im Container
    protocol: UDP # Oder TCP, je nach deinem Game-Server
  
  # Die Lifecycle-Hooks für den Game-Server
  # Wichtig: Der Game-Server MUSS das Agones SDK verwenden!
  health:
    initialDelaySeconds: 5
    periodSeconds: 3
  
  template:
    spec:
      containers:
      - name: simple-gameserver
        image: gcr.io/agones-images/simple-game-server:0.16
        # Argumente, die an den Game-Server übergeben werden
        args:
          - --listen-port=7654
          - --health-port=8080 # Der Health-Check-Port für das Agones SDK
          - --ready-port=8080 # Ein weiterer Port für das Agones SDK
        
        # Die Ports, die der Container exponiert
        ports:
        - containerPort: 7654
          name: game-port
          protocol: UDP
        - containerPort: 8080
          name: health-port
          protocol: TCP

Kurze Erklärung zu den wichtigsten Parametern:

• ports: Hier definierst du, welche Ports dein Game-Server im Container verwendet und wie Agones diese nach außen exponieren soll. portPolicy: Dynamic ist super praktisch, da Agones automatisch einen freien NodePort zuweist.
• health: Agones braucht Health Checks, um zu wissen, ob dein Game-Server läuft und bereit ist, Spieler anzunehmen. Dein Game-Server muss hierfür das Agones SDK nutzen und einen Health-Endpunkt bereitstellen.
• template.spec.containers: Das ist im Grunde eine normale Kubernetes-Container-Definition. Hier gibst du das Docker-Image und die Argumente an.

GameServer deployen

Jetzt wenden wir die YAML-Datei auf unseren Cluster an:

kubectl apply -f simple-gameserver.yaml

Status überprüfen

Überprüfe den Status deines neuen GameServers:

kubectl get gameserver

Du solltest eine Ausgabe ähnlich dieser sehen:

NAME                   STATE   ADDRESS         PORT   NODE              AGE
simple-gameserver-abcd Ready   192.168.1.100   7000   k8s-worker-node   30s

Wichtig zu wissen: Der STATE sollte irgendwann auf Ready wechseln. Das bedeutet, dein Game-Server-Container läuft, die Health Checks sind erfolgreich und das Agones SDK hat gemeldet, dass der Server bereit ist. Du siehst auch die ADDRESS (die IP deines Kubernetes-Nodes) und den PORT (der dynamisch zugewiesene NodePort), unter dem dein Game-Server erreichbar ist.

Mein Tipp: Wenn der Status auf Pending oder Unhealthy bleibt, schau dir die Logs des GameServer-Pods an. Das ist der erste Anlaufpunkt für Fehlersuche.

3. Game-Server skalieren und verwalten

Ein einzelner GameServer ist nett, aber die wahre Stärke von Agones liegt in der Verwaltung mehrerer Instanzen und der Skalierung. Dafür gibt es die GameServerSet und Fleet Ressourcen.

GameServerSet verwenden

Ein GameServerSet ist vergleichbar mit einem Kubernetes ReplicaSet. Es stellt sicher, dass eine bestimmte Anzahl von GameServer-Instanzen läuft.

Erstelle eine Datei namens simple-gameserverset.yaml:

apiVersion: agones.dev/v1
kind: GameServerSet
metadata:
  name: simple-gameserverset
spec:
  replicas: 3 # Wir wollen 3 GameServer-Instanzen
  template:
    spec:
      ports:
      - name: default
        portPolicy: Dynamic
        containerPort: 7654
        protocol: UDP
      health:
        initialDelaySeconds: 5
        periodSeconds: 3
      template:
        spec:
          containers:
          - name: simple-gameserver
            image: gcr.io/agones-images/simple-game-server:0.16
            args:
              - --listen-port=7654
              - --health-port=8080
              - --ready-port=8080
            ports:
            - containerPort: 7654
              name: game-port
              protocol: UDP
            - containerPort: 8080
              name: health-port
              protocol: TCP

Wende die Konfiguration an:

kubectl apply -f simple-gameserverset.yaml

Jetzt siehst du, wie Agones drei einzelne GameServer-Instanzen hochfährt:

kubectl get gameserver

Du kannst die Anzahl der Replikas im GameServerSet ändern, und Agones skaliert automatisch hoch oder runter.

Fleet für dynamische Skalierung

Für eine noch dynamischere Verwaltung und Skalierung verwendet man am besten Fleet-Ressourcen. Eine Fleet ist wie ein Deployment für GameServerSets und ermöglicht es, GameServer-Instanzen basierend auf Spielerzahlen oder anderen Metriken zu skalieren. Das geht aber über den Rahmen dieses Einstiegs-Guides hinaus. Für den Anfang ist das GameServerSet eine hervorragende Basis.

Häufige Fehler und Lösungen

In meiner Erfahrung stolpert man bei der Einrichtung von Cloud-nativen Systemen wie Agones oft über ähnliche Probleme. Hier sind ein paar typische Stolpersteine und wie du sie behebst.

1. GameServer bleibt im Status "Pending" oder "Unhealthy"

Das ist der Klassiker. Dein GameServer-Pod startet, aber Agones meldet keinen "Ready"-Status.

• Fehlerursache: Meistens liegt es an einem Problem im Container selbst oder an den Health Checks. Der Game-Server meldet sich nicht über das Agones SDK als bereit, oder die Health Checks schlagen fehl.
• Lösung:
  1. Pod-Logs prüfen: Das Wichtigste zuerst: Schau in die Logs des GameServer-Pods. Finde den Pod-Namen (kubectl get pods) und dann:

     kubectl logs <gameserver-pod-name>

     Hier findest du oft Fehlermeldungen deines Game-Servers.
  2. Health-Check-Konfiguration: Überprüfe die health-Sektion in deiner GameServer-YAML. Stimmen die Ports und Protokolle mit dem überein, was dein Game-Server tatsächlich bereitstellt?
  3. Agones SDK-Integration: Dein Game-Server muss das Agones SDK verwenden und die Funktionen Ready() und Health() korrekt implementieren. Das SDK kommuniziert den Status an Agones. Wenn dein Game-Server ein "dummer" Container ist, der das SDK nicht nutzt, wird Agones ihn nie als "Ready" markieren können. Mein Tipp: Starte immer mit dem Agones simple-game-server-Image, um sicherzustellen, dass die Basis-Kommunikation funktioniert, bevor du deinen eigenen Game-Server einbindest.

2. Netzwerkzugriff auf den GameServer nicht möglich

Der GameServer ist "Ready", aber du kannst von deinem Client aus keine Verbindung herstellen.

• Fehlerursache: Typischerweise Firewall-Probleme, falsche Port-Weiterleitungen oder ein Missverständnis, wie Kubernetes den Netzwerkverkehr handhabt.
• Lösung:
  1. Agones GameServer-Details prüfen: Schau dir die Details deines GameServers an, insbesondere die address und port Felder:

     kubectl get gameserver <gameserver-name> -o yaml | grep -E "address|port"

     Die angezeigte Adresse ist die IP eines deiner Kubernetes-Nodes, und der Port ist der dynamisch zugewiesene NodePort.
  2. Firewall auf dem Node: Stell sicher, dass die Firewall auf dem Kubernetes-Node, auf dem dein GameServer läuft, den Zugriff auf diesen NodePort erlaubt. Bei K3s oder MicroK8s ist das oft standardmäßig offen, aber bei selbstgebauten Clustern musst du eventuell ufw oder firewalld konfigurieren.
  3. Heimrouter/NAT: Wenn du von außerhalb deines Heimnetzes zugreifen willst, musst du eine Port-Weiterleitung (NAT) in deinem Heimrouter einrichten, die den externen Port auf die IP des Kubernetes-Nodes und den von Agones zugewiesenen NodePort weiterleitet.
  4. Protokoll: Hast du das richtige Protokoll (UDP/TCP) in deiner GameServer-YAML und auf Client-Seite verwendet?

3. "Error from server (Forbidden): gameservers is forbidden" oder ähnliche RBAC-Fehler

Wenn du versuchst, GameServer-Ressourcen zu erstellen oder zu verwalten, und Kubernetes sagt dir, dass du keine Berechtigung hast.

• Fehlerursache: Dein kubectl-Kontext verwendet ein Benutzerkonto, das nicht die notwendigen Role-Based Access Control (RBAC)-Berechtigungen hat, um mit Agones-Ressourcen zu interagieren. Wer das zum ersten Mal einrichtet, hat oft nur Standard-User-Rechte.
• Lösung:
  1. Admin-Kontext verwenden: Stell sicher, dass du kubectl mit einem Benutzer ausführst, der Cluster-Administratorrechte hat. Bei K3s ist das oft der kubeconfig-Inhalt aus /etc/rancher/k3s/k3s.yaml.
  2. RBAC prüfen: Für fortgeschrittene Szenarien oder wenn du dedizierte Benutzer für Agones verwalten willst, musst du die Kubernetes RBAC-Konfiguration (Roles, RoleBindings, ClusterRoles, ClusterRoleBindings) anpassen. Agones selbst installiert die notwendigen ClusterRoles und ClusterRoleBindings für seinen eigenen Controller, aber dein Benutzer braucht möglicherweise auch Zugriff.

Fazit und nächste Schritte

Glückwunsch! Du hast Agones erfolgreich in deinem Heimlabor installiert und deinen ersten Game-Server über Kubernetes verwaltet. In meiner Erfahrung ist das ein riesiger Schritt in Richtung eines modernen, resilienten und skalierbaren Game-Server-Hostings. Die Zeiten, in denen man manuell SSH-Verbindungen aufbauen und Prozesse starten musste, sind damit vorbei.

Agones ist ein mächtiges Werkzeug, das dir erlaubt, Game-Server wie jede andere Cloud-native Anwendung zu behandeln. Die Integration mit Kubernetes eröffnet dir eine Welt voller Möglichkeiten: automatische Skalierung, Überwachung mit Prometheus und Grafana, Blue/Green Deployments für Game-Server-Updates und vieles mehr.

Was sind die nächsten Schritte? Ich würde dir empfehlen:

• Eigenen Game-Server integrieren: Bau ein Docker-Image deines bevorzugten Game-Servers (z.B. Minecraft, Valheim, Factorio) und integriere das Agones SDK (oder nutze einen Wrapper, falls der Server selbst nicht modifizierbar ist).
• Fleets erkunden: Vertiefe dich in Fleet-Ressourcen, um die dynamische Skalierung und Verwaltung von GameServer-Instanzen zu meistern.
• Metrics und Monitoring: Integriere Agones-Metriken in dein bestehendes Monitoring-Setup (z.B. Prometheus und Grafana), um die Auslastung und den Status deiner Game-Server zu überwachen.
• Allocation Service: Schau dir den Agones Allocation Service an, um Game-Server programmatisch für Spieler zu reservieren.

Das Agones-Projekt hat eine hervorragende Dokumentation, die ich dir wärmstens empfehlen kann. Viel Spaß beim Experimentieren in deinem Heimlabor!