Traefik ist mit der wichtigste Teil in der ganzen Installation da darueber die Browser-Zugriffe auf die Container verteilt werden und auch ein Zertifikat fuer https zur Verfuegung gestellt wird.

Traefik muss auf einem Manager Node installiert werden.

apt install apache2-utils (Für htpasswd um den Passwort Hash fuer Broser Benutzer erstellen zu koennen)

export EMAIL=meinname@beispiel.de
export DOMAIN=traefik.net17.porz

Hiermit erzeugen wir jetzt fuer den Benutzer admin mit Passwort „secure_password“ einen Hashwert. Das wird dann nachher beim Browserzugriff abgefragt.

htpasswd -nb admin secure_password

Dann noch ein eigenes Netzwerk für Trafik in Docker anlegen über das nachher der Kontakt der Container zu traefik stattfindet und wodurch traefik auch automatische neue Container erkennen kann und diese zugreifbar macht.

docker network create --driver=overlay traefik_proxy (Der Name des Netzwerkes am Ende des Befehls ist egal, er muss nur nachher in jedem compose-file verwendet werden)
docker network ls (Test ob das neue Netzwerk angelegt wurde)

Dann noch die beiden Manager mit Labels versehen so das traefik nur darauf startet. Der Grund ist die schon oft erwähnte Cluster-IP Adresse (172.17.200.24 und .25) da diese nur auf einem dieser beiden Nodes verfuegbar ist.

Dazu mit

docker node ls
ID                            HOSTNAME      STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
h1ueklwju2myqotsbpkqhuknl *   dockerman01   Ready     Active         Leader           20.10.21
n4u23ksil3wqdp4ee4iz5n43j     dockerman02   Ready     Active         Reachable        20.10.21
tjghr95cvd5bf8cvz5qcxn2du     dockerwrk02   Ready     Active                          20.10.21
jfctstt12sri9q0fr4snnxaa3     dockerwrk04   Ready     Active                          20.10.21

die IDs der beiden Manager rauskriegen und dann mit den Befehlen

docker node update --label-add traefik-node=true h1ueklwju2myqotsbpkqhuknl
docker node update --label-add traefik-node=true n4u23ksil3wqdp4ee4iz5n43j

die Labels vergeben. Die Labels sind quasi nur Notizen die zu einem Node gehoeren und nachher in Konfigurationen fuer Dienste benannt werden koennen. So kann z.B. ein bestimmter Container nur auf einem bestimmten PI gestartet werden falls gewuenscht.

Jetzt bereiten wir noch einen Benutzer und andere Angaben fuer traefik vor:

export USERNAME=admin
export DOMAIN=traefik.net17.porz
export EMAIL=name@beispiel.de
export PASSWORD=EIN_PASSWORT

das Passwort wandeln wir dann in einen Hash um mit dem Befehl

export HASHED_PASSWORD=$(openssl passwd -apr1 $PASSWORD)

oder so falls das Klartext-Passwort nicht in einer Umgebungsvariable rumdümpeln soll, es wird dann danach gefragt:

export HASHED_PASSWORD=$(openssl passwd -apr1)

Mit

echo $HASH_PASSWORD

sollte jetzt sowas wie „$apr1$89eqM5Ro$CxaFELthUKV21DpI3UTQO.“ rauskommen.

Für traefik benutze ich auf meinem NFS drei Verzeichnisse:

mkdir -p /docker/data/volumes/traefik/certs
mkdir /docker/data/volumes/traefik/conf
mkdir /docker/data/volumes/traefik/data

Im Verzeichnis certs liegen meine Zertifikate die ich selbst für meine interne Domain erstellt habe (siehe unten).

Es gibt jetzt drei Dateien die wir konfigurieren muessen.

1. /docker/data/compose/traefik/mn-traefik.yml (Konfiguration des traefik Service in Docker)
2. /docker/data/volumes/traefik/conf/dynamic_conf.yml (Dynamische traefik Konfiguration, kann zur Laufzeit angepasst werden)
3. /docker/data/volumes/traefik/data/traefik.yml (Statische traefik Konfiguration, wird nur beim Start von traefik geladen)

Jetzt braucht man noch eine compose Datei für traefik um es schlussendlich in den Swarm aufzunehmen. Eine Vorlage kann man aus dem Internet laden mit dem Befehl:

curl -L dockerswarm.rocks/traefik.yml -o traefik.yml

Damit hat man eine Grundlage mit allen wichtigen Befehlen. Ich habe einige Stellen darin angepasst weil ich die nicht brauche oder meine Umgebung anders ist.

version: "3"
services:
  traefik:
    image: traefik:latest
    ports:
      - 80:80
      - 82:82
      - 443:443
      - 8080:8080
    command: --docker --docker.domain=net17.porz --providers.file.directory=/mnconf/ --providers.file.watch=true --entrypoints.http.address=:80 --entrypoints.https.address=:443 --accesslog --log --api
    deploy:
      placement:
        constraints:
          - node.labels.traefik-node == true
      labels:
        - traefik.enable=true
        - traefik.docker.network=traefik_proxy
        - traefik.http.middlewares.traefik-auth.basicauth.users=admin:$$2y$$05$$IPSaQ2uuefW/TuvwT773UOuShpxNYcuTNdwEXqUBYaju3IbeqqPbK
        - traefik.http.routers.traefik.entrypoints=http
        - traefik.http.middlewares.https-redirect.redirectscheme.scheme=https
        - traefik.http.middlewares.https-redirect.redirectscheme.permanent=true

        - traefik.http.routers.traefik_proxy-http.rule=Host(`traefik.net17.porz`)
        - traefik.http.routers.traefik_proxy-http.entrypoints=http
        - traefik.http.routers.traefik_proxy-http.middlewares=https-redirect

        - traefik.http.routers.traefik_proxy-https.rule=Host(`traefik.net17.porz`)
        - traefik.http.routers.traefik_proxy-https.entrypoints=https
        - traefik.http.routers.traefik_proxy-https.tls=true

        # Use the special Traefik service api@internal with the web UI/Dashboard
        - traefik.http.routers.traefik_proxy-https.service=api@internal

        # Define the port inside of the Docker service to use
        - traefik.http.services.traefik_proxy.loadbalancer.server.port=8080
    networks:
      - traefik_proxy

    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /docker/data/volumes/traefik/data/traefik.yml:/traefik.yml:ro
      - /docker/data/volumes/traefik/data/acme.json:/acme.json
      - /docker/data/volumes/traefik/logs/:/var/log/traefik/
      - /docker/data/volumes/traefik/conf/:/mnconf/
      - /docker/data/volumes/traefik/certs/:/certs/
      - /docker/data/volumes/traefik/conf/dynamic_conf.yml:/mnconf/dynamic_conf.yml:ro

networks:
  traefik_proxy:
    external: true

Traefik hat zwei Arten der Konfiguration, statische und dynamische. Manche Befehle und Konfigurationen gibt es nur als statische, manche nur als dynamische Version. Die dynamische findet bei mir über eine Datei dynamic_conf.yml statt und die statische über eine Datei die trafik.yml heisst aber woanders liegt.

Unter conf liegt die dynamische dynamic_conf.yml

root@dockerman01:/docker/data/compose# cat ../volumes/traefik/conf/dynamic_conf.yml 
tls:
  certificates:
    - certFile: /certs/net17.porz-crt.pem
      keyFile: /certs/net17.porz-key.pem
      stores:
        - default
  stores:
    default:
      defaultCertificate:
        certFile: /certs/net17.porz-crt.pem
        keyFile: /certs/net17.porz-key.pem
    Store0:
      defaultCertificate:
        certFile: /certs/net17.porz-crt.pem
        keyFile: /certs/net17.porz-key.pem
  options:
    default:
      minVersion: VersionTLS12
      cipherSuites:
        - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
        - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        - TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305
        - TLS_AES_128_GCM_SHA256
        - TLS_AES_256_GCM_SHA384
        - TLS_CHACHA20_POLY1305_SHA256
      curvePreferences:
        - CurveP521
        - CurveP384
      sniStrict: true
http:
  middlewares:
    secHeaders:
      headers:
        browserXssFilter: true
        contentTypeNosniff: true
        frameDeny: true
        sslRedirect: true
        #HSTS Configuration
        stsIncludeSubdomains: true
        stsPreload: true
        stsSeconds: 31536000
        customFrameOptionsValue: "SAMEORIGIN"

Unter data liegt die statische traefik.yml:

api:
  dashboard: true
  insecure: true
entryPoints:
  dns:
    address: ":53"
  http:
    address: ":80"
  https:
    address: ":443"
providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
    watch: true
    swarmMode: true
  file:
    directory: "/mnconf/"
    watch: true
log:
  level: DEBUG
  filePath: "/var/log/traefik/traefik.log"
accessLog:
  filePath: "/var/log/traefik/access.log"

Jetzt kann man endlich traefik ausrollen und starten

docker stack deploy -c traefik.yml traefik

es dauert allerdings beim ersten Start wieder eine Weile bis das herunterladen beendet ist. Mit

docker container ls

kann man beobachten ob sich schon was getan hat. Als Schreibfaule kann man auch

watch docker container ls

benutzen. Das Ganze kann man dann mit CTRL+C bzw. STRG+C abbrechen.

Danach kann auf das traefik Dashboard per Browser zugegriffen werden: http://172.17.200.24:8080

Nicht wundern das da schon Port 53 aufgeführt wird. Den hatte ich schon testweise als Entrypoint konfiguriert da ich den nachher für DNS bzw. Pihole brauche.

Um unsere Dienste auch verschluesselt zur Verfuegung zu stellen brauchen wir ein Zertifikat. Man kann sich einerseits eines kostenfreies von zum Beispiel Let's Encrypt holen, ein kommerzielles kaufen oder, wie ich es gemacht habe, ein selbsterselltes benutzen.

Das Wahl fiel auf ein selbsterstelltes Zertfikat da ich ein generisches Zertfikat moechte und dieses nur kommerziell fuer richtig Geld verfuegbar ist. Ich haette natuerlich auch mehrere Let's Encrypt Zertifikate verwenden koennen aber das war mir zu viel Aufwand und Arbeit die zu erstellen und zu verwalten.

Normalerweise gibt es eine 1:1 Beziehung zwischen Servername www.beispiel.de und dem Namen der im Zertifikat hinterlegt ist. Wenn das nicht uebrein stimmt gibt es eine Warnung vom Browser, die Verbindung ist zwar nach Bestaetigung trotzdem verschluesselt aber es verunsichert Nutzer.

Da ich diverse Dienste benutze wie apache Webbrowser, traefik, iobroker, pihole usw. wuerde ich auch mehrere Einzelzertifikate benoetigen, daher die Idee ein generisches *.beispiel.domain zu verwenden. Diese gilt fuer alle Namen wie apache.beispiel.domain, traefik.beispiel.domain usw.

Das Zertfikat und alles was dazu benoetigt wird erstellen wir durch den openssl Befehl auf der Linuk Konsole. Als erstes muessen wir uns eine kurze Konfigurationsdatei erstellen:

  mkdir ssl-cert
  cd ssl-cert

Hier legen wir jetzt eine Datei openssl.ss.cnf an mit folgendem Inhalt:

basicConstraints=CA:FALSE
subjectAltName=DNS:*.beispiel.domain
extendedKeyUsage=serverAuth

Dann erstellen wir noch ein Skript gen_wildcard.sh mit folgendem Inhalt:

echo Erstelle CA Key
openssl genrsa -des3 -out CAPrivate.key 4096
echo Erstelle CA Cert
openssl req -x509 -new -nodes -key CAPrivate.key -sha256 -days 365 -out CAPrivate.pem
echo Erstelle Domain private Key
openssl genrsa -out beispiel.domain-key.pem 4096
echo CSR fuer beispiel.domain erzeugen
openssl req -new -key beispiel.domain-key.pem -extensions v3_ca -out beispiel.domain-csr.csr
echo beispiel.domain Certificate erzeugen
openssl x509 -req -in beispiel.domain-csr.csr -CA CAPrivate.pem -CAkey CAPrivate.key -CAcreateserial -extfile openssl.ss.cnf -out beispiel.domain-crt.pem -days 3650 -sha256

Auf die Einzelheiten der Zertfikatserzeugung gehe ich mal nicht ein da das ein ganzer Artikel waere und man dazu im Internet eigentlich genug Informationen findet.