DS-Lite umgehen: Reverse Proxy mit Docker & Pangolin
Lerne, wie du mit einem Tunnel das DS-Lite-Problem umgehst und deine lokalen Dienste sicher über einen Reverse Proxy mit Docker und Pangolin zugänglich machst.

Inhaltsverzeichnis
In Zeiten von DS-Lite (Dual Stack Lite) wird es immer schwieriger, eigene Dienste wie Webseiten, APIs oder andere Anwendungen aus dem Internet zu erreichen. Warum? Weil viele Internetanbieter keine öffentlichen IPv4-Adressen mehr bereitstellen. Aber keine Sorge – in diesem Artikel zeige ich dir, wie du dieses Problem lösen kannst! Mit dem open-source Reverse Proxy Pangolin erstellst du einen sicheren DS-Lite Tunnel zwischen deinem lokalen Server und einem externen VPS. So kannst du deine Dienste problemlos von überall aus erreichen.
Warum DS-Lite ein Problem darstellt
Bevor wir loslegen, schauen wir uns kurz an, warum DS-Lite überhaupt ein Hindernis ist:
- Keine öffentliche IPv4-Adresse: Bei DS-Lite erhältst du keine eigene öffentliche IPv4-Adresse. Das bedeutet, dass dein Router nicht direkt über das Internet erreichbar ist.
- Eingeschränkter Fernzugriff: Ohne eine öffentliche IP-Adresse kannst du keine Ports freigeben, um z. B. einen Webserver oder andere Dienste von außen zu erreichen.
- IPv6 als Alternative? Theoretisch könntest du IPv6 nutzen, aber viele Netzwerke und Geräte unterstützen IPv6 noch nicht vollständig. Außerdem ist die Konfiguration oft kompliziert und nicht zuverlässig.
Die Lösung ist simpel: Ein externer VPS (virtueller Server) als Brücke zwischen deinem lokalen Netzwerk und dem Internet. Klingt nach viel Arbeit? Ist es nicht, wenn du weißt, wie’s geht.
Was ist ein Reverse Proxy?
Ein Reverse Proxy ist ein Server, der Anfragen von außen entgegennimmt und sie an den richtigen Dienst in deinem lokalen Netzwerk weiterleitet.
Mit Pangolin wird dieser Prozess noch einfacher. Pangolin ist eine Open-Source-Software, die speziell dafür entwickelt wurde, sichere Tunnel zwischen deinem lokalen Server und einem externen VPS aufzubauen.
Was du für dieses Setup brauchst
Bevor wir beginnen, hier eine kurze Liste der Dinge, die du benötigst:
- Einen lokalen Server: Das kann ein Raspberry Pi, ein alter PC oder ein anderer Rechner sein, auf dem deine Dienste laufen.
- Einen externen VPS: Ein virtueller Server, der über eine öffentliche IP-Adresse verfügt. Ich empfehle Netcup, da sie preiswerte Optionen ab 1 € pro Monat anbieten.
- Domain: Eine Domain, bei der du die DNS-Einstellungen anpassen kannst. Auch hier käme Netcup mit 0,42 € pro Monat in Frage.
- Grundlegende Linux-Kenntnisse: Du solltest wissen, wie man sich per SSH mit einem Server verbindet und einfache Befehle ausführt.
Ist dir ein Video mit allen Schritten lieber? Dann schau dir dieses Tutorial auf Youtube an.
Schritt-für-Schritt: Dein Reverse Proxy mit Pangolin einrichten
Den lokalen Server vorbereiten
Zuerst richtest du deinen lokalen Server ein.
Installiere Docker und Docker Compose, falls noch nicht geschehen.
Einen VPS mieten und einrichten
Als nächstes mietest du einen VPS mit Ubuntu als Betriebssystem. Nachdem du dich per SSH mit dem Server verbunden hast, aktualisierst du das System und installierst Docker.
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/raspbian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/raspbian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Pangolin installieren
Erstelle die notwendigen Ordner für Pangolin sowie die Konfigurationsdateien.
mkdir -p pangolin/config
touch pangolin/config/traefik_config.yaml
touch pangolin/config/dynamic_config.yml
touch pangolin/docker-compose.yml
Passe die Dateien an deine Bedürfnisse an – insbesondere die Domain.
docker-compose.yml:
services:
pangolin:
image: fosrl/pangolin:1.0.0-beta.14
container_name: pangolin
restart: unless-stopped
volumes:
- ./config:/app/config
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:3001/api/v1/"]
interval: "3s"
timeout: "3s"
retries: 5
gerbil:
image: fosrl/gerbil:1.0.0-beta.3
container_name: gerbil
restart: unless-stopped
depends_on:
pangolin:
condition: service_healthy
command:
- --reachableAt=http://gerbil:3003
- --generateAndSaveKeyTo=/var/config/key
- --remoteConfig=http://pangolin:3001/api/v1/gerbil/get-config
- --reportBandwidthTo=http://pangolin:3001/api/v1/gerbil/receive-bandwidth
volumes:
- ./config/:/var/config
cap_add:
- NET_ADMIN
- SYS_MODULE
ports:
- 51820:51820/udp
- 443:443 # Port for traefik because of the network_mode
- 80:80 # Port for traefik because of the network_mode
traefik:
image: traefik:v3.3.3
container_name: traefik
restart: unless-stopped
network_mode: service:gerbil # Ports appear on the gerbil service
depends_on:
pangolin:
condition: service_healthy
command:
- --configFile=/etc/traefik/traefik_config.yml
volumes:
- ./config/traefik:/etc/traefik:ro # Volume to store the Traefik configuration
- ./config/letsencrypt:/letsencrypt # Volume to store the Let's Encrypt certificates
networks:
default:
driver: bridge
name: pangolin
traefik_config.yaml:
api:
insecure: true
dashboard: true
providers:
http:
endpoint: "http://pangolin:3001/api/v1/traefik-config"
pollInterval: "5s"
file:
filename: "/etc/traefik/dynamic_config.yml"
experimental:
plugins:
badger:
moduleName: "github.com/fosrl/badger"
version: "v1.0.0-beta.3"
log:
level: "INFO"
format: "common"
certificatesResolvers:
letsencrypt:
acme:
httpChallenge:
entryPoint: web
email: admin@example.com # REPLACE THIS WITH YOUR EMAIL
storage: "/letsencrypt/acme.json"
caServer: "https://acme-v02.api.letsencrypt.org/directory"
entryPoints:
web:
address: ":80"
websecure:
address: ":443"
transport:
respondingTimeouts:
readTimeout: "30m"
http:
tls:
certResolver: "letsencrypt"
serversTransport:
insecureSkipVerify: true
dynamic_config.yml (hier die E-Mail-Adresse anpassen):
http:
middlewares:
redirect-to-https:
redirectScheme:
scheme: https
routers:
# HTTP to HTTPS redirect router
main-app-router-redirect:
rule: "Host(`proxy.example.com`)" # REPLACE THIS WITH YOUR DOMAIN
service: next-service
entryPoints:
- web
middlewares:
- redirect-to-https
# Next.js router (handles everything except API and WebSocket paths)
next-router:
rule: "Host(`proxy.example.com`) && !PathPrefix(`/api/v1`)" # REPLACE THIS WITH YOUR DOMAIN
service: next-service
entryPoints:
- websecure
tls:
certResolver: letsencrypt
# API router (handles /api/v1 paths)
api-router:
rule: "Host(`proxy.example.com`) && PathPrefix(`/api/v1`)" # REPLACE THIS WITH YOUR DOMAIN
service: api-service
entryPoints:
- websecure
tls:
certResolver: letsencrypt
# WebSocket router
ws-router:
rule: "Host(`proxy.example.com`)" # REPLACE THIS WITH YOUR DOMAIN
service: api-service
entryPoints:
- websecure
tls:
certResolver: letsencrypt
services:
next-service:
loadBalancer:
servers:
- url: "http://pangolin:3002" # Next.js server
api-service:
loadBalancer:
servers:
- url: "http://pangolin:3000" # API/WebSocket server
Container starten
Starte die Container, um die restlichen Dateien zu erstellen.
sudo docker compose -f pangolin/docker-compose.yml up -d
Sobald die config/config.yaml
erstellt wurde, kannst du die Container wieder stoppen und die Datei anpassen.
sudo docker compose -f pangolin/docker-compose.yml down
sudo nano pangolin/config/config.yaml
app:
dashboard_url: "https://example.com" # Auf deine Domain anpassen
base_domain: "example.com" # Auf deine Domain anpassen
log_level: "info" # debug, info, warn, error
save_logs: false # true, false
# log_failed_attempts: true # true, false
server:
external_port: 3000
internal_port: 3001
next_port: 3002
internal_hostname: "pangolin"
session_cookie_name: "p_session_token"
resource_access_token_param: "p_token"
resource_session_request_param: "p_session_request"
traefik:
cert_resolver: "letsencrypt"
http_entrypoint: "web"
https_entrypoint: "websecure"
prefer_wildcard_cert: true
gerbil:
start_port: 51820
base_endpoint: "example.com" # Auf deine Domain anpassen
use_subdomain: false
block_size: 24
site_block_size: 30
subnet_group: 100.89.137.0/20
rate_limits:
global:
window_minutes: 1
max_requests: 100
email:
smtp_host: "host.hoster.net" # Auf deine E-Mail-Einstellungen anpassen
smtp_port: 587 # Auf deine E-Mail-Einstellungen anpassen
smtp_user: "no-reply@example.com" # Auf deine E-Mail-Einstellungen anpassen
smtp_pass: "aaaaaaaaaaaaaaaaaa" # Auf deine E-Mail-Einstellungen anpassen
no_reply: "no-reply@example.com" # Auf deine E-Mail-Einstellungen anpassen
users:
server_admin:
email: "admin@example.com" # Login Daten anpassen
password: "Password123!" # Login Daten anpassen
flags:
require_email_verification: true
disable_signup_without_invite: true
disable_user_create_org: true
allow_raw_resources: true
allow_base_domain_resources: true
Anmeldung
Öffne deinen Browser und rufe die URL auf, die du in der config.yaml
angegeben hast. Melde dich mit den in der config.yaml
festgelegten Anmeldedaten an. Speichere die Newt Konfiguration für einen Tunnel zwischen deinem lokalen Server und dem VPS.
Newt installieren
Mit Newt erstellst du einen sicheren Tunnel zwischen deinem lokalen Server und dem VPS. Dieser Tunnel ermöglicht es dir, deine lokalen Dienste über den externen Server zu erreichen.
Dazu muss Newt auf dem lokalen Server installiert werden.
mkdir newt
touch newt/docker-compose.yml
nano newt/docker-compose.yml
services:
newt:
image: fosrl/newt
container_name: newt
restart: unless-stopped
environment:
- PANGOLIN_ENDPOINT=https://example.com
- NEWT_ID=2ix2t8xk22ubpfy
- NEWT_SECRET=nnisrfsdfc7prqsp9ewo1dvtvci50j5uiqotez00dgap0ii2
Die Werte für PANGOLIN_ENDPOINT
, NEWT_ID
und NEWT_SECRET
müssen angepasst werden.
Starte den Container.
sudo docker compose -f newt/docker-compose.yml up -d
Nun sollte eine erfolgreiche Verbindung in der Pangolin Oberfläche angezeigt werden.
Resource erstellen
Erstelle eine Resource in der Pangolin Oberfläche, um den Zugriff auf deinen lokalen Server zu ermöglichen.
Fazit
Mit einem Reverse Proxy und Pangolin kannst du das DS-Lite-Problem elegant umgehen und deine lokalen Dienste sicher und zuverlässig von überall aus zugänglich machen.
Probiere es selbst aus und teile deine Erfahrungen in den Kommentaren!