Dockge selbst hosten: Compose-Stacks bequem per Web-UI

Warum Dockge?

Portainer verwaltet Container und Stacks über eine eigene Datenbank – Dockge geht einen anderen Weg: Es ist ein compose-Datei-orientierter Manager. Deine Stack-Ordner liegen auf der Platte, Dockge zeigt sie in einer übersichtlichen UI und bietet Editor, Logs, Terminal und Update-Buttons. Da keine Datenbank „zwischen“ dir und deinen Dateien steht, kannst du jederzeit zur CLI zurückwechseln – oder Dockge sogar parallel zu Portainer betreiben.

Konzept: dateibasiert statt Datenbank

• Stacks-Verzeichnis: Alle Compose-Projekte liegen in einem zentralen Ordner (Default: /opt/stacks). Jeder Unterordner = ein Stack mit eigener compose.yaml.
• Editor mit Preview: Änderungen an der Compose-Datei lassen sich vor dem Deploy validieren (docker compose config) und als Diff anzeigen.
• Logs, Terminal & Stats: pro Stack direkt in der UI – ohne SSH.
• Deploy / Update / Neustart: entspricht docker compose up -d bzw. pull + up.
• 2-Wege-Prinzip: Dateien außerhalb von Dockge ändern? Beim nächsten Seitenaufruf ist der Stand in der UI aktuell.

Vorbereitung: Ordner & Stacks-Verzeichnis

mkdir -p ~/dockge/data
sudo mkdir -p /opt/stacks
cd ~/dockge

• ./data → /app/data: Dockge-interne Daten (Einstellungen der UI).
• /var/run/docker.sock: Zugriff auf die Docker-API – wird für Deploy/Update/Logs benötigt (mounten wie im offiziellen Beispiel, ohne :ro).
• /opt/stacks: dein Stacks-Verzeichnis. Wer bereits Stacks hat, kann deren übergeordneten Ordner verwenden – Dockge erkennt vorhandene compose.yaml-Unterordner automatisch.

Docker Compose – die Datei

Deine Vorlage, bereinigt (doppeltes services: entfernt – so wie sie eingefügt war, wäre die Datei ungültig) und kommentiert:

services:
  dockge:
    image: louislam/dockge:1
    restart: unless-stopped
    ports:
      # Host-Port : Container-Port
      - "127.0.0.1:50510:5001"   # Web-UI nur lokal, Proxy macht den Rest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./data:/app/data

      # Für private Registries: Auth-Datei mit Dockge teilen
      # - /root/.docker/:/root/.docker

      # Stacks-Verzeichnis (WICHTIG: links === rechts, absolut!)
      - /opt/stacks:/opt/stacks
    environment:
      # Dockge mitteilen, wo die Stacks liegen
      - DOCKGE_STACKS_DIR=/opt/stacks

• louislam/dockge:1: Das offizielle Setup nutzt das Major-Tag :1 – Updates holst du dir damit über docker compose pull, ohne nach Versionsnummern zu suchen.
• 127.0.0.1:50510:5001: Dockge lauscht intern auf Port 5001, gebunden wird nur an localhost.
• DOCKGE_STACKS_DIR muss dem rechten Mount-Pfad entsprechen (/opt/stacks).
• Der auskommentierte Registry-Block ist nur nötig, wenn Dockge Images aus privaten Registries ziehen soll (Docker-Login des Hosts).

Konfiguration: Stacks-Pfad & Regeln

Reverse Proxy & WebSockets

Die UI spricht nur HTTP, der Port lauscht auf localhost – also gehört ein TLS-terminierender Proxy davor. Dockge nutzt für Live-Logs und das Terminal WebSockets, die müssen durchgereicht werden:

server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  server_name dg.meine.domain;

  # auth_basic "Restricted Content";
  # auth_basic_user_file /etc/nginx/.htpasswd;

  # ---------------------------------------------------------------- Zertifikat (ECDSA)
  ssl_certificate     /etc/ssl/private/dg.meine.domain_ecc/fullchain.cer;
  ssl_certificate_key /etc/ssl/private/dg.meine.domain_ecc/dg.meine.domain.key;

  # ---------------------------------------------------------------- TLS-Feinschliff
  ssl_buffer_size 1400;                 # passt gut zu 1500-Byte-Ethernet-MTU
  ssl_session_timeout 1d;
  ssl_session_cache shared:SSL:50m;
  ssl_session_tickets off;              # Session-Tickets aus: bessere Forward Secrecy
  ssl_protocols TLSv1.2 TLSv1.3;
  ssl_prefer_server_ciphers off;        # TLS 1.3 entscheidet der Client; aktueller Rat
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_ecdh_curve X25519:P-384:P-256:P-521;
  
  # OPTIMIERUNG 2: Lokalen Resolver (oder Quad9/Cloudflare) eintragen für besseren Datenschutz als Google
  resolver 9.9.9.9 1.1.1.1 valid=300s;
  resolver_timeout 5s;
 
  add_header Strict-Transport-Security "max-age=31536000; includeSubdomains; preload";
  add_header X-Xss-Protection "1; mode=block";
  add_header X-Content-Type-Options nosniff;
  add_header Referrer-Policy same-origin;
  proxy_cookie_path / "/; HTTPOnly; Secure";
  add_header Expect-CT "enforce, max-age=21600";
  add_header Feature-Policy "payment none";
 
  keepalive_timeout    70;
  sendfile             on;
  client_max_body_size 0;
 
   location / {
        log_not_found off;
        proxy_cache_valid 200 120m;
        proxy_set_header        Host    $http_host;
        proxy_set_header        X-Real-IP $remote_addr;
        proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header        X-Scheme $scheme;
        proxy_pass http://127.0.0.1:50510/;
        }

}

Erster Start & erste Stacks

cd ~/dockge
docker compose up -d
docker compose logs -f dockge   # bis keine Fehler mehr kommen

Danach https://stacks.meine.domain öffnen:

• Die Startseite zeigt vorhandene Stacks aus /opt/stacks – ist der Ordner leer, erscheint ein leerer Bereich mit „Neuen Stack erstellen“.
• Neuer Stack: Namen vergeben, compose.yaml im Editor einfügen (z. B. eines unserer Tutorials) und auf Deploy klicken.
• Vor dem Deploy: Preview/Validierung nutzen – Dockge prüft die Datei und zeigt dir Fehler, bevor irgendetwas startet.
• Logs und Terminal pro Stack findest du direkt in der Stack-Ansicht; mit dem Update-Button ziehst du neue Images (pull + up -d).

Backups, Updates & Migration

Weil Dockge dateibasiert arbeitet, ist das Backup denkbar einfach: /opt/stacks (alle Compose-Dateien und Stack-Daten) plus ./data (UI-Einstellungen). Ein Backup ist also gleichzeitig die komplette Stack-Verwaltung.

Häufige Probleme (FAQ)

Fazit

Dockge füllt eine echte Lücke: eine schlanke Web-UI für Docker Compose, die dich nicht in eine eigene Datenbank einsperrt. Deine Stacks bleiben normale Dateien, der Editor validiert vor dem Deploy, Logs und Terminal sind einen Klick entfernt – und wer mag, bedient die Stacks weiterhin parallel per CLI.