Anleitung: CS2-Server mit Portainer und dauerhaftem Volume

docs/portainer-cs2.md beschreibt Stack, einmaligen Download, Updates ohne
Neu-Download, Anbindung per Static- oder Docker-Adapter, mehrere Server
und Fehlersuche. Standard-Image auf joedwards32/cs2 umgestellt, da
cm2network/cs2 nicht mehr gepflegt wird.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.env.example

@@ -45,7 +45,7 @@ CS2_GSLT=
 CS2_PUBLIC_HOST=
 # Adresse, unter der das Backend die RCON-Ports der Container erreicht
 CS2_RCON_HOST=127.0.0.1
-CS2_DOCKER_IMAGE=cm2network/cs2:latest
+CS2_DOCKER_IMAGE=joedwards32/cs2:latest
 # Pro Match werden zwei Ports belegt (Spiel TCP+UDP, CSTV UDP)
 CS2_PORT_RANGE_START=27015
 CS2_PORT_RANGE_END=27115

README.md

@@ -177,6 +177,8 @@ Die Wahl wird als `mp_teamname_1` (Team mit CT-Start) und `mp_teamname_2` (T-Sta
 
 ## Echte Server anbinden
 
+> **Schritt-für-Schritt mit Portainer:** [docs/portainer-cs2.md](docs/portainer-cs2.md) beschreibt, wie du einen CS2-Server als Portainer-Stack aufsetzt, dessen Spieldateien nur einmal heruntergeladen werden, und ihn mit CS2 Mapveto verbindest.
+
 Die Serververwaltung ist hinter [`server/src/servers/adapter.js`](server/src/servers/adapter.js) gekapselt. Auswahl über `SERVER_ADAPTER`.
 
 ### Ablauf, den jeder Adapter bedient
@@ -195,7 +197,7 @@ Die Serververwaltung ist hinter [`server/src/servers/adapter.js`](server/src/ser
 
 ### Option A: Docker (`SERVER_ADAPTER=docker`)
 
-Startet pro Match einen Container mit dem Community-Image [`cm2network/cs2`](https://github.com/CM2Walki/CS2) (SteamCMD, CS2-Dedicated-Server App 730).
+Startet pro Match einen Container mit dem Community-Image [`joedwards32/cs2`](https://github.com/joedwards32/CS2) (SteamCMD, CS2-Dedicated-Server App 730; gepflegter Nachfolger von `cm2network/cs2`).
 
 Voraussetzungen:
 
@@ -256,7 +258,7 @@ Zuschauer verbinden sich mit `password <tvpasswort>; connect <host>:<tvPort>`. S
 Die offizielle Seite [Counter-Strike 2/Dedicated Servers](https://developer.valvesoftware.com/wiki/Counter-Strike_2/Dedicated_Servers) im Valve Developer Wiki war während der Entwicklung wegen eines Bot-Schutzes nicht automatisiert abrufbar. Grundlage waren:
 
 - das [Source-RCON-Protokoll](https://developer.valvesoftware.com/wiki/Source_RCON_Protocol)
-- die Dokumentation des Images [cm2network/cs2](https://github.com/CM2Walki/CS2): Umgebungsvariablen, Ports, `TV_*`
+- die Dokumentation des Images [joedwards32/cs2](https://github.com/joedwards32/CS2) (vormals cm2network/cs2): Umgebungsvariablen, Ports, `TV_*`
 - Hoster-Anleitungen zu CSTV, z. B. [ZAP-Hosting](https://zap-hosting.com/guides/de/docs/cs2-cstv)
 - [FACEIT zu CSTV-Zuschauern](https://support.faceit.com/hc/en-us/articles/17050697184668)
 

docs/portainer-cs2.md

@@ -0,0 +1,245 @@
+# CS2-Server mit Portainer einrichten
+
+Diese Anleitung richtet einen CS2-Dedicated-Server als Portainer-Stack ein, dessen Spieldateien (ca. 60 GB) **einmal** heruntergeladen und danach dauerhaft in einem Docker-Volume gespeichert werden. Neustarts, Image-Updates und neue Matches laden die Dateien nicht neu.
+
+Anschließend wird der Server mit CS2 Mapveto verbunden.
+
+---
+
+## So funktioniert das Speichern der Dateien
+
+Das Image [`joedwards32/cs2`](https://github.com/joedwards32/CS2) installiert das Spiel mit SteamCMD nach `/home/steam/cs2-dedicated/`. Bei **jedem** Containerstart prüft es mit `app_update`, ob es ein Update gibt.
+
+- **Beim ersten Start** ist das Verzeichnis leer, also werden die kompletten ~60 GB geladen.
+- **Bei jedem weiteren Start** liegen die Dateien schon im Volume. SteamCMD vergleicht nur die Version, das dauert Sekunden bis wenige Minuten.
+- **Wenn Valve ein Update veröffentlicht**, lädt SteamCMD nur die geänderten Teile (Delta-Update).
+
+Entscheidend ist also: Das Verzeichnis `/home/steam/cs2-dedicated/` muss auf einem **benannten Volume** (oder einem Host-Ordner) liegen, nicht im Container selbst. Dann übersteht es auch das Löschen und Neuerstellen des Containers.
+
+> Hinweis zum Image: `cm2network/cs2` ist die ältere Fassung desselben Projekts und wird seit September 2025 nicht mehr aktualisiert. Verwende `joedwards32/cs2` (auch als `ghcr.io/joedwards32/cs2`). Die Umgebungsvariablen sind identisch.
+
+---
+
+## Voraussetzungen
+
+- Docker-Host mit Portainer (CE reicht), **Linux** empfohlen
+- **ca. 70 GB freier Speicher** für Spieldateien und Updates, idealerweise auf einer SSD
+- Mindestens 2 CPU-Kerne und 4 GB RAM pro gleichzeitig laufendem Server
+- **Game Server Login Token (GSLT)** für App-ID **730**: <https://steamcommunity.com/dev/managegameservers>. Ohne Token ist der Server nur im LAN-Modus nutzbar (siehe unten). Pro gleichzeitig laufendem Server brauchst du ein eigenes Token.
+- Freigegebene Ports (Router/Firewall), pro Server:
+  - Spielport, Standard **27015**, **UDP und TCP**. Über TCP läuft auch RCON, das nur das Backend erreichen muss.
+  - CSTV-Port, Standard **27020**, **UDP**
+
+---
+
+## Schritt 1: Stack in Portainer anlegen
+
+1. Portainer öffnen, die richtige **Environment** wählen (dein Docker-Host).
+2. Links auf **Stacks** und dann **+ Add stack** klicken.
+3. **Name:** `cs2`
+4. **Build method:** *Web editor*. Diesen Inhalt einfügen:
+
+```yaml
+services:
+  cs2-1:
+    image: joedwards32/cs2:latest
+    container_name: cs2-1
+    restart: unless-stopped
+    environment:
+      - SRCDS_TOKEN=${SRCDS_TOKEN}          # GSLT aus Schritt "Voraussetzungen"
+      - STEAMAPPVALIDATE=0                  # 0 = nur Update prüfen, NICHT jedes Mal alles verifizieren
+      - CS2_SERVERNAME=MaxLAN CS2 #1
+      - CS2_PORT=27015
+      - CS2_RCONPW=${CS2_RCONPW}            # RCON-Passwort, wird in CS2 Mapveto eingetragen
+      - CS2_PW=${CS2_PW}                    # Serverpasswort (CS2 Mapveto setzt pro Match ein eigenes)
+      - CS2_MAXPLAYERS=12
+      - CS2_SERVER_HIBERNATE=0              # kein Ruhemodus, sonst reagiert RCON verzögert
+      - CS2_LAN=0                           # 1 = reiner LAN-Betrieb (siehe unten)
+      - CS2_GAMETYPE=0
+      - CS2_GAMEMODE=1
+      - CS2_MAPGROUP=mg_active
+      - CS2_STARTMAP=de_dust2
+      - TV_ENABLE=1                         # CSTV für Zuschauer und Stream
+      - TV_PORT=27020
+      - TV_PW=${TV_PW}
+      - TV_RELAY_PW=${TV_PW}
+      - TV_DELAY=90
+      - TV_AUTORECORD=0
+    volumes:
+      - cs2-gamefiles:/home/steam/cs2-dedicated/
+    ports:
+      - "27015:27015/tcp"
+      - "27015:27015/udp"
+      - "27020:27020/udp"
+    stdin_open: true
+    tty: true
+
+volumes:
+  cs2-gamefiles:
+    # Fester Name, damit Portainer keinen Stack-Präfix voranstellt
+    # und CS2 Mapveto (Docker-Adapter) dasselbe Volume findet.
+    name: cs2-mapveto-gamefiles
+```
+
+5. Darunter bei **Environment variables** auf *+ Add an environment variable* klicken und anlegen:
+
+   | Name | Wert |
+   |---|---|
+   | `SRCDS_TOKEN` | dein GSLT |
+   | `CS2_RCONPW` | langes, zufälliges Passwort (nur Buchstaben und Ziffern) |
+   | `CS2_PW` | beliebiges Serverpasswort |
+   | `TV_PW` | Passwort für CSTV |
+
+   So stehen die Zugangsdaten nicht im Stack-Text selbst.
+
+6. **Deploy the stack** klicken.
+
+---
+
+## Schritt 2: Ersten Download abwarten
+
+1. In Portainer auf **Containers** und dann **cs2-1** klicken, danach auf **Logs**.
+2. Ein Haken bei *Auto-refresh logs* hilft. Du siehst den SteamCMD-Fortschritt, z. B. `Update state (0x61) downloading, progress: 12.34 %`.
+3. Je nach Leitung dauert das **30 Minuten bis mehrere Stunden**. Den Container in dieser Zeit nicht neu starten.
+4. Fertig ist der Server, wenn im Log `Success! App '730' fully installed.` steht und danach der Serverstart folgt. Am Ende stehen Zeilen wie `GC Connection established for server` bzw. `Connection to Steam servers successful.`
+
+Ab jetzt liegen die Dateien im Volume `cs2-mapveto-gamefiles`. Unter **Volumes** siehst du es mit etwa 60 GB.
+
+**Test:** In der CS2-Konsole `connect <Host-IP>:27015; password <CS2_PW>` eingeben.
+
+---
+
+## Schritt 3: Updates und Neustarts ohne neuen Download
+
+| Aktion in Portainer | Was passiert mit den Dateien |
+|---|---|
+| Container **Restart** | bleiben erhalten, nur Update-Prüfung |
+| Stack **Update the stack** (z. B. geänderte Variablen) | bleiben erhalten |
+| **Re-pull image and redeploy** | neues Image, Dateien bleiben im Volume |
+| Container **Remove** und neu deployen | bleiben erhalten (Volume ist unabhängig) |
+| Stack **löschen** | Volume bleibt standardmäßig bestehen |
+| **Volume löschen** (*Volumes*, *Remove*) | **Dateien sind weg**, nächster Start lädt 60 GB neu |
+
+Wenn Valve CS2 aktualisiert, lehnen Server mit alter Version Spieler ab. Dann reicht ein **Restart** des Containers, er zieht nur das Delta.
+
+> Setze `STEAMAPPVALIDATE` nur auf `1`, wenn Dateien beschädigt sind. Dann werden alle 60 GB geprüft, was sehr lange dauert. Danach wieder auf `0` stellen.
+
+---
+
+## Schritt 4: Mit CS2 Mapveto verbinden
+
+Für einen dauerhaft laufenden Server wie diesen ist der **Static-Adapter** gedacht. CS2 Mapveto reserviert ihn pro Match, setzt Passwörter und Map per RCON und gibt ihn nach dem Match wieder frei. Der Container läuft dabei durchgehend.
+
+In der `.env` von CS2 Mapveto:
+
+```env
+SERVER_ADAPTER=static
+# host:spielport:rconPasswort:cstvPort
+CS2_STATIC_SERVERS=192.168.178.50:27015:DEIN_CS2_RCONPW:27020
+```
+
+- `192.168.178.50` durch die IP des Docker-Hosts ersetzen, die **Spieler** erreichen. Sie wird ihnen als Verbindungsadresse angezeigt.
+- Das Backend von CS2 Mapveto muss dieselbe Adresse per **TCP** auf dem Spielport erreichen (RCON).
+- Danach CS2 Mapveto neu starten (`npm run dev` bzw. `npm start`).
+
+**Prüfen:** Ein neues Match erstellen. Im Serverpanel muss nach wenigen Sekunden **„Server bereit“** erscheinen, ohne „Demo“. Bleibt es bei „Server startet“, zeigt die Meldung darunter den RCON-Fehler, z. B. falsches Passwort oder Port nicht erreichbar.
+
+---
+
+## Mehrere Matches gleichzeitig
+
+Jeder gleichzeitig laufende Server braucht eigene Ports, ein eigenes GSLT und, wichtig, ein **eigenes Installationsverzeichnis**. Zwei Container dürfen **nicht gleichzeitig** dasselbe Volume aktualisieren, sonst können sich SteamCMD-Downloads gegenseitig beschädigen.
+
+Zweiten Server im selben Stack ergänzen:
+
+```yaml
+  cs2-2:
+    image: joedwards32/cs2:latest
+    container_name: cs2-2
+    restart: unless-stopped
+    environment:
+      - SRCDS_TOKEN=${SRCDS_TOKEN_2}
+      - STEAMAPPVALIDATE=0
+      - CS2_SERVERNAME=MaxLAN CS2 #2
+      - CS2_PORT=27025
+      - CS2_RCONPW=${CS2_RCONPW}
+      - CS2_PW=${CS2_PW}
+      - CS2_SERVER_HIBERNATE=0
+      - TV_ENABLE=1
+      - TV_PORT=27030
+      - TV_PW=${TV_PW}
+      - TV_DELAY=90
+    volumes:
+      - cs2-gamefiles-2:/home/steam/cs2-dedicated/
+    ports:
+      - "27025:27025/tcp"
+      - "27025:27025/udp"
+      - "27030:27030/udp"
+    stdin_open: true
+    tty: true
+```
+
+…und unter `volumes:` ergänzen:
+
+```yaml
+  cs2-gamefiles-2:
+    name: cs2-mapveto-gamefiles-2
+```
+
+In CS2 Mapveto beide eintragen:
+
+```env
+CS2_STATIC_SERVERS=192.168.178.50:27015:PASSWORT:27020,192.168.178.50:27025:PASSWORT:27030
+```
+
+**Damit der zweite Server nicht erneut 60 GB aus dem Internet lädt**, gibt es zwei Wege:
+
+1. **Volume kopieren (einmalig):** Server 1 in Portainer stoppen, dann auf dem Docker-Host:
+   ```bash
+   docker volume create cs2-mapveto-gamefiles-2
+   docker run --rm -v cs2-mapveto-gamefiles:/from -v cs2-mapveto-gamefiles-2:/to alpine sh -c "cp -a /from/. /to/"
+   ```
+   Danach Server 1 wieder starten und Server 2 deployen. Er findet die Dateien schon vor und prüft nur noch die Version.
+2. **[Lancache](https://lancache.net/)** im LAN betreiben, typisch für LAN-Partys: Steam-Downloads werden lokal zwischengespeichert. Jeder weitere Server lädt dann mit LAN-Geschwindigkeit. Im Stack dafür beim Service `dns: - <Lancache-IP>` ergänzen (siehe [Beispiel des Images](https://github.com/joedwards32/CS2/blob/main/examples/docker-compose-lancache.yml)).
+
+---
+
+## Alternative: CS2 Mapveto startet Container selbst (Docker-Adapter)
+
+Statt dauerhaft laufender Server kann CS2 Mapveto pro Match einen eigenen Container starten und danach wieder entfernen (`SERVER_ADAPTER=docker`). Damit auch dabei nichts neu geladen wird, nutzt der Adapter das Volume **`cs2-mapveto-gamefiles`**. Das ist genau das Volume, das der Stack oben angelegt und befüllt hat.
+
+```env
+SERVER_ADAPTER=docker
+CS2_GSLT=dein_gslt
+CS2_PUBLIC_HOST=192.168.178.50
+CS2_DOCKER_VOLUME=cs2-mapveto-gamefiles
+CS2_DOCKER_IMAGE=joedwards32/cs2:latest
+```
+
+Wichtig dabei:
+
+- **Den Stack-Server vorher stoppen**, damit nicht zwei Container gleichzeitig dasselbe Volume aktualisieren. Der Stack dient dann nur zum einmaligen Befüllen und für Updates.
+- Für gleichzeitige Matches gilt dasselbe Problem: Alle Match-Container teilen sich das Volume und prüfen beim Start auf Updates. Das ist unkritisch, solange kein Valve-Update ansteht. Kurz nach einem CS2-Patch nur **ein** Match auf einmal starten.
+- Das Backend braucht Zugriff auf den Docker-Daemon (es läuft auf demselben Host bzw. hat `/var/run/docker.sock`).
+
+Für eine LAN-Party mit festen Servern ist der **Static-Adapter mit Stack aus Schritt 1** die einfachere und robustere Wahl.
+
+---
+
+## LAN-Betrieb ohne GSLT
+
+Für reine LAN-Veranstaltungen kann `CS2_LAN=1` gesetzt werden (`sv_lan 1`). Der Server ist dann nur im lokalen Netz erreichbar und braucht kein Token. Spieler müssen im selben Netz sein. Für Zuschauer über das Internet oder externe Teams ist ein GSLT nötig.
+
+---
+
+## Fehlersuche
+
+| Symptom | Ursache / Lösung |
+|---|---|
+| Download startet bei jedem Neustart von vorn | Volume fehlt oder ist falsch eingehängt. Prüfen, ob `/home/steam/cs2-dedicated/` auf ein Volume zeigt (Container, *Volumes*). |
+| `Permission denied` beim Download | Bei **Host-Ordnern** statt Volume: `chown -R 1000:1000 /pfad/zum/ordner`, weil der Container als Benutzer `steam` (UID 1000) läuft. |
+| `Error! App '730' state is 0x202` | Zu wenig Speicher. Mindestens 70 GB frei halten. |
+| Spieler werden mit „Server läuft auf älterer Version“ abgewiesen | Valve-Update: Container neu starten. |
+| CS2 Mapveto meldet „RCON-Passwort wurde abgelehnt“ | `CS2_RCONPW` im Stack und Passwort in `CS2_STATIC_SERVERS` vergleichen. |
+| CS2 Mapveto meldet „Zeitüberschreitung“ | TCP-Port 27015 vom Backend aus nicht erreichbar (Firewall) oder Server lädt noch. |
+| Server nicht in der Serverliste, aber per IP erreichbar | GSLT fehlt oder ist ungültig. Token prüfen, pro Server ein eigenes. |

server/src/config.js

@@ -62,7 +62,7 @@ export function loadConfig(overrides = {}) {
 
     docker: {
       bin: str('DOCKER_BIN', 'docker'),
-      image: str('CS2_DOCKER_IMAGE', 'cm2network/cs2:latest'),
+      image: str('CS2_DOCKER_IMAGE', 'joedwards32/cs2:latest'),
       host: str('CS2_PUBLIC_HOST'),
       rconHost: str('CS2_RCON_HOST', '127.0.0.1'),
       portRangeStart: int('CS2_PORT_RANGE_START', 27015),

server/src/servers/dockerAdapter.js

@@ -6,7 +6,7 @@ import { runRcon } from './rcon.js';
 const exec = promisify(execFile);
 
 /**
- * Startet pro Match einen eigenen CS2-Container (Standard-Image: cm2network/cs2).
+ * Startet pro Match einen eigenen CS2-Container (Standard-Image: joedwards32/cs2, Nachfolger von cm2network/cs2).
  * Benötigt Docker auf dem Backend-Host, ein Game Server Login Token (CS2_GSLT)
  * und eine öffentlich erreichbare Adresse (CS2_PUBLIC_HOST).
  *