WireGuard VPN fürs Homelab: Remote-Zugriff sicher einrichten

WireGuard VPN für dein Homelab einrichten — sicherer Remote-Zugriff auf alle Dienste. Installation auf pfSense, Linux und als Docker-Container. Inkl. Mobile-Apps und Split-Tunneling.

Warum WireGuard dein VPN der Wahl sein sollte#

Du sitzt im Café, willst kurz auf deine Nextcloud zugreifen, und merkst: Dein Reverse Proxy ist aus Sicherheitsgründen nicht öffentlich erreichbar. Klar, du könntest Ports öffnen und mit Fail2ban und Crowdsec absichern — oder du machst es richtig und baust einen verschlüsselten Tunnel direkt in dein Homelab. Das ist, wofür VPNs erfunden wurden.

WireGuard ist die moderne Antwort auf OpenVPN. Während OpenVPN mit 400.000 Zeilen Code und unzähligen Konfigurationsoptionen daherkommt, hat WireGuard ~4.000 Zeilen. Das macht es nicht nur einfacher zu auditieren (weniger Code = weniger potenzielle Bugs), sondern auch verdammt schnell. Auf modernen Geräten liefert WireGuard Gigabit-Durchsatz bei einem Bruchteil der CPU-Last von OpenVPN.

WireGuard vs. OpenVPN: Die ehrliche Gegenüberstellung#

Aspekt WireGuard OpenVPN

Setup-Aufwand 5 Minuten, ein Config-File 30 Minuten, Zertifikate, TAR-Files Performance ~1 Gbit/s auf moderater Hardware ~200-400 Mbit/s Code-Basis ~4.000 Zeilen (C) ~100.000 Zeilen (C/C++) Kryptographie ChaCha20, Poly1305, Curve25519 Verschiedene Cipher-Suites Roaming Nahtlos (IP/Port-Wechsel transparent) Reconnect nötig NAT-Durchdringung Gut (UDP + PersistentKeepalive) Gut (TCP Fallback verfügbar) Protokoll Nur UDP UDP oder TCP Verbindungsaufbau 1-RTT (sofort) 3-5 RTT (TLS-Handshake) Mobile Battery Minimal (keine Keepalives) Höher (konstante Verbindung) Audits Ja (Kernel-Integration) Ja (seit 20 Jahren)

Kurzfassung: Für neue Homelab-Setups ist WireGuard die klare Empfehlung. Einziger Grund für OpenVPN: Legacy-Support oder Firmen-Policy.

Architektur-Entscheidung: Wo läuft dein WireGuard-Server?#

Du hast drei Optionen, jede mit Vor- und Nachteilen:

Option 1: WireGuard auf pfSense/OPNsense#

Vorteile:

  • Zentrale Verwaltung mit Firewall-Integration
  • Direkte Anbindung an VLANs
  • Kein zusätzlicher Server nötig

Nachteile:

  • pfSense WireGuard-Package ist manchmal 1-2 Versionen hinterher
  • GUI-Konfiguration weniger flexibel als CLI

Ideal für: Homelabs mit pfSense/OPNsense als zentralem Router.

Option 2: WireGuard auf dediziertem Linux-Server#

Vorteile:

  • Volle Kontrolle, neueste WireGuard-Version
  • Einfach zu scripting und automatisieren
  • Kann auf Proxmox-VM oder LXC laufen

Nachteile:

  • Separater Server → extra Wartung
  • Routing zwischen VPN und internem Netz muss konfiguriert werden

Ideal für: Fortgeschrittene Setups, Multi-Site, oder wenn pfSense nicht der Router ist.

Option 3: WireGuard als Docker-Container#

Vorteile:

  • Einfach via Docker Compose deployen
  • Updates per docker compose pull
  • Web-GUI optional verfügbar (wg-easy, WireGuard-UI)

Nachteile:

  • Container muss NET_ADMIN Capabilities haben
  • Kernel-Modul muss auf dem Host geladen sein

Ideal für: Docker-zentrierte Homelabs, schnelle Testsetups.

Ich zeige dir alle drei. Such dir aus, was passt.

Option 1: WireGuard auf pfSense einrichten#

Installation#

System → Package Manager → Available Packages

Suche nach wireguard → Install.

Nach der Installation erscheint VPN → WireGuard im Menü.

Tunnel erstellen#

VPN → WireGuard → Tunnels → Add Tunnel

Feld Wert

Enabled ✅ Description Homelab VPN Listen Port 51820 (Standard, oder beliebig) Interface Keys Generate (erzeugt automatisch Private/Public Key) Interface Addresses 10.99.0.1/24 (VPN-Subnet, nicht überlappen mit LAN!)

Save.

Notiere den Public Key — den brauchen deine Clients.

Firewall-Regeln#

1. WAN-Regel: VPN-Port öffnen#

Firewall → Rules → WAN → Add

Feld Wert

Action Pass Source Any Destination WAN address Destination Port 51820 Description Allow WireGuard VPN

Save → Apply Changes.

2. WireGuard-Interface-Regel: VPN-Clients dürfen ins LAN#

Firewall → Rules → WireGuard (neues Interface) → Add

Feld Wert

Action Pass Source WireGuard net Destination LAN net (oder any, je nach Bedarf) Description Allow VPN to LAN

Save → Apply Changes.

Peer hinzufügen (Client)#

VPN → WireGuard → Peers → Add Peer

Feld Wert

Enabled ✅ Tunnel Homelab VPN (dein Tunnel) Description Handy-Pixel7 (oder welcher Client) Public Key (wird vom Client generiert, siehe unten) Allowed IPs 10.99.0.2/32 (IP für diesen Client)

Wichtig: Jeder Client bekommt eine eigene /32 IP aus dem VPN-Subnet. Beispiel:

  • Client 1: 10.99.0.2/32
  • Client 2: 10.99.0.3/32
  • Client 3: 10.99.0.4/32

Option 2: WireGuard auf Linux (Debian/Ubuntu)#

Installation#

apt update
apt install wireguard wireguard-tools

WireGuard ist seit Kernel 5.6 direkt integriert — keine DKMS-Module nötig.

Server-Config erstellen#

# Private und Public Key generieren
wg genkey | tee /etc/wireguard/server_private.key | wg pubkey > /etc/wireguard/server_public.key

# Server-Config anlegen
cat > /etc/wireguard/wg0.conf << 'EOF'
[Interface]
PrivateKey = <INHALT VON server_private.key>
Address = 10.99.0.1/24
ListenPort = 51820

# NAT für VPN-Traffic
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

# Client 1
[Peer]
PublicKey = <CLIENT1_PUBLIC_KEY>
AllowedIPs = 10.99.0.2/32

# Client 2
[Peer]
PublicKey = <CLIENT2_PUBLIC_KEY>
AllowedIPs = 10.99.0.3/32
EOF

Wichtig: eth0 durch dein tatsächliches LAN-Interface ersetzen (ip link zeigt alle Interfaces).

Server starten#

# Interface hochfahren
wg-quick up wg0

# Beim Boot automatisch starten
systemctl enable wg-quick@wg0

# Status prüfen
wg show

Output sollte zeigen:

interface: wg0
  public key: <DEIN_SERVER_PUBLIC_KEY>
  private key: (hidden)
  listening port: 51820

peer: <CLIENT_PUBLIC_KEY>
  allowed ips: 10.99.0.2/32

Firewall#

# UFW (falls genutzt)
ufw allow 51820/udp

# Oder iptables direkt:
iptables -A INPUT -p udp --dport 51820 -j ACCEPT
iptables-save > /etc/iptables/rules.v4

IP-Forwarding aktivieren#

echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
sysctl -p

Option 3: WireGuard als Docker-Container (mit GUI)#

wg-easy ist ein WireGuard-Server mit Web-GUI — perfekt fürs Homelab.

Docker Compose Setup#

mkdir -p /opt/docker/wireguard
cat > /opt/docker/wireguard/docker-compose.yml << 'EOF'
services:
  wireguard:
    image: ghcr.io/wg-easy/wg-easy:14
    container_name: wireguard
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.conf.all.src_valid_mark=1
      - net.ipv4.ip_forward=1
    ports:
      - "51820:51820/udp"  # WireGuard-Port
      - "51821:51821/tcp"  # Web-GUI
    volumes:
      - ./config:/etc/wireguard
    environment:
      - WG_HOST=deine-domain.de  # Oder öffentliche IP
      - PASSWORD_HASH=$$2y$$10$$dein_bcrypt_hash_hier  # Siehe unten!
      - WG_DEFAULT_ADDRESS=10.99.0.x
      - WG_DEFAULT_DNS=192.168.1.1  # Dein Router/Pi-hole
      - WG_ALLOWED_IPS=192.168.0.0/16,10.0.0.0/8  # Erlaubte Subnetze (Split-Tunnel)
EOF

cd /opt/docker/wireguard
docker compose up -d

Passwort-Hash generieren#

Seit wg-easy v12 (bis einschließlich v14) muss das Passwort als bcrypt-Hash übergeben werden (nicht im Klartext):

# Hash generieren (htpasswd oder Docker):
docker run --rm ghcr.io/wg-easy/wg-easy wgpw 'dein-sicheres-passwort'
# Ausgabe: $2y$10$... ← Das kommt in PASSWORD_HASH
# WICHTIG: In docker-compose.yml $ mit $$ escapen!

Web-GUI nutzen#

  • URL: http://DOCKER-HOST-IP:51821
  • Passwort: Das, dessen Hash du bei PASSWORD_HASH gesetzt hast

In der GUI:

  1. New Client → Name eingeben → Create
  2. QR-Code scannen (iOS/Android) oder Download Config-File (Desktop)

Fertig. Kein manuelles Key-Management, keine Config-Files tippen.

Client-Konfiguration (Alle Plattformen)#

Android/iOS#

App installieren:

Zwei Wege:

  1. QR-Code scannen (wenn wg-easy GUI genutzt)
  2. Manuell einrichten:

In der App: + → Create from scratch

[Interface]
PrivateKey = <GENERIERE IN DER APP>
Address = 10.99.0.2/32
DNS = 192.168.1.1

[Peer]
PublicKey = <SERVER_PUBLIC_KEY>
Endpoint = deine-domain.de:51820
AllowedIPs = 192.168.0.0/16, 10.0.0.0/8  # Split-Tunnel
PersistentKeepalive = 25

Wichtig: Den Public Key deines Clients kopieren und im Server als Peer hinzufügen!

Linux Desktop#

apt install wireguard

# Client-Config erstellen
cat > /etc/wireguard/homelab.conf << 'EOF'
[Interface]
PrivateKey = <CLIENT_PRIVATE_KEY>
Address = 10.99.0.2/32
DNS = 192.168.1.1

[Peer]
PublicKey = <SERVER_PUBLIC_KEY>
Endpoint = deine-domain.de:51820
AllowedIPs = 192.168.0.0/16, 10.0.0.0/8
PersistentKeepalive = 25
EOF

# Verbinden
wg-quick up homelab

# Beim Boot starten
systemctl enable wg-quick@homelab

Windows#

WireGuard App: https://www.wireguard.com/install/

  1. App installieren
  2. Add Tunnel → Add empty tunnel
  3. Config-File einfügen (wie oben)
  4. Activate

macOS#

WireGuard App: Mac App Store

Gleiches Vorgehen wie Windows.

Split-Tunneling vs. Full-Tunnel#

Full-Tunnel (alles übers VPN)#

AllowedIPs = 0.0.0.0/0

Bedeutung: Jeglicher Traffic (auch Internet) geht durchs Homelab. Vorteil: Du nutzt deinen Pi-hole für DNS-Blocking auch unterwegs. Nachteil: Latenz und Bandbreite deines Heim-Uplinks limitieren dich.

Split-Tunnel (nur Homelab-Traffic übers VPN)#

AllowedIPs = 192.168.0.0/16, 10.0.0.0/8

Bedeutung: Nur private IP-Ranges werden übers VPN geroutet. YouTube, Netflix, etc. gehen direkt über deine mobile Verbindung. Schneller, schont Homelab-Bandbreite.

Meine Empfehlung: Split-Tunnel. Du willst aufs NAS zugreifen, nicht deinen gesamten Internet-Traffic durch deinen DSL-Upload quetschen.

Einzelne Hosts/Dienste (granular)#

Wenn du nur Proxmox und NAS übers VPN erreichen willst:

AllowedIPs = 192.168.1.100/32, 192.168.1.50/32

So spezifisch wie nötig, so offen wie sinnvoll.

DNS im VPN: Pi-hole unterwegs nutzen#

Wenn du Pi-hole im Homelab hast, willst du es auch unterwegs nutzen. So geht’s:

Im WireGuard-Client#

[Interface]
DNS = 192.168.1.53  # IP deines Pi-hole

Pi-hole: Interface Listening anpassen#

Standardmäßig hört Pi-hole nur auf dem LAN-Interface. Damit VPN-Clients funktionieren:

Pi-hole Admin → Settings → DNS → Interface listening:

  • Listen on all interfaces (oder spezifisch: LAN + WireGuard)

Alternative (sicherer):

pfSense/Router als DNS-Proxy konfigurieren:

  • VPN-Clients nutzen pfSense als DNS (10.99.0.1)
  • pfSense forwarded an Pi-hole (192.168.1.53)

So müssen Pi-hole und WireGuard-Clients nicht direkt kommunizieren.

Sicherheit: Best Practices#

1. Öffentliche Keys sind öffentlich, Private Keys sind privat#

Klingt offensichtlich, ist aber wichtig: Der Public Key darf überall hin. Der Private Key verlässt niemals das Gerät. Wenn du glaubst, dein Private Key wurde kompromittiert: Neues Keypair generieren, Config aktualisieren. Fertig. Kein Zertifikatswiderruf wie bei OpenVPN.

2. PersistentKeepalive = 25#

Diese Zeile im Client sendet alle 25 Sekunden ein Keepalive-Paket. Warum?

  • Hält NAT-Mappings offen (wichtig bei Home-Routern)
  • Ermöglicht, dass der Server den Client erreicht (Push-Notifications, etc.)

Ohne Keepalive: VPN scheint verbunden, aber du erreichst nichts. Mit: stabil.

3. Port-Forwarding minimieren#

WireGuard braucht einen UDP-Port (51820). Nicht mehr. Kein HTTP, kein SSH, kein zusätzlicher Management-Port. Minimale Angriffsfläche.

4. WireGuard und Brute-Force-Schutz#

Gute Nachricht: WireGuard braucht kein Fail2ban. Das Protokoll ist so designt, dass es auf unauthentifizierte Pakete komplett schweigt — keine Antwort, kein Log, nichts. Ein Angreifer ohne gültigen Public Key sieht nicht mal, dass auf dem Port ein Dienst läuft. Das ist Security by Design: Die Angriffsfläche ist praktisch null.

Trotzdem sinnvoll: Per iptables Rate-Limiting auf den WireGuard-Port setzen, um UDP-Floods abzumildern:

iptables -A INPUT -p udp --dport 51820 -m recent --set --name wg
iptables -A INPUT -p udp --dport 51820 -m recent --update --seconds 60 --hitcount 10 --name wg -j DROP

Das droppt IPs, die mehr als 10 Pakete in 60 Sekunden an den WireGuard-Port senden.

VPN + VLANs: Zugriff steuern#

Wenn du VLANs im Homelab nutzt, kannst du VPN-Clients in unterschiedliche Netze routen.

Beispiel: Admin-VPN vs. Family-VPN#

Admin-Tunnel (voller Zugriff):

Address = 10.99.0.1/24
AllowedIPs = 192.168.0.0/16  # Alle VLANs

Family-Tunnel (nur Jellyfin, Nextcloud):

Address = 10.98.0.1/24
AllowedIPs = 192.168.1.50/32, 192.168.1.60/32  # Nur diese Hosts

Zwei separate Tunnel-Interfaces, unterschiedliche Firewall-Regeln. Granulare Kontrolle.

Performance-Tuning#

MTU optimieren#

WireGuard hat 80 Bytes Overhead. Wenn dein Netzwerk 1500 MTU hat:

[Interface]
MTU = 1420  # 1500 - 80

Verhindert Fragmentierung → bessere Performance.

Multi-threaded Crypto (Server)#

Linux-Kernel nutzt automatisch alle CPU-Cores für WireGuard. Keine manuelle Konfiguration nötig — das ist der Vorteil von In-Kernel-Implementation.

Roaming optimieren#

WireGuard ist roam-freundlich (Wechsel von WiFi zu LTE), aber manche Netzwerke blocken UDP. Lösung:

UDP Port Randomization (erschwert Blocking):

  • Mehrere Ports öffnen (51820, 51821, 443/udp)
  • Clients konfigurieren mit alternativem Port
# pfSense: Mehrere WAN-Regeln auf verschiedene Ports
# Clients: Endpoint = deine-domain.de:443 (statt 51820)

Troubleshooting: Wenn WireGuard nicht will#

Verbindung steht, aber kein Traffic#

Checkliste:

  1. IP-Forwarding aktiviert?

    ::: highlight

    sysctl net.ipv4.ip_forward  # sollte "1" sein

    :::

  2. Firewall erlaubt VPN → LAN?

    • pfSense: Regel auf WireGuard-Interface
    • Linux: iptables -L FORWARD

  3. NAT konfiguriert?

    • PostUp/PostDown-Rules in /etc/wireguard/wg0.conf
    • pfSense: NAT Outbound sollte VPN-Subnet enthalten

  4. DNS funktioniert?

    ::: highlight

    # Im VPN-Client:
nslookup google.com  # Nutzt es den richtigen DNS?

    :::

Handshake schlägt fehl#

# Server-Logs:
journalctl -u wg-quick@wg0 -f

# Client-Logs (Android): In der App unter "Log"

Häufige Ursachen:

  • Falscher Public Key (Server oder Client)
  • Endpoint nicht erreichbar (falsche Domain/IP, Port geblockt)
  • Systemzeit falsch (WireGuard nutzt Timestamps, >5min Abweichung = Fail)

Performance schlecht#

# Bandwidth-Test übers VPN:
iperf3 -s  # auf Server
iperf3 -c 192.168.1.100  # auf Client

Erwartungswerte:

  • Mini-PC (J4125): ~300-500 Mbit/s
  • Moderner Server (i5/Ryzen): ~1 Gbit/s
  • Raspberry Pi 4: ~200-300 Mbit/s

Wenn deutlich drunter: MTU, CPU-Auslastung, oder Netzwerk-Bottleneck prüfen.

Monitoring: Ist dein VPN noch da?#

Mit Zabbix kannst du WireGuard überwachen:

# Custom Item in Zabbix: WireGuard Peer Status
wg show wg0 latest-handshake | awk ''

Wenn der letzte Handshake >3 Minuten her ist → Client offline oder Problem.

Weitere Metriken:

  • Anzahl verbundener Peers
  • Traffic pro Peer
  • Handshake-Fehler (aus Logs)

Wenn du dir die manuelle Template-Erstellung sparen willst: Im Zabbix Monitoring Kit sind Netzwerk-Monitoring-Templates und Alerting-Configs dabei, die du direkt importieren kannst.

Alternative zu selbst hosten: Tailscale#

Tailscale ist WireGuard-as-a-Service. Zero-Config, Mesh-VPN, NAT-Durchdringung ohne Port-Forwarding.

Vorteile:

  • Kein Port-Forwarding nötig
  • Automatisches Mesh (alle Geräte sehen sich direkt)
  • DERP-Relay wenn direkte Verbindung nicht klappt
  • ACLs per Web-GUI

Nachteile:

  • Drittanbieter (Tailscale sieht deine Topologie, nicht den Traffic)
  • Free Tier: 100 Geräte, 3 User
  • Self-Hosting möglich (Headscale), aber dann wieder Konfigurationsaufwand

Wann Tailscale statt WireGuard?

  • Du willst Zero-Config
  • Du brauchst Mesh (alle Geräte untereinander, nicht nur Homelab → Client)
  • Du hast kein Port-Forwarding (Carrier-Grade NAT, restriktives Firmen-Netzwerk)

Für klassisches “Client → Homelab”-VPN: WireGuard selbst hosten ist simpler und kostet nichts.

Integration mit bestehenden Setups#

VPN + Reverse Proxy#

Wenn dein Reverse Proxy nur intern erreichbar ist:

  1. VPN verbinden
  2. Browser: https://nextcloud.mein-homelab.de (über Split-DNS)
  3. Traffic geht übers VPN → Proxy → Service

Kein öffentlicher Port 443, trotzdem voller Zugriff.

VPN + Backup-Strategie#

Restic-Backup von unterwegs ins Homelab pushen:

# Via VPN:
restic -r sftp:192.168.1.50:/mnt/backup/laptop backup /home

Schneller als Cloud-Upload, sicherer als offener SFTP-Port.

Kosten & Hardware-Anforderungen#

Cloud-Server als VPN-Einsprungpunkt (optional)#

Wenn dein ISP kein Port-Forwarding erlaubt oder deine IP alle 24h wechselt:

Hetzner Cloud CX23: ab 4,09€/Monat, 20 TB Traffic

  • WireGuard Server auf dem VPS
  • Homelab connectet sich zum VPS
  • Clients connecten sich zum VPS
  • VPS routet Traffic ins Homelab
Client → VPS (statische IP) → Homelab (dynamische IP)

Setup:

  • WireGuard auf VPS (wie Option 2)
  • Site-to-Site Tunnel: Homelab als Peer auf dem VPS
  • Routing: VPS forwarded VPN-Client-Traffic ins Homelab

Hardware-Beschleunigung#

AES-NI (Intel/AMD) hilft nicht — WireGuard nutzt ChaCha20, nicht AES. Aber moderne CPUs (ab ~2015) haben genug Leistung für Gigabit-WireGuard ohne Probleme.

Häufige Fehler (und wie du sie vermeidest)#

1. AllowedIPs falsch verstehen#

AllowedIPs bedeutet nicht “Von wo darf Traffic kommen”, sondern “Wohin wird Traffic geschickt”. Es ist eine Routing-Tabelle, keine Firewall-Regel.

  • Client: AllowedIPs = 192.168.0.0/16 → “Schicke alles für 192.168.x.x übers VPN”
  • Server: AllowedIPs = 10.99.0.2/32 → “Traffic von/zu 10.99.0.2 gehört zu diesem Peer”

2. Überlappende Subnetze#

Wenn dein VPN-Subnet (10.99.0.0/24) und ein Subnetz unterwegs (Café-WiFi) überlappen → Routing-Konflikt. Deswegen nutzen die meisten 10.x.x.x oder 172.x.x.x Ranges, die in öffentlichen WLANs selten sind.

3. Firewall auf dem Client vergessen#

Auch der Client hat oft eine Firewall (Windows Defender, ufw). Wenn Traffic ins VPN geht, aber Antworten nicht ankommen: Client-Firewall prüfen.

Nächste Schritte#

  1. VLANs einrichten und VPN-Zugriff pro VLAN steuern
  2. Site-to-Site VPN zwischen zwei Homelab-Standorten
  3. WireGuard + Pi-hole für Werbeblockierung unterwegs
  4. Monitoring — Zabbix-Integration für VPN-Status

🛒 Empfohlene Hardware & Services#

🖥️

Hetzner Cloud als VPN-Relay

WireGuard-Server in der Cloud mit fester IP? Hetzner Cloud VPS ab 4€/Monat — perfekt als VPN-Endpoint. Hetzner ausprobieren →

Fazit#

WireGuard ist das VPN, das OpenVPN hätte sein sollen: Schnell, sicher, simpel. Die Konfiguration passt auf einen Zettel, die Performance ist exzellent, und die moderne Kryptographie gibt dir ein sicheres Gefühl.

Ob auf pfSense, einem dedizierten Linux-Server, oder als Docker-Container — WireGuard fügt sich nahtlos in dein Homelab ein. Nach der Einrichtung vergisst du, dass du überhaupt ein VPN nutzt — es funktioniert einfach. Kein Gefummel mit Zertifikaten, kein “Verbindung getrennt” alle 5 Minuten, kein merklicher Geschwindigkeitsverlust.

Fang mit einem Testclient an. Handy, Laptop — egal. Config erstellen, QR-Code scannen, verbinden. Die ersten 30 Sekunden entscheiden, ob du WireGuard liebst — und ich garantiere dir: Du wirst es lieben.

Von jetzt an ist dein Homelab immer nur einen Toggle-Button entfernt. Egal ob du im Café, im Zug oder auf einem anderen Kontinent sitzt. Das ist die Freiheit, für die wir überhaupt ein Homelab betreiben.

Zuletzt aktualisiert: Februar 2026 | WireGuard 1.0.x | pfSense 2.7 | wg-easy 14.x

Hinweis: wg-easy v15 (erschienen 2025) ist ein kompletter Rewrite mit geänderter Konfiguration — die meisten Umgebungsvariablen wurden entfernt und durch ein CLI/Web-Setup ersetzt. Wenn du eine Neuinstallation machst, schau dir die aktuelle Dokumentation an. Die obige Compose-Datei nutzt bewusst v14 für Stabilität.

Einige Links auf dieser Seite sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision — für dich ändert sich am Preis nichts. So unterstützt du diesen Blog und ermöglichst weitere kostenlose Tutorials. Danke! 🙏

[« Vorherige]
Backup-Strategie fürs Homelab: PBS, BorgBackup und Restic im Praxisvergleich