Ankündigung

**Lapheus** · 07.02.2022, 00:21

Traefik als IPv4 zu IPv6 Tunnel

Ich beschreibe hier wie mit einem lokalen Traefik (lok-Traefik) und einem auf einem VServer gehosteten Traefik (virt-Traefik) ein IPv4 zu IPv6 Tunnel erstellt wird.
Wie funktioniert es:

Auf dem lok-Traefik werden zwei DNS Namen gepflegt, zum Beispiel alexa.my-domain.de und alexa-v6.my-domain.de
Auf dem virt-Traefik wird nur die Domain alexa.my-domain.de konfiguriert.
Für alexa.my-domain.de werden feste DNS A-Einträge erstellt. Da der VServer eine feste IP hat ist das sehr einfach.
Für alexa.my-domain.de und alexa-v6.my-domain.de werden per Skript, die DNS AAAA-Einträge aktuell gehalten. Sie zeigen auf den Docker-Host wo lok-Traefik läuft.
Die Adresse alexa-v6.my-domain.de ist nur dazu da, damit der Traefik auf dem VServer ein festes Ziel hat das NUR IPv6 spricht.

Ein externer Webbrowser kann bei IPv6 direkt über den DNS AAAA Eintrag auf alexa.my-domain.de zugreifen. Im DNS steht die IPv6 Adresse des Docker-Hosts. Der gibt es dann entsprechend über lok-Traefik intern weiter.
Ein externer Webbrowser kann bei IPv4 direkt über den DNS A Eintrag auf alexa.my-domain.de zugreifen. Er landet direkt auf dem VServer und virt-Traefik nimmt die Verbindung an und terminiert sie sauber (Zertifikat etc.). Der virt-Traefik schickt laut Regel die Anfrage weiter an alexa-v6.my-domain.de. Die zeigt durch den DNS AAAA-Eintrag auf dem Docker Host und landet bei dem lok-Traefik. Weiterer Verlauf ist bekannt.

Was geht bereits:

Durchleiten des Alexa Zugriffs
Automatische Aktualisierung der Letsencrypt Zertifikate
Anfragen auf Port 80 werden automatisch auf Port 443 umgeleitet.
Anwendungen wie Geofency, Opensprinkler oder UnfiController Webinterface

ToDo:

Durchreichen des (Edomi-) Client Zertifikates bringt noch Fehler
Konfiguration des Websockets für die Edomi-Visu

Voraussetzungen:

Für IPv6 muss alles IPv6 sprechen, vom Endgerät bis zum Server. Die Mobilfunknetze D1 und D2 unterstützen beide vollständig IPv6.
Auf dem Router muss IPv6 aktiviert sein. Es muss das Präfix vom Anbieter im lokalen Netz weitergegeben werden.
- Achtung der Router sollte mit einem ULA Präfix konfiguriert werden
- Zum Beispiel kann man sich hier eine ULA Adresse generieren
- IPv6 Adresse des DNS Server PiHole per Router Advertisment bzw. DHCPv6 verteilen.
Der PiHole ist der lokale DNS Server, auch für IPv6.
- Hier ist es wichtig das der PiHole eine ULA Adresse aus dem gleichen Netz bekommt. Sonst unterstützt PiHole kein IPv6!
- Zusätzlich sollte diese ULA Adresse des PiHole per Router Advertisement konfiguriert werden, wie im Punkt vorher erwähnt.
- Im PiHole unter Settings -> DNS muss bei IPv6 beide Felder aktiviert sein.
Die IPv4 Portweiterleitung aus dem ersten Post können wegfallen.
Die DNS Aktualisierung auf dem Router kann auch wegfallen.
Alles was ich unter Voraussetzungen im ersten Post festgehalten habe, gilt auch hier.
Wir benötigen ein Tool, das nur die IPv6 DNS Einträge auf den DNS Server aktualisiert. Da habe ich so einige Sachen ausprobiert. Letztendlich habe ich für die DNS-API von Servercow ein Skript geschrieben was genau das macht.

Folgende Konfiguration:

VServer

Bei Ionos oder einem anderen Anbieter einen VServer bestellen und Linux installieren. Ich habe hier Ubuntu 20.04 installiert.
Ich habe gleich den Zugriff abgesichert. Nach der Aktivierung mit einem Authorized_Key mit Passwort-Abfrage(!) wurde die Passwort Anmeldung gesperrt.
Die Firewall für Ionos Server gibt von sich aus die Ports 22, 80 und 443 frei.
Auf dem Server eine IPv6 Adresse aktivieren.
System auf aktuellen Stand bringen (apt update && apt upgrade)
Die Installation/Konfiguration von Docker erfolgte nach dieser Anleitung.
Die Installation/Konfiguration von Docker-compose nach dieser Anleitung.

Ich habe mir dann folgende Ordnerstruktur erstellt in dem ich meiner Daten ablege.

Code:

mkdir /docker-host
mkdir /docker-host/traefik
mkdir /docker-host/traefik/data
mkdir /docker-host/traefik/secrets

Dort werden nun folgende Dateien erstellt.

Datei /docker-host/traefik/traefik.yml (die gleiche wie oben)

Code:

api:
  dashboard: true
  debug: true
entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entrypoint:
           to: websecure
           scheme: https
  websecure:
     address: ":443"
providers:
  docker:
      endpoint: "unix:///var/run/docker.sock"
      exposedByDefault: false
   file:
     filename: /config.yml
     watch: true
certificatesResolvers:
   servercow:
      acme:
         email: certificates@my-domain.de
         storage: acme.json
         dnsChallenge:
             provider: servercow
             resolvers:
                - "9.9.9.9:53"
                - "149.112.112.112:53"

Datei /docker-host/traefik/docker-compose.yml

Code:

version: '3.3'

secrets:
  servercow_username:
    file: "./secrets/servercow_username.secret"
  servercow_password:
    file: "./secrets/servercow_password.secret"

services:
  traefik:
    image: traefik:latest
    container_name: traefik
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - proxy
    ports:
      - 80:80
      - 443:443
    secrets:
      - "servercow_username"
      - "servercow_password"
    environment:
      - "SERVERCOW_USERNAME_FILE=/run/secrets/servercow_username"
      - "SERVERCOW_PASSWORD_FILE=/run/secrets/servercow_password"
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /docker-data/traefik/data/traefik.yml:/traefik.yml:ro
      - /docker-data/traefik/data/acme.json:/acme.json
      - /docker-data/traefik/config.yml:/config.yml:ro
    labels:
      - "traefik.enable=true"
      - "traefik.http.middlewares.traefik-auth.basicauth.users=<USER>:<PASSWORT>"
      - "traefik.http.middlewares.sslheader.headers.custom requestheaders.X-Forwarded-Proto=https"
      - "traefik.http.routers.traefik-secure.entrypoints=websecure"
      - "traefik.http.routers.traefik-secure.rule=Host(`traefik-api.my-domain.de`)"
      - "traefik.http.routers.traefik-secure.middlewares=traefik-auth"
      - "traefik.http.routers.traefik-secure.tls=true"
      - "traefik.http.routers.traefik-secure.tls.certresolver=servercow"
      - "traefik.http.routers.traefik-secure.service=api@internal"

networks:
  proxy:
    external: true

Mit folgenden Befehlen wird ein Benutzer mit Passwort erstellt.
Der wird dann für den Zugriff auf das Dashboard von virt-Traefik genutzt.
Dabei bitte <USER> durch einen Benutzernamen und <PASSWORT> mit deinem Kennwort ersetzen.
Die Ausgabe des Befehls anstatt "<USER>:<PASSWORT>" in die Datei eintragen.
Hier als Beispiel ist Benutzer admin mit dem Kennwort geheim:

Code:

admin:$$apr1$$FZuF2WCo$$56qZy0kLe91O3qxwWfG9I0

Code:

sudo apt install apache2-utils
echo $(htpasswd -nb <USER> <PASSWORD>) | sed -e s/\\$/\\$\\$/g

Datei /docker-host/traefik/data/acme.json erstellen Darin speichert Traefik die Zertifikate.

Code:

touch /docker-host/traefik/data/acme.json
chmod 600 /docker-host/traefik/data/acme.json

Datei /docker-host/traefik/secrets/servercow_username.secret erstellen
Darin wird der zu erstellende Benutzername für die DNS-API hinterlegt.

Code:

nano /docker-host/traefik/secrets/servercow_username.secret

Datei /docker-host/traefik/secrets/servercow_password.secret erstellen
Darin wird das Passwort des Benutzers für die DNS-API hinterlegt.

Code:

nano /docker-host/traefik/secrets/servercow_password.secret

Jetzt erstellen wir noch die Datei /docker-host/traefik/config.yml
Darin definieren wir unsere Weiterleitung auf unseren Docker-Host Server Zuhause.

Code:

http:
  #region routers
  routers:
    edomi:
      entryPoints:
         - "websecure"
      rule: "Host(`edomi.my-domain.de`)"
      middlewares:
        - default-headers
        - edomi-passtlsclientcert
      tls:
        certResolver: servercow
      service: edomi
    alexa:
      entryPoints:
       - "websecure"
      rule: "Host(`alexa.my-domain.de`)"
      middlewares:
       - default-headers
      tls:
        certResolver: servercow
    service: alexa
      unifi:
        entryPoints:
         - "websecure"
        rule: "Host(`unifi.my-domain.de`)"
        middlewares:
          - default-headers
        tls:
          certResolver: servercow
        service: unifi
#endregion
#
#region services
  services:
    edomi:
      loadBalancer:
        servers:
           - url: "https://edomi-v6.my-domain.de"
         passHostHeader: true
    alexa:
        loadBalancer:
          servers:
            - url: "https://alexa-v6.my-domain.de"
          passHostHeader: true
     unifi:
        loadBalancer:
          servers:
            - url: "https://unifi-v6.my-domain.de"
          passHostHeader: true
#endregion

  middlewares:
    default-headers:
      headers:
        frameDeny: true
        sslRedirect: true
        browserXssFilter: true
        contentTypeNosniff: true
        forceSTSHeader: true
        stsPreload: true
        stsSeconds: 15552000
        customFrameOptionsValue: SAMEORIGIN
        customRequestHeaders:
        X-Forwarded-Proto: https,wss
    edomi-passtlsclientcert:
      passTLSClientCert:
        info:
          notAfter: true
          notBefore: true
          sans: true
          subject:
            country: true
            province: true
            locality: true
            commonName: true
            serialNumber: true
            domainComponent: true
          issuer:
            country: true
            province: true
            locality: true
            organization: true
            commonName: true
            serialNumber: true
            domainComponent: true

tls:
  options:
    default:
      minVersion: VersionTLS12
      cipherSuites:
        - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        - TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
        - TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
        - TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
        - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256

Hier eine weitere ULA Adresse generieren.
Im folgenden Befehl das ULA Prefix dreimal mal einsetzen wo <ULA-PREFIX> steht.
Eventuell die Netzwerkkarte "ens192" anpassen.
Das benötigte Docker Netzwerk mit IPv6 Support wird so erstellt.
Der zweite Befehl hat mich viel Nerven gekostet! ☹
Innerhalb des Docker Netzwerkes mit aktivem IPv6 gibt es kein NAT von IPv6.
Mit der Iptables Regel wird das manuell aktiviert.

In den Ordner /docker-host/traefik wechseln

Code:

docker network create -d bridge --ipv6 --subnet <ULA-PREFIX>::/48 --gateway <ULA-PREFIX>::1 -o parent=ens192 proxy
ip6tables -t nat -A POSTROUTING -s <ULA-PREFIX>::/48 ! -o docker0 -j MASQUERADE
docker-compose up -d
docker exec traefik ping6 heise.de

Der letzte Befehl (ping6 aus dem Container) sollte eine entsprechende Ping Antwort ergeben.

Code:

PING heise.de (2a02:2e0:3fe:1001:302::): 56 data bytes
64 bytes from 2a02:2e0:3fe:1001:302::: seq=0 ttl=55 time=5.191 ms
64 bytes from 2a02:2e0:3fe:1001:302::: seq=1 ttl=55 time=5.207 ms
64 bytes from 2a02:2e0:3fe:1001:302::: seq=2 ttl=55 time=5.398 ms
64 bytes from 2a02:2e0:3fe:1001:302::: seq=3 ttl=55 time=5.187 ms
64 bytes from 2a02:2e0:3fe:1001:302::: seq=4 ttl=55 time=5.204 ms

Folgende DNS Konfiguration auf der DNS Oberfläche von Servercow vornehmen:

edomi.my.domain.de zeigt als DNS A-Record auf die IP des Ionos VServers
alexa.my.domain.de zeigt als DNS A-Record auf die IP des Ionos VServers
traefik-dashboard.my-domain.de zeigt als DNS A-Record auf die IP des Ionos VServers
unifi.my-domain.de zeigt als DNS A-Record auf die IP des Ionos VServers

Da sich die IP des VServers nicht ändert muss das nur einmal gemacht werden.

In der config.yml des lok-Traefik muss folgendes angepasst werden

Code:

    edomi-rtr:
       entryPoints:
         - "websecure"
       rule: "Host(`edomi.my-domain.de`)"
      middlewares:
        - default-headers
      tls:
        certResolver: servercow
          domains:
            - main: "edomi.my-domain.de"
          options: "edomi-user-cert"
        service: edomi-sevi

mit folgendem ersetzen:

Code:

    edomi-rtr:
       entryPoints:
         - "websecure"
        rule: "Host(`edomi.f-plass.de`) || Host(`edomi-v6.f-plass.de`)"
      middlewares:
        - default-headers
      tls:
        certResolver: servercow
          domains:
            - main: "edomi.my-domain.de"
              sans:
                - "edomi-v6.my-domain.de"
          options: "edomi-user-cert"
        service: edomi-sevi

Dann per ssh auf den lok-Traefik folgendes ausführen:

Code:

cd /docker-data/traefik/
docker-compose up -d --force-recreate

Auf dem VServer haben wir die beim TLS Part keine expliziten Domains angelegt. Traefik behandelt das dann so, das dafür ein Wildcard Zertifikat generiert wird und das für alle Dienste genommen wird.
Da wir oben auf dem lok-Traefik im TLS Part die DNS Namen angegeben haben werden dort einzelne Zertifikate erstellt.
Ich nutze das um im Webbrowser festzustellen auf welchem Traefik ich gerade terminiere.

Auf dem lokale Docker Host wird IPv6 aktiviert.
Bei meinem LXT Container auf Proxmox kann ich einfach die Option SLAAC aktivieren im Reiter Netzwerk des LXT Containers aktivieren.

Auf dem Router muss nun eine Freigabe bzw. eine Firewall Regel erstellt werden, die den Datenverkehr auf Port 80 und 443 über IPv6 auf den Docker Host direkt zulässt. Hier KEINEN Exposed Host konfigurieren! Eventuell müsst Ihr die Netzwerk Konfig so ändern das keine privaten IPv6 Adressen genutzt werden.

Jetzt auf dem Docker-Host noch für die Aktualisierung DNS AAAA Rekords sorgen.

Folgendes Skript macht das bei mir:
/usr/local/bin/dnsupdate.sh

Bitte wieder die Benutzer Daten des Servercow DNS-API Users eintragen
<SERVERCOW_USERNAME>
<SERVERCOW_PASSWORD>

Code:

#!/bin/bash

USER="<SERVERCOW_USERNAME>"
PASSWORD="<SERVERCOW_PASSWORD>"
HOSTNAMES=( ""edomi.my-domain.de" "edomi-v6.my-domain.de" "alexa.my-domain.de" "alexa-v6.my-domain.de" "unifi.my-domain.de" "unifi-v6.my-domain.de" )
CACHE_FILE="/var/cache/dnsupdate/cachefile"
ZONE="my-domain.de"
DNSTYPE="AAAA"

if [ -f $CACHE_FILE ]; then
IP_CACHE=$(<$CACHE_FILE)
else
IP_CACHE=""
fi
if [[ "${DNSTYPE}" == "AAAA" ]]; then
#get IPV6 IP
IP=`ip -6 addr show eth0 | sed -e 's/^.*inet6 \(2[^ ]*\)\/.*$/\1/;t;d'`
echo "IPv6: ${IP}"
elif [[ "${DNSTYPE}" == "A" ]]; then
IP='ip addr show eth0 | grep -Po 'inet \K[0-9.]+''
echo "IPv$: ${IP}"
else
echo "can not get ip"
exit 1
fi

for HOST in "${HOSTNAMES[@]}"
do
if [[ "${IP_CACHE}" != "${IP}" ]]; then
api_return=$(curl -sX POST "https://api.servercow.de/dns/v1/domains/$ZONE" \
-H "X-Auth-Username: $USER" \
-H "X-Auth-Password: $PASSWORD" \
-H 'Content-Type: application/json' \
--data "{\"type\":\"$DNSTYPE\",\"name\":\"$HOST\",\"conte nt\":\"$IP\",\"ttl\":60}")
echo "$api_return" | grep -qi '{"message":"ok"}'
if [[ $? != 0 ]]; then
echo -e "\n\t ERROR: Post to API failed: ${api_return} \n"
exit 1
else
echo -e "\t API call succeeded: ${api_return}"
echo $IP > $CACHE_FILE
fi
fi
done

Ausführbar machen.
Dann einmal testen ob der Befehl funktioniert

Code:

chmod 755 /usr/local/bin/dnsupdate.sh
cd /usr/local/bin/
./dnsupdate.sh

Wenn in Ordnung dann in die Crontab eintragen:

Code:

*/15  *  *  * * /usr/local/bin/dnsupdate.sh > /dev/null 2>&1

Anleitung wurde nach bestem Wissen und Gewissen erstellt, Umsetzung auf eigene Gefahr.
Auf ssllabs gibt es dafür bei meiner Einstellung eine A+ Bewertung.

**Lapheus** · 12.02.2022, 22:07

Hier einmal für Portainer das docker-compose File und weiter Konfigurationsschritte

Code:

mkdir docker-data/portainer
mkdir docker-data/portainer/data
cd /docker-data/portainer

docker.compose.yml

Code:

version: "3"
  services:
    portainer:
      image: portainer/portainer-ce
      container_name: portainer
      restart: unless-stopped
      security_opt:
        - no-new-privileges:true
      networks:
        - proxy
      volumes:
        - /etc/localtime:/etc/localtime:ro
        - /var/run/docker.sock:/var/run/docker.sock:ro
        - /docker-data/portainer/data:/data
      labels:
        - "traefik.enable=true"
        - "traefik.http.routers.portainer-secure.entrypoints=websecure"
        - "traefik.http.routers.portainer-secure.rule=Host(`portainer.my-domain.de`)"
        - "traefik.http.routers.portainer-secure.tls=true"
        - "traefik.http.routers.portainer-secure.tls.certresolver=servercow"
        - "traefik.http.routers.portainer-secure.service=portainer"
        - "traefik.http.services.portainer.loadbalancer.serv er.port=9000"
        - "traefik.docker.network=proxy"

networks:
  proxy:
    external: true

Code:

docker-compose up

Wenn keine Fehler kommen mit STRG & C stoppen und mit folgendem Befehl starten:

Code:

docker-compose up -d

Unter PiHole einen CNAME Eintrag erstellen:

portainer.my-domain.de zeigt als CNAME Record auf docker-host.my.domain.de

Jetzt kann ich im Webbrowser portainer.my-domain.de aufrufen und bin auf dem Webinterface des Portainer Containers.
Das funktioniert obwohl der Port 9000 des Containers nicht freigegeben wurde!

**Lapheus** · 12.02.2022, 22:44

Hier mal ein Docker Compose File für den Unifi Controller.

Auf der Shell des docker-host:

Code:

cd /docker-data
mkdir unifi
groupadd -g 944 unifi
adduser unifi --gecos "" --home /docker-data/unifi --disabled-login --shell /usr/sbin/nologin --uid 944 --ingroup unifi
chown unifi:unifi unifi

Ich habe im Portainer unter Stacks die folgende docker-compose.yml aktiviert.

Code:

version: "2.1"
services:
  unifi:
    image: lscr.io/linuxserver/unifi-controller
    container_name: unifi
    restart: unless-stopped
    networks:
      - proxy
    environment:
      - PUID=944
      - PGID=944
      - TZ="Europe/Berlin"
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /docker-data/unifi:/config
    ports:
      - 3478:3478/udp
      - 10001:10001/udp
 # Umzug auf Port 8090, da ich 8080 noch für Edomi brauche
      - 8090:8080

    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.unifi-rtr.rule=Host(`unifi.my-domain.de`) || Host(`unifi-v6.my-domain.de`)"
      - "traefik.http.routers.unifi-rtr.entryPoints=websecure"
      - "traefik.http.routers.unifi-rtr.tls=true"
      - "traefik.http.routers.unifi-rtr.tls.certresolver=servercow"
      - "traefik.http.routers.unifi-rtr.tls.domains[0].main=unifi.my-domain.de"
      - "traefik.http.routers.unifi-rtr.tls.domains[0].sans=unifi-v6.my-domain.de"
      - "traefik.http.routers.unifi-rtr.service=unifi-sevi"
      - "traefik.http.services.unifi-sevi.loadbalancer.server.port=8443"
      - "traefik.http.services.unifi-sevi.loadbalancer.server.scheme=https"
      - "traefik.http.services.unifi-sevi.loadbalancer.serversTransport=unifi-trans"
      - "traefik.http.serversTransports.unifi-trans.insecureSkipVerify=true"

- "traefik.docker.network=proxy"

networks:
proxy:
external: true

Da ich aktuell noch den Port 8080 für den Websocker von Edomi benötige ist der Unifi Inform Port auf 8090 umgezogen.
Das erfordert aktuell noch manuelle Nacharbeit, indem man auf den Switchen und AP einmal per ssh drauf muss und folgendes ausführt

Code:

set-inform http://<docker-host-ip>:8090/inform

Unter PiHole einen CNAME Eintrag erstellen:

unifi.my-domain.de zeigt als CNAME Record auf docker-host.my.domain.de

Damit ist der Unifi Controller über https://unifi.my-domain.de erreichbar.
Der Port hat sich damit auf Port 443 geändert, also Standard https.
Für die interne Weiterleitung auf den Port 8443 des Containers wurde die Zertifikatsvalidierung deaktivert (insecureSkipVerify=true).
Wenn man in das DNS Scipt aus Post#2 die beiden DNS Namen mit einträgt, ist der Unifi Controller intern und extern erreichbar.
Aus Post#1 wäre nur die DNS Aktualisierung des Routers mit dem DNS Namen unifi.my-domain.de zu ergänzen.

Ich finde es beeindruckend mit wie wenig Zeilen man Zertifikate für seine Dienste aktiviert.

**Lapheus** · 12.02.2022, 22:49

So das Grundgerüst steht hiermit.

Vielleicht ist ja noch jemand dazu bereit, das hier so zu erweitern, wie im Thread von Thorsten Gehrig mit Nginx Proxy Manager.
Ich bin aktuell bei folgenden Themen noch nicht weiter gekommen:

Edomi Websocker (Port8080) Durchleitung allgemein
Edomi Websocket Umlegung auf Port 443
Auf dem virt-Traefik funktioniert die Client Zertifikat Weiterleitung noch nicht richtig.

**DerSeppel** · 13.02.2022, 19:54

Danke für die Zusammenfassung! Werde mir das morgen mal im Detail durchlesen. Ich habe zuletzt auch mit Traefik experiementiert und will die meisten meiner Docker Container eh mal auf neuer HW neu aufsetzen.
Edomi wäre dann auch auf meiner Liste zum Umzug in einen Container.

**Glotzkowski** · 06.06.2024, 12:11

Zitat von Lapheus Beitrag anzeigen

Edomi Websocket Umlegung auf Port 443

Hat das bereits jemand in traefik gemacht bzw. nutzt jemand traefik als Reverseproxy für den Zugriff auf EDOMI?

In meinem Setup habe ich bisher eine DMZ mit nginx als Reverseproxy, welchen ich gerne durch traefik ersetzen würde.
Dabei läuft traefik auf einem eigenen Docker-System in der DMZ und EDOMI auf einem anderen System (noch nicht als Docker-Container) in meinem LAN.

In den letzten Tagen konnte ich damit experimentieren und es scheint so, als ob ich ne Lösung dafür gefunden habe.
Vielleicht gibt es ja jemanden, welcher dies ebenfalls einsetzt und gebrauchen kann, da ich den nativen (unverschlüsselten) Zugriff via Websockets nicht hinbekommen habe (was ja auch gut so ist).
Die Vorlage dafür kommt von philipp900 aus dem Thread von ThorstenGehrig.

Code:

http:
  routers:
    edomi:
      tls:
        certResolver: le
        options: edomi_user_cert
      entryPoints: websecure
      rule: Host(`DNS-FQDN`) && (PathPrefix(`/visu/`) || PathPrefix(`/shared/`) || PathPrefix(`/data/`))
      middlewares:
        - security-headers
        - edomi_wss_rewrite
      service: edomi

    edomi_wss:
      tls:
        certResolver: le
        options: edomi_user_cert
      entrypoints: websecure
      rule: Host(`DNS-FQDN`) && PathPrefix(`/wss`)
      service: edomi_wss

  services:
    edomi:
      loadBalancer:
        servers:
          - url: http://192.168.0.101
        passHostHeader: true

    edomi_wss:
      loadBalancer:
        servers:
            - url: http://192.168.0.101:8080
        passHostHeader: true

  middlewares:
    edomi_wss_rewrite:
      plugin:
        plugin-rewritebody:
          lastModified: true
          rewrites:
            - regex: WebSocket\(serverProtocol\+':\/\/'\+serverIp\+':'\+serverPort\)
              replacement: WebSocket(serverProtocol+'://'+serverIp+':443/wss')

tls:
  options:
    edomi_user_cert:
      clientAuth:
        caFiles:
          - /etc/traefik/Home_CA.pem
        clientAuthType: RequireAndVerifyClientCert

Damit die Middleware für das Rewrite des JS-Content genutzt werden kann, muss das entsprechende Plugin für traefik geladen werden.
per CLI-Command im Docker-Compose-File geht dies z.B. so:

Code:

      - --experimental.plugins.plugin-rewritebody.modulename=github.com/traefik/plugin-rewritebody
      - --experimental.plugins.plugin-rewritebody.version=v0.3.1

**starwarsfan** · 06.06.2024, 19:16

Hallo miteinander

In meinem Edomi-Image sowie im ProxMox-Template braucht es keinen separaten Port für den Websocket mehr, dort geht alles via http Port 80 (bzw. welchen Port man auch immer beim Docker-Image konfiguriert). Was noch nicht geht ist https aber da man i.d.R. genau dafür einen Reverse-Proxy vor den eigentlichen Applikationen hat, ist der Bedarf IMHO nicht wirklich gross.

Ankündigung

EDOMI über Traefik als Reverse-Proxy, als Erweiterung Traefik als IPv4 zu IPv6 Tunnel

[Handbuch] EDOMI über Traefik als Reverse-Proxy, als Erweiterung Traefik als IPv4 zu IPv6 Tunnel

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar