Eintrag

Pangolin: Selbstgehosteter Reverse Proxy mit WireGuard-Tunnel

Veröffentlicht Aktualisiert
Preview Image
Von Darth Vaper
16 Minuten Lesezeit
Pangolin: Selbstgehosteter Reverse Proxy mit WireGuard-Tunnel

Du kennst das Problem: Du hast einen Haufen cooler Services in deinem Homelab laufen, aber wie bekommst du die sicher ins Internet? Port-Forwarding ist ein Sicherheitsalptraum, deine dynamische IP nervt, und mit CGNAT geht sowieso nichts mehr. Pangolin löst genau dieses Problem auf elegante Weise: Ein selbstgehosteter Reverse Proxy mit WireGuard-Tunnel, der deine Dienste nach außen bringt, ohne dass du auch nur einen einzigen Port in deinem Heimnetz öffnen musst. Klingt zu gut? Lass uns einen Blick darauf werfen.

Das Problem: Homelab-Dienste im Internet

Wenn du Services wie Jellyfin, Nextcloud oder Home Assistant von unterwegs nutzen möchtest, stehst du vor mehreren Herausforderungen:

flowchart LR
    Internet([Internet]) -.Port 443.-> Router[Home Router]
    Router --> FW{Port Forwarding}
    FW --> Service[Homelab Service]

    style Router fill:#ff6b6b
    style FW fill:#ff6b6b
    style Service fill:#51cf66

Die klassischen Probleme:

  • Port Forwarding: Jeder offene Port ist ein potentielles Sicherheitsrisiko
  • Dynamische IP: Du brauchst DDNS und musst hoffen, dass es zuverlässig funktioniert
  • CGNAT: Viele ISPs vergeben gar keine öffentliche IPv4 mehr
  • Exponierte Home-IP: Deine echte IP-Adresse ist für jeden sichtbar
  • SSL-Zertifikate: Let’s Encrypt HTTP-Challenge wird kompliziert
  • Firewall-Regeln: Jeder Service braucht seine eigene Regel

Die meisten Homelab-Betreiber greifen zu VPN-Lösungen wie WireGuard oder Tailscale. Das funktioniert gut für persönlichen Zugriff, aber was ist mit Services, die du öffentlich teilen willst? Nicht jeder will einen VPN-Client installieren.

Wie Pangolin funktioniert

Pangolin dreht das Problem um: Statt eingehende Verbindungen zu deinem Homelab zu routen, baut dein Homelab eine ausgehende Verbindung zu einem VPS auf. Das ist der Schlüssel, denn ausgehende Verbindungen funktionieren immer, egal ob CGNAT, restriktive Firewall oder dynamische IP.

Pangolin Architektur

Der Datenfluss sieht so aus:

sequenceDiagram
    participant User
    participant VPS as VPS (Pangolin)
    participant WG as WireGuard Tunnel
    participant Newt as Newt Agent
    participant Service as Homelab Service

    Note over Newt,VPS: Newt initiiert Verbindung (outbound)
    Newt->>VPS: WireGuard Handshake
    VPS-->>Newt: Tunnel established (10.0.0.x)

    Note over User,Service: User greift auf Service zu
    User->>VPS: HTTPS Request (jellyfin.domain.com)
    VPS->>VPS: Traefik: SSL Termination
    VPS->>Newt: Forward via WireGuard
    Newt->>Service: HTTP Request (local)
    Service-->>Newt: Response
    Newt-->>VPS: Response via WireGuard
    VPS-->>User: HTTPS Response

Der Workflow:

  1. Pangolin läuft auf einem VPS mit öffentlicher IP
  2. Newt (der Agent) läuft in deinem Homelab und verbindet sich ausgehend via WireGuard
  3. Traffic-Flow: Benutzer → VPS (Pangolin/Traefik) → WireGuard-Tunnel → Homelab (Newt → lokaler Service)
  4. Kein einziger eingehender Port muss in deinem Heimnetz geöffnet werden

Pangolin nutzt WireGuard für den Tunnel, was bedeutet: State-of-the-art Verschlüsselung, minimaler Overhead und rock-solid Performance.

Die Komponenten

Pangolin ist ein Ökosystem aus mehreren Komponenten, die zusammenarbeiten:

Komponente Zweck Wo läuft es Port
Pangolin Management-UI, Konfiguration, API VPS 443 (HTTPS)
Gerbil WireGuard-Server, Tunnel-Management VPS 51820 (UDP)
Traefik Reverse Proxy, SSL-Termination, Routing VPS 80, 443
Newt WireGuard-Client, Agent für Homelab Homelab -

Pangolin ist das Gehirn der Operation. Über die Web-UI verwaltest du Sites (Homelabs), Resources (Services) und Konfigurationen. Es generiert automatisch Traefik-Configs und steuert Let’s Encrypt-Zertifikate.

Gerbil ist der WireGuard-Server. Für jeden Newt-Agent wird ein WireGuard-Peer konfiguriert. Gerbil verwaltet die Tunnel-Konfigurationen und Schlüssel.

Traefik ist der eigentliche Reverse Proxy. Es nimmt HTTPS-Requests entgegen, terminiert SSL, und routet den Traffic durch den WireGuard-Tunnel zum richtigen Service im Homelab.

Newt ist der Agent, den du in deinem Homelab installierst. Er baut die WireGuard-Verbindung auf, hält sie aufrecht, und leitet Traffic zu deinen lokalen Services weiter.

Pangolin bringt sein eigenes Traefik mit, das auf dem VPS laeuft. Das hat nichts mit dem Reverse Proxy in deinem Homelab zu tun. Wenn du lokal Nginx Proxy Manager (oder einen anderen Reverse Proxy) nutzt, aendert sich daran nichts - Pangolin arbeitet unabhaengig davon. Der Newt-Agent leitet Traffic direkt an die IP:Port-Kombination deiner lokalen Services weiter.

Voraussetzungen

Bevor du loslegst, brauchst du:

Auf der VPS-Seite:

  • Einen VPS mit öffentlicher IPv4 (1 vCPU, 1GB RAM reicht völlig)
  • Root-Zugriff oder zumindest Docker-Berechtigungen
  • Eine Domain mit DNS-Zugriff (z.B. über Cloudflare, Hetzner DNS, etc.)
  • Docker und Docker Compose installiert

Im Homelab:

  • Docker installiert
  • Ausgehende Verbindungen zu Port 51820/UDP erlaubt (normalerweise kein Problem)
  • Zugriff auf die Services, die du exposen willst

Nice to have:

  • Grundkenntnisse in Docker und Reverse Proxies
  • SSH-Zugang zum VPS für Troubleshooting
  • Ein Text-Editor deiner Wahl

Für den VPS empfehle ich Anbieter wie Hetzner Cloud (ab 4,15€/Monat), Netcup (ab 2,99€/Monat) oder Contabo. Du brauchst keine High-End-Maschine, eine kleine Instanz reicht völlig.

Installation auf dem VPS

Schritt 1: DNS-Records einrichten

Zuerst richten wir die DNS-Einträge für Pangolin ein. Du brauchst einen A-Record für die Pangolin-UI und einen Wildcard-Record für deine Services:

A     pangolin.example.com      -> 198.51.100.42
A     *.pangolin.example.com    -> 198.51.100.42

Ersetze 198.51.100.42 mit der IP deines VPS und example.com mit deiner Domain.

Wenn du Cloudflare nutzt, deaktiviere den Proxy (orange cloud) für diese Records. Let’s Encrypt braucht direkten Zugriff für die HTTP-Challenge.

Schritt 2: Verzeichnisse und Dateien vorbereiten

SSH dich auf deinen VPS und erstelle das Pangolin-Verzeichnis:

1
2
3
4
5
6
7
8
9
10

# Verzeichnisstruktur anlegen
mkdir -p /opt/pangolin/{config,data}
cd /opt/pangolin

# Beispiel-Dateien herunterladen
curl -o docker-compose.yml https://raw.githubusercontent.com/fosrl/pangolin/main/docker-compose.yml
curl -o config.example.yml https://raw.githubusercontent.com/fosrl/pangolin/main/config.example.yml

# Konfiguration kopieren
cp config.example.yml config.yml

Schritt 3: Konfiguration anpassen

Öffne die config.yml und passe sie an deine Umgebung an:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# Pangolin Hauptkonfiguration
pangolin:
  domain: pangolin.example.com
  email: [email protected]
  dashboardPort: 443

  # Admin-User für erste Anmeldung
  adminUser: admin
  adminPassword: changeme123  # WICHTIG: Sofort ändern!

# Gerbil (WireGuard Server)
gerbil:
  wireguardPort: 51820
  subnet: 10.0.0.0/24

  # Öffentliche IP des VPS
  publicEndpoint: 198.51.100.42

  # Interface-Name
  interface: wg0

# Traefik (Reverse Proxy)
traefik:
  httpPort: 80
  httpsPort: 443

  # Let's Encrypt
  letsencryptEmail: [email protected]
  letsencryptServer: https://acme-v02.api.letsencrypt.org/directory

  # Für Testing: staging-Server nutzen
  # letsencryptServer: https://acme-staging-v02.api.letsencrypt.org/directory

# Datenbank
database:
  type: sqlite
  path: /data/pangolin.db

Das Standard-Admin-Passwort solltest du sofort nach der ersten Anmeldung ändern. Pangolin speichert es gehasht in der Datenbank.

Schritt 4: Docker Compose anpassen

Die heruntergeladene docker-compose.yml sollte bereits passen, aber prüfe sie trotzdem:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

version: '3.8'

services:
  pangolin:
    image: fosrl/pangolin:latest
    container_name: pangolin
    restart: unless-stopped
    volumes:
      - ./config.yml:/app/config.yml:ro
      - ./data:/data
    ports:
      - "443:443"
    environment:
      - CONFIG_PATH=/app/config.yml
    depends_on:
      - gerbil
      - traefik

  gerbil:
    image: fosrl/gerbil:latest
    container_name: gerbil
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.forwarding=1
    volumes:
      - ./config.yml:/app/config.yml:ro
      - ./data/wireguard:/etc/wireguard
    ports:
      - "51820:51820/udp"

  traefik:
    image: traefik:v2.10
    container_name: traefik
    restart: unless-stopped
    command:
      - --api.dashboard=false
      - --providers.file.directory=/etc/traefik/dynamic
      - --providers.file.watch=true
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
      - --certificatesresolvers.letsencrypt.acme.email=${ACME_EMAIL}
      - --certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json
      - --certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./data/traefik:/etc/traefik/dynamic
      - ./data/letsencrypt:/letsencrypt
    environment:
      - ACME_EMAIL=${ACME_EMAIL:[email protected]}

Schritt 5: Starten und testen

Jetzt können wir Pangolin starten:

1
2
3
4
5
6
7
8

# Container starten
docker compose up -d

# Logs prüfen
docker compose logs -f

# Status prüfen
docker compose ps

Nach etwa 30 Sekunden sollte Pangolin unter https://pangolin.example.com erreichbar sein. Melde dich mit dem Admin-User an und ändere sofort das Passwort.

Newt-Agent im Homelab installieren

Jetzt kommt der spannende Teil: Wir verbinden das Homelab mit Pangolin.

Schritt 1: Site in Pangolin erstellen

  1. Login in die Pangolin-UI
  2. Navigiere zu Sites → Add New Site
  3. Vergib einen Namen (z.B. “Homelab”)
  4. Klicke auf Generate Config
  5. Kopiere die angezeigten Werte: SITE_ID und SITE_SECRET

Pangolin generiert automatisch:

  • WireGuard-Schlüsselpaar für den Newt-Agent
  • Peer-Konfiguration in Gerbil
  • Eine IP aus dem konfigurierten Subnet (z.B. 10.0.0.2)

Schritt 2: Newt-Agent konfigurieren

Erstelle auf deinem Homelab-Server eine docker-compose.yml für Newt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

version: '3.8'

services:
  newt:
    image: fosrl/newt:latest
    container_name: newt
    restart: unless-stopped

    # Network-Mode host für optimale Performance
    network_mode: host

    cap_add:
      - NET_ADMIN

    environment:
      # Pangolin-Endpunkt
      - PANGOLIN_ENDPOINT=https://pangolin.example.com

      # Site-Credentials aus Pangolin-UI
      - SITE_ID=homelab-abc123
      - SITE_SECRET=super-secret-token-xyz

      # WireGuard-Konfiguration (wird von Pangolin bereitgestellt)
      - WIREGUARD_ENDPOINT=198.51.100.42:51820
      - WIREGUARD_ALLOWED_IPS=10.0.0.0/24

      # Logging
      - LOG_LEVEL=info

    volumes:
      # Persistente WireGuard-Config
      - ./newt-data:/etc/wireguard

Schritt 3: Newt starten und Verbindung prüfen

1
2
3
4
5
6
7
8

# Container starten
docker compose up -d

# Logs prüfen
docker compose logs -f newt

# Verbindung testen
docker exec newt wg show

Du solltest eine Ausgabe wie diese sehen:

1
2
3
4
5
6
7
8
9
10

interface: wg0
  public key: ABC123...
  private key: (hidden)
  listening port: 51820

peer: XYZ789...
  endpoint: 198.51.100.42:51820
  allowed ips: 10.0.0.0/24
  latest handshake: 15 seconds ago
  transfer: 2.43 MiB received, 1.87 MiB sent

Wenn “latest handshake” nicht aktualisiert wird, prüfe, ob Port 51820/UDP ausgehend erlaubt ist. Manche restriktive Firewalls blockieren auch ausgehenden UDP-Traffic.

Dienst freigeben (Step-by-Step)

Jetzt kommt der magische Moment: Wir machen einen Service öffentlich zugänglich.

Beispiel: Jellyfin nach außen bringen

Angenommen, Jellyfin läuft in deinem Homelab unter http://192.168.1.100:8096.

Schritt 1: Resource in Pangolin erstellen

  1. Login in Pangolin-UI
  2. Wähle deine Site (z.B. “Homelab”)
  3. Klicke auf Resources → Add Resource
  4. Fülle das Formular aus:
    • Name: Jellyfin
    • Target URL: http://192.168.1.100:8096
    • Public Hostname: jellyfin.pangolin.example.com
    • Protocol: HTTP (da lokal kein SSL)
    • Enable SSL: Ja (Let’s Encrypt)
  5. Klicke auf Save

Schritt 2: DNS-Record prüfen

Der Wildcard-Record *.pangolin.example.com sollte bereits existieren. Wenn nicht, füge ihn hinzu:

A     *.pangolin.example.com    -> 198.51.100.42

Schritt 3: Warten und testen

Pangolin macht jetzt automatisch:

  • Traefik-Regel erstellen
  • Let’s Encrypt-Zertifikat anfordern (dauert 1-2 Minuten)
  • Routing via WireGuard konfigurieren

Nach etwa 2 Minuten sollte https://jellyfin.pangolin.example.com erreichbar sein.

1
2
3
4
5
6
7

# Zertifikat prüfen
curl -I https://jellyfin.pangolin.example.com

# Sollte zeigen:
# HTTP/2 200
# server: traefik
# ...

Schritt 4: Weitere Services hinzufügen

Wiederhole den Prozess für weitere Services:

Service Target URL Public Hostname
Nextcloud http://192.168.1.101:80 cloud.pangolin.example.com
Home Assistant http://192.168.30.85:8123 hass.pangolin.example.com
Vaultwarden http://192.168.1.102:8000 vault.pangolin.example.com
Uptime Kuma http://192.168.1.103:3001 status.pangolin.example.com

Du kannst theoretisch unbegrenzt viele Services über einen Newt-Agent tunneln. Der einzige Flaschenhals ist die Bandbreite deines VPS.

Sicherheitsfeatures

Pangolin ist nicht nur ein Tunnel, sondern bringt auch wichtige Security-Features mit.

SSL/TLS-Verschlüsselung

Alle öffentlichen Endpunkte werden automatisch mit Let’s Encrypt-Zertifikaten ausgestattet. Der Traffic zwischen User und VPS ist immer verschlüsselt. Der Traffic im WireGuard-Tunnel ist ebenfalls verschlüsselt.

flowchart LR
    User([User]) -->|HTTPS/TLS| Traefik[Traefik]
    Traefik -->|WireGuard/Encrypted| Newt[Newt Agent]
    Newt -->|HTTP/Local| Service[Service]

    style User fill:#51cf66
    style Traefik fill:#4dabf7
    style Newt fill:#4dabf7
    style Service fill:#51cf66

Authentication Middleware

Pangolin unterstützt verschiedene Auth-Methoden, die du pro Resource aktivieren kannst:

Basic Auth:

1
2
3
4
5

# In Pangolin-UI: Resource → Authentication
type: basic
users:
  - username: admin
    password: securepass123  # wird gehasht gespeichert

OAuth2/OIDC:

1
2
3
4
5
6

type: oauth2
provider: google
clientId: your-client-id
clientSecret: your-secret
allowedDomains:
  - example.com

SSO via Authentik/Authelia:

1
2

type: forward-auth
endpoint: https://auth.example.com/api/verify

Rate Limiting

Schütze deine Services vor Brute-Force-Angriffen:

1
2
3
4
5
6

# Pro Resource konfigurierbar
rateLimit:
  enabled: true
  requests: 100
  period: 60s  # 100 Requests pro Minute
  burst: 20

IP Whitelisting

Beschränke Zugriff auf bestimmte IP-Bereiche:

1
2
3
4
5

ipWhitelist:
  enabled: true
  sourceRange:
    - 203.0.113.0/24
    - 198.51.100.0/24

Sicherheitsebenen im Überblick

flowchart TB
    User([User]) --> CF[Optional: Cloudflare]
    CF --> Traefik[Traefik + SSL/TLS]
    Traefik --> Auth[Auth Middleware]
    Auth --> Rate[Rate Limiter]
    Rate --> IP[IP Whitelist]
    IP --> WG[WireGuard Tunnel]
    WG --> Newt[Newt Agent]
    Newt --> Service[Homelab Service]

    style Traefik fill:#4dabf7
    style Auth fill:#fab005
    style Rate fill:#fab005
    style IP fill:#fab005
    style WG fill:#4dabf7
    style Service fill:#51cf66

Access Logs und Monitoring

Pangolin loggt alle Zugriffe:

1
2
3
4
5
6

# Logs auf dem VPS
docker compose logs traefik | grep jellyfin

# Beispiel-Output:
# 2026-02-02T12:34:56Z [jellyfin] 203.0.113.42 - GET /web/index.html 200 1.2ms
# 2026-02-02T12:35:12Z [jellyfin] 203.0.113.42 - GET /api/items 200 45ms

Du kannst auch Metriken nach Prometheus exportieren:

1
2
3
4
5

# In config.yml
monitoring:
  prometheus:
    enabled: true
    port: 9090

Für Production-Umgebungen empfehle ich zusätzlich Fail2Ban auf dem VPS zu installieren, um automatisch IPs nach zu vielen fehlgeschlagenen Login-Versuchen zu blocken.

Vergleich: Pangolin vs. Alternativen

Wie schlägt sich Pangolin im Vergleich zu anderen Lösungen?

Feature Pangolin Cloudflare Tunnel Tailscale Funnel FRP
Self-Hosted Ja Nein Nein Ja
Management-UI Ja Ja (Cloud) Ja (Cloud) Nein
Eigene Domain Ja Ja Eingeschränkt Ja
SSL/Let’s Encrypt Automatisch Automatisch Automatisch Manuell
Auth-Middleware Ja Ja Nein Nein
Multi-Site Ja Ja Nein Ja
Tunnel-Protokoll WireGuard QUIC/HTTP2 WireGuard TCP
Bandbreite VPS-abhängig Unlimitiert Unlimitiert VPS-abhängig
Kosten VPS (ca. 3-5€) Kostenlos Kostenlos (Beta) VPS (ca. 3-5€)
Open Source Ja Nein Nein Ja
Datenschutz Volle Kontrolle CF sieht Traffic Tailscale sieht Metadata Volle Kontrolle
Komplexität Mittel Niedrig Niedrig Hoch

Cloudflare Tunnel ist die einfachste Lösung, aber du gibst Kontrolle ab. Cloudflare terminiert SSL und sieht allen Traffic. Für sensible Daten nicht ideal.

Tailscale Funnel ist super einfach, aber noch in Beta. Es fehlen Features wie Auth-Middleware oder Multi-Site-Support. Gut für simple Use-Cases.

FRP (Fast Reverse Proxy) ist der Klassiker, aber ohne UI sehr mühsam zu konfigurieren. Jede Änderung erfordert manuelle Config-Edits.

Pangolin bietet die beste Balance: Self-Hosted, volle Kontrolle, einfache UI, und moderne Features. Der Preis ist ein günstiger VPS.

Wann welche Lösung?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Cloudflare Tunnel:
  - Du willst maximale Einfachheit
  - Datenschutz ist nicht kritisch
  - Du brauchst DDoS-Protection

Tailscale Funnel:
  - Du nutzt bereits Tailscale
  - Sehr simple Use-Cases
  - Keine Auth-Anforderungen

FRP:
  - Du magst Config-Files
  - Minimale Dependencies
  - Du brauchst absolute Kontrolle

Pangolin:
  - Du willst Self-Hosting
  - Multi-Site-Management
  - Volle Kontrolle + UI
  - Production-Ready Features

Tipps für den Betrieb

VPS-Sizing

Für die meisten Homelabs reicht eine kleine VPS-Instanz:

Dienste vCPU RAM Bandbreite Kosten/Monat
1-5 Services 1 1GB 1TB ~3€
5-15 Services 2 2GB 2TB ~5€
15+ Services 2 4GB 3TB ~8€

Bandbreite ist meist der limitierende Faktor, nicht CPU oder RAM. Für Media-Streaming (Jellyfin etc.) solltest du mindestens 2TB/Monat einplanen.

Monitoring mit Uptime Kuma

Überwache die Verfügbarkeit deiner Services:

1
2
3
4
5
6
7
8
9
10

# In deinem Homelab: Uptime Kuma aufsetzen
services:
  uptime-kuma:
    image: louislam/uptime-kuma:latest
    container_name: uptime-kuma
    ports:
      - "3001:3001"
    volumes:
      - ./data:/app/data
    restart: unless-stopped

Dann über Pangolin exposen: status.pangolin.example.com

Füge Checks hinzu für:

  • Alle öffentlichen Services
  • Pangolin-UI selbst
  • WireGuard-Tunnel (via ping zu 10.0.0.1)

Backup-Strategie

Sichere regelmäßig die wichtigen Daten:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# Auf dem VPS
#!/bin/bash
# /opt/pangolin/backup.sh

BACKUP_DIR="/opt/backups/pangolin"
DATE=$(date +%Y%m%d-%H%M%S)

mkdir -p "$BACKUP_DIR"

# Config und Datenbank sichern
tar -czf "$BACKUP_DIR/pangolin-$DATE.tar.gz" \
  /opt/pangolin/config.yml \
  /opt/pangolin/data/pangolin.db \
  /opt/pangolin/data/wireguard

# Alte Backups löschen (älter als 30 Tage)
find "$BACKUP_DIR" -name "pangolin-*.tar.gz" -mtime +30 -delete

echo "Backup erstellt: pangolin-$DATE.tar.gz"

Cronjob einrichten:

1
2

# Täglich um 3 Uhr morgens
0 3 * * * /opt/pangolin/backup.sh

Update-Strategie

Pangolin-Updates sollten mit Bedacht durchgeführt werden:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 1. Backup erstellen
/opt/pangolin/backup.sh

# 2. Changelog prüfen
curl -s https://api.github.com/repos/fosrl/pangolin/releases/latest | jq -r '.body'

# 3. Images pullen (ohne zu starten)
docker compose pull

# 4. Container neu starten
docker compose up -d

# 5. Logs prüfen
docker compose logs -f

Für Production-Umgebungen: Teste Updates zuerst auf einem separaten VPS, bevor du sie auf deinen Live-VPS ausspielst.

Log-Rotation

Verhindere, dass Logs die Disk vollschreiben:

1
2
3
4
5
6
7
8

# In docker-compose.yml für alle Services
services:
  pangolin:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Das limitiert jeden Container auf 3 Log-Files à 10MB.

Performance-Tuning

Für high-traffic Services:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# In config.yml
performance:
  # HTTP/2 für bessere Multiplexing
  http2:
    enabled: true

  # Gzip-Kompression
  compression:
    enabled: true
    types:
      - text/html
      - text/css
      - application/json

  # Caching für statische Assets
  cache:
    enabled: true
    maxAge: 3600

Wartungsfenster kommunizieren

Nutze Uptime Kuma’s Status-Page Feature, um geplante Wartungen anzukündigen. Alternativ ein simples HTML auf dem VPS:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!-- /opt/pangolin/maintenance.html -->
<!DOCTYPE html>
<html>
<head>
  <title>Wartung</title>
  <style>
    body { font-family: sans-serif; text-align: center; padding: 50px; }
    h1 { color: #e03131; }
  </style>
</head>
<body>
  <h1>Wartungsarbeiten</h1>
  <p>Diese Dienste sind vorübergehend nicht verfügbar.</p>
  <p>Voraussichtlich wieder online: 14:00 Uhr</p>
</body>
</html>

Traefik so konfigurieren, dass es bei gestoppten Containern diese Seite zeigt.

Fazit

Pangolin ist die perfekte Lösung, wenn du Homelab-Services öffentlich zugänglich machen willst, ohne:

  • Ports in deinem Heimnetz zu öffnen
  • Deine echte IP zu exposen
  • Dich mit DDNS rumzuschlagen
  • Auf Cloud-Dienste angewiesen zu sein

Die Kombination aus WireGuard-Tunnel, Traefik-Reverse-Proxy und einer übersichtlichen Management-UI macht Pangolin zur besten self-hosted Alternative zu Cloudflare Tunnel oder anderen Cloud-Lösungen.

Wann solltest du Pangolin nutzen?

Du brauchst öffentlich zugängliche Services (nicht nur VPN für dich persönlich):

  • Blog, Portfolio, oder andere Websites
  • APIs für externe Clients
  • Shared Services (Jellyfin für Familie/Freunde)
  • Status-Pages, Monitoring, etc.

Du willst volle Kontrolle über deine Daten:

  • Kein Traffic durch Third-Party-Provider
  • Selbst gehostete Zertifikate
  • Voller Zugriff auf Logs und Metriken

Du hast mehrere Homelabs oder Sites:

  • Multi-Site-Support out-of-the-box
  • Zentrale Verwaltung aller Tunnel
  • Ein VPS für alle Standorte

Wann solltest du Alternativen in Betracht ziehen?

Für persönlichen VPN-Zugriff reicht Tailscale oder WireGuard direkt. Wenn Datenschutz keine Rolle spielt und du maximale Einfachheit willst, ist Cloudflare Tunnel super. Und für extrem simple Use-Cases ohne Auth-Anforderungen könnte Tailscale Funnel ausreichen.

Aber für die meisten Homelab-Betreiber, die ihre Services professionell nach außen bringen wollen, ist Pangolin die beste Wahl. Die Investition in einen günstigen VPS zahlt sich durch Flexibilität, Sicherheit und Kontrolle schnell aus.

Ressourcen

Pangolin:

VPS-Anbieter:

Alternativen:

Tools:

Viel Erfolg beim Exposen deiner Homelab-Services!

Homelab, Netzwerk
pangolin reverse-proxy wireguard tunnel self-hosted docker homelab networking vpn security
Dieser Eintrag ist vom Autor unter CC BY 4.0 lizensiert.