Eintrag

Dockhand: Moderne Docker-Verwaltung als Portainer-Alternative

Veröffentlicht Aktualisiert
Preview Image
Von Darth Vaper
13 Minuten Lesezeit
Dockhand: Moderne Docker-Verwaltung als Portainer-Alternative

Wer sein Homelab oder seine Container-Infrastruktur mit einer Web-UI verwalten will, kommt an Portainer meist nicht vorbei. Doch in letzter Zeit häufen sich die Beschwerden über zunehmende Feature-Beschränkungen in der Community Edition und das aggressive Upselling zur Business-Version. Zeit für Alternativen! Eine besonders vielversprechende Option ist Dockhand – ein modernes, schlankes Docker-Management-Tool, das den Fokus auf Einfachheit und Usability legt, ohne künstliche Limitierungen.

Was ist Dockhand?

Dockhand ist eine Open-Source Web-UI für die Verwaltung von Docker-Containern, Images, Volumes und Netzwerken. Das Projekt wurde entwickelt, um eine leichtgewichtige und benutzerfreundliche Alternative zu schwergewichtigen Management-Plattformen zu bieten.

Kernmerkmale

  • Modern Stack: Entwickelt mit zeitgemäßen Web-Technologien für eine flüssige Benutzererfahrung
  • Fokus auf Docker Compose: Erstklassige Unterstützung für Compose-Stacks mit integriertem Editor
  • Schlank und schnell: Minimaler Ressourcen-Footprint, ideal für Raspberry Pi und kleine VMs
  • Selbst-gehostet: Vollständige Kontrolle über deine Daten, keine Cloud-Anbindung erforderlich
  • Aktive Entwicklung: Regelmäßige Updates und responsive Community

Die Philosophie von Dockhand ist einfach: Alle wichtigen Features sollten verfügbar sein, ohne dass du für eine “Pro”-Version bezahlen musst. Das macht es besonders attraktiv für Homelab-Betreiber und kleine Teams.

Features im Überblick

Dockhand deckt alle wichtigen Aspekte der Docker-Verwaltung ab. Hier ein Überblick über die wichtigsten Funktionen:

Feature Beschreibung Verfügbarkeit
Container-Management Start, Stop, Restart, Pause, Logs, Shell-Zugriff Vollständig
Compose-Editor Syntax-Highlighting, Validierung, direktes Deployment Vollständig
Image-Management Pull, Remove, Tag, Prune, Layer-Inspection Vollständig
Volume-Management Erstellen, Löschen, Durchsuchen, Backup Vollständig
Network-Management Bridge, Host, Overlay-Netzwerke verwalten Vollständig
Git-Integration Compose-Files direkt aus Git-Repos deployen Vollständig
Multi-Host Verwaltung mehrerer Docker-Hosts via Hawser-Agent Vollständig
Resource-Monitoring CPU, RAM, Disk, Network-Stats in Echtzeit Vollständig
Template-System Vorgefertigte Compose-Templates für gängige Apps In Entwicklung
Backup & Restore Automatische Backups von Compose-Stacks In Entwicklung

Alle Kernfeatures sind ohne Einschränkungen verfügbar – keine künstlichen Limits bei der Anzahl von Containern, Hosts oder Benutzern.

Installation

Die Installation von Dockhand ist denkbar einfach. Du benötigst lediglich einen Docker-Host und ein paar Minuten Zeit.

Basis-Installation mit Docker Compose

Erstelle eine docker-compose.yml Datei mit folgendem Inhalt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

services:
  dockhand:
    image: dockhand/dockhand:latest
    container_name: dockhand
    ports:
      - "3000:3000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - dockhand_data:/data
    environment:
      - TZ=Europe/Berlin
      - DOCKHAND_ADMIN_USER=admin
      - DOCKHAND_ADMIN_PASSWORD=changeme
    restart: unless-stopped
    labels:
      - "com.dockhand.managed=true"

volumes:
  dockhand_data:
    driver: local

Starte den Container mit:

1

docker compose up -d

Dockhand ist nun unter http://localhost:3000 erreichbar. Beim ersten Login wirst du aufgefordert, das Admin-Passwort zu ändern.

Der Docker-Socket-Zugriff gewährt Dockhand Root-Rechte auf dem Host! Nutze die :ro (read-only) Option für mehr Sicherheit, beachte aber, dass einige Schreib-Operationen dann nicht funktionieren.

Installation mit Docker Socket Proxy

Für produktive Umgebungen empfiehlt sich ein Socket-Proxy als zusätzliche Sicherheitsschicht:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

services:
  docker-socket-proxy:
    image: tecnativa/docker-socket-proxy:latest
    container_name: docker-socket-proxy
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - CONTAINERS=1
      - IMAGES=1
      - NETWORKS=1
      - VOLUMES=1
      - INFO=1
      - POST=1
    restart: unless-stopped
    networks:
      - dockhand-backend

  dockhand:
    image: dockhand/dockhand:latest
    container_name: dockhand
    ports:
      - "3000:3000"
    volumes:
      - dockhand_data:/data
    environment:
      - TZ=Europe/Berlin
      - DOCKER_HOST=tcp://docker-socket-proxy:2375
    restart: unless-stopped
    networks:
      - dockhand-backend
    depends_on:
      - docker-socket-proxy

volumes:
  dockhand_data:

networks:
  dockhand-backend:
    driver: bridge

Diese Konfiguration isoliert den Docker-Socket und erlaubt nur spezifische API-Calls – deutlich sicherer als direkter Socket-Zugriff.

UI-Walkthrough

Nach dem Login erwartet dich ein übersichtliches, modernes Interface. Hier ein Überblick über die wichtigsten Bereiche.

Dashboard

Das Dashboard bietet einen Überblick über deine Docker-Umgebung:

  • Anzahl laufender/gestoppter Container
  • Disk-Usage von Images, Containern und Volumes
  • CPU- und RAM-Auslastung der Container
  • Quick-Actions für häufige Aufgaben
graph LR
    A[Dashboard] --> B[Container-Liste]
    A --> C[Image-Registry]
    A --> D[Compose-Stacks]
    A --> E[Volumes]
    A --> F[Networks]
    B --> G[Container-Details]
    G --> H[Logs]
    G --> I[Terminal]
    G --> J[Stats]

Container-Management

Die Container-Übersicht zeigt alle laufenden und gestoppten Container mit wichtigen Infos:

  • Status-Indicator (grün/rot/gelb)
  • Image-Name und Tag
  • Ports und Netzwerke
  • Ressourcen-Verbrauch
  • Quick-Actions (Start, Stop, Restart, Delete)

Ein Klick auf einen Container öffnet die Detailansicht mit Tabs für:

  • Overview: Konfiguration, Environment-Variablen, Volumes
  • Logs: Echtzeit-Logs mit Suchfunktion und Auto-Scroll
  • Terminal: Web-basierte Shell direkt im Container
  • Stats: CPU, RAM, Disk, Network in Echtzeit-Graphen
  • Inspect: Vollständige JSON-Config des Containers

Der integrierte Terminal-Emulator unterstützt volle ANSI-Farben und funktioniert auch mit interaktiven Programmen wie htop oder vim.

Compose-Editor

Der Compose-Editor ist eines der Highlights von Dockhand. Er bietet:

  • Syntax-Highlighting für YAML mit Docker-Compose-Schema
  • Auto-Completion für Service-Namen, Image-Tags und Optionen
  • Validierung in Echtzeit mit hilfreichen Fehlermeldungen
  • Template-System für gängige App-Stacks
  • Diff-View beim Bearbeiten bestehender Stacks
  • Git-Integration zum Pullen von Compose-Files aus Repositories

Beispiel-Workflow:

  1. Klick auf “New Stack” im Compose-Bereich
  2. Name vergeben (z.B. “monitoring”)
  3. Template auswählen oder eigenes Compose-File einfügen
  4. Optional: Git-Repo verknüpfen für automatische Updates
  5. “Deploy” klicken – Dockhand startet die Services
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# Beispiel: Monitoring-Stack mit Prometheus und Grafana
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    restart: unless-stopped
    depends_on:
      - prometheus

volumes:
  prometheus_data:
  grafana_data:

Image-Management

Der Image-Bereich zeigt alle lokal verfügbaren Images mit:

  • Repository, Tag und Image-ID
  • Size und Creation-Date
  • Anzahl verwendender Container
  • Layer-Inspection (Dockerfile-Schritte nachvollziehen)

Funktionen:

  • Pull: Images von Docker Hub oder privaten Registries ziehen
  • Remove: Ungenutzte Images löschen
  • Prune: Alle dangling Images auf einmal entfernen
  • Tag: Images umbenennen oder für andere Registries taggen

Settings

Im Settings-Bereich kannst du:

  • User-Management: Benutzer anlegen und Rollen zuweisen
  • Remote Hosts: Weitere Docker-Hosts hinzufügen
  • Notifications: Webhooks für Container-Events konfigurieren
  • Backup: Automatische Backups von Compose-Stacks einrichten
  • UI-Preferences: Theme (Dark/Light), Sprache, Anzeigeoptionen

Multi-Host mit Hawser

Ein besonders nützliches Feature ist die Multi-Host-Verwaltung über den Hawser-Agent. Damit kannst du mehrere Docker-Hosts zentral von einer Dockhand-Instanz aus verwalten.

Funktionsweise

graph TB
    A[Dockhand UI] --> B[Dockhand Server]
    B --> C[Lokaler Docker-Socket]
    B --> D[Hawser Agent Host 1]
    B --> E[Hawser Agent Host 2]
    B --> F[Hawser Agent Host 3]
    D --> G[Docker-Socket Host 1]
    E --> H[Docker-Socket Host 2]
    F --> I[Docker-Socket Host 3]

Der Hawser-Agent ist ein schlanker Proxy, der auf jedem Remote-Host läuft und die Docker-API über eine verschlüsselte Verbindung bereitstellt.

Hawser-Agent Installation

Auf jedem Remote-Host:

1
2
3
4
5
6
7
8

# Hawser-Agent via Docker starten
docker run -d \
  --name hawser \
  --restart unless-stopped \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  -p 7777:7777 \
  -e HAWSER_TOKEN=dein-sicheres-token \
  dockhand/hawser:latest

In Dockhand unter Settings → Remote Hosts:

  1. “Add Host” klicken
  2. Name: z.B. “Proxmox Node 1”
  3. URL: https://192.168.60.10:7777
  4. Token: Das gleiche wie HAWSER_TOKEN oben
  5. “Connect” klicken

Dockhand zeigt nun alle Hosts in einem Dropdown – du kannst jederzeit zwischen ihnen wechseln und Container auf verschiedenen Hosts verwalten.

Der Hawser-Agent sollte hinter einem Reverse Proxy mit TLS laufen oder über ein VPN erreichbar sein. Öffne Port 7777 niemals direkt ins Internet!

Vergleich: Dockhand vs. Portainer CE vs. Dockge vs. Yacht

Die Auswahl an Docker-Management-Tools ist groß. Hier ein detaillierter Vergleich der wichtigsten Alternativen:

Feature Dockhand Portainer CE Dockge Yacht
Lizenz MIT (Open Source) Zlib (Open Source) MIT (Open Source) MIT (Open Source)
Sprache TypeScript/React Go/Angular TypeScript/Vue Python/Vue
Compose-Editor Ja, mit Highlighting Ja, basic Ja, sehr gut Ja, basic
Multi-Host Ja (Hawser) Ja (Agent) Nein Nein
Stacks/Projects Unbegrenzt Max. 5 in CE Unbegrenzt Unbegrenzt
Git-Integration Ja Nur Business Nein Ja
Resource-Monitoring Ja Ja Basic Ja
Docker Socket Optional Proxy Direkt Direkt Direkt
Kubernetes Nein Ja (Business) Nein Nein
User-Management Ja (RBAC) Ja (max. 5 User in CE) Nein (Single-User) Ja
Template-System In Entwicklung Ja Nein Ja
Aktive Entwicklung Sehr aktiv Aktiv (Focus auf Business) Aktiv Weniger aktiv
Mobile UI Responsive Responsive Responsive Basic
Community Wachsend Groß Klein Klein
Container-Limits Keine Keine Keine Keine
Image-Registry Geplant Ja (Business) Nein Nein

Wann welches Tool?

Dockhand ist ideal, wenn du:

  • Eine moderne, schlanke Alternative zu Portainer suchst
  • Multi-Host-Management ohne künstliche Limits brauchst
  • Git-Integration für Compose-Files nutzen willst
  • Ein aktiv entwickeltes Open-Source-Projekt bevorzugst

Portainer CE macht Sinn, wenn du:

  • Kubernetes-Support brauchst
  • Mit max. 5 Stacks und 5 Usern auskommst
  • Ein etabliertes Projekt mit großer Community willst
  • Eventuell auf die Business-Version upgraden möchtest

Dockge ist perfekt, wenn du:

  • Nur einen einzelnen Host verwaltest
  • Maximalen Fokus auf Compose-Stacks legst
  • Eine besonders minimalistische UI bevorzugst
  • Keine Multi-User-Features brauchst

Yacht passt, wenn du:

  • Ein Template-basiertes Deployment bevorzugst
  • Eine einfache Lösung für kleine Setups suchst
  • Mit weniger aktiver Entwicklung leben kannst

Meine Empfehlung: Probiere Dockhand und Dockge parallel aus. Beide sind so schlank, dass sie problemlos nebeneinander laufen können. Starte beide auf verschiedenen Ports und entscheide nach ein paar Tagen, welches Tool besser zu deinem Workflow passt.

Sicherheitshinweise

Docker-Management-Tools benötigen Zugriff auf den Docker-Socket – das ist gleichbedeutend mit Root-Zugriff auf dem Host-System. Hier einige wichtige Sicherheitsmaßnahmen:

Docker Socket Isolation

Der Docker-Socket (/var/run/docker.sock) gewährt vollständigen Zugriff auf die Docker-API. Wer diesen Socket kontrolliert, kann beliebige Container starten – auch mit Root-Rechten und Host-Mounts.

Empfohlene Maßnahmen:

  1. Socket-Proxy verwenden: Nutze tecnativa/docker-socket-proxy (siehe Installation oben)
  2. Read-Only Mount: Wenn möglich, mounte den Socket mit :ro (limitiert aber Schreib-Operationen)
  3. Netzwerk-Isolation: Lasse Dockhand in einem separaten Docker-Netzwerk laufen
  4. Firewall-Regeln: Beschränke Zugriff auf Dockhand-Port auf vertrauenswürdige Netzwerke

Zugriffskontrolle

Dockhand sollte niemals direkt ins Internet exponiert werden. Stelle es immer hinter einen Reverse Proxy mit TLS.

Setze niemals den Dockhand-Port direkt ins Internet frei. Nutze immer einen Reverse Proxy mit TLS und idealerweise zusätzlicher Authentifizierung (Basic Auth, OAuth, VPN).

Variante 1: Nginx Proxy Manager (NPM)

Die einfachste Loesung fuer die meisten Homelab-Setups:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

services:
  dockhand:
    image: dockhand/dockhand:latest
    container_name: dockhand
    expose:
      - 3000
    volumes:
      - dockhand_data:/data
    environment:
      - DOCKER_HOST=tcp://docker-socket-proxy:2375
    restart: unless-stopped
    networks:
      - proxy
      - dockhand-backend

In NPM erstellst du dann einen Proxy Host:

  1. Domain: docker.example.com
  2. Forward Hostname: dockhand (Container-Name oder IP)
  3. Forward Port: 3000
  4. SSL: Let’s Encrypt aktivieren
  5. Access List: Erstelle eine Access List mit Authentifizierung (Basic Auth oder Authelia-Integration)

Durch die Nutzung von expose statt ports ist der Dockhand-Port nur im Docker-Netzwerk erreichbar - nicht von aussen. NPM routet den Traffic ueber das gemeinsame proxy-Netzwerk.

Variante 2: Traefik

Fuer Traefik-Setups via Docker-Labels:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

services:
  dockhand:
    image: dockhand/dockhand:latest
    container_name: dockhand
    expose:
      - 3000
    volumes:
      - dockhand_data:/data
    environment:
      - DOCKER_HOST=tcp://docker-socket-proxy:2375
    restart: unless-stopped
    networks:
      - proxy
      - dockhand-backend
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.dockhand.rule=Host(`docker.example.com`)"
      - "traefik.http.routers.dockhand.entrypoints=websecure"
      - "traefik.http.routers.dockhand.tls.certresolver=letsencrypt"
      - "traefik.http.routers.dockhand.middlewares=auth"
      - "traefik.http.services.dockhand.loadbalancer.server.port=3000"

Best Practices

  • Starke Passwörter: Nutze einen Passwort-Manager für Admin-Accounts
  • RBAC: Vergib nur die minimal notwendigen Rechte an User
  • Audit-Logs: Aktiviere Logging für alle Container-Operationen
  • Regelmäßige Updates: Halte Dockhand und alle Images aktuell
  • Backup: Sichere /data Volume regelmäßig (enthält Konfiguration und Secrets)
  • 2FA: Falls verfügbar, aktiviere Two-Factor-Authentication

Container Escape Prevention

Um zu verhindern, dass ein kompromittierter Container aus seiner Isolation ausbricht:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Beispiel: Security-Hardening für Dockhand
services:
  dockhand:
    image: dockhand/dockhand:latest
    security_opt:
      - no-new-privileges:true
      - apparmor:docker-default
      - seccomp:unconfined
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
    read_only: true
    tmpfs:
      - /tmp

Bei produktiven Setups solltest du auch Tools wie falco oder sysdig zur Runtime-Überwachung in Betracht ziehen.

Praxis-Tipps

Ein paar bewährte Workflows und Tricks, die dir den Alltag mit Dockhand erleichtern:

Stack-Templates nutzen

Erstelle eigene Template-Sammlungen für wiederkehrende Setups:

1
2
3
4
5
6
7
8
9
10
11

# Template-Struktur
~/dockhand-templates/
├── monitoring/
│   ├── docker-compose.yml
│   └── .env.example
├── media-server/
│   ├── docker-compose.yml
│   └── .env.example
└── reverse-proxy/
    ├── docker-compose.yml
    └── .env.example

In Dockhand: Settings → Templates → “Add Template Directory” → Mount als Volume

Git-Workflow für Compose-Files

1
2
3
4
5
6

# Compose-Stack mit Git-Auto-Update
services:
  dockhand:
    volumes:
      - dockhand_data:/data
      - /opt/compose-stacks:/stacks:ro

Dann auf dem Host:

1
2
3
4
5
6
7
8

# Git-Repo mit Compose-Files klonen
cd /opt
git clone https://gitlab.example.com/infra/compose-stacks.git

# Cronjob für Auto-Pull
cat > /etc/cron.d/compose-stacks << 'EOF'
*/15 * * * * root cd /opt/compose-stacks && git pull -q
EOF

Dockhand erkennt Änderungen automatisch und bietet an, Stacks neu zu deployen.

Backup-Strategie

1
2
3
4
5
6
7
8
9

# Backup-Script für Dockhand-Daten
#!/bin/bash
BACKUP_DIR="/backup/dockhand"
DATE=$(date +%Y%m%d_%H%M%S)

docker exec dockhand tar czf - /data > "$BACKUP_DIR/dockhand_$DATE.tar.gz"

# Alte Backups löschen (> 30 Tage)
find "$BACKUP_DIR" -name "dockhand_*.tar.gz" -mtime +30 -delete

Ausführen via Cron oder als Dockhand-Stack mit Cron-Container.

Performance-Tuning

Für große Umgebungen mit vielen Containern:

1
2
3
4
5
6

services:
  dockhand:
    environment:
      - DOCKHAND_POLLING_INTERVAL=5000  # 5 Sekunden (Standard: 2000)
      - DOCKHAND_LOG_LINES=500          # Max. angezeigte Log-Zeilen
      - DOCKHAND_CACHE_TTL=60           # Cache-Zeit für Docker-API-Calls

Migration von Portainer

Wenn du von Portainer zu Dockhand wechseln möchtest, hier ein kurzer Leitfaden:

1. Inventar erstellen

Exportiere alle Stacks aus Portainer:

1
2
3

# Via Portainer API (benötigt API-Key)
curl -X GET "https://portainer.example.com/api/stacks" \
  -H "X-API-Key: YOUR_API_KEY" | jq '.'

Oder manuell: Jede Stack-Definition kopieren und als docker-compose.yml speichern.

2. Dockhand parallel installieren

1
2
3

# Auf anderem Port installieren
# Port 3000 für Dockhand, 9000 für Portainer
docker compose -f dockhand-compose.yml up -d

3. Stacks in Dockhand importieren

  • Für jeden Stack: “New Stack” → Name vergeben → Compose-File einfügen
  • Environment-Variablen aus .env Files übernehmen
  • Networks und Volumes werden automatisch erkannt

4. Testen und validieren

Starte neue Stacks in Dockhand und prüfe:

  • Funktionieren alle Services?
  • Sind Persistent Volumes korrekt gemountet?
  • Funktionieren Inter-Container-Verbindungen?

5. Portainer deaktivieren

Wenn alles läuft:

1
2

docker stop portainer
docker rm portainer

Überstürze nichts! Lass beide Tools ein paar Tage parallel laufen, bevor du Portainer entfernst.

Fazit

Dockhand ist eine erfrischende Alternative im Docker-Management-Bereich. Es verzichtet auf künstliche Feature-Beschränkungen und bietet eine moderne, schnelle UI mit allen wichtigen Funktionen.

Wann ist Dockhand die richtige Wahl?

Dockhand passt perfekt, wenn du:

  • Eine Open-Source-Lösung ohne Feature-Paywalls suchst
  • Mehrere Docker-Hosts zentral verwalten willst
  • Wert auf einen guten Compose-Editor legst
  • Ein schlankes, ressourcenschonendes Tool bevorzugst
  • Git-Integration für Infrastructure-as-Code nutzen möchtest

Dockhand ist weniger geeignet, wenn du:

  • Kubernetes-Support benötigst (nutze dann Portainer Business oder Rancher)
  • Auf maximale Stabilität setzt (das Projekt ist noch relativ jung)
  • Umfangreiche Enterprise-Features wie LDAP/SAML brauchst
  • Ein riesiges Ökosystem mit Plugins bevorzugst

Ausblick

Die Entwicklung von Dockhand ist sehr aktiv. Auf der Roadmap stehen unter anderem:

  • Private Container-Registry-Integration
  • Erweiterte Monitoring-Features mit Prometheus-Export
  • Plugin-System für Custom-Funktionen
  • Mobile App für iOS und Android
  • Cluster-Orchestration (Docker Swarm Support)

Für ein Homelab oder kleine bis mittlere Container-Infrastrukturen ist Dockhand bereits jetzt eine ausgezeichnete Wahl. Die Community wächst stetig, und das Projekt wird aktiv weiterentwickelt – beste Voraussetzungen für eine langfristig nutzbare Lösung.

Ressourcen

Verwandte Tools

Docker-Dokumentation

Weiterführende Artikel

  • Self-Hosting Best Practices
  • Docker Security Hardening Guide
  • Infrastructure as Code mit Git und Docker Compose
  • Monitoring-Setup für Container-Infrastrukturen

Hast du Fragen oder Anmerkungen zu Dockhand? Ich freue mich über Feedback und Erfahrungsberichte in den Kommentaren!

Homelab, Management
dockhand docker container management portainer self-hosted homelab web-ui
Dieser Eintrag ist vom Autor unter CC BY 4.0 lizensiert.