--- title: "Dokploy installieren: Deployment-Plattform auf Docker Swarm selbst hosten" date: 2026-06-26T10:43:30+02:00 modified: 2026-11-08T20:08:38+01:00 category: docker type: how_to author: Marcel Schönfelder canonical: https://s-edv.com/anleitungen/dokploy-docker-deploy reading_time: 9 personalize_url: "https://s-edv.com/anleitungen/dokploy-docker-deploy#server_ip={server_ip}" variables: - name: server_ip label: "Server ip" default: "SERVER-IP" --- # Dokploy installieren: Deployment-Plattform auf Docker Swarm selbst hosten ## Anpassbare Werte Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`: | Platzhalter | Bedeutung | Beispielwert | | --- | --- | --- | | `{{server_ip}}` | Server ip | `SERVER-IP` | Link mit eigenen Werten: https://s-edv.com/anleitungen/dokploy-docker-deploy#server_ip=SERVER-IP Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. *Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben. **Dokploy** ist eine quelloffene, selbst gehostete Plattform für das Deployment von Anwendungen und Datenbanken: Sie verbinden ein Git-Repository oder ein Docker-Image, Dokploy baut und startet den Dienst, legt über Traefik die Domain an und holt ein Let’s-Encrypt-Zertifikat. Wichtig für die Planung: Dokploy setzt auf **Docker Swarm**. Das Panel selbst, seine PostgreSQL-Datenbank und alle Anwendungen laufen als Swarm-Dienste, Traefik als eigener Container. Ein reines Docker-Compose-Setup ohne Swarm reicht nicht, weil Dokploy Anwendungen über die Swarm-Schnittstelle (`createService`) anlegt. Diese Anleitung folgt der offiziellen Installation für Version 0.30.8, erklärt, was das Skript am Host verändert, und sichert das Panel danach ab. **Kurzfassung:** Nutzen Sie einen frischen Server, auf dem die Ports 80, 443 und 3000 frei sind und noch kein Swarm läuft. Laden Sie das `install.sh` des gewünschten Releases, lesen Sie es und führen Sie es als root aus: Es initialisiert Swarm, legt das Overlay-Netz `dokploy-network`, zwei Docker Secrets und die Dienste an. Schließen Sie Port 3000 vorher in der Firewall des Anbieters, denn Docker umgeht UFW, und legen Sie das Admin-Konto über einen SSH-Tunnel an. Danach binden Sie das Panel an eine HTTPS-Domain und entfernen die Freigabe von Port 3000. ## Voraussetzungen Dokploy baut Anwendungen auf demselben Server, auf dem es läuft. Der Bedarf an RAM und Speicher wächst deshalb mit jeder App und jedem Build. - [ ] **RAM und Speicher:** laut Hersteller mindestens 2 GB RAM und 30 GB Speicher, damit Builds den Server nicht zum Stillstand bringen. Für mehrere Anwendungen mit Datenbanken planen Sie entsprechend mehr ein. - [ ] **CPU und Architektur:** x86_64 oder ARM64; das Image `dokploy/dokploy:v0.30.8` gibt es für beide. - [ ] **Betriebssystem:** vom Hersteller getestet unter anderem Ubuntu 24.04, 22.04 und 20.04 LTS sowie Debian 12 und 11. Die automatische Sicherheitsprüfung von Dokploy zielt auf Ubuntu und Debian. - [ ] **Ports:** 80 und 443 (Traefik) sowie 3000 (Panel) müssen frei sein, sonst bricht das Skript ab. - [ ] **Kein bestehender Swarm:** Das Skript führt `docker swarm leave --force` aus. Auf einem Host, der schon Teil eines Swarms ist, zerstört das die laufenden Dienste. - [ ] **Kein Container:** Das Skript verweigert die Arbeit in Docker-Containern und auf macOS. Proxmox-LXC erkennt es und schaltet auf `--endpoint-mode dnsrr`. - [ ] **Domain:** für das Panel und die Anwendungen, mit A-Record auf die öffentliche IP. Nutzen Sie für Dokploy einen eigenen Server. Laufen dort bereits ein Reverse Proxy auf Port 80 und 443 oder andere Compose-Stacks, kollidieren sie mit Traefik. Wie Sie den Server vorher grundlegend absichern, beschreibt [VPS absichern und härten](https://s-edv.com/anleitungen/vps-absichern-haerten-ufw-ssh-keys-fail2ban). ## Schritt 1: Firewall vorbereiten Das Panel wird im Swarm-Modus `host` auf Port 3000 veröffentlicht. Docker schreibt dafür eigene iptables-Regeln und umgeht damit UFW; die Dokploy-Doku weist ausdrücklich darauf hin. Direkt nach der Installation zeigt Port 3000 die Einrichtungsseite, auf der das erste Konto zum Administrator wird. Wer sie zuerst aufruft, übernimmt das Panel. Sperren Sie Port 3000 deshalb vor der Installation in der Firewall Ihres Hosting-Anbieters, die vor dem Server greift. Offen bleiben nur SSH, 80 und 443. Die Hardening-Anleitung des Herstellers nennt genau diese drei Ports und empfiehlt zusätzlich `ufw-docker`, wenn Sie UFW einsetzen. Wie Sie UFW und Fail2ban einrichten, steht in [Linux-Server absichern: UFW-Firewall und Fail2ban](https://s-edv.com/anleitungen/linux-server-absichern-ufw-fail2ban). > **Prüfen:** Von einem anderen Rechner aus liefert `nc -zv {{server_ip}} 3000` nach der Installation einen Timeout oder „Connection refused“, `nc -zv {{server_ip}} 443` dagegen eine Verbindung. ## Schritt 2: Installationsskript prüfen Die Doku bietet `curl -sSL https://dokploy.com/install.sh | sh` an. Dieses Skript ermittelt beim Aufruf die jeweils neueste Version. Für eine nachvollziehbare Installation laden Sie stattdessen das Skript des konkreten Releases, das der Hersteller als Release-Asset bereitstellt, und lesen es vor der Ausführung: ```bash $ curl -fsSLO https://github.com/Dokploy/dokploy/releases/download/v0.30.8/install.sh $ less install.sh ``` Das Skript für v0.30.8 erledigt der Reihe nach: | Aktion | Details | | --- | --- | | Prüfungen | root, Linux, kein Container, Ports 80, 443, 3000 frei | | Docker | nur falls fehlend: Docker 28.5.0 über get.docker.com, danach `apt-mark hold` auf die Pakete | | Swarm | `docker swarm leave --force`, dann `docker swarm init --advertise-addr …` | | Netz | Overlay-Netz `dokploy-network` (attachable) | | Verzeichnis | `/etc/dokploy` mit Rechten 777 | | Secrets | `dokploy_postgres_password`, `dokploy_auth_secret` | | Dienste | `dokploy-postgres` (`postgres:16`), `dokploy` (`dokploy/dokploy:v0.30.8`, Port 3000, Docker-Socket) | | Traefik | Container `dokploy-traefik` (`traefik:v3.6.25`), Ports 80, 443/tcp und 443/udp | Der Dienst `dokploy` bekommt den Docker-Socket des Hosts eingebunden, denn er verwaltet alle weiteren Container und Dienste. Das ist gewollt, macht das Panel aber zum wertvollsten Ziel auf dem Server. Als Advertise-Adresse für Swarm wählt das Skript zuerst eine private IP (RFC 1918) einer echten Netzwerkschnittstelle, sonst die öffentliche IP. > **Prüfen:** `grep -n 'DOKPLOY_VERSION=' install.sh` zeigt `v0.30.8`, `grep -c 'swarm init' install.sh` liefert einen Treffer größer als null. Sie wissen jetzt, welche Änderungen am Host folgen. ## Schritt 3: Dokploy installieren Führen Sie das geprüfte Skript als root aus. Umgebungsvariablen geben Sie direkt im Aufruf mit, denn `sudo` setzt die Umgebung zurück und ein vorheriges `export` käme laut Doku nicht an: ```bash $ sudo sh install.sh ``` ```bash # mit fester Advertise-Adresse, etwa für ein VPN- oder privates Netz: ``` ```bash $ sudo ADVERTISE_ADDR=10.0.0.5 sh install.sh ``` ```bash # eigener Adressbereich für Swarm, wenn 10.0.0.0/8 mit dem Anbieternetz kollidiert: ``` ```bash $ sudo DOCKER_SWARM_INIT_ARGS="--default-addr-pool 172.20.0.0/16 --default-addr-pool-mask-length 24" sh install.sh ``` Kernel ohne IPVS-Unterstützung, etwa minimalistische Appliance-Systeme, brauchen laut Doku `ENDPOINT_MODE=dnsrr`. Am Ende meldet das Skript „Congratulations, Dokploy is installed!“ und bittet, etwa 15 Sekunden zu warten. > **Prüfen:** `docker info --format '{{.Swarm.LocalNodeState}}'` liefert `active`. `docker service ls` zeigt `dokploy` und `dokploy-postgres` mit `1/1` Replikaten, `docker ps --filter name=dokploy-traefik` einen laufenden Traefik-Container. `curl -sI http://127.0.0.1:3000` antwortet auf dem Server mit einem HTTP-Status. ## Schritt 4: Admin-Konto über SSH-Tunnel anlegen Weil Port 3000 von außen gesperrt ist, öffnen Sie das Panel über einen SSH-Tunnel von Ihrem Arbeitsplatz aus: ```bash $ ssh -L 3000:127.0.0.1:3000 benutzer@{{server_ip}} ``` Rufen Sie im Browser `http://localhost:3000` auf. Die Einrichtungsseite fragt die Daten des Administratorkontos ab. Aktivieren Sie danach im Profil die Zwei-Faktor-Anmeldung oder einen Passkey; die Hardening-Anleitung des Herstellers empfiehlt beides für jedes Konto mit Zugang zum Panel. Eine organisationsweite Pflicht zur Zwei-Faktor-Anmeldung gibt es ohne SSO laut Doku derzeit nicht, Sie müssen sie also als Regel vorgeben und kontrollieren. > **Prüfen:** Die Anmeldung mit dem neuen Konto öffnet das Dashboard. Ein zweiter Aufruf der Einrichtungsseite bietet keine erneute Kontoerstellung an. ## Schritt 5: Panel unter einer HTTPS-Domain betreiben Unter `Settings > Web Server` hinterlegen Sie die Domain für das Panel selbst, etwa `dokploy.firma.de`, und wählen Let’s Encrypt als Zertifikatsquelle. Der A-Record muss vorher auf den Server zeigen, und Port 80 und 443 müssen erreichbar sein. Sobald das Panel unter HTTPS erreichbar ist, entfernen Sie die direkte Freigabe von Port 3000: ```bash $ docker service update --publish-rm "published=3000,target=3000,mode=host" dokploy ``` Die Doku warnt: Führen Sie diesen Befehl erst aus, wenn die Domain mit HTTPS funktioniert, sonst sperren Sie sich aus. Den Zugang retten Sie dann nur mit einem erneuten `docker service update --publish-add` auf dem Server. > **Prüfen:** `curl -sI https://dokploy.firma.de` liefert eine Antwort mit gültigem Zertifikat. `docker service inspect dokploy --format '{{json .Endpoint.Ports}}'` enthält keinen Eintrag für Port 3000 mehr. ## Schritt 6: Erste Anwendung deployen Legen Sie ein Projekt an und darin eine Anwendung. Als Quelle dienen ein Git-Anbieter, ein beliebiges Git-Repository oder ein Docker-Image. Unter `Domains` weisen Sie eine eigene Domain zu; für Anwendungen erzeugt Dokploy dazu eine Traefik-Konfiguration mit HTTP-zu-HTTPS-Umleitung und `certResolver: letsencrypt`. Kostenlose `traefik.me`-Domains funktionieren laut Doku nur per HTTP. Für Docker-Compose-Projekte gilt eine Besonderheit: Hier setzt Dokploy Traefik-Labels, und die HTTPS-Umleitung müssen Sie laut Hardening-Anleitung selbst ergänzen. Datenbanken legen Sie als eigene Dienste an. Nutzen Sie für Anwendungen im selben Netz die internen Zugangsdaten und aktivieren Sie externe Zugangsdaten mit veröffentlichtem Port nur, wenn es wirklich nötig ist. > **Prüfen:** `docker service ls` listet die neue Anwendung als Swarm-Dienst mit `1/1`. Die zugewiesene Domain liefert die Anwendung über HTTPS aus, und `curl -sI http://app.firma.de` antwortet mit einer Umleitung auf HTTPS. ## Schritt 7: Backup, Updates und Notfallzugang Dokploy sichert sich selbst über `Web Server > Backups` auf ein zuvor eingerichtetes S3-Ziel: die Datenbank `dokploy-postgres` und das Verzeichnis `/etc/dokploy`, gemeinsam als ZIP-Datei. Die Rücksicherung löscht `/etc/dokploy` und die Datenbank und spielt die Sicherung ein. Die Archive verschlüsselt Dokploy nicht selbst; aktivieren Sie die Verschlüsselung am Bucket und beschränken Sie die S3-Zugangsdaten auf diesen Bucket. Datenbanken Ihrer Anwendungen sichern Sie zusätzlich über deren eigene Backup-Funktion. Updates spielen Sie mit dem Skript des Zielreleases ein. Den Container dokploy-traefik aktualisiert Dokploy dabei laut Doku bewusst nicht, um unerwartete Ausfälle zu vermeiden. Ein Traefik-Update ist ein eigener, manueller Schritt mit Blick auf die Release Notes. ```bash $ curl -fsSLO https://github.com/Dokploy/dokploy/releases/download/v0.30.8/install.sh $ sudo sh install.sh update ``` ```bash # Passwort vergessen: Container-ID ermitteln, dann ``` ```bash $ docker ps --filter name=dokploy $ docker exec -it CONTAINER-ID bash -c "pnpm run reset-password" ``` > **Prüfen:** Nach einem Backup-Lauf liegt im S3-Bucket eine neue ZIP-Datei. Nach einem Update zeigt `docker service inspect dokploy --format '{{.Spec.TaskTemplate.ContainerSpec.Image}}'` das neue Tag. ## Typische Fehler **„Error: something is already running on port 80“ (oder 443, 3000)** Ein anderer Dienst belegt den Port. Stoppen Sie ihn oder nutzen Sie einen eigenen Server. **„Error: Failed to initialize Docker Swarm“** Häufig findet das Skript keine passende Adresse. Mit `ADVERTISE_ADDR` die IP vorgeben. **Dienste erreichen sich nicht gegenseitig** Kernel ohne IPVS-Module; Neuinstallation mit `ENDPOINT_MODE=dnsrr`. **Port 3000 trotz UFW-Regel von außen erreichbar** Docker umgeht UFW. Firewall des Anbieters nutzen oder `ufw-docker` einrichten. **Anwendung antwortet mit 404 nach Traefik-Update** Die Doku warnt vor inkompatiblen Traefik-Versionen. Auf die zuvor genutzte Version `traefik:v3.6.25` zurückgehen und Release Notes prüfen. **Panel nach `--publish-rm` nicht mehr erreichbar** Domain war noch nicht funktionsfähig. Port per `docker service update --publish-add "published=3000,target=3000,mode=host" dokploy` wieder freigeben, Domain korrigieren. ## Häufige Fragen ### Kann ich Dokploy mit Docker Compose statt Swarm betreiben? Nein, nicht sinnvoll. Die offizielle Installation, auch die manuelle Variante für einen bestehenden Swarm, setzt Swarm-Dienste, Docker Secrets und ein Overlay-Netz voraus, und Dokploy legt Anwendungen und Datenbanken als Swarm-Dienste an. Ohne aktiven Swarm fehlt diese Grundlage. ### Ich betreibe bereits einen Swarm. Was nun? Verwenden Sie das Skript dann nicht, denn es verlässt den bestehenden Swarm per `docker swarm leave --force`. Die Doku beschreibt für diesen Fall unter „Existing Docker Swarm“ die einzelnen Befehle ohne Swarm-Initialisierung, auszuführen auf einem Manager-Knoten. ### Brauche ich mehrere Server? Für den Anfang nicht. Der Hersteller empfiehlt, mit einem Dokploy-Server zu starten. Später können Sie Anwendungen per SSH auf Remote-Server auslagern oder weitere Swarm-Knoten anbinden; Letzteres setzt eine Registry und gleiche Architektur voraus. ### Wie unterscheidet sich Dokploy von Coolify? Beide verfolgen dasselbe Ziel. Dokploy baut auf Docker Swarm und Traefik auf, Coolify auf eigenen Docker-Containern mit eigenem Proxy. Die Installation von Coolify beschreibt [Coolify mit Docker installieren](https://s-edv.com/anleitungen/coolify-docker-paas). ## Fazit Dokploy liefert eine vollständige Deployment-Plattform mit wenigen Befehlen, verlangt dafür aber einen Server, der ihm allein gehört: Swarm, Traefik auf 80 und 443 und ein Panel mit Zugriff auf den Docker-Socket. Wer das Installationsskript vorher liest, Port 3000 von Beginn an sperrt, das Admin-Konto per SSH-Tunnel anlegt und das Panel hinter HTTPS stellt, vermeidet die typischen Risiken. Sicherungen auf S3 mit verschlüsseltem Bucket und kontrollierte Updates über das Skript des jeweiligen Releases runden den Betrieb ab. ## Weiterführende Anleitungen und Quellen - [VPS absichern und härten: UFW, SSH-Keys und Fail2Ban](https://s-edv.com/anleitungen/vps-absichern-haerten-ufw-ssh-keys-fail2ban) - [Coolify mit Docker installieren](https://s-edv.com/anleitungen/coolify-docker-paas) - [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten) - [Dokploy: Installation](https://docs.dokploy.com/docs/core/installation) - [Dokploy: Manual Installation](https://docs.dokploy.com/docs/core/manual-installation) - [Dokploy: Production Hardening Guide](https://docs.dokploy.com/docs/core/guides/production-hardening) - [Dokploy: Backups](https://docs.dokploy.com/docs/core/backups) - [Dokploy: Deployment Options](https://docs.dokploy.com/docs/core/deployment-options) - [GitHub: Dokploy v0.30.8](https://github.com/Dokploy/dokploy/releases/tag/v0.30.8)