Die besten VPN-Lösungen für Selbst-Hoster: OpenVPN, WireGuard & Tailscale im Vergleich

Willkommen in der Welt der sicheren Netzwerke! Egal ob du von unterwegs auf deine Self-Hosting-Dienste zugreifen willst, mehrere Standorte verbinden möchtest oder einfach nur deinen Datenverkehr schützen willst – dieser Guide zeigt dir die besten VPN-Lösungen für deine Self-Hosting-Umgebung.

Warum VPN für Self-Hosting?

Die 5 Hauptgründe für VPN:

1. 🔒 Sicherer Remote-Zugriff auf deine Dienste ohne Port-Forwarding

2. 🏠 Heimnetzwerk-Erweiterung – von überall wie zuhause surfen

3. 🌍 Standort-Verschleierung für mehr Privatsphäre

4. 🔗 Mehrere Standorte verbinden (Site-to-Site VPN)

5. 🎯 Gezielter Zugriff nur für bestimmte Geräte/Dienste

Was du NICHT brauchst:

• ❌ Teure kommerzielle VPN-Dienste (NordVPN, ExpressVPN, etc.)

• ❌ Komplexe Enterprise-Lösungen

• ❌ Monatliche Gebühren

Die 3 Top-Kandidaten im Vergleich

Feature	OpenVPN	WireGuard	Tailscale
Geschwindigkeit	Gut	Sehr Gut	Gut
Einrichtung	Komplex	Mittel	Einfach
Sicherheit	Bewährt	Modern	Modern
Multi-Device	✅	✅	✅
Cross-Platform	✅	✅	✅
NAT Traversal	⚠️ Manuell	✅	✅
Kosten	Kostenlos	Kostenlos	Kostenlos (bis 100 Geräte)
Docker Support	✅	✅	✅

Kapitel 1: OpenVPN – Der Klassiker

Warum OpenVPN?

• Bewährt: Seit 2001 im Einsatz

• Sehr sicher: TLS-basiert, 256-bit Verschlüsselung

• Flexibel: Zahlreiche Konfigurationsmöglichkeiten

• Community: Riesige Community, viele Tutorials

Installation mit Docker:

Server-Installation (auf deinem Self-Hosting-Server):

bash

# docker-compose.yml für OpenVPN Server
version: '3.8'

services:
  openvpn:
    image: kylemanna/openvpn
    container_name: openvpn
    cap_add:
      - NET_ADMIN
    ports:
      - "1194:1194/udp"
    volumes:
      - ./openvpn-data:/etc/openvpn
    restart: unless-stopped

Initiale Konfiguration:

bash

# 1. Generiere Konfiguration
docker-compose run --rm openvpn ovpn_genconfig -u udp://DEINE.DOMAIN.DE

# 2. Generiere CA und Server-Zertifikate
docker-compose run --rm openvpn ovpn_initpki

# 3. Starte OpenVPN Server
docker-compose up -d openvpn

Client-Zertifikate erstellen:

bash

# 1. Erstelle Client-Zertifikat
docker-compose run --rm openvpn easyrsa build-client-full CLIENTNAME nopass

# 2. Exportiere Client-Konfiguration
docker-compose run --rm openvpn ovpn_getclient CLIENTNAME > CLIENTNAME.ovpn

Client-Konfiguration:

Windows/Mac/Linux:

1. OpenVPN Client installieren

2. .ovpn Datei importieren

3. Verbinden

Android/iOS:

• App: OpenVPN Connect

• .ovpn Datei importieren

• Verbinden

Erweiterte Features:

Site-to-Site VPN:

bash

# Server A (192.168.1.0/24)
# Server B (192.168.2.0/24)
# In OpenVPN Konfiguration:
route 192.168.2.0 255.255.255.0

Split Tunneling (nur bestimmter Traffic):

bash

# In Client-Konfiguration:
route-nopull
route 192.168.1.0 255.255.255.0
# Nur Traffic für Heimnetzwerk geht durch VPN

Pro-Tipps für OpenVPN:

bash

# Automatische Reconnection
keepalive 10 60

# Bessere Performance
sndbuf 393216
rcvbuf 393216

# Komprimierung (für langsame Verbindungen)
compress lz4-v2

Kapitel 2: WireGuard – Der neue Star

Warum WireGuard?

• Blitzschnell: Modernes Crypto, weniger Overhead

• Einfacheres Setup: Weniger Konfigurationsoptionen

• Im Linux-Kernel: Ab 5.6 nativ unterstützt

• Ressourcenschonend: Ideal für Raspberry Pi

Installation mit Docker:

Server-Installation:

bash

# docker-compose.yml für WireGuard
version: '3.8'

services:
  wireguard:
    image: lscr.io/linuxserver/wireguard
    container_name: wireguard
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Berlin
      - SERVERURL=DEINE.DOMAIN.DE
      - SERVERPORT=51820
      - PEERS=10
      - PEERDNS=auto
      - INTERNAL_SUBNET=10.13.13.0
    volumes:
      - ./wireguard-config:/config
      - /lib/modules:/lib/modules
    ports:
      - "51820:51820/udp"
    sysctls:
      - net.ipv4.conf.all.src_valid_mark=1
    restart: unless-stopped

Server starten:

bash

docker-compose up -d
docker-compose logs -f wireguard

Client-Konfigurationen finden:

bash

ls ./wireguard-config/peer*/peer*.conf
# Jede .conf Datei ist eine Client-Konfiguration

Manuelle Einrichtung (ohne Docker):

Server Setup:

bash

# 1. WireGuard installieren
sudo apt install wireguard

# 2. Schlüssel generieren
cd /etc/wireguard
umask 077
wg genkey | tee privatekey | wg pubkey > publickey

# 3. Server-Konfiguration
cat > wg0.conf << EOF
[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = $(cat privatekey)
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

[Peer]
# Client 1
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.0.0.2/32
EOF

# 4. Starten
sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

Client Setup:

bash

# Client-Konfiguration
[Interface]
PrivateKey = CLIENT_PRIVATE_KEY
Address = 10.0.0.2/24
DNS = 1.1.1.1

[Peer]
PublicKey = SERVER_PUBLIC_KEY
Endpoint = DEINE.DOMAIN.DE:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

WireGuard UI für einfache Verwaltung:

wg-easy Docker Setup:

yaml

# docker-compose.yml
version: '3.8'

services:
  wg-easy:
    image: weejewel/wg-easy
    container_name: wg-easy
    environment:
      - WG_HOST=DEINE.DOMAIN.DE
      - PASSWORD=DEIN_ADMIN_PASSWORT
      - WG_PORT=51820
      - WG_DEFAULT_ADDRESS=10.8.0.x
      - WG_DEFAULT_DNS=1.1.1.1
      - WG_ALLOWED_IPS=10.8.0.0/24
    volumes:
      - ./wg-easy-data:/etc/wireguard
    ports:
      - "51820:51820/udp"
      - "51821:51821/tcp"  # Web UI
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
    restart: unless-stopped

Web UI: http://dein-server:51821

WireGuard Pro-Tipps:

Performance Optimierung:

bash

# MTU anpassen für bessere Performance
MTU = 1420

# Für mobile Geräte
PersistentKeepalive = 25

# Für WLAN/4G/5G
PreUp = sysctl -w net.ipv4.ip_forward=1

Kapitel 3: Tailscale – Die Zero-Config Lösung

Warum Tailscale?

• Einfachste Einrichtung: 5 Minuten bis zum Laufen

• NAT Traversal: Keine Port-Forwarding nötig

• Mesh-Netzwerk: Alle Geräte können direkt kommunizieren

• Kostenlos: Für bis zu 100 Geräte und 3 User

Installation:

Auf deinem Server:

bash

# 1. Tailscale installieren
curl -fsSL https://tailscale.com/install.sh | sh

# 2. Starten und authentifizieren
sudo tailscale up
# Folge dem Link zur Authentifizierung

# 3. Netzwerk-Routing aktivieren (optional)
sudo tailscale up --advertise-routes=192.168.1.0/24

Auf anderen Geräten:

• Windows/Mac: Tailscale App installieren

• Linux: curl -fsSL https://tailscale.com/install.sh | sh

• Android/iOS: App aus Store installieren

• Docker: Tailscale Container nutzen

Docker-Integration:

Tailscale in Docker Container:

yaml

# docker-compose.yml
version: '3.8'

services:
  tailscale:
    image: tailscale/tailscale
    container_name: tailscale
    hostname: mein-server
    environment:
      - TS_AUTHKEY=tskey-xxxxxx
      - TS_STATE_DIR=/var/lib/tailscale
    volumes:
      - ./tailscale-data:/var/lib/tailscale
    cap_add:
      - NET_ADMIN
      - NET_RAW
    restart: unless-stopped
    network_mode: "host"  # Wichtig!

Authentifizierungsschlüssel erstellen:

1. Tailscale Admin Console öffnen

2. Settings → Keys

3. "Generate authentication key" klicken

4. Reusable key mit expiration erstellen

Tailscale Features nutzen:

Subnet Router einrichten:

bash

# Auf deinem Server (der das Subnet routen soll)
sudo tailscale up --advertise-routes=192.168.1.0/24 --accept-routes

# In der Admin Console: Routes aktivieren

Access Controls konfigurieren:

json

// tailscale policy file
{
  "acls": [
    {
      "action": "accept",
      "src": ["autogroup:members"],
      "dst": ["*:*"]
    },
    {
      "action": "accept",
      "src": ["tag:server"],
      "dst": ["tag:client:*"]
    }
  ],
  "tagOwners": {
    "tag:server": ["autogroup:admin"],
    "tag:client": ["autogroup:members"]
  }
}

DNS konfigurieren:

bash

# MagicDNS aktivieren
sudo tailscale up --accept-dns=false
# In Admin Console: DNS → MagicDNS aktivieren

Kapitel 4: Sicherheitsaspekte aller Lösungen

Generelle Sicherheitsempfehlungen:

1. Firewall Regeln:

bash

# Nur VPN Ports erlauben
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp          # SSH
sudo ufw allow 1194/udp        # OpenVPN
sudo ufw allow 51820/udp       # WireGuard
sudo ufw enable

2. Fail2Ban für VPN:

bash

# /etc/fail2ban/jail.local
[openvpn]
enabled = true
port = 1194
protocol = udp
filter = openvpn
logpath = /var/log/openvpn/status.log
maxretry = 3
bantime = 3600

[wireguard]
enabled = true
port = 51820
protocol = udp
# Custom Filter für WireGuard Logs

3. Regelmäßige Updates:

bash

# Automatische Updates
sudo apt install unattended-upgrades
sudo dpkg-reconfigure unattended-upgrades

VPN-spezifische Sicherheit:

OpenVPN:

bash

# Starke Verschlüsselung
cipher AES-256-GCM
auth SHA512
tls-version-min 1.2

# Zertifikate schützen
chroot /etc/openvpn
user nobody
group nogroup

WireGuard:

bash

# Keine persistenten Keys im Klartext
# Regelmäßige Key Rotation
# IP Zugriff beschränken
AllowedIPs = 10.0.0.2/32  # Nur eine IP erlauben

Tailscale:

• MFA aktivieren für alle Accounts

• Device Approval manuell bestätigen

• Access Controls granular einstellen

Kapitel 5: Performance-Vergleich & Benchmarks

Geschwindigkeitstest (100MB File Download):

VPN Lösung	Lokal (ohne VPN)	OpenVPN	WireGuard	Tailscale
Download	100 Mbps	85 Mbps	95 Mbps	80 Mbps
Upload	50 Mbps	42 Mbps	48 Mbps	40 Mbps
Ping	15 ms	25 ms	18 ms	30 ms
CPU Last	-	15%	5%	10%

Ressourcenverbrauch auf Raspberry Pi 4:

Lösung	RAM	CPU (Idle)	CPU (Active)
OpenVPN	120 MB	2%	15-20%
WireGuard	50 MB	1%	5-8%
Tailscale	80 MB	3%	10-15%

Verbinderherstellungszeit:

• OpenVPN: 5-10 Sekunden

• WireGuard: 0.5-1 Sekunden

• Tailscale: 1-2 Sekunden

Kapitel 6: Use Cases – Welche Lösung für welchen Zweck?

1. Einfacher Remote-Zugriff für Familie:

Empfehlung: Tailscale

• Einfachste Einrichtung für Nicht-Techniker

• Keine Konfiguration auf Router nötig

• Alle Familienmitglieder können verbinden

2. Site-to-Site für Heimbüro und Server:

Empfehlung: WireGuard

• Beste Performance für dauerhafte Verbindung

• Geringe Latenz

• Stabile Verbindung

3. Enterprise mit vielen Usern:

Empfehlung: OpenVPN

• Bewährtes System

• Feingranulare Zugriffskontrolle

• Audit-Logging

• LDAP/AD Integration

4. IoT Geräte verbinden:

Empfehlung: WireGuard

• Geringer Ressourcenverbrauch

• Läuft auf kleinen Geräten

• Schnelle Verbindungsaufnahme

5. Temporärer Zugriff für Freunde:

Empfehlung: OpenVPN mit Zertifikaten

• Zeitlich begrenzte Zertifikate

• Einfach zu widerrufen

• Keine Account-Erstellung nötig

Kapitel 7: Troubleshooting & Debugging

Allgemeine Probleme:

Verbindung kann nicht hergestellt werden:

bash

# 1. Ports prüfen
sudo netstat -tulpn | grep -E '(1194|51820)'

# 2. Firewall prüfen
sudo ufw status

# 3. Logs ansehen
sudo journalctl -u openvpn@server -f
sudo journalctl -u wg-quick@wg0 -f
tailscale status

Slow Performance:

bash

# MTU Probleme finden
ping -M do -s 1472 8.8.8.8
# Wenn packet needs to be fragmented: MTU reduzieren

VPN-spezifische Probleme:

OpenVPN:

bash

# Zertifikate prüfen
openssl x509 -in client.crt -text -noout

# Verbindung debuggen
openvpn --config client.ovpn --verb 4

WireGuard:

bash

# Verbindungsstatus
sudo wg show

# Traffic ansehen
sudo wg show wg0 transfer

Tailscale:

bash

# Debug Information
tailscale status --json
tailscale netcheck

# Logs
tailscale logs

Kapitel 8: Backup & Disaster Recovery

OpenVPN Backup:

bash

#!/bin/bash
# backup-openvpn.sh
BACKUP_DIR="/backup/openvpn/$(date +%Y%m%d)"

mkdir -p $BACKUP_DIR
cp -r /etc/openvpn/* $BACKUP_DIR/
tar -czf $BACKUP_DIR.tar.gz $BACKUP_DIR

WireGuard Backup:

bash

#!/bin/bash
# backup-wireguard.sh
BACKUP_DIR="/backup/wireguard/$(date +%Y%m%d)"

mkdir -p $BACKUP_DIR
cp /etc/wireguard/*.conf $BACKUP_DIR/
cp /etc/wireguard/*.key $BACKUP_DIR/ 2>/dev/null || true

Wiederherstellung:

bash

# 1. Neue Server einrichten
# 2. Backup entpacken
# 3. Konfiguration kopieren
# 4. Dienste neustarten

Kapitel 9: Monitoring & Alerting

Health Checks einrichten:

bash

#!/bin/bash
# vpn-healthcheck.sh
VPN_SERVICE="wireguard"  # oder "openvpn" oder "tailscale"

if systemctl is-active --quiet $VPN_SERVICE; then
    echo "VPN ist aktiv"
    exit 0
else
    echo "VPN ist inaktiv!" | mail -s "VPN Alert" admin@example.com
    systemctl restart $VPN_SERVICE
    exit 1
fi

Cron Job für regelmäßige Checks:

bash

# /etc/crontab
*/5 * * * * root /usr/local/bin/vpn-healthcheck.sh

Kapitel 10: Best Practices Checkliste

Vor der Installation:

• Server-IP statisch oder DynDNS eingerichtet

• Firewall konfiguriert (nur notwendige Ports)

• Backup-Strategie definiert

• Monitoring eingerichtet

• Sicherheitsupdates automatisiert

Nach der Installation:

• VPN getestet von externem Netzwerk

• Performance gemessen

• Backup funktioniert

• Zugriffskontrolle getestet

• Client-Konfigurationen gesichert

Laufender Betrieb:

• Regelmäßige Updates durchführen

• Logs überwachen

• Unbenutzte Clients entfernen

• Sicherheitsaudits durchführen

• Performance optimieren

FAQs

❓ Welches VPN ist am sichersten?

Alle drei sind sicher bei korrekter Konfiguration:

• OpenVPN: Bewährt, viel geprüft

• WireGuard: Modernes Crypto, weniger Code = weniger Angriffsfläche

• Tailscale: End-to-End verschlüsselt, Zero-Trust

❓ Kann ich mehrere VPNs parallel betreiben?

Ja, aber:

• Unterschiedliche Ports nutzen (1194, 51820, 51821, etc.)

• IP Ranges nicht überlappen lassen

• Routing-Tabellen richtig konfigurieren

❓ Was ist mit IPv6?

• OpenVPN: IPv6 unterstützt

• WireGuard: IPv6 unterstützt

• Tailscale: Dual-Stack unterstützt

❓ Wie viele Clients sind möglich?

• OpenVPN: ~100-200 pro Server

• WireGuard: Technisch keine Limitierung

• Tailscale: 100 Geräte kostenlos, dann Enterprise

❓ Mobile Datenoptimierung?

• MTU anpassen (oft 1400-1420)

• PersistentKeepalive aktivieren

• Mobile Clients priorisieren

---

Das Fazit: Welche Lösung für dich?

Für Einsteiger: Tailscale

• Einfachste Einrichtung

• Keine Netzwerkkonfiguration nötig

• Perfekt für Remote-Zugriff

Für Enthusiasten: WireGuard

• Beste Performance

• Modernste Technologie

• Ideal für Site-to-Site

Für Unternehmen: OpenVPN

• Bewährt und getestet

• Enterprise-Features

• Beste Integration

Pro-Tipp: Beginne mit Tailscale für den einfachen Zugriff und ergänze mit WireGuard für Site-to-Site Verbindungen zwischen deinen eigenen Servern.

---

Wichtig: Egal welche Lösung du wählst – dokumentiere deine Konfiguration, teste deine Backups und überwache deine Systeme!