FiveM Server mit Docker betreiben: Komplette Einrichtungsanleitung

Einen FiveM-Server in Docker zu betreiben gibt dir Umgebungskonsistenz, vereinfachte Backups, reproduzierbare Deployments und die Möglichkeit, mehrere isolierte Server-Instanzen auf einem einzigen Host zu betreiben. Wenn du jemals Stunden damit verbracht hast, einen Server zu debuggen, der auf einer Maschine funktioniert aber auf einer anderen nicht, eliminiert Docker dieses Problem vollständig.

Diese Anleitung führt dich durch den kompletten Prozess: vom Erstellen deines Dockerfiles bis zum Betrieb eines produktionsreifen FiveM-Servers mit docker-compose, persistentem Speicher, txAdmin und ordentlichem Ressourcen-Management.

Voraussetzungen

Bevor du startest, stelle sicher, dass du hast:

• Einen Linux VPS oder dedizierten Server (Ubuntu 22.04+ oder Debian 12+ empfohlen)
• Docker Engine 24+ und Docker Compose v2 installiert
• Einen Cfx.re-Account mit gültigem Server-Lizenzschlüssel
• Grundlegende Vertrautheit mit der Linux-Kommandozeile

Falls Docker noch nicht installiert ist, dauert die offizielle Installation weniger als eine Minute:

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

Melde dich ab und wieder an, damit die Gruppenänderung wirksam wird. Überprüfe mit docker --version und docker compose version.

Projektstruktur

Organisiere dein FiveM-Docker-Setup mit einer sauberen Verzeichnisstruktur. Diese Trennung hält deine Konfiguration, Ressourcen und Daten übersichtlich:

fivem-server/
├── docker-compose.yml       # Container-Orchestrierung
├── Dockerfile               # Server-Image-Definition
├── server-data/
│   ├── server.cfg           # FiveM-Server-Konfiguration
│   └── resources/           # Deine Scripts und Assets
│       ├── [system]/
│       ├── [gameplay]/
│       └── [maps]/
├── txData/                  # txAdmin persistente Daten
└── backups/                 # Automatisches Backup-Ziel

Erstelle die Grundstruktur:

mkdir -p fivem-server/{server-data/resources,txData,backups}
cd fivem-server

Das Dockerfile

Das Dockerfile baut ein minimales Image, das die neuesten FiveM-Server-Artifacts herunterlädt und die Laufzeitumgebung einrichtet:

FROM debian:12-slim

ARG FIVEM_VERSION=latest

RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        ca-certificates \
        curl \
        xz-utils \
        libatomic1 \
    && rm -rf /var/lib/apt/lists/*

RUN mkdir -p /opt/fivem /txData

# FiveM Server-Artifacts herunterladen und entpacken
RUN DOWNLOAD_URL=$(curl -s "https://changelogs-live.fivem.net/api/changelog/versions/linux/server" \
    | grep -oP '"latest":"[^"]*"' | head -1 | grep -oP 'https[^"]*') \
    && curl -Lo /tmp/fx-server.tar.xz "$DOWNLOAD_URL" \
    && tar -xf /tmp/fx-server.tar.xz -C /opt/fivem --strip-components=1 \
    && rm /tmp/fx-server.tar.xz

WORKDIR /opt/fivem

# FiveM Game-Port (UDP + TCP)
EXPOSE 30120/tcp
EXPOSE 30120/udp

# txAdmin Webinterface
EXPOSE 40120/tcp

ENTRYPOINT ["/opt/fivem/run.sh"]
CMD ["+exec", "/server-data/server.cfg"]

Baue das Image:

docker build -t fivem-server:latest .

Das Image wiegt ca. 200-300 MB — deutlich kleiner als eine vollständige Ubuntu-Installation mit denselben Abhängigkeiten.

Docker Compose Konfiguration

Docker Compose definiert, wie dein Container läuft, einschließlich Port-Mappings, Volume-Mounts, Ressourcen-Limits und Restart-Verhalten. Hier werden die operativen Vorteile von Docker greifbar.

Erstelle docker-compose.yml:

services:
  fivem:
    build: .
    image: fivem-server:latest
    container_name: fivem-server
    restart: unless-stopped
    stdin_open: true
    tty: true

    ports:
      - "30120:30120/tcp"
      - "30120:30120/udp"
      - "40120:40120/tcp"  # txAdmin

    volumes:
      - ./server-data:/server-data
      - ./txData:/txData

    environment:
      - TXADMIN_PORT=40120

    deploy:
      resources:
        limits:
          memory: 8G
        reservations:
          memory: 4G

    logging:
      driver: json-file
      options:
        max-size: "50m"
        max-file: "5"

Wichtige Entscheidungen in dieser Konfiguration:

• restart: unless-stopped stellt sicher, dass der Server nach Abstürzen oder Host-Neustarts zurückkommt, ohne Container neu zu starten, die du absichtlich gestoppt hast.
• Volume-Mounts halten deine Serverdaten und txAdmin-Konfiguration außerhalb des Containers. Ein Rebuild oder Update des Images berührt deine Daten nie.
• Speicher-Limits verhindern, dass ein Ressourcen-Leak oder schlecht geschriebenes Script den gesamten Host-RAM verbraucht und andere Dienste zum Absturz bringt.
• Log-Rotation verhindert, dass Docker-Logs deine Festplatte über Zeit füllen — ein häufiges Problem bei langlebigen Game-Servern.

Server-Konfiguration

Erstelle deine server-data/server.cfg mit den wesentlichen Direktiven:

# Server-Identität
sv_hostname "Mein Docker FiveM Server"
sv_projectName "Mein Server"
sv_projectDesc "Ein containerisierter FiveM-Server"
sets sv_projectName "Mein Server"

# Lizenz und Authentifizierung
sv_licenseKey "dein-lizenzschlüssel-hier"
sv_maxclients 32

# Netzwerk
endpoint_add_tcp "0.0.0.0:30120"
endpoint_add_udp "0.0.0.0:30120"

# Sicherheit
sv_scriptHookAllowed 0
set steam_webApiKey ""

# txAdmin
set txAdminPort 40120

# Ressourcen
ensure mapmanager
ensure spawnmanager
ensure sessionmanager
ensure basic-gamemode
ensure hardcap
ensure chat
ensure monitor

Ersetze dein-lizenzschlüssel-hier mit deinem tatsächlichen Cfx.re-Lizenzschlüssel. Du kannst einen auf keymaster.fivem.net generieren.

Server starten

Starte den Server mit einem einzigen Befehl:

docker compose up -d

Überwache den Startvorgang:

docker compose logs -f fivem

Du solltest sehen, wie der FiveM-Server initialisiert, Ressourcen lädt und schließlich die Server-Startmeldung anzeigt. txAdmin ist unter http://deine-server-ip:40120 erreichbar, sobald der Container läuft.

Zum geordneten Stoppen:

docker compose down

Zum Neustart nach Konfigurationsänderungen:

docker compose restart fivem

txAdmin-Einrichtung in Docker

Wenn du http://deine-server-ip:40120 zum ersten Mal aufrufst, führt txAdmin dich durch den Einrichtungsassistenten:

1. Erstelle deinen txAdmin-Admin-Account (getrennt von deinem Cfx.re-Account)
2. Verknüpfe deinen Cfx.re-Account zur Lizenzvalidierung
3. Wähle den Server-Datenpfad — zeige auf /server-data
4. Wähle dein Server-Template oder zeige auf deine bestehende server.cfg

Das txAdmin-Datenverzeichnis (/txData) ist als Volume gemountet, sodass deine Admin-Accounts, Spieler-Bans, geplante Neustarts und Backups Container-Rebuilds überstehen.

Ressourcen und Scripts hinzufügen

Installiere Scripts in dein server-data/resources/-Verzeichnis auf dem Host. Änderungen sind sofort im Container sichtbar dank des Volume-Mounts — kein Rebuild nötig.

# Beispiel: Ressource von GitHub installieren
cd server-data/resources/
git clone https://github.com/example/my-resource.git

# Dann in server.cfg eintragen
echo 'ensure my-resource' >> ../server.cfg

Starte den Server neu, um neue Ressourcen zu laden:

docker compose restart fivem

Für eine kuratierte Sammlung von FiveM-Scripts und Mods, durchstöbere unsere Free-Mods-Bibliothek oder den Premium-Shop für produktionsreife Ressourcen mit garantierter Kompatibilität.

Persistenter Speicher und Backups

Docker-Volumes stellen sicher, dass deine Daten Container-Neustarts, Updates und Rebuilds überleben. Die zwei kritischen Verzeichnisse sind:

• ./server-data: Deine Server-Konfiguration, Ressourcen und dateibasierte Daten
• ./txData: txAdmin-Konfiguration, Spieler-Datenbank, Ban-Listen und Admin-Accounts

Automatisiere Backups mit einem einfachen Cron-Job:

# In crontab eintragen (crontab -e)
0 4 * * * cd /path/to/fivem-server && tar -czf backups/backup-$(date +\%Y\%m\%d).tar.gz server-data/ txData/ --exclude='server-data/cache'

Das erstellt ein tägliches komprimiertes Backup um 4 Uhr morgens, ohne das Cache-Verzeichnis, das regeneriert werden kann. Rotiere alte Backups, um Festplatten-Füllstand zu verhindern:

# Letzte 14 Tage an Backups behalten
find /path/to/fivem-server/backups -name "backup-*.tar.gz" -mtime +14 -delete

FiveM-Server aktualisieren

Ein Dockerisierter FiveM-Server zu aktualisieren ist sauber und vorhersagbar. Deine Serverdaten bleiben unberührt — nur die Server-Artifacts ändern sich:

# Image mit neuesten Artifacts neu bauen
docker compose build --no-cache fivem

# Mit dem neuen Image neustarten
docker compose up -d fivem

Falls nach einem Update etwas kaputt geht, ist ein Rollback sofort möglich:

# Tagge dein aktuelles funktionierendes Image vor dem Update
docker tag fivem-server:latest fivem-server:backup

# Falls das Update Probleme verursacht, zurücksetzen
docker tag fivem-server:backup fivem-server:latest
docker compose up -d fivem

Diese Rollback-Fähigkeit allein macht Docker den Einrichtungsaufwand wert. Bei einer Bare-Metal-Installation bedeutet das Rückgängigmachen eines schlechten Updates manuelles Wiederherstellen von Dateien und Hoffen, dass nichts vergessen wurde.

Mehrere Server betreiben

Einer der stärksten Vorteile von Docker für FiveM-Hosting ist das Betreiben mehrerer isolierter Server-Instanzen auf einem einzigen Host. Jeder Server bekommt seinen eigenen Container, Ports und Daten:

services:
  fivem-main:
    build: .
    container_name: fivem-main
    restart: unless-stopped
    ports:
      - "30120:30120/tcp"
      - "30120:30120/udp"
      - "40120:40120/tcp"
    volumes:
      - ./servers/main/server-data:/server-data
      - ./servers/main/txData:/txData
    deploy:
      resources:
        limits:
          memory: 8G

  fivem-test:
    build: .
    container_name: fivem-test
    restart: unless-stopped
    ports:
      - "30121:30120/tcp"
      - "30121:30120/udp"
      - "40121:40120/tcp"
    volumes:
      - ./servers/test/server-data:/server-data
      - ./servers/test/txData:/txData
    deploy:
      resources:
        limits:
          memory: 4G

Starte beide Server:

docker compose up -d

Jeder Server ist komplett isoliert. Du kannst Scripts auf dem Test-Server testen, ohne deine Produktionsumgebung zu gefährden.

Datenbank-Integration

Die meisten FiveM-Server brauchen eine MySQL- oder MariaDB-Datenbank für Frameworks wie ESX, QBCore oder QBox. Füge sie zu deiner docker-compose.yml hinzu:

services:
  fivem:
    build: .
    container_name: fivem-server
    restart: unless-stopped
    depends_on:
      - db
    ports:
      - "30120:30120/tcp"
      - "30120:30120/udp"
      - "40120:40120/tcp"
    volumes:
      - ./server-data:/server-data
      - ./txData:/txData
    deploy:
      resources:
        limits:
          memory: 8G

  db:
    image: mariadb:11
    container_name: fivem-db
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: "aendere-dieses-starke-passwort"
      MYSQL_DATABASE: "fivem"
      MYSQL_USER: "fivem"
      MYSQL_PASSWORD: "aendere-das-auch"
    ports:
      - "3306:3306"
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data:

In deiner Ressourcen-Datenbankkonfiguration (z.B. oxmysql oder mysql-async) verwende db als Hostname, da Docker Compose ein internes Netzwerk erstellt, in dem Container sich gegenseitig über Servicenamen erreichen können:

set mysql_connection_string "mysql://fivem:aendere-das-auch@db:3306/fivem?charset=utf8mb4"

Produktions-Härtung

Bevor du deinen Dockerisierten FiveM-Server für Spieler freigibst, wende diese Produktions-Best-Practices an:

Firewall-Regeln

Gib nur die Ports frei, die du tatsächlich brauchst:

# FiveM Game-Traffic erlauben
sudo ufw allow 30120/tcp
sudo ufw allow 30120/udp

# txAdmin (wenn möglich auf deine IP beschränken)
sudo ufw allow from DEINE_IP to any port 40120

# Alles andere blockieren
sudo ufw enable

Health Checks

Füge einen Health Check zu deiner docker-compose.yml hinzu, damit Docker einen hängengebliebenen Server erkennen und neu starten kann:

services:
  fivem:
    # ... andere Konfiguration
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:30120/info.json"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

Ressourcen-Monitoring

Überwache den Ressourcenverbrauch deines Containers:

# Echtzeit-Statistiken
docker stats fivem-server

# Detaillierte Inspektion
docker inspect fivem-server --format='{{.State.Status}} - Memory: {{.HostConfig.Memory}}'

Richte Alerts ein, wenn Speicher- oder CPU-Nutzung Schwellenwerte überschreitet, um Probleme zu erkennen, bevor Spieler sie bemerken.

Fehlerbehebung häufiger Probleme

Container beendet sich sofort nach dem Start: Prüfe die Logs mit docker compose logs fivem. Häufige Ursachen: ungültiger Lizenzschlüssel, fehlende server.cfg oder Port-Konflikte. Stelle sicher, dass dein Lizenzschlüssel korrekt ist und kein anderer Prozess Port 30120 verwendet.

Keine Verbindung zum Server möglich: Stelle sicher, dass Ports 30120/tcp und 30120/udp in deiner Firewall offen und korrekt in der docker-compose.yml gemappt sind. Teste mit docker compose port fivem 30120, um das Mapping zu verifizieren.

txAdmin nicht erreichbar: Überprüfe, dass Port 40120 freigegeben und nicht von einer Firewall blockiert wird. Stelle sicher, dass die TXADMIN_PORT-Umgebungsvariable mit dem freigegebenen Port übereinstimmt.

Ressourcen laden nicht nach dem Hinzufügen: Volume-Mounts synchronisieren automatisch, aber FiveM braucht einen Neustart, um neue Ressourcen zu erkennen. Führe docker compose restart fivem aus und stelle sicher, dass die Ressource in der server.cfg mit ensure aufgelistet ist.

Datenbankverbindung abgelehnt: Wenn du Docker Compose Networking nutzt, verwende den Servicenamen (z.B. db) als Hostname, nicht localhost oder 127.0.0.1. Der Datenbank-Container muss laufen und gesund sein, bevor FiveM startet — depends_on regelt die Startreihenfolge.

Für tiefergehende Debugging-Techniken, schau dir unseren Guide an: Wie du deinen FiveM-Server debuggst.

Nächste Schritte

Mit deinem FiveM-Server in Docker hast du ein solides Fundament zum Skalieren und Warten deiner Community. Hier sind die logischen nächsten Schritte:

• Performance optimieren mit unserem FiveM Server-Optimierungsguide — Profiling, Script-Bereinigung und Netzwerk-Tuning
• txAdmin mit Discord einrichten mit unserem txAdmin Discord-Integrationsguide für Remote-Server-Management
• Produktionsreife Scripts durchstöbern in unserer Free-Mods-Bibliothek oder dem Premium-Shop — alles getestet und gepflegt
• Community skalieren mit Strategien aus unserem kompletten Server-Management-Guide

Docker verwandelt FiveM-Server-Management von manueller Systemadministration in reproduzierbare, versionskontrollierte Infrastruktur. Jede Konfigurationsänderung wird nachverfolgt, jedes Update ist umkehrbar und jedes Backup ist vorhersagbar. Diese betriebliche Disziplin unterscheidet Server, die bestehen, von Servern, die ausbrennen.