Docker im Homelab: Container-Setup für Anfänger

Docker ist das Herzstück jedes modernen Homelabs. Statt Software direkt auf deinem Server zu installieren, verpackst du alles in isolierte Container. Das Ergebnis: Sauberes System, einfache Updates und du kannst in wenigen Minuten neue Services aufsetzen.

In diesem Guide lernst du alles von der Installation bis zum fertigen Multi-Container-Setup mit Docker Compose. Am Ende läuft Portainer und Pi-hole auf deinem Homelab.

Was ist Docker?

Docker ist eine Container-Plattform. Ein Container ist wie eine Mini-VM, nur viel leichter und schneller. Jeder Container hat seine eigene isolierte Umgebung mit allen Abhängigkeiten, die er braucht.

Warum Docker im Homelab?

• Isolation: Jeder Service läuft unabhängig. Wenn Pi-hole abstürzt, läuft Nextcloud weiter
• Einfache Installation: Statt 20 Befehle einzutippen, startest du einen Container mit einer Zeile
• Portabilität: Container laufen überall gleich -- egal ob Mini-PC, VPS oder Raspberry Pi
• Sauberes System: Kein Dependency-Chaos. Deinstallieren heißt Container löschen, fertig
• Einfache Updates: Neues Image ziehen, Container neu starten. Dauert Sekunden

Docker installieren (Ubuntu/Debian)

Die folgende Anleitung funktioniert auf Ubuntu 22.04/24.04 und Debian 11/12. Wir installieren Docker aus dem offiziellen Docker-Repository, nicht die veraltete Version aus den Standard-Paketquellen.

1. System aktualisieren und Abhängigkeiten installieren

sudo apt update && sudo apt upgrade -y
sudo apt install ca-certificates curl gnupg lsb-release -y

2. Docker GPG-Key und Repository hinzufügen

# Docker GPG-Key hinzufügen
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Repository hinzufügen
echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Für Debian ersetzt du ubuntu in der URL durch debian.

3. Docker installieren

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

4. Docker ohne sudo nutzen

Damit du nicht jedes Mal sudo vor Docker-Befehle schreiben musst:

sudo usermod -aG docker $USER

Danach einmal ab- und wieder anmelden (oder newgrp docker ausführen), damit die Gruppenzugehörigkeit aktiv wird.

5. Installation prüfen

docker --version

Die Ausgabe sollte so ähnlich aussehen:

Docker version 27.x.x, build xxxxxxx

Erster Container starten

Jetzt wird es spannend. Wir starten unseren ersten Container.

Hello World

docker run hello-world

Docker lädt das hello-world-Image herunter, startet einen Container und gibt eine Willkommensnachricht aus. Wenn du "Hello from Docker!" siehst, funktioniert alles.

Nginx Webserver starten

Etwas Nützlicheres: Ein Nginx-Webserver in einem Container.

docker run -d --name mein-nginx -p 8080:80 nginx

Was passiert hier?

• -d -- Container läuft im Hintergrund (detached)
• --name mein-nginx -- Gibt dem Container einen Namen
• -p 8080:80 -- Port 8080 auf deinem Rechner wird auf Port 80 im Container gemappt
• nginx -- Das Docker-Image, das verwendet wird

Öffne jetzt http://deine-ip:8080 im Browser. Du siehst die Nginx-Willkommensseite. Ein ganzer Webserver in einem einzigen Befehl.

Container wieder stoppen und entfernen:

docker stop mein-nginx
docker rm mein-nginx

Docker Compose installieren

Einzelne Container per Hand starten funktioniert, aber im Homelab willst du meistens mehrere Services gleichzeitig betreiben. Dafür gibt es Docker Compose.

Mit Docker Compose definierst du alle Container in einer einzigen YAML-Datei und startest sie mit einem Befehl. Konfiguration als Code -- versionierbar, reproduzierbar, teilbar.

Prüfe die Version:

docker compose version

Ausgabe:

Docker Compose version v2.x.x

Erstes Docker Compose Setup: Portainer + Pi-hole

Jetzt bauen wir ein echtes Setup auf: Portainer als Docker-Management-UI und Pi-hole als netzwerkweiten Werbeblocker. Die folgende docker-compose.yml kannst du direkt kopieren und verwenden.

Projektverzeichnis anlegen

mkdir -p ~/homelab && cd ~/homelab

docker-compose.yml erstellen

Erstelle die Datei ~/homelab/docker-compose.yml mit folgendem Inhalt:

version: "3.8"

services:
  # Portainer - Docker Management UI
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: unless-stopped
    ports:
      - "9443:9443"
      - "9000:9000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    environment:
      - TZ=Europe/Berlin

  # Pi-hole - Netzwerkweiter Werbeblocker
  pihole:
    image: pihole/pihole:latest
    container_name: pihole
    restart: unless-stopped
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8080:80/tcp"
    volumes:
      - pihole_etc:/etc/pihole
      - pihole_dnsmasq:/etc/dnsmasq.d
    environment:
      - TZ=Europe/Berlin
      - WEBPASSWORD=dein-sicheres-passwort
      - FTLCONF_LOCAL_IPV4=192.168.1.100
    dns:
      - 127.0.0.1
      - 1.1.1.1

volumes:
  portainer_data:
  pihole_etc:
  pihole_dnsmasq:

Container starten

docker compose up -d

Docker lädt jetzt die Images herunter und startet beide Container im Hintergrund. Das dauert beim ersten Mal ein paar Minuten.

Zugriff auf die Services:

• Portainer: https://deine-ip:9443 (beim ersten Zugriff erstellst du einen Admin-Account)
• Pi-hole: http://deine-ip:8080/admin (Passwort wie oben gesetzt)

Alle Container stoppen

# Stoppen (Container bleiben erhalten)
docker compose stop

# Stoppen und Container entfernen (Daten in Volumes bleiben erhalten)
docker compose down

Wichtige Docker-Befehle

Diese Befehle wirst du ständig brauchen. Am besten ausdrucken oder bookmarken.

Container verwalten

# Alle laufenden Container anzeigen
docker ps

# Alle Container anzeigen (auch gestoppte)
docker ps -a

# Container stoppen
docker stop container-name

# Container starten
docker start container-name

# Container neustarten
docker restart container-name

# Container entfernen (muss gestoppt sein)
docker rm container-name

# Container stoppen und sofort entfernen
docker rm -f container-name

Images verwalten

# Alle heruntergeladenen Images anzeigen
docker images

# Image herunterladen (ohne Container zu starten)
docker pull nginx:latest

# Unbenutzte Images aufräumen
docker image prune -a

Logs und Debugging

# Logs eines Containers anzeigen
docker logs container-name

# Logs live verfolgen (wie tail -f)
docker logs -f container-name

# Letzte 50 Zeilen anzeigen
docker logs --tail 50 container-name

# In einen laufenden Container "einsteigen"
docker exec -it container-name /bin/bash

# Einen Befehl im Container ausführen
docker exec container-name ls /var/log

Aufräumen

# Alles aufräumen (gestoppte Container, unbenutzte Images, Netzwerke)
docker system prune -a

# Speicherverbrauch von Docker anzeigen
docker system df

Volumes und Persistente Daten

Container sind vergänglich. Wenn du einen Container löschst, sind normalerweise alle Daten weg. Volumes lösen dieses Problem -- sie speichern Daten unabhängig vom Container.

Es gibt zwei Wege, Daten persistent zu speichern:

1. Named Volumes (empfohlen)

Docker verwaltet den Speicherort selbst. Einfach und sicher:

# In docker-compose.yml
services:
  nextcloud:
    image: nextcloud:latest
    volumes:
      - nextcloud_data:/var/www/html

volumes:
  nextcloud_data:

# Volumes anzeigen
docker volume ls

# Details eines Volumes anzeigen
docker volume inspect nextcloud_data

2. Bind Mounts (lokale Ordner)

Du bestimmst den Speicherort selbst. Praktisch für Configs oder wenn du direkt auf die Dateien zugreifen willst:

# In docker-compose.yml
services:
  nginx:
    image: nginx:latest
    volumes:
      - ./nginx/html:/usr/share/nginx/html
      - ./nginx/conf:/etc/nginx/conf.d

# Backup eines Named Volumes erstellen
docker run --rm -v nextcloud_data:/data -v $(pwd):/backup \
  alpine tar czf /backup/nextcloud-backup.tar.gz -C /data .

Nützliche Container für das Homelab

Hier sind die beliebtesten Services, die Homelab-Betreiber als Docker-Container laufen lassen. Alle lassen sich einfach per Docker Compose hinzufügen.

Schnellstart: Alle Services auf einen Blick

# Uptime Kuma
docker run -d --name uptime-kuma -p 3001:3001 \
  -v uptime-kuma:/app/data --restart unless-stopped \
  louislam/uptime-kuma:latest

# Jellyfin
docker run -d --name jellyfin -p 8096:8096 \
  -v jellyfin-config:/config -v /pfad/zu/medien:/media \
  --restart unless-stopped jellyfin/jellyfin:latest

# Homepage Dashboard
docker run -d --name homepage -p 3000:3000 \
  -v homepage-config:/app/config \
  --restart unless-stopped ghcr.io/gethomepage/homepage:latest

Tipps und Best Practices

Container aktuell halten

Docker-Images werden regelmäßig aktualisiert (Sicherheitspatches, neue Features). So updatest du deine Container:

# Neue Images herunterladen
docker compose pull

# Container mit neuen Images neu starten
docker compose up -d

# Alte, unbenutzte Images aufräumen
docker image prune -a

Logging richtig einrichten

Docker-Logs können schnell viel Speicherplatz verbrauchen. Begrenze die Log-Größe global in der Docker-Daemon-Konfiguration:

# /etc/docker/daemon.json erstellen oder bearbeiten
sudo nano /etc/docker/daemon.json

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

# Docker Daemon neu starten
sudo systemctl restart docker

Damit wird jede Log-Datei maximal 10 MB groß und es werden maximal 3 Dateien pro Container aufbewahrt.

Docker-Netzwerke nutzen

Standardmäßig können sich alle Container gegenseitig erreichen. Für mehr Sicherheit und Übersicht erstelle eigene Netzwerke:

# In docker-compose.yml
services:
  nextcloud:
    image: nextcloud:latest
    networks:
      - frontend
      - backend

  db:
    image: mariadb:latest
    networks:
      - backend

networks:
  frontend:
  backend:

In diesem Beispiel kann nextcloud auf die Datenbank zugreifen, aber die Datenbank ist nicht direkt aus dem Frontend-Netzwerk erreichbar. So isolierst du Services voneinander.

Backup nicht vergessen

• Sichere deine docker-compose.yml Dateien (am besten in einem Git-Repository)
• Erstelle regelmäßige Backups deiner Volumes
• Teste die Wiederherstellung -- ein Backup das nicht funktioniert ist kein Backup

Ressourcen begrenzen

Verhindere, dass ein einzelner Container alle Ressourcen frisst:

# In docker-compose.yml
services:
  nextcloud:
    image: nextcloud:latest
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: "1.0"

Zusammenfassung

Das hast du in diesem Guide gelernt:

1. Docker auf Ubuntu/Debian installieren
2. Container starten und verwalten
3. Docker Compose für Multi-Container-Setups nutzen
4. Portainer und Pi-hole aufsetzen
5. Volumes für persistente Daten verwenden
6. Wichtige Docker-Befehle für den Alltag
7. Best Practices für ein stabiles Homelab

Docker ist der Einstieg in eine ganz neue Welt. Sobald du das Prinzip verstanden hast, wirst du kaum noch Software direkt auf dem Host installieren wollen. Fang mit Portainer und Pi-hole an, und erweitere dein Setup Schritt für Schritt.

Viel Spaß beim Experimentieren! Und keine Sorge -- wenn etwas schiefgeht, löschst du den Container einfach und fängst neu an. Das ist das Schöne an Docker.