Nie wieder Server-Shutdowns: Eigene Services mit Docker und NPM

Moin zusammen, liebe smoth.me-Community!

Als erfahrener Admin und Heimlabor-Enthusiast, der schon so einige Jahre mit Proxmox, Docker, Home Assistant und Co. verbracht hat, habe ich in den letzten Tagen wieder eine Nachricht gelesen, die mir ein Déjà-vu beschert hat: Sony schaltet die Server für „Firewall Ultra“ ab. Ein weiteres Online-Spiel, ein VR-Exklusivtitel, verschwindet einfach vom Markt. Und wisst ihr was? Das ist nicht das erste Mal und wird auch nicht das letzte Mal sein.

In meiner Erfahrung ist das ein wiederkehrendes Muster. Egal ob es Games sind, Smart-Home-Dienste, die plötzlich eingestellt werden, oder Cloud-Services, die ihre Geschäftsmodelle ändern und alte Features streichen – am Ende sind wir als Nutzer oft die Leidtragenden. Wir verlieren den Zugriff auf Inhalte, die wir vielleicht sogar bezahlt haben, oder auf Funktionalitäten, auf die wir uns verlassen haben. Das ist frustrierend und zeigt einmal mehr, wie wichtig es ist, die Kontrolle über die eigenen digitalen Dienste zu behalten.

Genau deshalb schreibe ich diesen Guide. Er ist inspiriert von genau solchen Meldungen und soll dir zeigen, wie du mit einer robusten Kombination aus Docker und Nginx Proxy Manager (NPM) deine eigenen Services hostest. Das Ziel ist klar: Unabhängigkeit schaffen, Resilienz aufbauen und dich nie wieder von den Launen externer Anbieter abhängig machen. Wer das zum ersten Mal einrichtet, stolpert oft über die Komplexität von Reverse Proxies und SSL-Zertifikaten – aber glaub mir, mit NPM wird das zum Kinderspiel.

Wir werden gemeinsam einen kleinen, beispielhaften Webdienst in einem Docker-Container aufsetzen und ihn sicher über Nginx Proxy Manager mit Let's Encrypt SSL-Zertifikaten nach außen zugänglich machen. So legst du eine solide Basis für dein eigenes, unabhängiges Home Lab.

Voraussetzungen für dein eigenes, resilientes Home Lab

Bevor wir loslegen, solltest du ein paar Dinge vorbereitet haben. Keine Sorge, nichts Weltbewegendes, aber die Basis muss stimmen.

• Ein Linux-Server: Das kann eine dedizierte Maschine sein, ein Raspberry Pi 4 oder 5, aber in meinem Home Lab nutze ich dafür am liebsten eine VM oder einen LXC unter Proxmox. Für diesen Guide gehe ich von einem aktuellen Debian oder Ubuntu Server aus. Achte darauf, dass er mindestens 2 GB RAM hat, besser 4 GB, wenn du mehrere Dienste hosten willst.
• Grundlegende Linux-Kenntnisse: Du solltest dich auf der Kommandozeile (CLI) zurechtfinden und wissen, wie man Pakete installiert und Textdateien bearbeitet (z.B. mit nano oder vim).
• Docker und Docker Compose: Diese beiden Werkzeuge sind das Herzstück unserer Container-Strategie. Wir werden sie gleich installieren.
• Eine Domain (optional, aber dringend empfohlen): Wenn du deine Dienste später von außerhalb deines Heimnetzwerks erreichen willst (z.B. für Home Assistant, Nextcloud, oder eben einen privaten Game-Server), brauchst du eine eigene Domain (z.B. deinedomain.de). Subdomains wie service.deinedomain.de sind ideal.
• Port-Weiterleitungen im Router: Für den externen Zugriff müssen die Ports 80 (HTTP) und 443 (HTTPS) auf die IP-Adresse deines Linux-Servers weitergeleitet werden. Das ist entscheidend für Let's Encrypt und den Zugriff über NPM.
• SSH-Zugang zum Server: Für die Installation und Konfiguration arbeiten wir komplett über SSH.

Mein Tipp: Wenn du noch keine Domain hast und nur intern testen willst, kannst du auch erst mal mit internen IPs arbeiten. Aber für den vollen Funktionsumfang von NPM (insbesondere Let's Encrypt) ist eine Domain Pflicht.

Schritt-für-Schritt: Eigene Services mit Docker und Nginx Proxy Manager

1. Server-Grundlage schaffen: Update und Docker-Installation

Zuerst bringen wir das System auf den neuesten Stand und installieren Docker. Das ist der Grundstein für alles, was danach kommt.

Verbinde dich per SSH mit deinem Server und führe die üblichen Updates durch:

sudo apt update
sudo apt upgrade -y

Danach installieren wir Docker und Docker Compose. Ich nutze hier die offizielle Methode, da sie die aktuellsten Versionen liefert und am stabilsten ist. Ich habe mit diesen Befehlen auf unzähligen Systemen gute Erfahrungen gemacht.

# Abhängigkeiten installieren
sudo apt install ca-certificates curl gnupg lsb-release -y

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

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

# Paketliste aktualisieren und Docker installieren
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

# Optional: Aktuellen Benutzer zur Docker-Gruppe hinzufügen, um "sudo" zu vermeiden
sudo usermod -aG docker $USER
# Nach diesem Befehl musst du dich einmal ab- und wieder anmelden oder den Server neu starten,
# damit die Gruppenmitgliedschaft wirksam wird.

Wichtig zu wissen: Nach sudo usermod -aG docker $USER musst du dich wirklich neu anmelden (oder SSH-Sitzung schließen und neu öffnen), damit die Änderungen wirksam werden. Sonst bekommst du immer noch "permission denied" Fehler, wenn du Docker-Befehle ohne sudo ausführst.

Überprüfe die Installation mit:

docker run hello-world
docker compose version

Wenn alles glattgeht, siehst du die "Hello from Docker!"-Nachricht und die Version von Docker Compose.

2. Nginx Proxy Manager (NPM) aufsetzen

Nginx Proxy Manager ist ein absolutes Goldstück in meinem Home Lab. Es nimmt dir den ganzen Ärger mit Nginx-Konfigurationen und Let's Encrypt ab. Du bekommst eine schicke Web-Oberfläche, über die du Reverse Proxies, SSL-Zertifikate und Weiterleitungen im Handumdrehen einrichtest. Das ist der Schlüssel, um deine internen Dienste sicher nach außen zu bringen.

Wir erstellen ein Verzeichnis für NPM und darin eine docker-compose.yml-Datei.

mkdir -p ~/npm
cd ~/npm
nano docker-compose.yml

Füge den folgenden Inhalt in die Datei ein:

version: '3.8'
services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
      - '81:81' # Web-UI von NPM
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    environment:
      DB_MYSQL_HOST: "db"
      DB_MYSQL_PORT: 3306
      DB_MYSQL_USER: "npm"
      DB_MYSQL_PASSWORD: "npm_password" # Ändere dies zu einem sicheren Passwort!
      DB_MYSQL_NAME: "npm"
  db:
    image: 'mariadb:latest'
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: "mysql_root_password" # Ändere dies zu einem SEHR sicheren Passwort!
      MYSQL_DATABASE: "npm"
      MYSQL_USER: "npm"
      MYSQL_PASSWORD: "npm_password" # Verwende das gleiche Passwort wie oben für DB_MYSQL_PASSWORD
    volumes:
      - ./mysql:/var/lib/mysql

Mein Tipp: Ändere die Passwörter in der docker-compose.yml sofort! Das sind die Zugangsdaten für die Datenbank, die NPM nutzt. Sicherheit geht vor, auch im Home Lab.

Starte NPM mit Docker Compose:

docker compose up -d

Warte ein paar Minuten, bis die Container hochgefahren sind. Du kannst den Status mit docker compose ps überprüfen.

Greife nun auf die Web-Oberfläche von NPM zu: Öffne deinen Browser und navigiere zu http://<DEINE_SERVER_IP>:81.

Die Standard-Anmeldedaten sind:

• Email: admin@example.com
• Password: changeme

Wichtig: Ändere diese Zugangsdaten SOFORT nach dem ersten Login! Du wirst automatisch dazu aufgefordert.

3. Einen beispielhaften Service containerisieren (Whoami)

Um zu demonstrieren, wie NPM funktioniert, setzen wir einen super einfachen Docker-Container auf: whoami. Dieser kleine Dienst zeigt dir einfach die IP-Adresse und den Hostnamen des Containers an, der die Anfrage verarbeitet. Perfekt zum Testen!

Erstelle ein neues Verzeichnis für unseren Test-Service und darin eine weitere docker-compose.yml:

mkdir -p ~/whoami
cd ~/whoami
nano docker-compose.yml

Füge diesen Inhalt ein:

version: '3.8'
services:
  whoami:
    image: "traefik/whoami"
    container_name: whoami
    restart: unless-stopped
    ports:
      - "8000:80" # Der Dienst lauscht intern auf Port 80, wir mappen ihn auf 8000 des Hosts

Starte den whoami-Container:

docker compose up -d

Du kannst jetzt prüfen, ob der Dienst intern läuft, indem du http://<DEINE_SERVER_IP>:8000 in deinem Browser öffnest. Du solltest eine einfache Seite mit "I am " sehen. Das ist unser interner Dienst.

4. Service über NPM veröffentlichen

Jetzt kommt der spannende Teil: Wir machen den whoami-Dienst über deine Domain und mit HTTPS zugänglich.

Bevor du in NPM etwas einstellst, musst du einen DNS-Eintrag bei deinem Domain-Provider erstellen. Lege einen A-Record oder CNAME-Record an, der auf die öffentliche IP-Adresse deines Servers zeigt. Wenn dein Server zum Beispiel unter whoami.deinedomain.de erreichbar sein soll, muss dieser Eintrag auf die IP deines Routers zeigen, der dann Port 80 und 443 an deinen Server weiterleitet.

Beispiel DNS-Eintrag (A-Record):

• Typ: A
• Name/Host: whoami
• Wert/IP-Adresse: DEINE_OEFFENTLICHE_IP_ADRESSE

Warte, bis der DNS-Eintrag propagiert ist (kann ein paar Minuten dauern). Du kannst das mit dig whoami.deinedomain.de auf der Kommandozeile prüfen.

Gehe nun zurück in die Nginx Proxy Manager Web-Oberfläche (http://<DEINE_SERVER_IP>:81).

1. Navigiere zu "Hosts" -> "Proxy Hosts".
2. Klicke auf "Add Proxy Host".
3. Fülle die Felder wie folgt aus:
   • Domain Names: whoami.deinedomain.de (ersetze mit deiner Subdomain)
   • Scheme: http
   • Forward Hostname / IP: <DEINE_SERVER_IP> (die interne IP deines Linux-Servers)
   • Forward Port: 8000 (der Port, auf dem unser whoami-Dienst auf dem Host lauscht)
4. Aktiviere "Block Common Exploits" (guter Standard).
5. Gehe zum Tab "SSL":
   • Wähle "Request a new SSL Certificate".
   • Aktiviere "Force SSL" (sehr wichtig für Sicherheit).
   • Aktiviere "HTTP/2 Support" (Performance-Verbesserung).
   • Gib deine E-Mail-Adresse ein und stimme den Let's Encrypt ToS zu.
6. Klicke auf "Save".

NPM wird nun versuchen, ein Let's Encrypt Zertifikat für deine Domain zu beantragen. Wenn die DNS-Einstellungen und Port-Weiterleitungen korrekt sind, sollte dies erfolgreich sein.

5. Testen und Absichern

Öffne deinen Browser und navigiere zu https://whoami.deinedomain.de (ersetze mit deiner Subdomain). Du solltest nun deinen whoami-Dienst sehen, der über HTTPS von Let's Encrypt gesichert ist!

Glückwunsch! Du hast erfolgreich deinen ersten selbstgehosteten Dienst über Docker und Nginx Proxy Manager nach außen gebracht. Das ist ein riesiger Schritt in Richtung Unabhängigkeit. Von hier aus kannst du praktisch jeden Docker-Dienst (Home Assistant, Nextcloud, Jellyfin, N8N, etc.) auf die gleiche Weise veröffentlichen.

Mein Tipp: Denke immer an Backups! Proxmox bietet hier fantastische Möglichkeiten für VM-Backups. Für Docker-Container solltest du die Volumes sichern, wo die Daten liegen (in unserem Fall ./data, ./letsencrypt, ./mysql für NPM und keine für whoami).

Häufige Fehler und Lösungen

Wer das zum ersten Mal einrichtet, stolpert oft über die gleichen Dinge. Keine Sorge, das ist normal. Hier sind die häufigsten Probleme, die ich in meiner Erfahrung sehe, und wie du sie löst:

1. DNS-Probleme: Domain nicht erreichbar oder zeigt auf falsche IP

Symptom: Du kannst deine Domain im Browser nicht erreichen oder sie zeigt auf eine andere Seite/Fehlermeldung. Let's Encrypt in NPM schlägt fehl mit einer Meldung wie "Domain is not reachable".

Ursache: Dein DNS-Eintrag (A-Record oder CNAME) ist entweder falsch konfiguriert, noch nicht vollständig propagiert oder zeigt nicht auf die öffentliche IP-Adresse deines Routers.

Lösung:

1. DNS-Eintrag prüfen: Gehe zu deinem Domain-Provider und überprüfe den A-Record für deine Subdomain (z.B. whoami.deinedomain.de). Er muss exakt auf die öffentliche IP-Adresse deines Heimnetzwerks zeigen.
2. DNS-Propagierung testen: Nutze Tools wie dnschecker.org oder führe auf deiner lokalen Maschine dig whoami.deinedomain.de oder nslookup whoami.deinedomain.de aus. Die angezeigte IP muss deine öffentliche IP sein.
3. Cache leeren: Manchmal hilft es, den DNS-Cache deines Rechners zu leeren (ipconfig /flushdns unter Windows, sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder unter macOS).

2. Port-Konflikte oder Firewall blockiert

Symptom: NPM kann keine Zertifikate anfordern oder du kannst die NPM-Oberfläche auf Port 81 nicht erreichen. Browser zeigt "Verbindung fehlgeschlagen" oder "ERR_CONNECTION_REFUSED".

Ursache:

• Die Ports 80 und 443 sind nicht auf deinen Server weitergeleitet (Port Forwarding im Router fehlt oder ist falsch).
• Eine lokale Firewall auf deinem Linux-Server (z.B. UFW) blockiert die Ports.
• Ein anderer Dienst auf deinem Server verwendet bereits Port 80, 443 oder 81.

Lösung:

1. Router-Port-Forwarding prüfen: Logge dich in deinen Router ein und stelle sicher, dass die Ports 80 (TCP) und 443 (TCP) auf die interne IP-Adresse deines Linux-Servers weitergeleitet werden. Wenn du von außen auf Port 81 zugreifen willst, musst du auch diesen weiterleiten (aber das ist weniger sicher und nicht unbedingt nötig).
2. Server-Firewall prüfen: Wenn du UFW (Uncomplicated Firewall) verwendest, stelle sicher, dass die Ports 80, 443 und 81 erlaubt sind:

   sudo ufw allow 80/tcp
   sudo ufw allow 443/tcp
   sudo ufw allow 81/tcp
   sudo ufw enable # Wenn noch nicht aktiviert
   sudo ufw status
   

3. Port-Belegung prüfen: Schau nach, ob ein anderer Dienst die Ports belegt:

   sudo netstat -tulpn | grep -E "80|443|81"
   

   Wenn hier etwas anderes als Docker-Container auftaucht, musst du den Konflikt lösen (z.B. den anderen Dienst stoppen oder auf einen anderen Port verschieben).

3. Let's Encrypt Fehler: Zertifikat kann nicht ausgestellt werden

Symptom: Im NPM-Interface beim Anfordern des SSL-Zertifikats erscheint eine Fehlermeldung, oft mit Details aus den Let's Encrypt Logs.

Ursache: Meistens hängt dies mit DNS- oder Port-Forwarding-Problemen zusammen (siehe oben). Let's Encrypt muss deine Domain von außen erreichen können, um zu verifizieren, dass du der Besitzer bist.

Lösung:

1. Vorherige Fehler beheben: Stelle sicher, dass DNS und Port-Weiterleitungen (80 und 443) korrekt funktionieren und von außen erreichbar sind. Das ist die absolute Basis.
2. NPM-Logs prüfen: Gehe in NPM unter "Logs" und schau dir die genauen Fehlermeldungen an. Dort steht oft der entscheidende Hinweis. Auch die Docker-Logs des NPM-Containers können helfen:

   docker compose logs app
   

3. E-Mail-Adresse prüfen: Vergewissere dich, dass du eine gültige E-Mail-Adresse im SSL-Tab eingegeben hast und den Let's Encrypt ToS zugestimmt hast.
4. Firewall auf Server prüfen: Manchmal blockiert auch die Server-Firewall ausgehende Verbindungen, die Let's Encrypt benötigt, um seine Prüfungen durchzuführen. Dies ist aber seltener der Fall.

Fazit: Die Macht der Selbstbestimmung

Wir haben es geschafft! Du hast gelernt, wie du deine eigenen Dienste mit Docker containerisierst und sie sicher über Nginx Proxy Manager veröffentlichst. Dieses Setup ist nicht nur elegant und wartungsarm, sondern vor allem: Es gibt dir die Kontrolle zurück.

Die Nachricht über die Abschaltung von "Firewall Ultra" ist nur ein weiteres Beispiel dafür, dass wir uns nicht blind auf externe Anbieter verlassen können. Indem du deine eigenen Services hostest, schützt du dich vor solchen Entscheidungen und stellst sicher, dass deine Daten und deine digitalen Erlebnisse dir gehören und unter deiner Kontrolle bleiben.

Das ist erst der Anfang. Von hier aus kannst du dein Home Lab in unzählige Richtungen erweitern:

• Installiere Home Assistant für deine Smart-Home-Zentrale.
• Setze Nextcloud auf, um deine eigene Cloud zu betreiben.
• Experimentiere mit N8N für leistungsstarke Automatisierungen.
• Hoste einen privaten Game-Server für deine Freunde, der nicht einfach abgeschaltet wird.
• Richte ein Monitoring mit Prometheus und Grafana ein, um deine Dienste im Blick zu behalten.

Die Möglichkeiten sind endlos. Bleib neugierig, probiere dich aus und behalte die Kontrolle. Dein Home Lab wartet darauf, von dir erobert zu werden!