Home Blog About
HOMESERVER

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.

DS-Lite umgehen: Reverse Proxy mit Docker & Pangolin-heroimage

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:

  1. 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.
  2. 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.
  3. 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:

  1. Einen lokalen Server: Das kann ein Raspberry Pi, ein alter PC oder ein anderer Rechner sein, auf dem deine Dienste laufen.
  2. 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.
  3. Domain: Eine Domain, bei der du die DNS-Einstellungen anpassen kannst. Auch hier käme Netcup mit 0,42 € pro Monat in Frage.
  4. 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!

#anleitung #docker #ds lite #homeserver #pangolin #server
Zurück zu allen Beiträgen
Diese Website verwendet Cookies. Diese sind notwendig, um die Funktionalität der Website zu gewährleisten. Weitere Informationen finden Sie in der Datenschutzerklärung