Proxmox, Docker & NPM: Dein Heimnetzwerk sicher veröffentlichen

Einleitung: Dein Home Lab auf Steroiden – Proxmox, Docker & Nginx Proxy Manager

Servus, Kollegen! Als langjähriger Systemadministrator und passionierter Heimlabor-Enthusiast habe ich in den letzten Jahren so einige Setups auf die Beine gestellt, optimiert und manchmal auch wieder eingerissen, nur um es noch besser zu machen. Proxmox, Docker, Home Assistant, N8N – das sind nur einige der Bausteine, die mein digitales Zuhause am Laufen halten. Und ein zentraler Punkt, der immer wieder aufkommt, wenn man seine Dienste nicht nur lokal, sondern auch sicher von unterwegs erreichen möchte, ist ein vernünftiger Reverse Proxy.

Heute teile ich mit dir meine Erfahrungen und zeige dir Schritt für Schritt, wie du ein robustes Fundament für dein Home Lab legst: Eine Proxmox-VM, die als Docker-Host dient, und darauf der Nginx Proxy Manager (NPM). Mit diesem Setup kannst du deine Docker-Container, sei es Home Assistant, Nextcloud oder ein kleiner Webserver, elegant und vor allem sicher über eine eigene Domain erreichen – inklusive kostenloser SSL-Zertifikate von Let's Encrypt. In meiner Erfahrung ist das die Königsdisziplin, um Kontrolle über deine Dienste zu behalten und sie gleichzeitig professionell zu präsentieren. Wer das zum ersten Mal einrichtet, stolpert oft über Netzwerk- oder Zertifikatskonfigurationen. Keine Sorge, das kriegen wir gemeinsam hin!

Voraussetzungen: Was du mitbringen solltest

Bevor wir ins Eingemachte gehen, lass uns kurz checken, ob wir auf dem gleichen Stand sind. Dieser Guide richtet sich an technisch versierte Admins, die keine Scheu vor der Kommandozeile haben. Das ist kein "Klick-mich-bunt"-Tutorial, sondern ein Hands-on-Ansatz für Leute, die wissen, wie man einen SSH-Client bedient.

• Proxmox VE Installation: Du solltest einen laufenden Proxmox VE-Server haben. Die Basisinstallation decke ich hier nicht ab, da es dazu schon hervorragende Guides gibt. Wichtig ist, dass du Zugriff auf die Proxmox-Weboberfläche und idealerweise auch per SSH auf den Host hast.
• Hardware: Dein Proxmox-Server sollte genügend Ressourcen (mindestens 8GB RAM, besser 16GB+; ausreichend CPU-Kerne) haben, um eine zusätzliche VM mit Docker und den darauf laufenden Diensten zu befeuern. SSD-Speicher ist für die Performance ein Muss.
• Netzwerkkenntnisse: Grundlegendes Verständnis von IP-Adressen, Subnetzen, Ports und DNS ist unerlässlich.
• Domain: Du benötigst eine eigene Domain (z.B. deinedomain.de), die du kontrollierst. Diese ist notwendig, um Let's Encrypt-Zertifikate zu erhalten und deine Dienste von außen erreichbar zu machen.
• Router-Zugriff: Du musst Port-Weiterleitungen (Port 80 und 443 TCP) auf deinem Router einrichten können, die auf die IP-Adresse deines zukünftigen Nginx Proxy Managers zeigen.
• Betriebssystem-Image: Ein ISO-Image von Debian oder Ubuntu Server, um deine Docker-VM zu erstellen. Ich persönlich nutze gerne Debian als Basis für meine VMs, da es schlank und stabil ist.

Mein Tipp: Bevor du anfängst, skizziere dir kurz deine gewünschte Netzwerkstruktur. Welche IP-Adressen sollen deine VMs bekommen? Welche Subdomains willst du nutzen? Das spart später viel Zeit und Frust.

Schritt 1: Netzwerk-Grundlagen für dein Docker-Setup

Die Netzwerk-Konfiguration ist oft der erste Stolperstein. Wir wollen, dass unsere Docker-VM eine feste IP-Adresse bekommt und über ein eigenes virtuelles Netzwerk kommunizieren kann. In Proxmox nutzen wir dafür eine Bridge.

Virtuelles Netzwerk in Proxmox vorbereiten (Optional, aber empfohlen)

Standardmäßig haben deine Proxmox-VMs Zugriff über die Bridge vmbr0. Wenn du dein Docker-Host-Netzwerk sauber trennen möchtest, könntest du eine weitere Bridge erstellen. Für die meisten Home Labs reicht es aber, die Docker-VM einfach an vmbr0 anzubinden und ihr eine statische IP zu geben.

Wichtig zu wissen: Die VM, auf der Nginx Proxy Manager läuft, muss von extern über Port 80 und 443 erreichbar sein. Stelle sicher, dass dein Router diese Ports auf die IP-Adresse dieser VM weiterleitet.

Ich gehe davon aus, dass du deine Docker-VM an vmbr0 anschließt. Um Probleme mit dynamischen IP-Adressen zu vermeiden, weisen wir der VM später eine statische IP zu. Das ist entscheidend für die Port-Weiterleitung auf deinem Router.

Schritt 2: Die Docker-VM vorbereiten

Zeit, unsere dedizierte Docker-Maschine in Proxmox zu erstellen. Ich verwende hier ein Debian 12 (Bookworm) als Basis, da es schlank und stabil ist.

Neue VM in Proxmox erstellen

1. Logge dich in die Proxmox-Weboberfläche ein.
2. Klicke oben rechts auf "VM erstellen".
3. General: Gib einen Namen (z.B. docker-host-01) und eine VM-ID an.
4. OS: Wähle dein Debian/Ubuntu Server ISO-Image aus.
5. System: Standardeinstellungen sind meistens okay.
6. Disks: Ich empfehle mindestens 32GB für das Systemlaufwerk, besser 64GB oder mehr, je nachdem, wie viele Container du später speichern willst. Wähle "VirtIO Block" für bessere Performance.
7. CPU: Gib der VM mindestens 2 Cores, besser 4, wenn du viele Dienste planst.
8. Memory: Starte mit 2GB RAM, aber sei bereit, auf 4GB oder mehr zu erhöhen, sobald du mehr Container laufen lässt. Docker selbst ist nicht so hungrig, aber die Container können es sein.
9. Network: Wähle vmbr0 und "VirtIO (paravirtualisiert)" für den Netzwerkadapter.
10. Bestätige die Erstellung und starte die VM anschließend.

Betriebssystem installieren und Basiskonfiguration

Installiere Debian/Ubuntu Server wie gewohnt. Achte darauf, einen SSH-Server zu installieren, damit du die VM später bequem per SSH verwalten kannst. Nach der Installation:

1. Logge dich per SSH in deine neue VM ein.
2. Aktualisiere das System:

sudo apt update && sudo apt upgrade -y

3. Installiere einige nützliche Tools:

sudo apt install -y curl wget git vim htop screen net-tools

4. Statische IP-Adresse konfigurieren: Das ist essenziell für unser Setup. Bearbeite die Netzwerk-Konfiguration. Unter Debian/Ubuntu ist das oft /etc/network/interfaces oder, moderner, via Netplan unter Ubuntu. Hier ein Beispiel für Debian mit /etc/network/interfaces:

sudo nano /etc/network/interfaces

Passe den Eintrag für deine Netzwerkschnittstelle (oft ens18 oder eth0) an:

# The primary network interface
auto ens18
iface ens18 inet static
    address 192.168.1.100  # Deine gewünschte statische IP
    netmask 255.255.255.0
    gateway 192.168.1.1   # IP deines Routers
    dns-nameservers 192.168.1.1 8.8.8.8 # Dein Router und z.B. Google DNS

Speichern und neu starten, damit die Änderungen wirksam werden:

sudo systemctl restart networking
# Oder bei Problemen:
sudo reboot

Überprüfe die IP-Adresse mit ip a.

Schritt 3: Docker und Docker Compose installieren

Jetzt wird's ernst: Docker kommt auf die Maschine. Ich empfehle immer die offizielle Installationsanleitung von Docker zu nutzen, da die Paketquellen in den Distributionen oft veraltet sind.

Docker Engine installieren

# Alte Versionen deinstallieren (falls vorhanden)
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt remove $pkg; done

# Docker GPG-Schlüssel hinzufügen
sudo apt update
sudo apt install ca-certificates curl gnupg
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

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

Benutzer zur Docker-Gruppe hinzufügen

Damit du Docker-Befehle ohne sudo ausführen kannst, füge deinen Benutzer zur docker-Gruppe hinzu:

sudo usermod -aG docker $USER
# Melde dich ab und wieder an (oder starte die SSH-Session neu), damit die Gruppenmitgliedschaft wirksam wird.

Teste die Installation mit:

docker run hello-world

Wenn du die "Hello from Docker!"-Nachricht siehst, ist alles paletti.

Schritt 4: Nginx Proxy Manager (NPM) mit Docker Compose

Der Nginx Proxy Manager ist ein Segen für jeden, der mehrere Webdienste im Home Lab betreibt. Er vereinfacht das Reverse Proxying und die SSL-Zertifikatsverwaltung enorm. Wir installieren ihn mit Docker Compose.

Verzeichnisstruktur anlegen

Ich erstelle gerne ein dediziertes Verzeichnis für meine Docker Compose-Projekte:

mkdir -p ~/docker/npm
cd ~/docker/npm

docker-compose.yml für Nginx Proxy Manager

Erstelle eine Datei namens docker-compose.yml:

nano docker-compose.yml

Füge folgenden Inhalt ein:

version: '3.8'

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'    # HTTP
      - '443:443'  # HTTPS
      - '81:81'    # NPM Admin Panel
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    environment:
      DB_MYSQL_HOST: "db"
      DB_MYSQL_PORT: 3306
      DB_MYSQL_USER: "npm"
      DB_MYSQL_PASSWORD: "npm_password" # Wichtig: Ändere dies zu einem sicheren Passwort!
      DB_MYSQL_NAME: "npm"
    depends_on:
      - db

  db:
    image: 'mariadb:latest'
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: "root_password" # Wichtig: Ändere dies zu einem sicheren Passwort!
      MYSQL_DATABASE: "npm"
      MYSQL_USER: "npm"
      MYSQL_PASSWORD: "npm_password" # Wichtig: Ändere dies zu einem sicheren Passwort!
    volumes:
      - ./mysql:/var/lib/mysql

Wichtig: Ändere die Passwörter für DB_MYSQL_PASSWORD, MYSQL_ROOT_PASSWORD und MYSQL_PASSWORD zu sicheren, einzigartigen Werten! Das ist absolut kritisch für die Sicherheit deines Setups.

NPM starten und initialer Zugriff

Starte den Nginx Proxy Manager:

docker compose up -d

Warte einen Moment, bis die Container gestartet sind. Du kannst den Status mit docker compose ps überprüfen.

Nun kannst du das Admin-Panel von NPM über deinen Browser aufrufen: http://<IP_deiner_Docker-VM>:81. Der Standard-Login ist:

• E-Mail: admin@example.com
• Passwort: changeme

Wichtig: Direkt nach dem ersten Login wirst du aufgefordert, diese Zugangsdaten zu ändern. Tu das sofort! Erstelle einen neuen Benutzer mit deiner eigenen E-Mail-Adresse und einem sicheren Passwort.

Schritt 5: Dienste hinter NPM veröffentlichen (Beispiel: Home Assistant)

Jetzt, da NPM läuft, können wir unsere ersten Dienste dahinter verbergen und sicher veröffentlichen. Nehmen wir Home Assistant als Beispiel.

Home Assistant Container starten

Gehe zurück in dein Docker-Verzeichnis (z.B. ~/docker/homeassistant) und erstelle eine weitere docker-compose.yml:

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

version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: "ghcr.io/home-assistant/home-assistant:stable"
    volumes:
      - ./config:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    privileged: true # Nur wenn du USB-Geräte durchreichen musst
    network_mode: host # Oder bridge mit Portmapping, wenn du mehr Kontrolle willst
    # Wenn network_mode: host nicht geht oder du es nicht willst, nutze:
    # ports:
    #   - 8123:8123
    # network_mode: bridge # Dies ist der Standard

Mein Tipp: Für Home Assistant nutze ich oft network_mode: host, da es die Integration von Geräten im lokalen Netzwerk vereinfacht. Wenn du mehr Kontrolle über die Port-Exposition haben möchtest, nutze network_mode: bridge und mappe Port 8123. Für dieses Beispiel nehmen wir an, Home Assistant ist auf Port 8123 deiner Docker-VM erreichbar.

Starte Home Assistant:

docker compose up -d

Überprüfe, ob Home Assistant läuft, indem du http://<IP_deiner_Docker-VM>:8123 im Browser aufrufst.

NPM-Konfiguration für Home Assistant

1. Gehe ins Nginx Proxy Manager Admin-Panel (http://<IP_deiner_Docker-VM>:81).
2. Gehe zu "Hosts" -> "Proxy Hosts" und klicke auf "Add Proxy Host".
3. Details:
   • Domain Names: Gib die Subdomain ein, über die du Home Assistant erreichen willst (z.B. ha.deinedomain.de).
   • Scheme: http (da Home Assistant im Container über HTTP läuft)
   • Forward Hostname / IP: Die IP-Adresse deiner Docker-VM (z.B. 192.168.1.100)
   • Forward Port: 8123 (der Port, auf dem Home Assistant läuft)
4. SSL:
   • Wähle "Request a new SSL Certificate" aus.
   • Aktiviere "Force SSL".
   • Gib deine E-Mail-Adresse für Let's Encrypt-Benachrichtigungen ein.
   • Aktiviere "I Agree to the Let's Encrypt Terms of Service".
5. Klicke auf "Save".

Wichtig: Damit Let's Encrypt das Zertifikat ausstellen kann, müssen deine Domain-Einträge korrekt sein. Du benötigst einen A-Record bei deinem Domain-Provider, der ha.deinedomain.de (und ggf. www.ha.deinedomain.de) auf die öffentliche IP-Adresse deines Routers zeigt. Außerdem müssen die Port-Weiterleitungen für 80 und 443 auf deinem Router auf die IP deiner Docker-VM zeigen.

Wenn alles richtig konfiguriert ist, solltest du Home Assistant jetzt über https://ha.deinedomain.de erreichen können, geschützt durch ein gültiges SSL-Zertifikat.

Häufige Fehler und Lösungen

In meiner Erfahrung gibt es ein paar Klassiker, die immer wieder für Kopfzerbrechen sorgen. Hier sind die Top 3:

1. Port-Konflikte (Error: 'Port 80/443 already in use')

Problem: Wenn du NPM startest, bekommst du Fehlermeldungen, dass Port 80 oder 443 bereits belegt ist. Das kann passieren, wenn ein anderer Dienst auf deiner Docker-VM diese Ports schon nutzt (z.B. ein Apache- oder Nginx-Server, der direkt auf der VM läuft) oder wenn du Docker Compose-Dateien hast, die Ports doppelt mappen.

Lösung:

• Überprüfe, welche Dienste auf deiner VM Ports belegen:

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

  Wenn du hier Prozesse siehst, die nicht zu Docker gehören, musst du diese stoppen oder deinstallieren.
• Stelle sicher, dass keine anderen Docker-Container Ports 80 oder 443 direkt auf dem Host mappen, die NPM ebenfalls benötigt. NPM ist der einzige, der diese Ports direkt exponieren sollte.
• Wenn du eine andere Docker-Bridge als die Standard-Bridge (bridge) verwendest, stelle sicher, dass die Ports korrekt zugewiesen sind.

2. DNS-Probleme und Let's Encrypt-Fehler (Zertifikat kann nicht ausgestellt werden)

Problem: NPM kann kein Let's Encrypt-Zertifikat anfordern. Oft liegt das an der DNS-Konfiguration oder daran, dass Let's Encrypt deinen Server nicht erreichen kann.

Lösung:

• DNS-A-Record prüfen: Stelle sicher, dass dein A-Record (z.B. ha.deinedomain.de) bei deinem Domain-Provider auf die öffentliche IP-Adresse deines Routers zeigt. Nutze Tools wie dig oder Online-DNS-Checker, um dies zu verifizieren.
• Port-Weiterleitung prüfen: Überprüfe auf deinem Router, ob Port 80 und 443 TCP von außen auf die statische IP-Adresse deiner Docker-VM weitergeleitet werden. Ohne diese Weiterleitung kann Let's Encrypt deinen Server nicht erreichen, um die Domain-Validierung durchzuführen.
• Firewall: Prüfe, ob die Firewall auf deinem Proxmox-Host oder in deiner Docker-VM (ufw) eingehende Verbindungen auf Port 80 und 443 blockiert. Temporäres Deaktivieren der VM-Firewall kann zur Fehlersuche helfen.
• Logs prüfen: Schau in die Logs des Nginx Proxy Manager Containers:

  docker compose logs app

  Hier findest du oft detaillierte Fehlermeldungen von Let's Encrypt.

3. "502 Bad Gateway" oder "Connection Refused" nach erfolgreichem Zertifikat

Problem: Das SSL-Zertifikat wurde ausgestellt, aber wenn du deine Subdomain aufrufst, siehst du einen "502 Bad Gateway"-Fehler oder die Verbindung wird abgelehnt.

Lösung:

• Forward Hostname / IP: Überprüfe in NPM unter den Proxy Host-Einstellungen, ob der "Forward Hostname / IP" und "Forward Port" korrekt sind. Die IP muss die interne IP deiner Docker-VM sein und der Port der Port, auf dem der Dienst (z.B. Home Assistant) innerhalb deiner VM erreichbar ist.
• Dienst läuft: Stelle sicher, dass der Container des Zieldienstes (z.B. Home Assistant) auch wirklich läuft und auf dem angegebenen Port lauscht. Du kannst dies mit docker compose ps und einem Test von der Docker-VM selbst (z.B. curl http://localhost:8123) überprüfen.
• Interne Firewall: Wenn auf deiner Docker-VM eine Firewall (z.B. ufw) aktiv ist, stelle sicher, dass sie den Zugriff auf den Port des internen Dienstes (z.B. 8123 für Home Assistant) nicht blockiert.
• Docker-Netzwerke: Falls du spezifische Docker-Netzwerke verwendest, stelle sicher, dass der NPM-Container und der Ziel-Container im selben Netzwerk sind oder so konfiguriert sind, dass sie miteinander kommunizieren können. Im Standard-Bridge-Netzwerk von Docker Compose ist das meist kein Problem.

Fazit und nächste Schritte

Glückwunsch! Du hast jetzt ein solides Fundament für dein Home Lab geschaffen. Mit Proxmox als Basis, Docker für die Containerisierung und Nginx Proxy Manager als Reverse Proxy mit automatischer SSL-Verwaltung bist du bestens aufgestellt, um deine Dienste sicher und professionell von überall zu erreichen. Dieses Setup ist in meiner täglichen Arbeit im Home Lab Gold wert und spart unzählige Stunden beim manuellen Zertifikats-Management.

Was sind die nächsten Schritte? Nun, die Möglichkeiten sind grenzenlos:

• Weitere Dienste hinzufügen: Jetzt kannst du nach Belieben weitere Docker-Container auf deinem Host starten (Nextcloud, Plex, N8N, Portainer für Docker-Management) und sie einfach über NPM veröffentlichen.
• Monitoring: Integriere Prometheus und Grafana, um die Performance deiner VMs und Container zu überwachen.
• Backups: Richte regelmäßige Backups deiner Proxmox-VMs und der Docker-Volumes ein. Proxmox bietet hier schon hervorragende Bordmittel.
• Sicherheit: Vertiefe dich in Firewall-Regeln, Fail2ban und weitere Sicherheitsmaßnahmen, um dein System noch robuster zu machen.

Ich hoffe, dieser Guide hilft dir dabei, dein Home Lab auf das nächste Level zu heben. Teile deine Erfahrungen in der smoth.me Community – ich bin gespannt auf deine Setups und Optimierungen!