Dokploy mit Docker installieren: Open-Source-Alternative zu Vercel und Netlify

Wer Webapplikationen für Kunden oder den eigenen Betrieb deployt, kennt das Problem: Vercel und Netlify sind bequem, aber teuer und proprietär. Heroku hat seine kostenlose Tier gestrichen. Die Alternative ist eine eigene PaaS-Plattform – und genau das liefert Dokploy. Das Open-Source-Projekt (34.800+ GitHub-Stars, Stand Juni 2026) bündelt Traefik als Reverse-Proxy, Let's-Encrypt-SSL-Automatisierung, verwaltete Datenbanken (PostgreSQL, MySQL, MongoDB, MariaDB, Redis, libsql) und Container-Orchestrierung in einer einzigen Weboberfläche. Du deployst beliebige Apps aus Git-Repos, Docker-Images oder Compose-Dateien – auf einem Server, den du selbst kontrollierst. Diese Anleitung richtet sich an KMU-Admins, Webagenturen und Selfhoster, die auf einem Linux-VPS oder einem dedizierten Server eine robuste Deployment-Plattform aufbauen wollen.

Voraussetzungen

1. Linux-Server (Ubuntu 24.04/22.04, Debian 12/11 oder Fedora 40 auf x86_64) mit mindestens 2 GB RAM und 30 GB freiem Speicherplatz; 4 GB RAM empfohlen
2. Docker Engine (mind. 24.x) und das Docker Compose Plugin v2 installiert – Befehl lautet docker compose (ohne Bindestrich); eine Schritt-für-Schritt-Einrichtung findest du unter Docker und Docker Compose auf Linux installieren
3. Root- oder sudo-Zugriff auf den Server sowie einen SSH-Zugang
4. Ports 80, 443 und 3000 müssen auf dem Host frei sein (kein laufender Nginx, Apache oder anderer Webserver)
5. Öffentliche IP-Adresse des Servers; optional eine Domain/Subdomain mit A-Record auf diese IP für SSL
6. Internetzugang für Image-Downloads (ca. 750 MB für alle vier Services)
7. openssl auf dem Server für die Secret-Generierung

Eckdaten auf einen Blick

Schritt 1: Ports prüfen und Projektordner anlegen

Bevor du irgendetwas startest, stellst du sicher, dass die drei Pflicht-Ports frei sind. Ein belegter Port 80 oder 443 durch Nginx oder Apache lässt Traefik lautlos scheitern.

# Ports 80, 443 und 3000 auf Belegung prüfen
ss -tlnp | grep -E ':80 |:443 |:3000 '

Zeigt der Befehl keine Ausgabe, sind alle Ports frei. Taucht ein Prozess auf (z.B. nginx oder apache2), stoppst du ihn vorher:

sudo systemctl stop nginx   # oder apache2

Dann legst du den Projektordner an:

sudo mkdir -p /opt/dokploy
cd /opt/dokploy

Verifizieren: ls /opt/dokploy gibt ein leeres Verzeichnis zurück. ss -tlnp | grep -E ':80 |:443 |:3000 ' zeigt keine Prozesse.

Schritt 2: Secrets generieren und .env-Datei anlegen

Dokploy benötigt zwei sicherheitskritische Werte: ein Datenbankpasswort und ein Auth-Secret für Session-Signing. Beide generierst du mit openssl rand und speicherst sie in einer .env-Datei, die Docker Compose automatisch einliest.

# Zufällige Werte generieren
POSTGRES_PW=$(openssl rand -hex 24)
AUTH_SECRET=$(openssl rand -hex 32)

# .env-Datei schreiben
cat > /opt/dokploy/.env << EOF
POSTGRES_PASSWORD=${POSTGRES_PW}
BETTER_AUTH_SECRET=${AUTH_SECRET}
EOF

# Berechtigungen einschränken (nur root darf lesen)
chmod 600 /opt/dokploy/.env

Notiere das POSTGRES_PASSWORD an einem sicheren Ort – es wird für eventuelle manuelle DB-Zugriffe benötigt.

Verifizieren: wc -c /opt/dokploy/.env liefert einen Wert über 100 Bytes. stat -c %a /opt/dokploy/.env gibt 600 zurück.

Schritt 3: Docker-Netzwerk anlegen

Das Netzwerk dokploy-network wird in der compose.yaml als external: true deklariert – es muss also vorab existieren. Das ermöglicht später, deployte Apps in dasselbe Netzwerk einzuhängen und sie über Traefik erreichbar zu machen.

docker network create --driver bridge --attachable dokploy-network

Verifizieren:

docker network ls | grep dokploy-network

Erwartete Ausgabe: eine Zeile mit dokploy-network und Driver bridge.

Schritt 4: compose.yaml erstellen

Jetzt legst du die eigentliche Compose-Datei an. Passe die E-Mail-Adresse bei --certificatesresolvers.letsencrypt.acme.email auf eine echte Adresse an – Let's Encrypt sendet dorthin Ablauf-Warnungen für Zertifikate.

services:
  traefik:
    image: traefik:v3.6.7
    restart: unless-stopped
    command:
      - "--api.dashboard=true"
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedByDefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=admin@beispiel.de"
      - "--certificatesresolvers.letsencrypt.acme.storage=/etc/dokploy/traefik/acme.json"
      - "--providers.file.directory=/etc/dokploy/traefik/dynamic"
      - "--providers.file.watch=true"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /etc/dokploy/traefik:/etc/dokploy/traefik
    networks:
      - dokploy-network

  postgres:
    image: postgres:16
    restart: unless-stopped
    environment:
      POSTGRES_USER: dokploy
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: dokploy
    volumes:
      - dokploy-postgres:/var/lib/postgresql/data
    networks:
      - dokploy-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U dokploy -d dokploy"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 20s

  redis:
    image: redis:7
    restart: unless-stopped
    volumes:
      - dokploy-redis:/data
    networks:
      - dokploy-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  dokploy:
    image: dokploy/dokploy:latest
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      DATABASE_URL: postgresql://dokploy:${POSTGRES_PASSWORD}@postgres:5432/dokploy
      REDIS_HOST: redis
      PORT: 3000
      TRAEFIK_PORT: 80
      TRAEFIK_SSL_PORT: 443
      BETTER_AUTH_SECRET: ${BETTER_AUTH_SECRET}
      TZ: Europe/Berlin
    ports:
      - "3000:3000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /etc/dokploy:/etc/dokploy
      - dokploy:/root/.docker
    networks:
      - dokploy-network
    labels:
      - "traefik.enable=false"

volumes:
  dokploy-postgres:
  dokploy-redis:
  dokploy:

networks:
  dokploy-network:
    external: true

Speichere diese Datei unter /opt/dokploy/compose.yaml. Hinweis zur Versionspinnung: dokploy/dokploy:latest zeigt derzeit auf v0.29.8. Für reproduzierbare Deployments kannst du stattdessen dokploy/dokploy:v0.29.8 angeben.

Verifizieren:

docker compose -f /opt/dokploy/compose.yaml config --quiet && echo "YAML valide"

Erwartete Ausgabe: YAML valide ohne Fehlermeldungen. Taucht ein Parsing-Fehler auf, prüfe Einrückungen (2 Leerzeichen, keine Tabs).

Schritt 5: Stack starten

Mit einer einzigen Zeile ziehst du alle Images und startest die vier Services im Hintergrund. Die depends_on-Bedingungen mit Healthchecks sorgen dafür, dass Dokploy erst startet, wenn PostgreSQL und Redis wirklich bereit sind – das verhindert die häufigste Race Condition bei Neuinstallationen.

cd /opt/dokploy
docker compose up -d

Der erste Start dauert ein bis drei Minuten, da alle Images heruntergeladen werden. Danach prüfst du den Status:

docker compose ps

Erwartete Ausgabe – alle vier Services müssen im Status running sein, postgres und redis zusätzlich healthy:

NAME                  IMAGE                      STATUS
dokploy-dokploy-1     dokploy/dokploy:latest     Up 2 minutes
dokploy-postgres-1    postgres:16                Up 2 minutes (healthy)
dokploy-redis-1       redis:7                    Up 2 minutes (healthy)
dokploy-traefik-1     traefik:v3.6.7             Up 2 minutes

Zeigt ein Service Restarting, sofort die Logs prüfen:

docker compose logs --tail=50 dokploy

Verifizieren:

curl -s -o /dev/null -w "%{http_code}" http://localhost:3000

Erwartete Ausgabe: 200 oder 302. Alles andere bedeutet, Dokploy ist noch nicht vollständig gestartet – warte 30 Sekunden und wiederhole den Befehl.

Schritt 6: Erst-Einrichtung im Browser

Öffne im Browser http://SERVER-IP:3000. Beim ersten Aufruf erscheint der Setup-Assistent, in dem du einen Admin-Account mit E-Mail-Adresse und Passwort anlegst. Dieser Account erhält vollständige Plattform-Kontrolle – wähle ein starkes Passwort.

Nach der Registrierung landest du im Dokploy-Dashboard. Links im Menü siehst du:

1. Projects: Hier erstellst du Projekte und darin Services (Apps, Datenbanken, Compose-Stacks)
2. Settings → Server: Server-Einstellungen, Domain-Konfiguration für die UI selbst
3. Settings → Notifications: Webhook-Anbindung für Slack, Discord, Telegram oder E-Mail
4. Monitoring: Echtzeit-CPU-, RAM- und Netzwerk-Metriken des Host-Servers

Möchtest du die Dokploy-UI selbst über HTTPS und eine Domain erreichbar machen, trägst du unter Settings → Server → Domain deine Domain ein. Traefik stellt dann automatisch ein Let's-Encrypt-Zertifikat aus – vorausgesetzt, der DNS-A-Record zeigt bereits auf die Server-IP. Wie du einen Reverse-Proxy mit automatischem HTTPS grundsätzlich einrichtest, beschreibt unsere Anleitung zu Traefik als Docker-Reverse-Proxy mit automatischem HTTPS.

Verifizieren: Du siehst das Dokploy-Dashboard mit dem Menüpunkt „Projects" und kannst dich ein- und ausloggen. Unter „Monitoring" werden Server-Metriken angezeigt.

Schritt 7: Erste App deployen

Um das Setup zu testen, deployest du eine einfache App. Im Dashboard klickst du auf Create Project, vergibst einen Namen und wählst dann Create Service → Application. Als Deployment-Quelle stehen dir zur Verfügung:

1. Git-Repository: GitHub, GitLab, Bitbucket oder self-hosted; Dokploy klont das Repo und baut das Image mit einem Builder (Nixpacks, Dockerfile, Buildpacks)
2. Docker Image: direkt ein Image von Docker Hub oder einer privaten Registry
3. Docker Compose: eine eigene compose.yaml hochladen oder einfügen

Ein wichtiger Hinweis: Damit Traefik deployte Apps per HTTPS erreichbar macht, muss die App intern auf 0.0.0.0 lauschen, nicht auf 127.0.0.1. Viele JavaScript-Dev-Server (Vite, Astro, Vue) binden sich standardmäßig nur an Localhost – das führt zu einem 502 Bad Gateway. Füge in der App-Konfiguration explizit host: '0.0.0.0' ein.

Umgebungsvariablen für deployte Apps trägst du im Reiter Environment des jeweiligen Services ein. Beachte: Dokploy schreibt sie in eine .env-Datei im Container-Kontext, injiziert sie aber nicht automatisch. Deine compose.yaml muss explizit env_file: .env oder ${VARIABLE}-Referenzen enthalten.

Verifizieren: Im Service-Reiter „Deployments" siehst du einen grünen Status „Done". Im Reiter „Logs" erscheinen die Container-Logs in Echtzeit. Ein curl -I https://deine-domain.de liefert HTTP 200 mit einem gültigen TLS-Zertifikat.

Updates und Backup

Dokploy aktualisierst du mit dem offiziellen Update-Skript:

curl -sSL https://dokploy.com/install.sh | sh -s update

Alternativ, wenn du die Compose-Variante nutzt:

cd /opt/dokploy
docker compose pull
docker compose up -d

Die persistenten Daten liegen in den Named Volumes dokploy-postgres, dokploy-redis und dokploy sowie im Bind-Mount /etc/dokploy. Für automatisierte Datenbank-Backups zu S3-kompatiblen Zielen (AWS S3, MinIO, Backblaze B2) nutzt du die eingebaute Backup-Funktion in den jeweiligen Datenbank-Einstellungen der Dokploy-UI. Eine allgemeine Backup-Strategie für Docker-Volumes beschreibt unsere 3-2-1-Backup-Strategie-Anleitung.

Um Speicherplatz freizugeben, wenn viele Deployments alte ungenutzte Images hinterlassen haben:

docker system prune -a
docker builder prune -a

Danach den Dokploy-Service neu starten: docker compose restart dokploy.

Troubleshooting / Typische Fehler

1. Port bereits belegt – Traefik startet nicht: Wenn docker compose logs traefik einen „bind: address already in use"-Fehler zeigt, ist Port 80 oder 443 besetzt. Prüfen mit ss -tlnp | grep -E ':80|:443', dann den blockierenden Dienst stoppen und docker compose up -d erneut ausführen.
2. Dokploy bleibt in Restarting-Schleife: Meistens eine Race Condition – PostgreSQL war noch nicht bereit. Die depends_on-Healthchecks in der obigen compose.yaml verhindern das; falls doch aufgetreten: docker compose restart dokploy nach 30 Sekunden Wartezeit.
3. Let's Encrypt schlägt fehl – „404 Not Found" in Traefik-Logs: Der DNS-A-Record zeigt noch nicht auf die Server-IP. ACME HTTP-Challenge erfordert, dass Port 80 öffentlich erreichbar ist und die Domain korrekt auflöst. DNS-TTL abwarten, dann docker compose restart traefik.
4. 502 Bad Gateway bei deployter App: Die App lauscht intern nur auf 127.0.0.1. Lösung: App-Konfiguration auf 0.0.0.0 umstellen. Besonders häufig bei Vite, Astro, SvelteKit und ähnlichen Dev-Servern.
5. „field not found, node: passHostHeader" – Traefik crasht: Fehlerhafte YAML-Syntax in einer dynamischen Traefik-Konfigurationsdatei unter /etc/dokploy/traefik/dynamic/. Datei prüfen und korrigieren, dann docker compose restart traefik.
6. Kein Speicherplatz – Datenbank im Recovery-Mode: Zu viele akkumulierte Docker-Images von Deployments. docker system prune -a && docker builder prune -a && docker image prune -a ausführen, danach Dokploy-Service neu starten.
7. Umgebungsvariablen kommen nicht im Container an: Dokploy schreibt die Variablen in eine .env-Datei, injiziert sie aber nicht automatisch. Die compose.yaml der deployte App muss env_file: .env oder explizite ${VAR}-Referenzen enthalten.
8. Volumes mit absoluten Pfaden werden geleert: Bei deployte Apps werden absolute Host-Pfade in Compose-Dateien bei Deployments geleert. Relative Pfade oder Named Volumes verwenden.

Häufige Fragen

Kann ich Dokploy auf einem Server mit laufendem Webserver installieren?

Ohne Anpassungen nicht. Ports 80 und 443 müssen frei sein, da Traefik diese direkt belegt. Bestehende Nginx- oder Apache-Instanzen müssen vorher gestoppt oder dauerhaft auf andere Ports verschoben werden. Wer Nginx behalten möchte, kann ihn als vorgelagerten Proxy konfigurieren, der Anfragen an Traefik weiterleitet – das erfordert aber manuelle Traefik-Konfiguration und ist nicht der empfohlene Weg.

Unterstützt Dokploy ARM64 (z.B. Oracle Ampere, Raspberry Pi)?

Die offizielle Dokumentation und Docker Hub nennen ARM64 nicht als explizit unterstützte Architektur. Getestete und dokumentierte Plattformen sind Ubuntu 20.04/22.04/24.04, Debian und Fedora auf x86_64. Ein Betrieb auf ARM64 ist möglicherweise funktionsfähig, aber nicht offiziell garantiert.

Brauche ich eine Domain, um Dokploy zu nutzen?

Nein. Das Web-UI ist direkt per http://SERVER-IP:3000 erreichbar. Eine Domain ist erst nötig, wenn deployte Apps mit TLS/SSL-Zertifikaten über HTTPS erreichbar sein sollen – für Let's Encrypt muss der DNS-A-Record auf die Server-IP zeigen.

Wie sichere ich Datenbankdaten in deployte Apps?

Dokploy unterstützt automatische Backups auf S3-kompatible Speicher wie AWS S3, MinIO oder Backblaze B2. Die Konfiguration erfolgt in der UI unter den jeweiligen Datenbank-Einstellungen des Services. Für MinIO als lokalen S3-Speicher gibt es eine eigene Anleitung: MinIO S3 selbst hosten mit Docker und Traefik.

Kann ich mehrere Server mit Dokploy verwalten?

Ja. Dokploy nutzt Docker Swarm und erlaubt das Hinzufügen weiterer Server als Worker-Nodes über die UI unter „Remote Servers". Wichtig: Logs und Monitoring sind im Multi-Node-Betrieb nur auf dem Manager-Node vollständig verfügbar. Apps auf Worker-Nodes zeigen in der UI keine Echtzeit-Logs.

Was ist der Unterschied zwischen der Compose-Variante hier und dem offiziellen install.sh-Skript?

Das offizielle Skript richtet Docker Swarm ein (docker swarm init) und deployt Dokploy als Swarm-Service mit Docker Secrets für Passwörter. Die in dieser Anleitung gezeigte compose.yaml ist eine standalone-Alternative für Einzelserver ohne Swarm-Anforderung – einfacher aufzusetzen, aber leicht weniger sicher (Klartext-Variablen statt Secrets). Für Produktionsumgebungen mit hohen Sicherheitsanforderungen ist das offizielle Skript die bessere Wahl. Wie du Docker Compose generell für sichere Produktions-Setups absicherst, zeigt unsere Anleitung Docker Compose absichern: Secrets, Healthchecks und Non-Root.

Fazit

Dokploy ist eine ausgereifte und aktiv gepflegte PaaS-Alternative, die in etwa 20 Minuten auf einem beliebigen Linux-Server läuft. Die Kombination aus Traefik, automatischem SSL, verwalteten Datenbanken und einer durchdachten Web-UI macht es für KMU-Admins und Webagenturen besonders attraktiv: Ein Tool ersetzt mehrere manuelle Konfigurationsschritte. Der Wachstum auf 34.800+ GitHub-Stars in kurzer Zeit zeigt, dass die Community das ähnlich sieht. Einschränkungen gibt es bei ARM64 (keine offizielle Unterstützung) und bei Multi-Node-Logs (nur Manager-Node). Wer eine schlanke Alternative ohne Swarm-Komplexität sucht, schaut sich das Geschwisterprojekt Coolify an – der Vergleich lohnt sich: Coolify mit Docker installieren.

Weiterführende Anleitungen und Quellen

1. Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage
2. Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten
3. Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb
4. Coolify mit Docker installieren: Self-Hosted PaaS im Vergleich
5. MinIO S3 selbst hosten mit Docker: Compose-Anleitung mit Traefik und HTTPS
6. VPS absichern und härten: Anleitung mit UFW, SSH-Keys und Fail2Ban

Quellen: Dokploy Offizielle Dokumentation – Installation | Dokploy Manuelle Installation | Dokploy GitHub Repository | Dokploy Docker Hub | Dokploy Troubleshooting

Passende Anleitungen auf S-EDV

1. OpenSSL: Neun Schwachstellen im Sicherheitsrelease vom 9. Juni 2026, darunter Hi
2. Automatische Sicherheitsupdates unter Debian/Ubuntu mit unattended-upgrades rich
3. PostgreSQL schließt elf Sicherheitslücken in den Versionen 14 bis 18