Stack unabhängig vom Host: deploy/compose.yml mit .env

CS2 Mapveto startet jetzt auf jedem Docker-Host (Linux) mit 'docker compose --env-file deploy/.env -f deploy/compose.yml up -d'. Die Adresse kommt aus HOST_IP, nichts ist mehr fest eingetragen. Anleitung für einen neuen Server: Image laden oder bauen, Spieldateien kopieren oder neu laden, konfigurieren, starten. Geprüft auf amp-cluster mit Demo-Adapter: Stack startet, Webseite antwortet, Stack wieder entfernt, Spieldateien unverändert.
2026-10-25 22:46:51 +01:00
1 parent 1b7c13b592
commit 5527c2ce58
@@ -2,120 +2,171 @@

 CS2 Mapveto läuft als **ein** Container: Webseite, Backend, Datenbank (SQLite) und ein Docker-Client.
 Er steht auf demselben Docker-Host wie die CS2-Server und startet pro Match über `/var/run/docker.sock`
-einen eigenen CS2-Container (Docker-Adapter). Ein PC mit Node.js oder SSH wird dafür nicht mehr gebraucht.
+einen eigenen CS2-Container. Der Host kann jeder Linux-Rechner mit Docker sein, ein AMP-Server ist nicht nötig.

 ```
-Docker-Host (z. B. amp-cluster, 192.168.178.111)
-├── cs2-mapveto            ← dieser Container, Port 3000
-├── cs2mv-<match>          ← CS2-Server pro Match, Ports ab 27100 (startet/entfernt CS2 Mapveto)
-├── Volume cs2-mapveto-gamefiles   CS2-Spieldateien (~73 GB, einmal befüllt)
-└── Volume cs2-mapveto-data        Datenbank von CS2 Mapveto
+Docker-Host (beliebig, Linux, Adresse z. B. 192.168.178.111)
+├── cs2-mapveto            ← diese Anwendung, Port 3000
+├── cs2mv-<match>          ← CS2-Server pro Match (startet/entfernt CS2 Mapveto)
+├── Volume cs2-mapveto-gamefiles   CS2-Spieldateien (~73 GB)
+└── Volume cs2-mapveto-data        Datenbank der Anwendung
 ```

-> **Nur eine Instanz pro Docker-Host.** Läuft CS2 Mapveto zusätzlich auf einem PC mit `SERVER_ADAPTER=docker`
-> und demselben Docker-Host, vergeben beide unabhängig voneinander Ports und Containernamen. Die PC-Instanz
-> also beenden oder auf einen anderen Adapter stellen, bevor der Container läuft.
+> **Nur eine Instanz pro Docker-Host.** Läuft CS2 Mapveto zusätzlich anderswo mit demselben Host, streiten
+> sich beide um Ports und Containernamen. Die andere Instanz vorher beenden.

 ---

-## 1. Image bauen
+## Was du brauchst

-Das Image wird auf dem Docker-Host gebaut, beim Bauen laufen auch alle Tests. Am einfachsten vom PC aus, im
-Projektordner, über den SSH-Zugang zum Host:
+| | |
+|---|---|
+| Docker + Compose | `docker compose version` muss funktionieren |
+| Speicher | ~80 GB frei für Spieldateien, Images und Updates |
+| CPU / RAM | pro gleichzeitigem Match etwa 1–2 Kerne und 2–3 GB RAM |
+| Netz | Ports TCP/UDP 27100–27139 (Spiel, RCON) und UDP 27101… (CSTV) sowie TCP 3000 im LAN freigeben |
+| Dateien | das Image `cs2-mapveto` (siehe Schritt 1) und die CS2-Spieldateien (Schritt 2) |

-```powershell
-docker -H ssh://cs2docker build -t cs2-mapveto:latest .
+---
+
+## Schritt 1: Image auf den neuen Host bringen
+
+Du hast zwei Wege.
+
+### Weg A: Image-Datei kopieren (ohne Build, schnell)
+
+Auf dem Rechner, auf dem das Image gebaut wurde, liegt die Datei `dist/cs2-mapveto-image.tar` (294 MB). Sie
+auf den neuen Host kopieren und laden:
+
+```bash
+scp cs2-mapveto-image.tar USER@NEUERHOST:/tmp/
+ssh USER@NEUERHOST "docker load -i /tmp/cs2-mapveto-image.tar && rm /tmp/cs2-mapveto-image.tar"
 ```

-Ergebnis: Image `cs2-mapveto:latest` (~300 MB) auf dem Host. Alternativ direkt auf dem Host nach einem
-`git clone` des Repositorys: `docker build -t cs2-mapveto:latest .`
+Prüfen mit `docker image ls cs2-mapveto`.

-> Meldet Docker unter Windows `docker-credential-desktop: executable file not found`, kommt das von einer
-> Docker-Desktop-Einstellung. Abhilfe für den einen Befehl: `$env:DOCKER_CONFIG = "$env:TEMP\dockercfg"`
-> (Ordner mit einer Datei `config.json`, Inhalt `{}`).
+### Weg B: aus dem Repository bauen

-## 2. Stack in Portainer anlegen
+Auf dem neuen Host ist Git nötig. Das Repository liegt auf dem Gitea (`http://192.168.178.45:3002/marcel/Cs2-Mapveto.git`):

-Portainer → **Stacks** → **+ Add stack** → Name `cs2-mapveto` → *Web editor*:
-
-```yaml
-services:
-  cs2-mapveto:
-    image: cs2-mapveto:latest
-    container_name: cs2-mapveto
-    restart: unless-stopped
-    ports:
-      - "3000:3000"
-    environment:
-      - PUBLIC_URL=http://192.168.178.111:3000
-      - LOG_RECEIVER_URL=http://192.168.178.111:3000
-      - SERVER_ADAPTER=docker
-      - CS2_PUBLIC_HOST=192.168.178.111
-      - CS2_RCON_HOST=192.168.178.111
-      - CS2_GSLT=
-      - CS2_DOCKER_VOLUME=cs2-mapveto-gamefiles
-      - CS2_DOCKER_IMAGE=joedwards32/cs2:latest
-      - CS2_PORT_RANGE_START=27100
-      - CS2_PORT_RANGE_END=27139
-      - CREATE_MATCH_PASSWORD=
-      - STREAM_KEY=
-      - SERIES_AUTO_ADVANCE_SECONDS=30
-      - SERVER_IDLE_TIMEOUT_MINUTES=30
-    volumes:
-      - cs2-mapveto-data:/data
-      - /var/run/docker.sock:/var/run/docker.sock
-
-volumes:
-  cs2-mapveto-data:
-    name: cs2-mapveto-data
+```bash
+git clone http://192.168.178.45:3002/marcel/Cs2-Mapveto.git
+cd Cs2-Mapveto
+docker build -t cs2-mapveto:latest .
 ```

-**Deploy the stack.** Danach ist CS2 Mapveto unter `http://192.168.178.111:3000` erreichbar, die Stream-Übersicht
-unter `/stream`.
+Beim Bauen laufen alle Tests mit. Schlägt einer fehl, bricht der Build ab.

-Dieselbe Datei liegt als [`compose.yml`](../compose.yml) im Repository (dort zusätzlich mit `build: .`, für
-`docker compose up -d --build` direkt auf dem Host).
+---

-### Einstellungen
+## Schritt 2: CS2-Spieldateien auf den neuen Host bringen

-Alle Umgebungsvariablen aus [`.env.example`](../.env.example) funktionieren auch hier. Die wichtigsten:
+Das Volume `cs2-mapveto-gamefiles` muss vor dem ersten Match vorhanden und befüllt sein. Sonst lädt jeder Match-Start
+die ~60 GB neu. Zwei Wege:
+
+**a) Vom bisherigen Host kopieren** (im LAN, kein Internet nötig, dauert je nach Netz Stunden):
+
+```bash
+ssh ALTERHOST "docker run --rm -v cs2-mapveto-gamefiles:/from alpine tar -C /from -cf - ." \
+  | ssh NEUERHOST "docker volume create cs2-mapveto-gamefiles >/dev/null && docker run --rm -i -v cs2-mapveto-gamefiles:/to alpine tar -C /to -xf -"
+```
+
+**b) Neu laden** (braucht Internet, ~60 GB). Der Container lädt die Dateien und stoppt danach von selbst:
+
+```bash
+docker volume create cs2-mapveto-gamefiles
+docker run -d --name cs2-updater -e STEAMAPPVALIDATE=0 -e CS2_RCONPW=updater1 -v cs2-mapveto-gamefiles:/home/steam/cs2-dedicated/ joedwards32/cs2:latest
+docker logs -f cs2-updater      # warten auf "Success! App '730' fully installed"
+docker rm -f cs2-updater
+```
+
+Danach liegen unter `docker system df -v` rund 73 GB im Volume.
+
+Das CS2-Image selbst (`joedwards32/cs2:latest`, ~3,7 GB) holt Docker beim ersten Match automatisch aus dem
+Docker Hub. Ohne Internet muss es vorher ebenfalls geladen werden (`docker save`/`docker load` wie bei Schritt 1).
+
+---
+
+## Schritt 3: Konfiguration
+
+Im Ordner `deploy/` die Vorlage kopieren und anpassen:
+
+```bash
+cp deploy/.env.example deploy/.env
+```
+
+Das Wichtigste:

 | Variable | Bedeutung |
 |---|---|
-| `PUBLIC_URL` | Adresse der Webseite für Einladungslinks |
-| `LOG_RECEIVER_URL` | Adresse, an die die CS2-Container ihre Logs schicken (Live-Ergebnisse) |
-| `CS2_PUBLIC_HOST` / `CS2_RCON_HOST` | IP des Docker-Hosts – Spieler verbinden sich dorthin, CS2 Mapveto steuert die Server darüber |
-| `CS2_GSLT` | leer = LAN-Modus; mit Token öffentlich erreichbar (ein Token pro gleichzeitigem Match) |
-| `CS2_PORT_RANGE_START/END` | Ports für Match-Container, zwei pro Match, in der Firewall freigeben |
-| `CREATE_MATCH_PASSWORD` | Passwort zum Anlegen von Matches |
-| `STREAM_KEY` | Schlüssel für `/stream?key=…` |
+| `HOST_IP` | **Pflicht.** IP des neuen Hosts im LAN. Spieler verbinden sich dorthin, Einladungslinks zeigen darauf |
+| `WEB_PORT` | Port der Webseite (Standard 3000) |
+| `SERVER_ADAPTER` | `docker` für echte Server, `demo` nur zum Ausprobieren ohne CS2 |
+| `CS2_GSLT` | leer = LAN-Modus (`sv_lan 1`), kein Token nötig |
+| `CS2_PORT_RANGE_START` / `_END` | Ports für Match-Server, zwei pro Match |
+| `CREATE_MATCH_PASSWORD` | Passwort zum Anlegen von Matches (empfohlen) |
+| `STREAM_KEY` | Schlüssel für `/stream?key=…` (optional) |

-**Passwörter und Schlüssel nur aus Buchstaben und Ziffern** wählen.
+Passwörter nur aus Buchstaben und Ziffern wählen.

-## 3. Updaten
+---

-1. Neues Image bauen (Schritt 1, gleicher Befehl).
-2. Portainer → Stack `cs2-mapveto` → **Update the stack** (bzw. Container → *Recreate*).
+## Schritt 4: Starten

-Die Datenbank liegt im Volume `cs2-mapveto-data` und bleibt erhalten. Laufende Match-Container übernimmt
-CS2 Mapveto nach dem Neustart wieder; ein Serverstart, der gerade lief, wird als unterbrochen markiert und
-lässt sich mit „Server neu starten“ wiederholen.
+```bash
+docker compose --env-file deploy/.env -f deploy/compose.yml up -d
+```

-## 4. Sicherheit
+Prüfen:

-Der Container hat über `/var/run/docker.sock` volle Kontrolle über Docker auf dem Host – das ist nötig, um
+```bash
+docker compose --env-file deploy/.env -f deploy/compose.yml ps     # Status "healthy" nach ~20 s
+curl http://HOST_IP:3000/api/config                                 # JSON mit "adapter": "docker"
+```
+
+Danach ist die Webseite unter `http://HOST_IP:3000` erreichbar, die Stream-Übersicht unter `/stream`.
+
+Stoppen und neu starten:
+
+```bash
+docker compose --env-file deploy/.env -f deploy/compose.yml down
+docker compose --env-file deploy/.env -f deploy/compose.yml up -d
+```
+
+Die Datenbank (Volume `cs2-mapveto-data`) bleibt dabei erhalten.
+
+### Mit Portainer statt Kommandozeile
+
+Portainer → Stacks → **Add stack** → Web editor: den Inhalt von `deploy/compose.yml` einfügen. Die Variablen aus
+`deploy/.env` als *Environment variables* eintragen (mindestens `HOST_IP`). Danach **Deploy the stack**.
+
+---
+
+## Aktualisieren
+
+1. Neues Image holen (Weg A oder B aus Schritt 1).
+2. `docker compose … up -d` erneut ausführen. Compose ersetzt den Container, die Datenbank bleibt.
+
+---
+
+## Sicherheit
+
+Der Container hat über `/var/run/docker.sock` volle Kontrolle über Docker auf dem Host. Das ist nötig, um
 Match-Container zu starten, entspricht aber Root-Rechten auf dem Host. Deshalb:

 - Port 3000 nur im LAN anbieten, nicht ins Internet weiterleiten.
 - `CREATE_MATCH_PASSWORD` setzen, wenn nicht jeder im LAN Matches anlegen soll.
- RCON-Ports (TCP 27100–27139) möglichst nur vom Host bzw. LAN erreichbar lassen.
+- `deploy/.env` enthält Passwörter. Nicht ins Repository einchecken (ist in `.gitignore`).

-## 5. Fehlersuche
+---
+
+## Fehlersuche

 | Symptom | Ursache / Lösung |
 |---|---|
-| „Server wird angefordert“ bleibt stehen | Container-Log prüfen (Portainer → `cs2-mapveto` → Logs); Docker-Socket eingebunden? |
-| `permission denied … docker.sock` im Log | Socket nicht eingebunden oder Docker mit Rootless-Modus – Pfad zum Socket anpassen |
-| Match-Container startet, „Server startet“ endet in Fehler | Ports 27100+ von `CS2_RCON_HOST` aus erreichbar? Firewall des Hosts |
-| Keine Live-Ergebnisse | `LOG_RECEIVER_URL` muss die Host-IP mit Port 3000 sein, nicht `localhost` |
-| Port bereits belegt | Eine zweite CS2-Mapveto-Instanz nutzt denselben Host (siehe Hinweis oben) |
+| `HOST_IP in deploy/.env eintragen` beim Start | `deploy/.env` fehlt oder `HOST_IP` ist leer |
+| „Server wird angefordert“ bleibt stehen | Log des Containers prüfen: `docker logs cs2-mapveto` |
+| `permission denied … docker.sock` im Log | Rootless-Docker oder anderer Socket-Pfad. Dann den Pfad im `volumes:`-Eintrag anpassen |
+| Match-Server startet, Spieler finden ihn nicht | Ports 27100–27139 im Host-Netz freigeben; `HOST_IP` muss die LAN-Adresse des Hosts sein |
+| Keine Live-Ergebnisse | `HOST_IP` falsch oder Port 3000 vom Match-Server aus nicht erreichbar |
+| Ein Match-Start dauert sehr lange | Spieldateien fehlen im Volume und werden neu geladen (Schritt 2) |