VPN ins Homelab: Sicherer Zugriff von überall

Warum VPN fürs Homelab?

Du hast dein Homelab eingerichtet, Docker-Container laufen, Proxmox ist konfiguriert -- aber was, wenn du unterwegs auf deine Services zugreifen willst? Viele Einsteiger machen den Fehler, Ports direkt am Router freizugeben. Das ist gefährlich:

• Portfreigaben exponieren Services direkt ins Internet -- jeder Bot-Scanner findet sie
• Brute-Force-Attacken auf SSH, Webinterfaces und APIs sind an der Tagesordnung
• Sicherheitslücken in einzelnen Services gefährden sofort das gesamte Netzwerk
• Kein zentraler Zugangspunkt -- jeder Service braucht eigene Absicherung

Mit einem VPN löst du alle diese Probleme auf einmal:

Kurz gesagt: Ein VPN verwandelt jede Internetverbindung in eine sichere Verlängerung deines Heimnetzwerks.

WireGuard vs Tailscale vs OpenVPN

Es gibt drei relevante VPN-Optionen für dein Homelab. Hier der direkte Vergleich:

Unsere Empfehlung: Nutze WireGuard, wenn du volle Kontrolle willst und einen Port am Router freigeben kannst. Nutze Tailscale, wenn du hinter CGNAT steckst oder es maximal einfach haben willst. OpenVPN ist 2026 keine sinnvolle Wahl mehr -- es ist langsamer, komplexer und bietet keinen Vorteil.

Option A: WireGuard mit Docker (wg-easy)

Die eleganteste Methode, WireGuard im Homelab zu betreiben, ist wg-easy -- ein Docker-Container mit Web-UI zum Verwalten deiner VPN-Clients.

Voraussetzungen

• Docker und Docker Compose installiert (siehe Docker Guide)
• Portfreigabe am Router: UDP Port 51820 auf deinen Homelab-Server
• Deine öffentliche IP oder eine DynDNS-Domain (z.B. über Fritz!Box oder DuckDNS)

docker-compose.yml

Erstelle einen neuen Ordner und die Compose-Datei:

mkdir -p ~/docker/wireguard && cd ~/docker/wireguard

# docker-compose.yml
services:
  wg-easy:
    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    environment:
      # Deine öffentliche IP oder DynDNS-Domain
      - WG_HOST=vpn.deinedomain.de
      # Passwort für das Web-Interface
      - PASSWORD_HASH=$$2y$$10$$dein_bcrypt_hash
      # Internes Subnetz für VPN-Clients
      - WG_DEFAULT_ADDRESS=10.8.0.x
      # DNS-Server für VPN-Clients (z.B. Pi-hole)
      - WG_DEFAULT_DNS=10.8.0.1
      # Allowed IPs (Standard: alles durch VPN)
      - WG_ALLOWED_IPS=192.168.1.0/24, 10.8.0.0/24
    volumes:
      - ./config:/etc/wireguard
    ports:
      - "51820:51820/udp"   # WireGuard VPN
      - "51821:51821/tcp"   # Web-UI
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.conf.all.src_valid_mark=1
      - net.ipv4.ip_forward=1
    restart: unless-stopped

Passwort-Hash erzeugen

Das Web-UI wird mit einem bcrypt-Hash geschützt. So erzeugst du ihn:

# Passwort-Hash erzeugen
docker run -it ghcr.io/wg-easy/wg-easy wgpw 'DEIN_SICHERES_PASSWORT'

# Ausgabe sieht so aus:
# PASSWORD_HASH='$2y$10$abc123...'
# Diesen Wert in docker-compose.yml eintragen
# Wichtig: $ muss als $$ escaped werden in Compose

Container starten

docker compose up -d

# Logs prüfen
docker compose logs -f wg-easy

Das Web-Interface ist jetzt unter http://DEINE-IP:51821 erreichbar. Dort kannst du neue Clients anlegen, QR-Codes generieren und Verbindungen überwachen.

WireGuard Clients einrichten

Nachdem der Server läuft, musst du für jedes Gerät einen eigenen Client anlegen. Das geht über die wg-easy Web-UI mit wenigen Klicks.

Neuen Client anlegen

1. Öffne das wg-easy Web-Interface unter http://DEINE-IP:51821
2. Melde dich mit deinem Passwort an
3. Klicke auf "+ New"
4. Vergib einen Namen (z.B. "Laptop", "iPhone", "Tablet")
5. Der Client wird automatisch mit Keys und IP erstellt

Smartphone (QR-Code)

Am schnellsten geht es per QR-Code:

1. Installiere die WireGuard App aus dem App Store / Play Store
2. Klicke in wg-easy auf das QR-Code-Symbol neben dem Client
3. Scanne den QR-Code mit der WireGuard App
4. Fertig -- VPN ist mit einem Tap aktivierbar

Laptop / Desktop (Config-Datei)

Für Computer lädst du die Konfigurationsdatei herunter:

1. Klicke in wg-easy auf das Download-Symbol neben dem Client
2. Speichere die .conf-Datei
3. Installiere den WireGuard Client für dein OS
4. Importiere die .conf-Datei im Client
5. Aktiviere den Tunnel

Eine typische Client-Konfiguration sieht so aus:

[Interface]
PrivateKey = <wird automatisch generiert>
Address = 10.8.0.2/32
DNS = 10.8.0.1

[Peer]
PublicKey = <Server Public Key>
PresharedKey = <wird automatisch generiert>
AllowedIPs = 192.168.1.0/24, 10.8.0.0/24
Endpoint = vpn.deinedomain.de:51820
PersistentKeepalive = 25

Option B: Tailscale (Zero-Config VPN)

Tailscale ist die komfortabelste VPN-Lösung für Homelabs. Es basiert intern auf WireGuard, nimmt dir aber die gesamte Konfiguration ab. Kein Port-Forwarding, kein Key-Management, keine DynDNS -- einfach installieren und verbinden.

Was ist Tailscale?

• Mesh-VPN: Alle Geräte verbinden sich direkt miteinander (Peer-to-Peer)
• NAT-Traversal: Funktioniert auch hinter CGNAT, Firewalls und Mobilfunk
• Zero Config: Keine Portfreigaben, keine statische IP nötig
• MagicDNS: Geräte sind über Namen erreichbar (z.B. homelab.tail1234.ts.net)

Tailscale: Vor- und Nachteile

Hinweis: Der eigentliche Traffic geht Peer-to-Peer -- nur die Koordination läuft über Tailscale-Server. Deine Daten werden nicht über Tailscale geroutet.

Tailscale im Homelab installieren

Schritt 1: Account erstellen

Registriere dich kostenlos unter tailscale.com mit deinem Google-, Microsoft- oder GitHub-Account.

Schritt 2: Auf dem Homelab-Server installieren

# Installation (Debian/Ubuntu)
curl -fsSL https://tailscale.com/install.sh | sh

# Tailscale starten und authentifizieren
sudo tailscale up

# Es erscheint ein Link -- im Browser öffnen und bestätigen

Schritt 3: Subnet Router einrichten

Damit du über Tailscale auch andere Geräte im Heimnetzwerk erreichst (nicht nur den Server selbst), richtest du einen Subnet Router ein:

# IP-Forwarding aktivieren
echo 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Tailscale als Subnet Router starten
sudo tailscale up --advertise-routes=192.168.1.0/24 --accept-dns=false

Danach musst du im Tailscale Admin Panel die Route genehmigen (unter "Edit route settings" des Geräts).

Schritt 4: Clients verbinden

Installiere Tailscale auf jedem Gerät, mit dem du zugreifen willst:

• Windows / macOS / Linux: Download von tailscale.com/download
• iOS / Android: App aus dem jeweiligen Store installieren
• Mit dem gleichen Account anmelden -- fertig

Schritt 5: Tailscale in Docker nutzen

Falls du Tailscale in einem Docker-Container betreiben möchtest:

# docker-compose.yml für Tailscale
services:
  tailscale:
    image: tailscale/tailscale:latest
    container_name: tailscale
    hostname: homelab
    environment:
      - TS_AUTHKEY=tskey-auth-xxxxx  # Auth Key aus Admin Panel
      - TS_EXTRA_ARGS=--advertise-routes=192.168.1.0/24
      - TS_STATE_DIR=/var/lib/tailscale
    volumes:
      - ./tailscale-state:/var/lib/tailscale
      - /dev/net/tun:/dev/net/tun
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    restart: unless-stopped

Den Auth Key generierst du im Tailscale Admin Panel unter Settings > Keys.

Split-Tunneling und DNS

Standardmäßig leiten manche VPN-Setups den gesamten Traffic durch den Tunnel. Für ein Homelab-VPN ist das meistens nicht gewünscht -- du willst nur den Homelab-Traffic durch das VPN schicken, nicht dein normales Surfen.

Split-Tunneling bei WireGuard

Der Schlüssel ist die AllowedIPs-Einstellung in der Client-Konfiguration:

# Nur Homelab-Traffic durch VPN (Split-Tunnel) -- EMPFOHLEN
AllowedIPs = 192.168.1.0/24, 10.8.0.0/24

# Gesamter Traffic durch VPN (Full-Tunnel)
AllowedIPs = 0.0.0.0/0, ::/0

In wg-easy konfigurierst du dies über die Umgebungsvariable WG_ALLOWED_IPS in der docker-compose.yml.

Split-Tunneling bei Tailscale

Tailscale verwendet standardmäßig Split-Tunneling. Nur der Traffic zu Tailscale-Geräten und beworbenen Subnetzen geht durch den Tunnel. Um Tailscale als Exit-Node zu nutzen (Full-Tunnel):

# Server als Exit-Node anbieten
sudo tailscale up --advertise-exit-node --advertise-routes=192.168.1.0/24

# Auf dem Client den Exit-Node nutzen
sudo tailscale up --exit-node=homelab

DNS-Konfiguration

Besonders nützlich: Leite DNS-Anfragen über dein Homelab, z.B. an Pi-hole oder AdGuard Home:

So profitierst du auch unterwegs von deinem Werbeblocker -- auf allen Geräten.

Sicherheits-Tipps

Ein VPN ist nur so sicher wie seine Konfiguration. Beachte diese Best Practices:

1. Keys regelmäßig rotieren

• WireGuard: Erstelle alle 6-12 Monate neue Clients und lösche die alten in wg-easy
• Tailscale: Key Expiry ist standardmäßig aktiviert (180 Tage). Lass es aktiviert!
• Entferne sofort Clients für verlorene oder verkaufte Geräte

2. Zugriffsregeln definieren

• WireGuard: Nutze iptables-Regeln auf dem Server, um zu bestimmen, welche Clients auf welche Dienste zugreifen dürfen
• Tailscale: Nutze die eingebauten ACLs (Access Control Lists), um granulare Regeln zu setzen

3. Web-UI absichern

• Das wg-easy Web-Interface sollte nur intern oder über VPN erreichbar sein
• Setze Port 51821 nicht als Portfreigabe am Router -- nur 51820 (VPN selbst)
• Verwende ein starkes Passwort (mindestens 16 Zeichen)

4. Monitoring einrichten

• Prüfe regelmäßig die verbundenen Clients in wg-easy oder im Tailscale Admin Panel
• Richte Benachrichtigungen ein, wenn neue Geräte hinzukommen
• Logge VPN-Verbindungen (wg-easy zeigt letzte Aktivität pro Client)

5. Updates nicht vergessen

# wg-easy Container updaten
cd ~/docker/wireguard
docker compose pull
docker compose up -d

# Tailscale updaten (Debian/Ubuntu)
sudo apt update && sudo apt upgrade tailscale

Fazit: Welches VPN für dein Homelab?

Egal welche Option du wählst -- ein VPN ist Pflicht für jedes Homelab. Nie wieder offene Ports, nie wieder unsicherer Zugriff von unterwegs. Beide Lösungen sind in unter 30 Minuten eingerichtet.