Crafty Controller für Minecraft mit Docker und Traefik bereitstellen

Jens Schanz

08 Juni 2026 • 10 Min. Lesezeit

Minecraft-Server lassen sich grundsätzlich direkt per Shell verwalten. Sobald jedoch mehrere Server, unterschiedliche Versionen, Backups, Logs oder Benutzerzugriffe ins Spiel kommen, wird die Verwaltung schnell unübersichtlich. Genau hier setzt Crafty Controller an.

Crafty Controller ist ein webbasiertes Management-Panel für Minecraft-Server. Es ermöglicht das Erstellen, Starten, Stoppen, Überwachen und Verwalten von Minecraft-Instanzen über eine komfortable Weboberfläche.

In diesem Beitrag wird Crafty Controller per Docker Compose bereitgestellt und über Traefik mit HTTPS veröffentlicht. Zusätzlich wird der passende Traefik-Stack mit Docker-Provider, Hetzner-DNS-Challenge, HTTP-Challenge-Fallback, Dashboard und Basic Auth eingerichtet.

Ziel des Setups

Das Ziel ist ein sauberer Docker-basierter Betrieb mit folgenden Eigenschaften:

Traefik als zentraler Reverse Proxy
Automatische TLS-Zertifikate über Let’s Encrypt
DNS-Challenge über Hetzner
Optionaler HTTP-Challenge-Fallback
Gesichertes Traefik-Dashboard
Crafty Controller als Docker-Container
Zugriff auf Crafty über HTTPS
Persistente Speicherung von Crafty-Konfiguration, Serverdaten, Logs und Backups
Veröffentlichung eines Minecraft-Portbereichs für mehrere Server
Unterstützung für Dynmap und Bedrock

Architektur

Das Setup besteht aus zwei Docker-Compose-Stacks:

/opt/docker/apps/traefik
├── docker-compose.yml
└── .env

/opt/docker/apps/craftycontrol
├── docker-compose.yml
└── .env

Beide Stacks verwenden dasselbe externe Docker-Netzwerk:

traefik

Traefik veröffentlicht die Webdienste auf Port 80 und 443. Crafty Controller hängt sich per Docker-Labels in Traefik ein und wird über eine eigene Domain veröffentlicht.

Voraussetzungen

Für dieses Setup werden folgende Komponenten vorausgesetzt:

Ein Linux-Server mit Docker und Docker Compose
Eine Domain bei Hetzner DNS oder Zugriff auf die DNS-Zone über Hetzner API
Ein Hetzner DNS API Token
Port 80 und 443 öffentlich erreichbar
Optional: Firewall-Freigaben für Minecraft-Serverports

Beispiel-Domains:

traefik-abc123.domain.tld
control.domain.tld

Die DNS-Einträge müssen auf die öffentliche IP-Adresse des Docker-Hosts zeigen.

Teil 1: Traefik Reverse Proxy bereitstellen

Verzeichnisstruktur für Traefik vorbereiten

Zuerst wird das Projektverzeichnis für Traefik erstellt:

mkdir -p /opt/docker/apps/traefik
cd /opt/docker/apps/traefik

Danach werden die persistenten Verzeichnisse für Zertifikate und Logs angelegt:

mkdir -p /opt/docker/volumes/traefik/letsencrypt
mkdir -p /opt/docker/volumes/traefik/logs

Die Datei für die Let’s-Encrypt-Zertifikate sollte restriktive Berechtigungen erhalten:

touch /opt/docker/volumes/traefik/letsencrypt/acme.json
chmod 600 /opt/docker/volumes/traefik/letsencrypt/acme.json

Externes Docker-Netzwerk erstellen

Traefik und alle später veröffentlichten Anwendungen sollen über ein gemeinsames externes Docker-Netzwerk kommunizieren.

docker network create traefik

Falls das Netzwerk bereits existiert, ist dieser Schritt nicht erneut notwendig.

Prüfen kann man das Netzwerk mit:

docker network ls

Basic-Auth-Hash für das Traefik-Dashboard erzeugen

Das Traefik-Dashboard sollte nicht ungeschützt veröffentlicht werden. Für Basic Auth wird ein Hash benötigt.

Beispiel mit htpasswd:

apt install apache2-utils -y
htpasswd -nbB admin 'DEIN_SICHERES_PASSWORT'

Die Ausgabe sieht ungefähr so aus:

admin:$2y$05$XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

In der .env-Datei wird später nur der Hash-Teil hinter admin: verwendet oder der vollständige Wert passend escaped.

Wichtig: In Docker-Compose-Labels müssen Dollarzeichen häufig doppelt escaped werden. Aus:

$2y$05$...

wird dann:

$$2y$$05$$...

Traefik `.env`

Im Traefik-Projektverzeichnis wird eine .env-Datei erstellt:

nano /opt/docker/apps/traefik/.env

Inhalt:

TRAEFIK_ACME_EMAIL=noreply@domain.tld
TRAEFIK_DASHBOARD_HOST=traefik-abc123.domain.tld
TRAEFIK_BASIC_AUTH_HASH=<AUTH-HASH>
HETZNER_API_TOKEN=<HETZNER-DNS-API-TOKEN>

Erklärung der Variablen

TRAEFIK_ACME_EMAIL - E-Mail-Adresse für Let’s Encrypt
TRAEFIK_DASHBOARD_HOST - Domain für das Traefik-Dashboard
TRAEFIK_BASIC_AUTH_HASH - Passwort-Hash für Basic Auth
HETZNER_API_TOKEN - API Token für die Hetzner DNS-Challenge

Der Hetzner API Token sollte niemals öffentlich geteilt, in Git gespeichert oder in Screenshots gezeigt werden.

Traefik `docker-compose.yml`

Nun wird die Datei docker-compose.yml erstellt:

nano /opt/docker/apps/traefik/docker-compose.yml

Inhalt:

# Traefik reverse proxy configuration
#
# Startet Traefik mit Docker-Provider, ACME-Zertifikaten via Hetzner DNS
# und einem gesicherten Dashboard auf Port 443.

services:
  traefik:
    image: traefik:latest
    container_name: traefik
    restart: unless-stopped

    command:
      # Dashboard
      - "--api.dashboard=true"
      - "--api.insecure=false"

      # EntryPoints
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"

      # Docker Provider
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"

      # Backend TLS
      - "--serverstransport.insecureskipverify=true"

      # ===== ACME via Hetzner DNS =====
      - "--certificatesresolvers.hetzner.acme.dnschallenge=true"
      - "--certificatesresolvers.hetzner.acme.dnschallenge.provider=hetzner"
      - "--certificatesresolvers.hetzner.acme.dnschallenge.delayBeforeCheck=60"
      - "--certificatesresolvers.hetzner.acme.email=${TRAEFIK_ACME_EMAIL}"
      - "--certificatesresolvers.hetzner.acme.storage=/letsencrypt/acme.json"
      - "--certificatesresolvers.hetzner.acme.dnschallenge.resolvers=1.1.1.1:53,8.8.8.8:53"

      # ===== Fallback ACME via HTTP =====
      - "--certificatesresolvers.http.acme.httpchallenge=true"
      - "--certificatesresolvers.http.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.http.acme.email=${TRAEFIK_ACME_EMAIL}"
      - "--certificatesresolvers.http.acme.storage=/letsencrypt/acme.json"

      # Logging
      - "--log.level=DEBUG"

      # Access Logs
      - "--accesslog=true"
      - "--accesslog.filepath=/var/log/traefik/access.log"
      - "--accesslog.format=json"
      - "--accesslog.bufferingsize=100"

    ports:
      - "80:80"
      - "443:443"

    env_file:
      - .env

    environment:
      - HETZNER_API_TOKEN=${HETZNER_API_TOKEN}

    labels:
      - "traefik.enable=true"

      # Dashboard Route
      - "traefik.http.routers.traefik.rule=Host(`${TRAEFIK_DASHBOARD_HOST}`)"
      - "traefik.http.routers.traefik.entrypoints=websecure"
      - "traefik.http.routers.traefik.service=api@internal"
      - "traefik.http.routers.traefik.tls=true"
      - "traefik.http.routers.traefik.tls.certresolver=hetzner"

      # Basic Auth
      - "traefik.http.routers.traefik.middlewares=auth"
      - "traefik.http.middlewares.auth.basicauth.users=admin:${TRAEFIK_BASIC_AUTH_HASH}"

      # Optional: Security Headers
      - "traefik.http.middlewares.secure.headers.stsSeconds=31536000"
      - "traefik.http.middlewares.secure.headers.stsIncludeSubdomains=true"
      - "traefik.http.middlewares.secure.headers.stsPreload=true"

    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /opt/docker/volumes/traefik/letsencrypt:/letsencrypt
      - /opt/docker/volumes/traefik/logs:/var/log/traefik

    networks:
      - traefik

networks:
  traefik:
    external: true

Hinweise zur Traefik-Konfiguration

Docker Provider

- "--providers.docker=true"
- "--providers.docker.exposedbydefault=false"

Traefik liest Docker-Container und deren Labels automatisch aus. Durch exposedbydefault=false werden Container aber nicht automatisch veröffentlicht. Jeder Dienst muss explizit mit folgendem Label aktiviert werden:

- "traefik.enable=true"

Das ist aus Sicherheitsgründen sinnvoll.

Backend TLS

- "--serverstransport.insecureskipverify=true"

Diese Einstellung erlaubt Traefik, HTTPS-Backends mit selbstsignierten oder intern nicht vertrauenswürdigen Zertifikaten anzusprechen.

Das ist für Crafty Controller relevant, weil Crafty intern auf Port 8443 per HTTPS läuft. Ohne diese Option kann es passieren, dass Traefik das Backend aufgrund eines Zertifikatsfehlers nicht sauber erreicht.

Hetzner DNS-Challenge

- "--certificatesresolvers.hetzner.acme.dnschallenge=true"
- "--certificatesresolvers.hetzner.acme.dnschallenge.provider=hetzner"

Mit der DNS-Challenge kann Traefik Let’s-Encrypt-Zertifikate ausstellen, indem ein TXT-Eintrag in der DNS-Zone gesetzt wird. Das funktioniert auch für Dienste, die nicht direkt über Port 80 erreichbar sind.

Der Hetzner API Token wird über die .env-Datei geladen:

environment:
  - HETZNER_API_TOKEN=${HETZNER_API_TOKEN}

HTTP-Challenge als Fallback

Zusätzlich ist ein HTTP-Challenge-Resolver definiert:

- "--certificatesresolvers.http.acme.httpchallenge=true"
- "--certificatesresolvers.http.acme.httpchallenge.entrypoint=web"

Dieser Resolver kann verwendet werden, wenn eine Domain direkt per HTTP erreichbar ist. In diesem Setup wird für das Traefik-Dashboard der Resolver hetzner verwendet, während Crafty Controller später wahlweise den Resolver http oder hetzner verwenden kann.

Traefik-Dashboard

Das Dashboard wird über folgende Domain veröffentlicht:

TRAEFIK_DASHBOARD_HOST=traefik-abc123.domain.tld

Der Zugriff erfolgt über:

https://traefik-abc123.domain.tld

Da das Dashboard über api@internal veröffentlicht wird, ist kein separater Port notwendig.

Traefik starten

Der Traefik-Stack wird mit folgendem Befehl gestartet:

cd /opt/docker/apps/traefik
docker compose up -d

Status prüfen:

docker compose ps

Logs anzeigen:

docker logs -f traefik

Oder:

docker compose logs -f

Nach erfolgreichem Start sollte das Dashboard erreichbar sein:

https://traefik-abc123.domain.tld

Teil 2: Crafty Controller bereitstellen

Verzeichnisstruktur für Crafty vorbereiten

Nun wird das Projektverzeichnis für Crafty Controller erstellt:

mkdir -p /opt/docker/apps/craftycontrol
cd /opt/docker/apps/craftycontrol

Zusätzlich werden die persistenten Datenverzeichnisse vorbereitet:

mkdir -p /opt/docker/volumes/craftycontrol/backups
mkdir -p /opt/docker/volumes/craftycontrol/logs
mkdir -p /opt/docker/volumes/craftycontrol/servers
mkdir -p /opt/docker/volumes/craftycontrol/config
mkdir -p /opt/docker/volumes/craftycontrol/import

Diese Verzeichnisse sorgen dafür, dass wichtige Daten auch nach einem Container-Neustart oder Image-Update erhalten bleiben.

Crafty `.env`

Die Konfiguration von Crafty Controller wird ebenfalls in eine .env-Datei ausgelagert:

nano /opt/docker/compose/craftycontrol/.env

Inhalt:

APP_NAME=craftycontrol
APP_ROUTER=craftycontrol
DOMAIN=control.domain.tld

TRAEFIK_NETWORK=traefik
TRAEFIK_CERTRESOLVER=http

APP_PORT=8443
APP_SERVER_SCHEME=https

Erklärung der Variablen

APP_NAME - Name der Anwendung
APP_ROUTER - Name des Traefik-Routers und Services
DOMAIN - Domain für das Crafty-Webinterface
TRAEFIK_NETWORK - Externes Docker-Netzwerk, in dem Traefik erreichbar ist
TRAEFIK_CERTRESOLVER - Zertifikatsresolver in Traefik
APP_PORT - Interner Port des Crafty-Webinterfaces
APP_SERVER_SCHEME - Protokoll zum Backend-Container

Wichtig ist:

APP_PORT=8443
APP_SERVER_SCHEME=https

Crafty Controller stellt sein Webinterface intern über HTTPS auf Port 8443 bereit. Deshalb muss Traefik nicht nur den richtigen Port verwenden, sondern auch wissen, dass das Backend per HTTPS angesprochen wird.

Wenn die Zertifikate ebenfalls über Hetzner DNS ausgestellt werden sollen, kann der Resolver angepasst werden:

TRAEFIK_CERTRESOLVER=hetzner

Wenn die Domain direkt über Port 80 erreichbar ist, kann auch der HTTP-Resolver genutzt werden:

TRAEFIK_CERTRESOLVER=http

Crafty `docker-compose.yml`

Nun wird die Datei docker-compose.yml erstellt:

nano /opt/docker/compose/craftycontrol/docker-compose.yml

Inhalt:

services:
  crafty:
    container_name: crafty_container
    image: registry.gitlab.com/crafty-controller/crafty-4:latest
    restart: always
    environment:
      - TZ=Europe/Berlin

    ports:
      # - "8443:8443" # HTTPS direkt, normalerweise nicht nötig bei Traefik
      - "8123:8123" # Dynmap
      - "19132:19132/udp" # Bedrock
      - "25500-25600:25500-25600" # Minecraft Server Port Range

    networks:
      - ${TRAEFIK_NETWORK}

    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=${TRAEFIK_NETWORK}"

      # ===== HTTPS Router =====
      - "traefik.http.routers.${APP_ROUTER}-secure.entrypoints=websecure"
      - "traefik.http.routers.${APP_ROUTER}-secure.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.${APP_ROUTER}-secure.tls=true"
      - "traefik.http.routers.${APP_ROUTER}-secure.tls.certresolver=${TRAEFIK_CERTRESOLVER}"
      - "traefik.http.routers.${APP_ROUTER}-secure.service=${APP_ROUTER}-svc"

      # ===== HTTP → HTTPS Redirect =====
      - "traefik.http.routers.${APP_ROUTER}.entrypoints=web"
      - "traefik.http.routers.${APP_ROUTER}.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.${APP_ROUTER}.middlewares=redirect-to-https"

      # ===== Service Definition =====
      - "traefik.http.services.${APP_ROUTER}-svc.loadbalancer.server.port=${APP_PORT}"
      - "traefik.http.services.${APP_ROUTER}-svc.loadbalancer.server.scheme=${APP_SERVER_SCHEME}"

      # ===== Middlewares =====
      - "traefik.http.middlewares.redirect-to-https.redirectscheme.scheme=https"
      - "traefik.http.middlewares.redirect-to-https.redirectscheme.permanent=true"

    volumes:
      - /opt/docker/volumes/craftycontrol/backups:/crafty/backups
      - /opt/docker/volumes/craftycontrol/logs:/crafty/logs
      - /opt/docker/volumes/craftycontrol/servers:/crafty/servers
      - /opt/docker/volumes/craftycontrol/config:/crafty/app/config
      - /opt/docker/volumes/craftycontrol/import:/crafty/import

networks:
  traefik:
    external: true
    name: ${TRAEFIK_NETWORK}

Warum Port 8443 nicht direkt veröffentlicht wird

In der Compose-Datei ist der Port 8443 bewusst auskommentiert:

# - "8443:8443" # HTTPS

Da der Zugriff auf das Crafty-Webinterface über Traefik erfolgen soll, muss der Port nicht direkt auf dem Host veröffentlicht werden. Traefik erreicht den Container intern über das gemeinsame Docker-Netzwerk und veröffentlicht die Anwendung anschließend sauber per HTTPS über die definierte Domain.

Der Zugriff erfolgt dadurch nicht über:

https://server-ip:8443

sondern über:

https://control.domain.tld

Das ist sauberer, sicherer und besser wartbar.

Veröffentlichte Ports für Minecraft

Neben dem Webinterface werden weitere Ports veröffentlicht:

- "8123:8123"
- "19132:19132/udp"
- "25500-25600:25500-25600"

Dynmap

Port 8123 wird häufig für Dynmap genutzt:

- "8123:8123"

Damit kann eine dynamische Minecraft-Karte über den Browser bereitgestellt werden, sofern Dynmap auf einem Minecraft-Server installiert und entsprechend konfiguriert ist.

Bedrock

Für Minecraft Bedrock wird UDP-Port 19132 veröffentlicht:

- "19132:19132/udp"

Das ist relevant, wenn neben Java-Servern auch Bedrock-Server oder entsprechende Crossplay-Setups betrieben werden sollen.

Minecraft Java Portbereich

Der Bereich 25500-25600 wird für Minecraft-Server veröffentlicht:

- "25500-25600:25500-25600"

Dadurch können mehrere Minecraft-Instanzen mit unterschiedlichen Ports betrieben werden, zum Beispiel:

25565
25566
25567

In Crafty Controller kann dann jedem Server ein eigener Port zugewiesen werden.

Crafty Controller starten

Nachdem die Dateien erstellt wurden, kann Crafty Controller gestartet werden:

cd /opt/docker/apps/craftycontrol
docker compose up -d

Den Status prüft man mit:

docker compose ps

Die Logs können wie folgt angezeigt werden:

docker logs -f crafty_container

Alternativ:

docker compose logs -f

Initialer Zugriff auf Crafty Controller

Nach dem Start sollte das Webinterface über die konfigurierte Domain erreichbar sein:

https://control.domain.tld

Falls der Zugriff nicht funktioniert, sollten folgende Punkte geprüft werden:

docker network ls
docker compose ps
docker logs -f crafty_container
docker logs -f traefik

Typische Fehlerquellen sind:

DNS zeigt nicht auf den Server
Traefik-Netzwerk existiert nicht
Traefik und Crafty befinden sich nicht im gleichen Docker-Netzwerk
falscher Zertifikatsresolver
Hetzner API Token ungültig
APP_SERVER_SCHEME=https fehlt
--serverstransport.insecureskipverify=true fehlt in Traefik
Port 8443 wurde nicht als interner Service-Port gesetzt
Firewall blockiert Port 80 oder 443

Teil 3: Betrieb und Wartung

Datenpersistenz

Die wichtigsten Crafty-Daten werden außerhalb des Containers gespeichert:

volumes:
  - /opt/docker/volumes/craftycontrol/backups:/crafty/backups
  - /opt/docker/volumes/craftycontrol/logs:/crafty/logs
  - /opt/docker/volumes/craftycontrol/servers:/crafty/servers
  - /opt/docker/volumes/craftycontrol/config:/crafty/app/config
  - /opt/docker/volumes/craftycontrol/import:/crafty/import

Damit bleiben folgende Daten erhalten:

Backups
- /opt/docker/volumes/craftycontrol/backups -> /crafty/backups
Logdateien
- /opt/docker/volumes/craftycontrol/logs -> /crafty/logs
Minecraft Serverdaten
- /opt/docker/volumes/craftycontrol/servers -> /crafty/servers
Crafty-Konfiguration
- /opt/docker/volumes/craftycontrol/config -> /crafty/app/config
Import-Verzeichnis
- /opt/docker/volumes/craftycontrol/import -> /crafty/import

Gerade das Server-Verzeichnis ist besonders wichtig, da hier die eigentlichen Minecraft-Welten und Serverdateien liegen.

Updates durchführen

Ein Update von Traefik erfolgt mit:

cd /opt/docker/apps/traefik
docker compose pull
docker compose up -d

Ein Update von Crafty Controller erfolgt mit:

cd /opt/docker/apps/craftycontrol
docker compose pull
docker compose up -d

Nicht mehr verwendete Images können anschließend entfernt werden:

docker image prune

Vor Updates sollten Backups geprüft oder manuell erstellt werden.

Backup-Empfehlung

Zusätzlich zu den internen Crafty-Backups sollten die persistenten Verzeichnisse regelmäßig gesichert werden:

tar -czf craftycontrol-backup-$(date +%F).tar.gz /opt/docker/volumes/craftycontrol

Optional kann auch Traefik gesichert werden:

tar -czf traefik-backup-$(date +%F).tar.gz /opt/docker/volumes/traefik

Das Crafty-Backup enthält Konfiguration, Logs, Serverdaten, Backups und Importdaten.

Das Traefik-Backup enthält insbesondere die Let’s-Encrypt-Zertifikatsdatenbank acme.json.

Firewall-Hinweise

Je nach Umgebung müssen folgende Ports auf dem Host oder in der externen Firewall freigegeben werden:

TCP/80 - HTTP, ACME HTTP-Challenge und Redirect auf HTTPS
TCP/443 - HTTPS über Traefik
TCP/8123 - Dynmap
UDP/19132 - Minecraft Bedrock
TCP/25500-25600 - Minecraft Java Server

Der Crafty-Webinterface-Port 8443 muss nicht öffentlich freigegeben werden, wenn der Zugriff ausschließlich über Traefik erfolgt.

Beispiel mit UFW

Falls UFW verwendet wird, könnten die Freigaben beispielhaft so aussehen:

ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 8123/tcp
ufw allow 19132/udp
ufw allow 25500:25600/tcp

Anschließend kann der Status geprüft werden:

ufw status verbose

Sicherheitshinweise

Crafty Controller ist ein Verwaltungsinterface für Minecraft-Server und sollte entsprechend geschützt werden.

Empfehlenswert sind insbesondere:

Zugriff nur per HTTPS
starke Passwörter
keine direkte Veröffentlichung von Port 8443
regelmäßige Updates
regelmäßige Backups
restriktive Firewall-Regeln
Traefik-Dashboard niemals ohne Authentifizierung veröffentlichen
Hetzner API Token niemals öffentlich speichern oder teilen
optional Zugriff auf Crafty zusätzlich per IP-Allowlist, VPN, Tailscale oder Headscale begrenzen

Wer das Panel nur selbst nutzt, kann überlegen, den Zugriff auf das Webinterface ausschließlich über VPN oder ein privates Overlay-Netzwerk zu erlauben.

Fehlersuche

Traefik erkennt Crafty nicht

Prüfen, ob der Container Labels besitzt und im richtigen Netzwerk hängt:

docker inspect crafty_container
docker network inspect traefik

Bad Gateway beim Aufruf von Crafty

Wahrscheinliche Ursachen:

falscher interner Port
falsches Backend-Schema
TLS-Zertifikat des Backends wird nicht akzeptiert

Wichtige Einstellungen:

APP_PORT=8443
APP_SERVER_SCHEME=https

Und in Traefik:

- "--serverstransport.insecureskipverify=true"

Zertifikat wird nicht erstellt

Logs prüfen:

docker logs -f traefik

Typische Ursachen:

DNS-Eintrag fehlt
Hetzner API Token ungültig
falscher Zertifikatsresolver
Port 80 nicht erreichbar bei HTTP-Challenge
DNS-Challenge noch nicht propagiert

Fazit

Mit Docker Compose, Traefik und einer ausgelagerten .env-Struktur lässt sich Crafty Controller sauber und flexibel bereitstellen. Traefik übernimmt die HTTPS-Terminierung, Zertifikatsverwaltung und Veröffentlichung der Weboberfläche. Crafty Controller selbst bleibt intern über Docker erreichbar und muss seinen Webinterface-Port 8443 nicht direkt auf dem Host veröffentlichen.

Das Setup eignet sich besonders gut, wenn mehrere Minecraft-Server zentral verwaltet werden sollen. Durch die persistenten Volumes bleiben Konfiguration, Welten, Logs und Backups dauerhaft erhalten und können einfach gesichert oder migriert werden.

In Kombination mit Traefik entsteht eine robuste Grundlage für den Betrieb eigener Minecraft-Server mit komfortabler Verwaltung, automatischen Zertifikaten und sauberer Trennung zwischen Reverse Proxy und Anwendung.

Ziel des Setups

Architektur

Voraussetzungen

Teil 1: Traefik Reverse Proxy bereitstellen

Verzeichnisstruktur für Traefik vorbereiten

Externes Docker-Netzwerk erstellen

Basic-Auth-Hash für das Traefik-Dashboard erzeugen

Traefik .env

Traefik docker-compose.yml

Hinweise zur Traefik-Konfiguration

Traefik-Dashboard

Traefik starten

Teil 2: Crafty Controller bereitstellen

Verzeichnisstruktur für Crafty vorbereiten

Crafty .env

Crafty docker-compose.yml

Crafty Controller starten

Initialer Zugriff auf Crafty Controller

Teil 3: Betrieb und Wartung

Datenpersistenz

Updates durchführen

Backup-Empfehlung

Firewall-Hinweise

Beispiel mit UFW

Sicherheitshinweise

Fehlersuche

Traefik erkennt Crafty nicht

Bad Gateway beim Aufruf von Crafty

Zertifikat wird nicht erstellt

Fazit

Traefik `.env`

Traefik `docker-compose.yml`

Crafty `.env`

Crafty `docker-compose.yml`