🐳 Pterodactyl Advanced: Docker-Installation, Multi-Node-Betrieb und Überwachung mit Prometheus

Dein Pterodactyl-Setup auf das nächste Level bringen 🚀

In den vorherigen Teilen haben wir die Grundinstallation und erste Erweiterungen behandelt. Heute wird es richtig professionell: Wir installieren Pterodactyl komplett mit Docker, bauen ein Multi-Node-Setup auf und richten ein echtes Monitoring mit Prometheus und Grafana ein. Perfekt für alle, die mehrere Server verwalten oder einen kleinen Hosting-Betrieb aufbauen wollen!

---

🐳 Teil 1: Pterodactyl mit Docker installieren

Die bisherigen Installationen waren "klassisch" – also direkt auf dem System. Docker bringt viele Vorteile: Isolation, einfache Updates und bessere Kontrolle. Hier ist die komplette Docker-Installation .

1.1 Vorbereitung

bash

# Docker und Docker Compose installieren (falls nicht vorhanden)
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Verzeichnisstruktur anlegen
mkdir -p ~/pterodactyl/{panel,wings,database,redis}
cd ~/pterodactyl

1.2 MariaDB (Datenbank) mit Docker Compose

Erstelle database/docker-compose.yml:

yaml

version: '3.8'

services:
  mariadb:
    image: mariadb:10.11
    container_name: pterodactyl-db
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=dein_root_passwort
      - MYSQL_DATABASE=pterodactyl
      - MYSQL_USER=pterodactyl
      - MYSQL_PASSWORD=dein_db_passwort
    volumes:
      - ./data:/var/lib/mysql
    ports:
      - "3306:3306"
    networks:
      - pterodactyl-network

networks:
  pterodactyl-network:
    driver: bridge

Starten:

bash

cd database
docker-compose up -d

1.3 Redis (Cache) einrichten

Erstelle redis/docker-compose.yml:

yaml

version: '3.8'

services:
  redis:
    image: redis:alpine
    container_name: pterodactyl-redis
    restart: unless-stopped
    volumes:
      - ./data:/data
    ports:
      - "6379:6379"
    networks:
      - pterodactyl-network

networks:
  pterodactyl-network:
    external: true

Starten:

bash

cd ../redis
docker-compose up -d

1.4 Pterodactyl Panel mit Docker

Erstelle panel/docker-compose.yml:

yaml

version: '3.8'

services:
  panel:
    image: ghcr.io/pterodactyl/panel:latest
    container_name: pterodactyl-panel
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    environment:
      # App-Konfiguration
      - APP_URL=https://panel.deine-domain.de
      - APP_TIMEZONE=Europe/Berlin
      - APP_SERVICE_AUTHOR=admin@deine-domain.de
      - TRUSTED_PROXIES=*
      
      # Datenbank
      - DB_HOST=pterodactyl-db
      - DB_PORT=3306
      - DB_DATABASE=pterodactyl
      - DB_USERNAME=pterodactyl
      - DB_PASSWORD=dein_db_passwort
      
      # Cache/Redis
      - CACHE_DRIVER=redis
      - SESSION_DRIVER=redis
      - QUEUE_DRIVER=redis
      - REDIS_HOST=pterodactyl-redis
      - REDIS_PORT=6379
      
      # Backup
      - APP_BACKUP_DRIVER=wings
    volumes:
      - ./var:/app/var/
      - ./logs:/app/storage/logs
      - ./nginx:/etc/nginx/http.d/
    networks:
      - pterodactyl-network
    depends_on:
      - mariadb
      - redis

networks:
  pterodactyl-network:
    external: true

Wichtig: Passe die Umgebungsvariablen an deine Domain und Passwörter an .

Starten und Admin anlegen:

bash

cd ../panel
docker-compose up -d

# Admin-Benutzer erstellen
docker-compose run --rm panel php artisan p:user:make

1.5 Wings (Daemon) mit Docker

Erstelle wings/docker-compose.yml:

yaml

version: '3.8'

services:
  wings:
    image: ghcr.io/pterodactyl/wings:latest
    container_name: pterodactyl-wings
    restart: unless-stopped
    privileged: true
    environment:
      - TZ=Europe/Berlin
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /var/lib/docker/containers/:/var/lib/docker/containers/
      - ./config:/etc/pterodactyl/
      - /var/lib/pterodactyl:/var/lib/pterodactyl
    ports:
      - "8080:8080"   # Wings API
      - "2022:2022"   # SFTP
      - "443:443"     # SSL (optional)
    networks:
      - wings-network

networks:
  wings-network:
    driver: bridge

Wichtig: Der Container läuft im privileged Mode, da er Docker-in-Docker benötigt .

Konfiguration: Bevor Wings startet, musst du im Panel einen Node anlegen und die config.yml in ./wings/config/ ablegen. Die Konfiguration holst du aus dem Panel unter Admin → Nodes → [Dein Node] → Configuration.

bash

cd ../wings
# config.yml hier ablegen
nano config/config.yml
# Token aus Panel einfügen
docker-compose up -d

---

🌐 Teil 2: Multi-Node-Setup – Mehrere Server verbinden

Ein echtes Hosting-Setup besteht aus mehreren Nodes (Wings-Instanzen), die von einem zentralen Panel gesteuert werden . So richtest du weitere Nodes ein:

2.1 Neuen Node im Panel anlegen

1. Location erstellen (falls noch nicht vorhanden):
   Admin → Locations → Create New → z.B. "Europe-Frankfurt"

2. Node anlegen:
   Admin → Nodes → Create New

   • Name: z.B. "Node-02"

   • Location: Auswählen

   • FQDN: node2.deine-domain.de (oder IP)

   • Public Ports: z.B. 25565-25600,27015-27030

   • Memory: Gesamt-RAM in MB

   • Disk: Gesamt-Festplatte in MB

   • Daemon Listen Port: 8080 (Standard)

3. Configuration Token kopieren (unter dem Tab "Configuration")

2.2 Zweiten Wings-Server einrichten

Auf dem zweiten Server (frische Maschine):

bash

# Docker installieren
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Wings-Verzeichnis anlegen
mkdir -p ~/pterodactyl/wings
cd ~/pterodactyl/wings

# Docker-Compose-Datei erstellen (gleiche wie oben)
nano docker-compose.yml
# Inhalt von oben einfügen

# Konfigurationsverzeichnis anlegen
mkdir -p config

# Token aus Panel einfügen
nano config/config.yml
# Hier den kompletten Inhalt aus dem Panel (Configuration-Tab) einfügen

# Wings starten
docker-compose up -d

2.3 Node-Verbindung prüfen

Im Panel siehst du unter Admin → Nodes → [Node-02] den Status. Sollte "Connected" anzeigen. Falls nicht:

bash

# Logs prüfen
docker logs pterodactyl-wings

# Häufige Fehler: Falscher Token, Ports nicht erreichbar, Firewall

Architektur im Überblick:

• Panel-Server: Läuft mit Docker (Panel + DB + Redis)

• Node-Server: Läuft nur Wings + Docker

• Alle Nodes kommunizieren über API mit dem Panel 

---

📊 Teil 3: Professionelles Monitoring mit Prometheus & Grafana

Das eingebaute Monitoring von Pterodactyl ist gut, aber für ernsthafte Hosting-Umgebungen brauchst du mehr: Langzeitdaten, Alarme und schöne Dashboards. Hier kommt der Pterodactyl Exporter ins Spiel .

3.1 Was ist der Pterodactyl Exporter?

Ein Python-Skript, das über die Pterodactyl-API Metriken abruft und für Prometheus aufbereitet. Damit kannst du:

• CPU/RAM-Auslastung aller Server über Zeit sehen

• Player-Zahlen tracken

• Alarme bei Überlastung einrichten

• Alles in Grafana visualisieren 

3.2 API-Key erstellen

1. Im Panel zu Account → API Credentials gehen

2. Create API Key

3. Description: "Prometheus Exporter"

4. Permissions: Mindestens Backup → Read für die zu überwachenden Server 

5. Key kopieren (wird später benötigt)

3.3 Pterodactyl Exporter installieren

Methode A: Als Service auf dem Panel-Server

bash

# Python und pip installieren
apt install -y python3 python3-pip python3-venv

# Als eigenständiger Benutzer (empfohlen)
useradd -r -s /bin/false prometheus

# Verzeichnis anlegen
mkdir -p /opt/pterodactyl_exporter
cd /opt/pterodactyl_exporter

# In virtualenv installieren (sauberer)
python3 -m venv venv
source venv/bin/activate
pip install pterodactyl-exporter
deactivate

Konfiguration erstellen config.yml:

yaml

host: panel.deine-domain.de
port: 9531  # Port für Prometheus
api_key: DEIN_API_KEY_HIER
https: true
ignore_ssl: false
server_list_type: all  # oder 'owner'
query_interval: 15  # Sekunden

Systemd-Service einrichten /etc/systemd/system/pterodactyl_exporter.service:

ini

[Unit]
Description=Pterodactyl Prometheus Exporter
After=network-online.target

[Service]
User=prometheus
Group=prometheus
WorkingDirectory=/opt/pterodactyl_exporter
ExecStart=/opt/pterodactyl_exporter/venv/bin/pterodactyl_exporter --config-file=/opt/pterodactyl_exporter/config.yml
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Starten:

bash

systemctl daemon-reload
systemctl enable pterodactyl_exporter
systemctl start pterodactyl_exporter
systemctl status pterodactyl_exporter

Methode B: Mit Docker (einfacher) 

bash

mkdir -p ~/pterodactyl-exporter
cd ~/pterodactyl-exporter

# config.yml herunterladen und anpassen
curl -fsSL -o config.yml https://raw.githubusercontent.com/LOENS2/pterodactyl_exporter/master/config.example.yml
nano config.yml  # API-Key und Host eintragen

# Docker-Compose erstellen
cat > docker-compose.yml <<EOF
version: '3'
services:
  exporter:
    image: loens/pterodactyl-exporter:latest
    container_name: ptero-exporter
    restart: unless-stopped
    ports:
      - "9531:9531"
    volumes:
      - ./config.yml:/app/config.yml
EOF

docker-compose up -d

3.4 Prometheus konfigurieren

In deiner prometheus.yml:

yaml

scrape_configs:
  - job_name: 'pterodactyl'
    static_configs:
      - targets: ['localhost:9531']  # Oder IP des Exporter-Servers
    scrape_interval: 30s

Prometheus neustarten:

bash

systemctl restart prometheus
# Oder docker-compose restart

3.5 Grafana-Dashboard importieren

1. In Grafana einloggen

2. Dashboards → Import

3. ID eingeben: 16575 

4. Datenquelle "Prometheus" auswählen

5. Import

Fertig! Du siehst jetzt:

• CPU-Auslastung pro Server

• RAM-Nutzung

• Disk I/O

• Netzwerk-Traffic

• Player-Zahlen (bei Spielen, die das unterstützen)

• Status aller Container 

3.6 Alarme einrichten (Beispiele)

In Prometheus (oder Alertmanager) kannst du Regeln definieren:

yaml

groups:
  - name: pterodactyl_alerts
    rules:
      - alert: ServerDown
        expr: pterodactyl_server_status == 0
        for: 5m
        annotations:
          summary: "Server {{ $labels.name }} ist down!"

      - alert: HighCPUUsage
        expr: pterodactyl_cpu_usage_percent > 80
        for: 10m
        annotations:
          summary: "Hohe CPU-Last auf {{ $labels.name }}"

---

🔧 Teil 4: Backup-Strategien für Multi-Node

4.1 S3-Backups für alle Nodes

In der Panel-.env (oder als Environment-Variable bei Docker):

bash

APP_BACKUP_DRIVER=s3
AWS_DEFAULT_REGION=eu-central-1
AWS_ACCESS_KEY_ID=dein_key
AWS_SECRET_ACCESS_KEY=dein_secret
AWS_BACKUPS_BUCKET=mein-pterodactyl-backup
AWS_ENDPOINT=https://s3.eu-central-1.wasabisys.com  # für Wasabi

# Für große Backups (optional)
BACKUP_MAX_PART_SIZE=1073741824  # 1GB
BACKUP_PRESIGNED_URL_LIFESPAN=120  # 2 Stunden

Alle Backups werden jetzt zentral in der Cloud gespeichert – unabhängig davon, auf welchem Node der Server läuft .

4.2 Backup-Rotation automatisch

Pterodactyl löscht alte Backups automatisch, wenn du die maximale Anzahl pro Server begrenzt. Im Panel unter Server → Backups kannst du Limits setzen.

4.3 Backup-Node als Feature Request

Aktueller Stand: Backups werden immer auf demselben Node gespeichert, auf dem der Server läuft. Es gibt aber eine Feature-Anfrage für dedizierte Backup-Nodes – also separate Server nur für Backups . Wer das heute schon braucht, muss mit S3 oder externen Skripten arbeiten.

---

🎯 Zusammenfassung & Architektur-Überblick

Dein erweitertes Pterodactyl-Setup sieht jetzt so aus:

text

┌─────────────────────────────────────────────────────┐
│                   Panel-Server                       │
│  ┌──────────────┐  ┌──────────────┐  ┌────────────┐ │
│  │   MariaDB    │  │    Redis     │  │   Panel    │ │
│  │   (Docker)   │  │   (Docker)   │  │  (Docker)  │ │
│  └──────────────┘  └──────────────┘  └────────────┘ │
└─────────────────────────┬───────────────────────────┘
                          │ API
        ┌─────────────────┼─────────────────┐
        │                 │                 │
┌───────▼───────┐ ┌───────▼───────┐ ┌───────▼───────┐
│   Node 01     │ │   Node 02     │ │   Node 03     │
│   (Wings)     │ │   (Wings)     │ │   (Wings)     │
│   + Spiele    │ │   + Spiele    │ │   + Spiele    │
└───────────────┘ └───────────────┘ └───────────────┘

┌─────────────────────────────────────────────────────┐
│               Monitoring-Server                      │
│  ┌──────────────┐  ┌──────────────┐  ┌────────────┐ │
│  │  Prometheus  │  │  Grafana     │  │  Exporter  │ │
│  │              │  │  Dashboard   │  │            │ │
│  └──────────────┘  └──────────────┘  └────────────┘ │
└─────────────────────────────────────────────────────┘

Was du jetzt hast:

Komponente	Funktion
Panel (Docker)	Zentrale Verwaltung aller Server
MariaDB (Docker)	Datenbank für Panel
Redis (Docker)	Cache für bessere Performance
Mehrere Nodes	Verteilte Gameserver
Exporter	Metriken für Monitoring
Prometheus	Zeitreihen-Datenbank
Grafana	Visualisierung + Dashboards
S3-Backups	Zentrale Backup-Speicherung

---

📚 Nützliche Befehle für den Betrieb

bash

# Alle Container logs anzeigen
docker logs pterodactyl-panel
docker logs pterodactyl-wings

# Alle Container neustarten
cd ~/pterodactyl/panel && docker-compose restart
cd ~/pterodactyl/wings && docker-compose restart

# Backup der Panel-Datenbank
docker exec pterodactyl-db mysqldump -u root -p pterodactyl > backup.sql

# Wings-Status auf Node prüfen
curl https://node.deine-domain.de:8080/api/system | jq .

# Exporter-Test
curl http://localhost:9531/metrics | grep pterodactyl

---

🚀 Ausblick

Mit diesem Setup bist du bestens gerüstet für professionelles Game-Server-Hosting. Du kannst jetzt:

• Hunderte Server auf mehreren Maschinen verwalten

• Die Auslastung im Blick behalten

• Automatisch alarmiert werden, wenn etwas schiefgeht

• Zentrale Backups in der Cloud speichern

Nächste Schritte für dich:

• Auto-Scaling überlegen (bei hoher Last automatisch neue Nodes)

• Kostenabrechnung für Kunden einrichten

• Eigene Eggs für exotische Spiele bauen

• Load Balancer vor die Nodes setzen