mregosar/Cs2-Mapveto
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
mregosar committed 2026-10-25 22:46:51 +01:00
1 parent 1b7c13b592
commit 5527c2ce58
5 files changed
+210 -122
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.gitignore
+1
View File
@@ -9,3 +9,4 @@ data/
.env.local .env.local
npm-debug.log* npm-debug.log*
.claude/ .claude/
dist/
compose.yml
-41
View File
@@ -1,41 +0,0 @@
# CS2 Mapveto auf einem Docker-Host (z. B. als Portainer-Stack).
# Die App startet pro Match einen CS2-Container auf demselben Host (Docker-Adapter).
#
# Vorher einmalig: Image bauen (siehe docs/container.md) und das Volume
# "cs2-mapveto-gamefiles" mit den CS2-Spieldateien befüllen (docs/portainer-cs2.md).
services:
cs2-mapveto:
image: cs2-mapveto:latest
build: .
container_name: cs2-mapveto
restart: unless-stopped
ports:
- "3000:3000"
environment:
# Adresse dieses Docker-Hosts im LAN – für Einladungslinks, Spieler-Verbindungen und Live-Logs
- PUBLIC_URL=http://${HOST_IP:-192.168.178.111}:3000
- LOG_RECEIVER_URL=http://${HOST_IP:-192.168.178.111}:3000
- SERVER_ADAPTER=docker
- CS2_PUBLIC_HOST=${HOST_IP:-192.168.178.111}
# RCON zu den Match-Containern über die veröffentlichten Ports des Hosts
- CS2_RCON_HOST=${HOST_IP:-192.168.178.111}
# leer = LAN-Modus (sv_lan 1)
- CS2_GSLT=${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=${CREATE_MATCH_PASSWORD:-}
- STREAM_KEY=${STREAM_KEY:-}
- SERIES_AUTO_ADVANCE_SECONDS=30
- SERVER_IDLE_TIMEOUT_MINUTES=30
volumes:
# Datenbank (Matches, Ergebnisse) überdauert Updates des Containers
- cs2-mapveto-data:/data
# Zugriff auf Docker, um Match-Container zu starten und zu entfernen
- /var/run/docker.sock:/var/run/docker.sock
volumes:
cs2-mapveto-data:
name: cs2-mapveto-data
deploy/.env.example
+31
View File
@@ -0,0 +1,31 @@
# Vorlage für deploy/.env – kopieren und anpassen:
# cp deploy/.env.example deploy/.env
# --- Pflicht ---
# IP oder Name des Docker-Hosts im LAN. Spieler verbinden sich dorthin.
HOST_IP=192.168.178.111
# --- Webseite ---
# Port der Webseite auf dem Host
WEB_PORT=3000
# Image: lokal gebaut oder mit "docker load" geladen (siehe docs/container.md)
CS2_MAPVETO_IMAGE=cs2-mapveto:latest
# --- Serververwaltung ---
# docker = pro Match ein CS2-Container (Standard)
# demo = nur Simulation, startet keine echten Server (zum Ausprobieren)
SERVER_ADAPTER=docker
# Game Server Login Token (App-ID 730). Leer = LAN-Modus (sv_lan 1).
CS2_GSLT=
CS2_DOCKER_IMAGE=joedwards32/cs2:latest
# Zwei Ports pro Match (Spiel TCP+UDP, CSTV UDP) – auf dem Host freigeben
CS2_PORT_RANGE_START=27100
CS2_PORT_RANGE_END=27139
SERVER_IDLE_TIMEOUT_MINUTES=30
# --- Matches und Stream ---
# Wenn gesetzt, braucht man dieses Passwort zum Anlegen von Matches
CREATE_MATCH_PASSWORD=
# Wenn gesetzt, braucht man /stream?key=… für die Stream-Übersicht
STREAM_KEY=
SERIES_AUTO_ADVANCE_SECONDS=30
deploy/compose.yml
+46
View File
@@ -0,0 +1,46 @@
# CS2 Mapveto – Start auf einem beliebigen Docker-Host (Linux, z. B. Portainer-Server, NAS, eigener Rechner).
#
# Voraussetzungen:
# 1. deploy/.env anlegen (Vorlage: deploy/.env.example), mindestens HOST_IP setzen
# 2. Image cs2-mapveto:latest auf dem Host (gebaut oder mit "docker load" geladen)
# 3. Volume cs2-mapveto-gamefiles mit den CS2-Spieldateien (siehe docs/container.md)
#
# Start: docker compose --env-file deploy/.env -f deploy/compose.yml up -d
# Stoppen: docker compose --env-file deploy/.env -f deploy/compose.yml down
name: cs2-mapveto
services:
cs2-mapveto:
image: ${CS2_MAPVETO_IMAGE:-cs2-mapveto:latest}
container_name: cs2-mapveto
restart: unless-stopped
ports:
- "${WEB_PORT:-3000}:3000"
environment:
PORT: "3000"
# Adresse des Docker-Hosts im LAN: Einladungslinks, Spieler-Verbindungen, Live-Logs
PUBLIC_URL: "http://${HOST_IP:?HOST_IP in deploy/.env eintragen}:${WEB_PORT:-3000}"
LOG_RECEIVER_URL: "http://${HOST_IP}:${WEB_PORT:-3000}"
DATABASE_FILE: /data/cs2-mapveto.db
SERVER_ADAPTER: ${SERVER_ADAPTER:-docker}
CS2_PUBLIC_HOST: ${HOST_IP}
CS2_RCON_HOST: ${HOST_IP}
CS2_GSLT: ${CS2_GSLT:-}
CS2_DOCKER_VOLUME: cs2-mapveto-gamefiles
CS2_DOCKER_IMAGE: ${CS2_DOCKER_IMAGE:-joedwards32/cs2:latest}
CS2_PORT_RANGE_START: ${CS2_PORT_RANGE_START:-27100}
CS2_PORT_RANGE_END: ${CS2_PORT_RANGE_END:-27139}
CREATE_MATCH_PASSWORD: ${CREATE_MATCH_PASSWORD:-}
STREAM_KEY: ${STREAM_KEY:-}
SERIES_AUTO_ADVANCE_SECONDS: ${SERIES_AUTO_ADVANCE_SECONDS:-30}
SERVER_IDLE_TIMEOUT_MINUTES: ${SERVER_IDLE_TIMEOUT_MINUTES:-30}
volumes:
# Datenbank (Matches, Ergebnisse) überdauert Updates
- cs2-mapveto-data:/data
# Zugriff auf Docker, um Match-Container zu starten und zu entfernen
- /var/run/docker.sock:/var/run/docker.sock
volumes:
cs2-mapveto-data:
name: cs2-mapveto-data
docs/container.md
+132 -81
View File
@@ -2,120 +2,171 @@
CS2 Mapveto läuft als **ein** Container: Webseite, Backend, Datenbank (SQLite) und ein Docker-Client. 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` 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) Docker-Host (beliebig, Linux, Adresse z. B. 192.168.178.111)
├── cs2-mapveto ← dieser Container, Port 3000 ├── cs2-mapveto ← diese Anwendung, Port 3000
├── cs2mv-<match> ← CS2-Server pro Match, Ports ab 27100 (startet/entfernt CS2 Mapveto) ├── cs2mv-<match> ← CS2-Server pro Match (startet/entfernt CS2 Mapveto)
├── Volume cs2-mapveto-gamefiles CS2-Spieldateien (~73 GB, einmal befüllt) ├── Volume cs2-mapveto-gamefiles CS2-Spieldateien (~73 GB)
└── Volume cs2-mapveto-data Datenbank von CS2 Mapveto └── 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` > **Nur eine Instanz pro Docker-Host.** Läuft CS2 Mapveto zusätzlich anderswo mit demselben Host, streiten
> und demselben Docker-Host, vergeben beide unabhängig voneinander Ports und Containernamen. Die PC-Instanz > sich beide um Ports und Containernamen. Die andere Instanz vorher beenden.
> also beenden oder auf einen anderen Adapter stellen, bevor der Container läuft.
--- ---
## 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 Prüfen mit `docker image ls cs2-mapveto`.
`git clone` des Repositorys: `docker build -t cs2-mapveto:latest .`
> Meldet Docker unter Windows `docker-credential-desktop: executable file not found`, kommt das von einer ### Weg B: aus dem Repository bauen
> Docker-Desktop-Einstellung. Abhilfe für den einen Befehl: `$env:DOCKER_CONFIG = "$env:TEMP\dockercfg"`
> (Ordner mit einer Datei `config.json`, Inhalt `{}`).
## 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*: ```bash
git clone http://192.168.178.45:3002/marcel/Cs2-Mapveto.git
```yaml cd Cs2-Mapveto
services: docker build -t cs2-mapveto:latest .
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
``` ```
**Deploy the stack.** Danach ist CS2 Mapveto unter `http://192.168.178.111:3000` erreichbar, die Stream-Übersicht Beim Bauen laufen alle Tests mit. Schlägt einer fehl, bricht der Build ab.
unter `/stream`.
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 | | Variable | Bedeutung |
|---|---| |---|---|
| `PUBLIC_URL` | Adresse der Webseite für Einladungslinks | | `HOST_IP` | **Pflicht.** IP des neuen Hosts im LAN. Spieler verbinden sich dorthin, Einladungslinks zeigen darauf |
| `LOG_RECEIVER_URL` | Adresse, an die die CS2-Container ihre Logs schicken (Live-Ergebnisse) | | `WEB_PORT` | Port der Webseite (Standard 3000) |
| `CS2_PUBLIC_HOST` / `CS2_RCON_HOST` | IP des Docker-Hosts – Spieler verbinden sich dorthin, CS2 Mapveto steuert die Server darüber | | `SERVER_ADAPTER` | `docker` für echte Server, `demo` nur zum Ausprobieren ohne CS2 |
| `CS2_GSLT` | leer = LAN-Modus; mit Token öffentlich erreichbar (ein Token pro gleichzeitigem Match) | | `CS2_GSLT` | leer = LAN-Modus (`sv_lan 1`), kein Token nötig |
| `CS2_PORT_RANGE_START/END` | Ports für Match-Container, zwei pro Match, in der Firewall freigeben | | `CS2_PORT_RANGE_START` / `_END` | Ports für Match-Server, zwei pro Match |
| `CREATE_MATCH_PASSWORD` | Passwort zum Anlegen von Matches | | `CREATE_MATCH_PASSWORD` | Passwort zum Anlegen von Matches (empfohlen) |
| `STREAM_KEY` | Schlüssel für `/stream?key=…` | | `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). ## Schritt 4: Starten
2. Portainer → Stack `cs2-mapveto` → **Update the stack** (bzw. Container → *Recreate*).
Die Datenbank liegt im Volume `cs2-mapveto-data` und bleibt erhalten. Laufende Match-Container übernimmt ```bash
CS2 Mapveto nach dem Neustart wieder; ein Serverstart, der gerade lief, wird als unterbrochen markiert und docker compose --env-file deploy/.env -f deploy/compose.yml up -d
lässt sich mit „Server neu starten“ wiederholen. ```
## 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: Match-Container zu starten, entspricht aber Root-Rechten auf dem Host. Deshalb:
- Port 3000 nur im LAN anbieten, nicht ins Internet weiterleiten. - Port 3000 nur im LAN anbieten, nicht ins Internet weiterleiten.
- `CREATE_MATCH_PASSWORD` setzen, wenn nicht jeder im LAN Matches anlegen soll. - `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 | | Symptom | Ursache / Lösung |
|---|---| |---|---|
| „Server wird angefordert“ bleibt stehen | Container-Log prüfen (Portainer → `cs2-mapveto` → Logs); Docker-Socket eingebunden? | | `HOST_IP in deploy/.env eintragen` beim Start | `deploy/.env` fehlt oder `HOST_IP` ist leer |
| `permission denied … docker.sock` im Log | Socket nicht eingebunden oder Docker mit Rootless-Modus – Pfad zum Socket anpassen | | „Server wird angefordert“ bleibt stehen | Log des Containers prüfen: `docker logs cs2-mapveto` |
| Match-Container startet, „Server startet“ endet in Fehler | Ports 27100+ von `CS2_RCON_HOST` aus erreichbar? Firewall des Hosts | | `permission denied … docker.sock` im Log | Rootless-Docker oder anderer Socket-Pfad. Dann den Pfad im `volumes:`-Eintrag anpassen |
| Keine Live-Ergebnisse | `LOG_RECEIVER_URL` muss die Host-IP mit Port 3000 sein, nicht `localhost` | | Match-Server startet, Spieler finden ihn nicht | Ports 27100–27139 im Host-Netz freigeben; `HOST_IP` muss die LAN-Adresse des Hosts sein |
| Port bereits belegt | Eine zweite CS2-Mapveto-Instanz nutzt denselben Host (siehe Hinweis oben) | | 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) |