Wie langjährige Leser meines Blogs oder Zuschauer meines YouTube Kanals wissen, nutze ich primär Traefik als Reverse Proxy unter Docker. Über die letzten Jahre hat sich entsprechend etwas an Know how angesammelt. Durch einenBeitrag (externer Link) auf Mastodon vonThomas Leister (externer Link) bin ich darauf gekommen auch mal http3 zu aktivieren. Was du entsprechend tun musst, um das bei dir ebenfalls einzurichten habe ich hier aufgeschrieben.

Vorteile von http3

HTTP/3 (externer Link) ist die neueste Version des Hypertext Transfer Protocols (HTTP) und bringt mehrere Vorteile gegenüber seinen Vorgängerversionen, insbesondere HTTP/1.1 und HTTP/2, mit sich. Hier sind einige der wichtigsten Vorteile von HTTP/3:

1. Schnellerer Verbindungsaufbau: HTTP/3 verwendet dasQUIC (externer Link) -Protokoll (Quick UDP Internet Connections), das auf UDP (User Datagram Protocol) basiert. Im Vergleich zu TCP (Transmission Control Protocol), das in vorherigen HTTP-Versionen verwendet wurde, ermöglicht QUIC einen schnelleren Verbindungsaufbau. Es beseitigt die Latenz, die durch den sogenannten “Handshake” in TCP verursacht wird.

2. Multiplexing ohne Head-of-Line-Blocking: HTTP/3 unterstützt effizientes Multiplexing von Anfragen und Antworten. Im Gegensatz zu HTTP/1.1, bei dem eine Verbindung nur eine Anfrage gleichzeitig behandeln kann (Head-of-Line-Blocking), können bei HTTP/3 mehrere Anfragen und Antworten gleichzeitig übertragen werden. Dies verbessert die Effizienz und verkürzt die Ladezeiten von Webseiten.

3. Bessere Leistung bei Netzwerkproblemen: HTTP/3 wurde entwickelt, um besser mit Netzwerkproblemen umzugehen. Das QUIC-Protokoll ermöglicht es, Verbindungen beizubehalten, auch wenn sich die Netzwerkbedingungen ändern. Dies trägt dazu bei, dass die Leistung aufrechterhalten wird, selbst wenn es zu Paketverlusten oder Netzwerkwechseln kommt.

4. Adaptivität: HTTP/3 wurde entwickelt, um sich besser an verschiedene Netzwerkbedingungen anzupassen. Es kann sich automatisch an veränderte Latenzen und Bandbreiten anpassen, um eine optimale Leistung zu gewährleisten.

5. Verbesserte Sicherheit: HTTP/3 unterstützt standardmäßig Verschlüsselung durch Transport Layer Security (TLS). Die Integration von TLS in den Kern des Protokolls trägt zur Sicherheit der Datenübertragung bei.

6. Flexibilität: HTTP/3 ist so konzipiert, dass es besser mit den Anforderungen moderner Webanwendungen und Dienste umgehen kann. Durch die kontinuierliche Entwicklung des Protokolls können zukünftige Anforderungen besser erfüllt werden.

Es ist wichtig zu beachten, dass die Einführung von HTTP/3 nicht nur von den Vorteilen, sondern auch von der Unterstützung auf Server- und Clientseite abhängt. Nicht alle Webserver und Browser unterstützen möglicherweise bereits HTTP/3, aber die Akzeptanz nimmt stetig zu.

Anpassen der traefik Konfiguration

Ich verwendet primär dietraefik.yml Datei um alles zu konfigurieren. Nutzt du mehr Labels, musst du das natürlich umbauen. Mit traefik 2.11 und 3 muss noch die experimentelle Funktion aktiviert werden. Dies kann zu einem späterern Zeitpunkt nicht mehr notwendig sein.

experimental:http3:true

Nun sind noch die Entrypoints anzupassen. meiner heißtwebsecure für die Verbindung von https. Entsprechend brauchen wir hier nur

http3:advertisedPort:'443'

hinzuzufügen. Der vollständigkeit halber sieht mein kompletter Block so aus:

entryPoints:ping:address:':88'web:address:':80'http:redirections:entryPoint:to:websecurescheme:httpswebsecure:address:':443'http:http3:advertisedPort:'443'proxyProtocol:trustedIPs:-10.0.0.0/8-172.16.0.0/12-192.168.0.0/16forwardedHeaders:trustedIPs:-10.0.0.0/8-172.16.0.0/12-192.168.0.0/16

Natürlich reicht das nicht ganz aus. Wie ihr seht, veröffentliche ich Port443 um http3 auszuliefern. Da http3 aber via QUIC über UPD kommuniziert, muss auch diedocker-compose.yaml Datei angepasst werden.

Die Portkonfiguration sieht dann entsprechen so aus:

ports:-target:80published:80protocol:tcpmode:host-target:443published:443protocol:tcpmode:host-target:443published:443protocol:udpmode:host

Der letztetarget Block ist der wichtige. Hier wird Port 443 auf udp ausgeliefert. Abschließend noch den Container neu starten

docker compose rm -sf&& docker compose up -d

Solltest du mehr als nur Traefik in der Datei haben, werden diese Services entsprechend auch neu gestartet. Ich empfehle zukünftig traefik zu separieren.

Mit diesem Traefik letsencrypt Tutorial möchte ich dir helfen einfach und sauber Zertifikate via freier CA Let’s Encrypt zu beantragen und zu verwalten. In diesem Tutorial gehe ich auf die Punkte http-challenge, dns-challenge sowie weiteres Zertifikatsmanagement ein. Sollte Dir ein Punkt fehlen, schreibe mir dazu gerne in Kommentare.

Solltest Du auf dieses Tutorial gestoßen sein, weil du Docker nutzt, kann ich dir meinedocker-compose Sammlung auf GitHub (externer Link) sehr ans Herz legen. Dort sind gerade für das ThemaHomelab sehr viele Softwareprodukte hinterlegt die eine direkteTraefik (externer Link) Anbindung realisieren. Sicherlich ist auch meine Traefik Konfiguration ein guter Startpunkt für ein gutes Gelingen.

Traefik Grundkonfiguration

Traefik lässt sich über mehrere Wege konfigurieren. Hierbei spielt es keine Rolle ob man sämtliche Befehle und Konfigurationen direkt in die docker-compose Datei oder in separate Dateien packt. Ich für meinen Teil verwende dedizierte um eine einfachere und übersichtliche Konfiguration zu haben. Solltest du einen anderen Weg bevorzugen ist dies für dieses Traefikletsencrypt (externer Link) Tutorial nicht wichtig. Du musst natürlich nur die Einstellungen adaptieren.

Das ist ist meine Docker Compose Beispielkonfiguration welche ich normalerweise einsetze. Je nach Umgebung kann diese aber natürlich ein wenig variieren. Ich gebe auch immer http3 mit aus, einfach weil ich es mag neue Standard direkt mit zu implentieren.

---services:traefik:image:traefik:v3container_name:traefikvolumes:-/etc/localtime:/etc/localtime:ro-/etc/timezone:/etc/timezone:ro-/var/run/docker.sock:/var/run/docker.sock-/var/log/auth.log:/var/log/auth.log:ro-/var/log/traefik:/var/log/traefik-./config:/etc/traefiknetworks:-traefik_proxy-defaultports:-target:80published:80protocol:tcpmode:host-target:443published:443protocol:tcpmode:host-target:443published:443protocol:udpmode:hostrestart:unless-stoppednetworks:traefik_proxy:external:truedefault:driver:bridge

Anschließend brauchen wir natürlich noch die zwei Dateien die wir oben als Volume angegeben haben. Starten wir mit dertraefik.yaml Diese beinhaltet alle notwenigen Eigenschaften umTraefik sauber ans laufen zu bekommen.

---log:level:"INFO"filePath:"/var/log/traefik/traefik.log"accessLog:filePath:"/var/log/traefik/access.log"bufferingSize:100providers:docker:endpoint:"unix:///var/run/docker.sock"exposedByDefault:falsenetwork:"traefik_proxy"file:filename:"/etc/traefik/dynamic.yml"watch:trueapi:dashboard:falseentryPoints:ping:address:':88'web:address:':80'http:redirections:entryPoint:to:websecurescheme:httpswebsecure:address:':443'http3:proxyProtocol:trustedIPs:-10.0.0.0/8-172.16.0.0/12-192.168.0.0/16forwardedHeaders:trustedIPs:-10.0.0.0/8-172.16.0.0/12-192.168.0.0/16certificatesResolvers:default:acme:email:"deine@email-adresse.example"#Email Adresse hier anpassenstorage:"/etc/traefik/ACME/acme.json"httpChallenge:entryPoint:webtls_resolver:acme:email:"deine@email-adresse.example"#Email Adresse hier anpassenstorage:"/etc/traefik/ACME/acme.json"tlsChallenge:{}

Gehen wir die Punkt einmal durch:

[log]

Das Loglevel sollte für den produktiven Betrieb so gewählt werden, dass nach Möglichkeit nicht die Festplatte voll läuft. Für den Beginn ist es evtl. ratsam hier aufDEBUG umzustellen um mehr zu sehen und um Fehler leichter erkennen zu können.

[providers]

Wir nutzen für diese Beispielkonfiguration Docker. Wir möchten allerdings nicht, dass grundsätzlich alleDocker Container via Traefik veröffentlicht werden (exposedByDefault = false) und setzen die jeweiligen Anpassungen für jeden Container dediziert. Traefik lassen wir auf den Docker Socket hören um zu wissen was Traefik so machen muss. Gegebenenfalls musst du den Parameter „network“ anpassen. Ich nutze hierfür immer „traefik_proxy“ als Netzwerk. Möchtest du das ebenfalls nutzen musst du

docker network create traefik_proxy

ausführen und das Netzwerk anzulegen.

[api]

Das Dashboard brauchen wir hierfür nicht, wird also deaktiviert

[entryPoints]

Die entryPoints sind die Ports und Protokolle auf die Traefik hört. Stand jetzt kann Traefik nur HTTP/HTTPS Traffic. Weitere Protokolle sollen in Zukunft kommen. Wir lauschen natürlich auch auf Port 80 (HTTP) und machen eine direkte Weiterleitung auf Port 443 (HTTPS). Unverschlüsselte Kommunikation sollte nur in Ausnahmefällen noch erlaubt sein.

Wie du siehst binden wir auch eine dynamic.yml Datei ein. Diese hat folgenden Aufbau

---tls:options:default:minVersion:VersionTLS12cipherSuites:-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_SHA256curvePreferences:-CurveP521-CurveP384sniStrict:truehttp:middlewares:default:chain:middlewares:-default-security-headers-gzipdefault-security-headers:headers:browserXssFilter:truecontentTypeNosniff:trueforceSTSHeader:trueframeDeny:truestsIncludeSubdomains:truestsPreload:truestsSeconds:31536000customFrameOptionsValue:"SAMEORIGIN"gzip:compress:{}

Die dynamic.yml ist zur Konfiguration aller Sicherheitsmerkmale gedacht. Bitte passe diese nach den aktuellen Gegebenheiten an, da sich gerade die Cipher Suites häufig ändern können! Die restlichen Werte sind nach langjähriger Erfahrung von mir so zusammen getragen und müssen nicht dem aktuellen Sicherheitsstandards entsprechend. Für Tipps bin ich aber dankbar und passe die Datei dann gerne an.

Traefik letsencrypt tlsChallenge

Mit der tlsChallange ist es wahrscheinlich die einfachste Variante Zertifikate via Let’s encrypt zu beantragen. Hier kann Traefik direkt so konfiguriert, bzw. über die Docker Konfiguration so eingerichtet werden, dass nur Port 443, also HTTPS, veröffentlicht werden muss. Möchte man nur ein paar wenige Zertifikate beantragen ist das meiner Meinung die empfehlenswerte Version.

Die Konfiguration der tlsChallenge ist ziemlich einfach. Man fügt in der traefik.toml Datei folgende Zeilen am Ende ein:

certificatesResolvers:default:acme:email:"deine@email-adresse.example"#Email Adresse hier anpassenstorage:"/etc/traefik/ACME/acme.json"

Email-Adresse ist für die Benachrichtigung von Let’s encrypt an dich gedacht. Entsprechend empfehle ich hier eine valide Email-Adresse anzugeben. Die Storage Angabe ist der Speicherort der Zertifikate. Entsprechend muss in der Docker Konfiguration auch das beachtet werden.

Traefik letsencrypt httpChallenge

Die httpChallenge ist quasi das gleich wie die tlsChallenge, allerdings via Port 80 anstatt 443. Hier muss als in der Docker Konfiguration auch Port 80 veröffentlicht werden. So ergibt sich daraus folgender Inhalt für die traefik.toml:

certificatesResolvers:default:acme:email:"deine@email-adresse.example"#Email Adresse hier anpassenstorage:"/etc/traefik/ACME/acme.json"httpChallenge:entryPoint:web

Traefik letsencrypt dnsChallenge (am Beispiel Cloudflare)

Die dnsChallenge ist quasi die Königsdisziplin. Allerdings nur wirklich dann sinnvoll wenn man z. B. Wildcard Zertifikate benötig oder wenn man viele Subdomainzertifikate benötigt. Entsprechend muss man hier auch ein wenig mehr konfigurieren und vor allen Dingen benötigt man einen DNS Provider der von Let’s encrypt unterstützt wird. Ich empfehle hier Cloudflare.

certificatesResolvers:default:acme:email:"mail@teqqy.de"storage:"/etc/traefik/ACME/acme.json"dnsChallenge:provider:"cloudflare"resolvers:-"1.1.1.1:53"-"1.0.0.1:53"

Hinzu kommt, dass wir in derdocker-compose.yaml noch den API Token für die Cloudflare API hinzufügen. Dazu einfach noch folgende Zeilen einfügen:

environment:CF_DNS_API_TOKEN:"{STRENGGEHEIMERAPIKEY}"

Zertifikate löschen

Zertifikate werden in deracme.json Datei gespeichert und könnten dort heraus gelöscht werden. Zu jedem Zertifikat gibt es einecertificate undkey Definition. Man kann also die Datei entsprechend editieren und die Zeichenketten entsprechend heraus löschen.

 {"domain": {"main":"teqqy.de","sans": ["www.teqqy.de" ] },"certificate":"<Zeichenkette>","key":"<Zeichenkette>","Store":"default" },

Notwendig ist dies aber nur dann, wenn bei der Erstellung ein Fehler aufgetreten ist oder Let’s Encrypt Zertifikate wg. Fehlern zurückruft. Andernfalls laufen die Zertifikate automatisch nach 90 Tagen ab. Ein manuelles Aufräumen ist nicht notwendig.

In allen meiner Tutorials verwende ich Traefik alsReverse Proxy für Docker Container, so natürlich auch auf meinemYouTube Kanal (externer Link) . Im Laufe der Zeit fragen immer wieder Leser und Zuschauer ob ich ihnen bei ihrem Problem helfen kann. Dies mache ich natürlich gerne. Für ein gewisse Selbsthilfe möchte ich dir allerdings diesen Traefik Troubleshooting Guide an die Hand geben.

Vorbereitende Maßnahmen

Um mit einem guten Troubeshooting zu beginnen möchte ich zwei Maßnahmen vorweg greifen. Diese helfen dir ein paar Dinge auszuschließen bzw. eventuell schnell selbst auf eine Lösung zu kommen.

Container richtig neu starten

Wenn ihr Änderungen am Container von Traefik oder gar an den Konfigurationsdateien vornimmt, muss Traefik komplett neu gestartet werden. Ein stoppen des jeweiligen ist nicht ausreichend. Beimeinen Compose Dateien (externer Link) verwende also bitte nach dem stoppen noch ein

docker-compose rm

um diesen komplett zu löschen. Anschließend kannst du den Container wieder starten und eine neue Konfiguration ist übernommen.

Erhöhen des Log Levels

Zum Traefik Troubleshooting gehört auf jeden Fall auch das betrachten der Log Dateien. In meiner Vorlage steht das Logging auf einer sehr kleinen Stufe um nicht unnötig Speicherplatz zu benötigen. Wenn du mit Traefik startest empfehle ich dir, dieses auf debug zu stellen.

Hierzu einfach die traefik.toml Datei anpassen:

[log]
level = "DEBUG"

Fehlerlösungen

Die Webseite wird als nicht sicher angezeigt

Dieser Fehler entsteht zumeist wenn Traefik keinLet’s Encrypt (externer Link) Zertifikat abrufen konnte. Leider kann das mehrere Ursachen haben:

Zu häufiges Abrufen von Zertifikaten

Im Log steht hier meist, dass die Anzahl der Möglichen Erstellversuche von Zertifikaten erreicht ist. LE lässt es nur zu 10 Versuche binnen 24 Stunden auf ein SSL-Zertifikat zu erstellen. Wenn du eine eigene Domain hast, versuche es mit einer anderen Subdomain erneut. Andernfalls hilft nur warten.

Ein anderer Container hört auf Port 80

Let’s Encrypt nutzt bei der ersten Kommunikation zwischen Server und Client auch HTTP (Port 80). Wenn dieser Port also noch durch einen anderen Container geblockt ist kann keine Verbindung aufgebaut werden. Ebenso könnte es sein, dass dein NAT in deinem Router Port 80 noch nicht weiter leitet.

Eine 404-Seite wird angezeigt

Jetzt wird es spannend. Sobald eine 404-Seite angezeigt wird, gibts nämlich ein Problem mit dem Routing zu den Containern. Folgende Dinge kannst du hier prüfen:

• Wird der korrekte Port weiter geleitet?
• Stimmen alle Middlewere-Configs überein?

k3s ist eine schlanke Variante zum vollen Kubernetes (k8s) Stack. Derk3s (externer Link) Cluster lässt sich daher mit wenigen Schritten installieren und einrichten. Dieses Tutorial beschreibt dir wie du den k3s Cluster installieren kannst.

Voraussetzungen

Für dieses Tutorial gibt es ein paar Voraussetzungen:

• Mindestens zwei Linux Systeme (egal ob VM oderRaspberry Pi (externer Link) ) mit mind. 2 Kernen und 1 GB RAM
• Grundlegende Kenntnisse von Linux
• Die Fähigkeit Tutorials komplett zu lesen (entschuldige den Sarkasmus)

Vorbereitungen

Solltest du eine VM verwenden, musst du nichts weiter vorbereiten als dein System auf den aktuellen Stand zu patchen. Zudem wäre es empfehlenswert, wenn du feste IP-Adressen verwenden würdest. Andernfalls kannst du natürlich auch die Kommunikation via DNS machen, dann benötigst du aber ein zuverlässiges DNS!

Solltest du allerdings einenRaspberry Pi (externer Link) verwenden müssen wir noch etwas am boot Prozess einstellen. Und zwar erweitern wir die cmdline.txt Datei. Diese liegt bei Rasbian und Ubuntu (ja auch das gibts für denRPi (externer Link) ) unter verschiedenen Orten:

Rasbian

sudo vim /boot/cmdline.txt

Ubuntu

sudo vim /boot/firmware/cmdline.txt

Am Ende der Zeile fügen wir noch folgendes ein

cgroup_enable=1 cgroup_memory=1 cgroup_enable=memory

Solltest du das bei den Raspberry Pis nicht tun, wird k3s nicht starten!

k3s Cluster installieren

Master installieren

Fangen wir mir dem Master an. Dieser lässt sich quasi mit copy & paste von der k3s.io Webseite kopieren. Allerdings wollten wir ja die Installation ein wenig anpassen. Wir verwenden z. B. MetalLB als Cluster Load Balancer um IP Adressen aus dem normalen Netzbereich unseres Netzwerkes zu verwenden. Zudem bin ich ein Fan von Traefik. Zwar kommt der k3s Cluster im Standard schon mit Traefik daher, allerdings wollen wir die Funktion erweitern. Entsprechend müssen wir die Installation ein wenig abändern.

curl -sfL https://get.k3s.io | sh -s - --disable traefik --disable servicelb

Nach ein paar Augenblicken sollte der Cluster soweit sein. Wir kontrollieren das mit

kubectl get nodes

Und sollten eine Node sehen die den Status ready hat.

Agenten hinzufügen

Diesen Schritt wiederholst du entsprechend so oft wie viele Agenten du zu dem Cluster hinzufügen möchtest.

Allerdings benötigen wir als erstes deinen Token um die verschlüsselte Kommunikation zu erlauben. Diesen lesen wir wie folgt aus

cat /var/lib/rancher/k3s/server/node-token

Es erscheint eine lange Zeile aus Buchstaben und Zahlen z. B.

K10c8c26950c31536167a7a38f11979060f977cf33cfe10a5e7b130e057a8e1d4df::server:de0d941e347301d8ac112e4c2ef2826b

Natürlich sieht das bei dir anders aus, daher ist ein einfaches kopieren aller Befehle in diesem Tutorialnicht möglich.

Nun verbinden wir die Agenten mit dem Master

curl -sfL https://get.k3s.io | K3S_URL=https://{IP-Server}:6443 K3S_TOKEN={Token} sh -

Passe bitte die zwei Variablen in dem Befehl an deine Gegebenheiten an.

Auf dem Master führen wir nun den Befehl

kubectl get nodes --watch

aus. Nach ein paar Augenblicken sollte der Agent dort erscheinen und nach ein paar weiteren in den Status Ready wechseln.

Da jetzt der Cluster läuft, können wir uns um MetalLB kümmern.

MetalLB installieren

MetalLB ist wie gesagt ein LoadBalancer um Anfragen über den Cluster zu verteilen. Wir werden MetalLB als Layer2 LB verwenden. Alternativen für Menschen mit mehr Netzwerkkenntnissen wären z. B. noch BGP. Layer2 reicht aber für das Homelab und benötigt keine spezielle Konfiguration an Firewall und/oder Switchen.

Die Version des Programmes ändert sich natürlich fortlaufend. Entsprechend ist zu beachten, dass du in den Befehlen die Version auf den neusten Stand bringst. Am besten ist, du wirfst immer vorher ein Blick in die offizielleDokumentation (externer Link) .

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.9.5/manifests/namespace.yaml
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.9.5/manifests/metallb.yaml
# On first install only
kubectl create secret generic -n metallb-system memberlist --from-literal=secretkey="$(openssl rand -base64 128)"

Ein paar Sekunden später ist die Grundarbeit erledigt. Jetzt legen wir noch den IP-Bereich fest, den MetalLB zur Verfügung hat. Dazu erstellen wir uns eine kleine Datei

vim ConfigMap.yaml

und fügen folgenden Inhalt ein

---apiVersion:v1kind:ConfigMapmetadata:namespace:metallb-systemname:configdata:config:| address-pools: - name: default protocol: layer2 addresses: - 192.168.10.50-192.168.10.59

Den IP-Bereich unten passt du bitte so an, dass er bei dir passt!

Last but not leased benötigen wir noch einen reverse proxy. Wie immer bei mir: Traefik.

Traefik installieren

Für Traefik verwenden wir zwei sogenannte Manifest Dateien. Erste Datei:

vim CustomRessourceDefinition.yaml

Und da rein kommt folgender langer Inhalt

---apiVersion:apiextensions.k8s.io/v1beta1kind:CustomResourceDefinitionmetadata:name:ingressroutes.traefik.containo.usspec:group:traefik.containo.usversion:v1alpha1names:kind:IngressRouteplural:ingressroutessingular:ingressroutescope:Namespaced---apiVersion:apiextensions.k8s.io/v1beta1kind:CustomResourceDefinitionmetadata:name:middlewares.traefik.containo.usspec:group:traefik.containo.usversion:v1alpha1names:kind:Middlewareplural:middlewaressingular:middlewarescope:Namespaced---apiVersion:apiextensions.k8s.io/v1beta1kind:CustomResourceDefinitionmetadata:name:ingressroutetcps.traefik.containo.usspec:group:traefik.containo.usversion:v1alpha1names:kind:IngressRouteTCPplural:ingressroutetcpssingular:ingressroutetcpscope:Namespaced---apiVersion:apiextensions.k8s.io/v1beta1kind:CustomResourceDefinitionmetadata:name:ingressrouteudps.traefik.containo.usspec:group:traefik.containo.usversion:v1alpha1names:kind:IngressRouteUDPplural:ingressrouteudpssingular:ingressrouteudpscope:Namespaced---apiVersion:apiextensions.k8s.io/v1beta1kind:CustomResourceDefinitionmetadata:name:tlsoptions.traefik.containo.usspec:group:traefik.containo.usversion:v1alpha1names:kind:TLSOptionplural:tlsoptionssingular:tlsoptionscope:Namespaced---apiVersion:apiextensions.k8s.io/v1beta1kind:CustomResourceDefinitionmetadata:name:tlsstores.traefik.containo.usspec:group:traefik.containo.usversion:v1alpha1names:kind:TLSStoreplural:tlsstoressingular:tlsstorescope:Namespaced---apiVersion:apiextensions.k8s.io/v1beta1kind:CustomResourceDefinitionmetadata:name:traefikservices.traefik.containo.usspec:group:traefik.containo.usversion:v1alpha1names:kind:TraefikServiceplural:traefikservicessingular:traefikservicescope:Namespaced---kind:ClusterRoleapiVersion:rbac.authorization.k8s.io/v1beta1metadata:name:traefik-ingress-controllerrules:-apiGroups:-""resources:-services-endpoints-secretsverbs:-get-list-watch-apiGroups:-extensionsresources:-ingressesverbs:-get-list-watch-apiGroups:-extensionsresources:-ingresses/statusverbs:-update-apiGroups:-traefik.containo.usresources:-middlewares-ingressroutes-traefikservices-ingressroutetcps-ingressrouteudps-tlsoptions-tlsstoresverbs:-get-list-watch---kind:ClusterRoleBindingapiVersion:rbac.authorization.k8s.io/v1beta1metadata:name:traefik-ingress-controllerroleRef:apiGroup:rbac.authorization.k8s.iokind:ClusterRolename:traefik-ingress-controllersubjects:-kind:ServiceAccountname:traefik-ingress-controllernamespace:default

Hiermit werden alle benötigen Clusterweiten Ressourcen und Abhängigkeiten eingerichtet. Anschließend brauchen wir natürlich noch den Container selbst.

vim Deployment.yaml

mit folgendem Inhalt

---apiVersion:v1kind:Servicemetadata:name:traefikspec:ports:-protocol:TCPname:webport:80-protocol:TCPname:adminport:8080-protocol:TCPname:websecureport:443type:LoadBalancerselector:app:traefik---apiVersion:v1kind:ServiceAccountmetadata:namespace:kube-systemname:traefik-ingress-controller---apiVersion:apps/v1kind:Deploymentmetadata:namespace:kube-systemname:traefiklabels:app:traefikspec:replicas:1selector:matchLabels:app:traefiktemplate:metadata:labels:app:traefikspec:serviceAccountName:traefik-ingress-controllercontainers:-name:traefikimage:traefik:v2.3args:- --api.insecure- --accesslog- --entrypoints.web.Address=:80- --entrypoints.websecure.Address=:443- --providers.kubernetescrd- --certificatesresolvers.myresolver.acme.tlschallenge- --certificatesresolvers.myresolver.acme.email=mail@example.com- --certificatesresolvers.myresolver.acme.storage=acme.jsonports:-name:webcontainerPort:80-name:websecurecontainerPort:443-name:admincontainerPort:8080

Nach kurzer Zeit sollte der Container auch erscheinen und den Status Ready bekommen

kubectl get pods --watch

Als letztes kontrollieren wir noch ob Traefik auch eine IP-Adresse aus dem LoadBalancer Bereich erhalten hat

kubectl get svc

Hier sollten wir eine Zeile ähnlich zu dieser haben

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
traefik LoadBalancer 10.43.43.165 192.168.10.50 80:32049/TCP,8080:31750/TCP,443:31764/TCP 18h

Jetzt kannst du beginnen entsprechende Workload auf deinen Cluster zu bringen. Allerdings derzeit nur mit lokalem Storage. In weiteren Beiträgen werde ich noch Storagemöglichkeiten beschreiben.

Vor einiger Zeit gab es von mir ein Nextcloud Docker Setup Tutorial bereits auf meinemYouTube Kanal. (externer Link) Dies ist soweit auch weiterhin aktuell. Allerdings bedarf es für eine gute Nextcloud Installation noch weiterer Konfiguration.

Um Nextcloud immer von überall aus erreichen zu können, empfehle ich dir die Installation auf einem virtuellen Server bei einem Hosting Provider. Ich nutze hierfür Netcup, welche ich sehr empfehlen kann.

Nextcloud Docker Setup als Video

Mit diesem Video hast du das Basissetup von Nextcloud. Jetzt werden wir das ganz noch etwas besser einrichten und vor allen Dingen die Warnungen aus dem Administrationsbereich beseitigen.

Wenn du Nextcloud nicht in deinem Homelab selbst hosten möchtest, empfehle ich dir Netcup als Hostingunternehmen. Meine langjährige Erfahrung mit Netcup hat mit gelehrt das ein zuverlässiger Partner im Bereich Hosting Gold wert ist. Auch wenn das manchmal ein paar Euro im Jahr mehr kostet.

Aktuelle Compose Datei verwenden

MeineDocker Compose Dateien (externer Link) ändern sich zwischendurch. Beachte also bitte, dass du die aktuellen Dateien verwendest. Dieses Tutorial ist fürTraefik als reverse proxy ausgelegt. Solltest du etwas anderes nutzen wollen, musst du dir diverse Einstellungen herleiten. Gerade auch die Traefik Konfiguration ändert sich, gerade was die Sicherheitseinstellungen angeht, auch. Bitte updatete daher gegebenenfalls auch diese.

Installation durchführen

Nun kannst du die Installation, wie im Video beschrieben, durchführen. Ich gehe entsprechend davon aus, dass du jetzt eine funktionsfähige Installation hast.

Reverse Proxy Konfiguration

Nextcloud möchte, dass wir die notwendigen Einstellungen vornehmen um der Installation die reverse proxy Konfiguration mitzugeben. Als erstes benötigen wir die IP Adresse inCIDR (externer Link) Notation unseres Traefik Containers

~~bash docker inspect traefik

Nun rattern ein paar Zeilen config durchs Bild. Interessant ist für uns eigentlich nur der letzte Abschnitt:

 "traefik_proxy": {
"IPAMConfig": null,
"Links": null,
"Aliases": [
"0d9ab883d62e",
"traefik"
],
"NetworkID": "b23ae2baa87df4b02c1cbed4679c8ea3c4ef4d2b8c8d05efb4b0bf0d94ced7f2",
"EndpointID": "44b9f2e00a25177f6084ecfa270df6be9cc75430ed64609ce60897fda8ca67b6",
"Gateway": "172.19.0.1",
"IPAddress": "172.19.0.4",
"IPPrefixLen": 16,
"IPv6Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"MacAddress": "02:42:ac:13:00:04",
"DriverOpts": null
}

Diese Informationen sind häufig unterschiedlich. Du solltest also meine Werte nicht einfach blind übernehmen. Aus dem obrigen Teil benötigen wir die Punkte „IPAddress“ und „IPPrefixLen“.
Damit editieren wir nun die config.php Datei unserer Nextcloud Installation und passen diese im Bereich „trused\_proxies“ an. Die Angabe setzt sich also aus IP-Adresse mit anschließender Netzgröße zusammen.

’trusted_proxies’ => ‘172.19.0.4/16’

### Datenbank Optimierungen durchführen
Die Übersichtsseite möchte das wir noch ein paar Änderungen in der Datenbank durchführen. Dieses machen wir, indem wir uns mit einem „docker exec“ Befehl kurz in den Container verbinden und den notwendigen Befehl der Nextcloud CLI durchführen. Beide Befehle solltest du nach Möglichkeit vor weiterer Einrichtung und Benutzung von Nextcloud durchführen. Andernfalls können diese Befehle einige Zeit in Anspruch nehmen.
~~~bash
docker exec --user www-data nextcloud-app php occ db:add-missing-indicesdocker exec --user www-data nextcloud-app php occ db:convert-filecache-bigint

Beide Befehle brauchen jeweils einen kurzen Moment. Je nach Leistung deines Servers.

Nextcloud Client Einstellungen anpassen

Damit wir den Nextcloud Client benutzen können, musste ich noch ein paar weitere Einstellungen an der config.php durchführen. Ändere die Option „overwrite.cli.uri“ ab und füge noch zwei Zeilen hinzu:

 'overwrite.cli.url' => 'https://nextcloud.example.com', 'overwriteprotocol' => 'https', 'overwritehost' => 'nextcloud.example.com',

Natürlich musst du die jeweiligen URLs an deine Installation anpassen.

Container sauber neu starten

Damit dieses Nextcloud Docker Tutorial auch wirklich funktioniert müssen wir anschließend unsere Container komplett neu starten. Erst einmal beenden wir alles

docker compose stop

und anschließend löschen wir die Container, damit die Konfiguration auch wirklich übernommen wird

docker compose rm -f

Jetzt sind wir bereit die Instanz frisch zu starten

docker compose up -d

Unter Einstellungen -> Überblick sollten also keine weiteren Meldungen mehr auftauchen.

Nun sollte dein Nextcloud Docker Setup hervorragend laufen. Sollte dem nicht so sein, tritt doch meinemDiscord Server (externer Link) bei und lass dir von der Community helfen.

Traefik nutze ich primär um als reverse proxy von extern auf meine Docker Container zugreifen zu können. Dies natürlichSSL terminiert. Verschiedene Dienste sollen allerdings nicht extern erreichbar sein und benötigen auch – aus meiner Sicht – nicht zwingend eine verschlüsstele Verbindung.

Aus diesem Grund habe ich auf meinem internen Docker ServerTraefik als reverse proxy laufen, welcher den verschiedenen Diensten via netzwerkinterner DNS-Auflösung ein DNS Namen verpasst. So kann ich z. B. viahttp://phpipam.docker.domain.local (externer Link) auf meinPHPIPAM (externer Link) Dienst zugreifen.

Voraussetzungen

• Docker Host
• Bereits eingerichtet Services (ich empfehle die Services intern immer erst mal rudimentär zu testen und dann zu erweitern)
• internen DNS Server (ich nutze hier Windows DNS)

Auf meinem Windows DNS Server lege ich im DNS eine neue primäre Zone mit dem Namen „docker.domain.local“ (entsprechend an deine Bedürfnisse anpassen). Diese erhält dann einen einzigen A-Record der als Wildcard auf den Docker-Host zeigt.

Traefik einrichten

Um Traefik dann nutzen zu können, bediene ich mich zum Teil meiner vorhandenenDocker-Compose Sammlung (externer Link) aufGithub (externer Link) . Den Traefik Container und die traefik.toml Datei wird dabei ein wenig angepasst.

traefik.toml:

[log]level ="DEBUG"[providers][providers.docker]exposedByDefault =falseendpoint ="unix:///var/run/docker.sock"network ="traefik_proxy"[entryPoints][entryPoints.web]address =":80"

docker-compose.yaml

---version:'3.3'services:traefik:image:traefik:latestcontainer_name:traefikrestart:alwaysvolumes:-/var/run/docker.sock:/var/run/docker.sock-$PWD/config:/etc/traefik-/etc/localtime:/etc/localtimeports:-"80:80"networks:-default-traefik_proxynetworks:traefik_proxy:external:truedefault:driver:bridge

Anschließend lässt sich der Container starten und ist bereit um Container als reverse proxy anzubieten.

Bei den anzubietenden Services müssen wir dann natürlich auch noch die Compose Datei anpassen. Beispielhaft hier meine zu phpIPAM:

---version:'3'services:phpipam-mysql:image:mysql:5.7container_name:phpipam-mysqlrestart:unless-stoppedvolumes:-$PWD/mysql:/var/lib/mysqlenvironment:-MYSQL_ROOT_PASSWORD=ROOTPASSWORDphpipam-phpipam:image:pierrecdn/phpipam:latestcontainer_name:phpipam-phpipamrestart:unless-stoppedenvironment:-MYSQL_ENV_MYSQL_USER=root-MYSQL_ENV_MYSQL_ROOT_PASSWORD=ROOTPASSWORD-MYSQL_ENV_MYSQL_HOST=phpipam-mysqllabels:-"traefik.enable=true"-"traefik.http.routers.phpipam-http.entrypoints=web"-"traefik.http.routers.phpipam-http.rule=Host(`phpipam.docker.domain.local`)"#Domain anpassen-"traefik.http.services.phpipam.loadbalancer.server.port=80"depends_on:-phpipam-mysqlnetworks:-traefik_proxy-defaultnetworks:traefik_proxy:external:truedefault:driver:bridge

Anschließend auch noch diese Compose Datei starten und nun lässt sich, wenn alles korrekt eingerichtet wurde, der Service als URL öffnen. So ist es wesentlich einfacherer als ich für jeden Service einen neuen Port überlegen zu müssen.

In meinen Videos verwende ich recht häufig Docker um Anwendungen zu installieren. Daher habe ich eine Docker-Compose Sammlung für Homelabs gestartet. Diese docker-compose.yaml Dateien sind von mir erstellt und/oder vorhandene editiert. Damit kannst du dein Docker Homelab schnell und einfach aufbauen.

Docker kommt beim heimischen Anwender immer mehr an. Zumindest wenn dieser technikinteressiert ist und sich auch die Arbeit damit machen möchte. Wer ein Docker Homelab starten möchte, kommt an Anfang nicht darum herum viel zu lesen. Allerdings möchte ich diesen Einstieg etwas einfacher gestalten.

Zwar gibt es immer noch das eine oder andere Problem mit dem reverse proxy (ich setze hierbei aufTraefik ), dennoch ist es mit ein paar Schritten schnell erledigt seine Lieblingsanwendung schnell und gut Verfügbar zu machen.

Auf der Plattformgithub.com (externer Link) habe ich daher einRepository (externer Link) erstellt das ständig erweitert und aktualisiert wird. Gestartet habe ich jetzt erst mal mit Nextcloud undTaefik . Hierzu wurde bereits ein Video veröffentlicht in dem ich das en detail zeige wie ihr das einrichten müsst.

Mit zukünftigen Videos wird auf dieses Repository immer hingewiesen und ich werde immer diese docker-compose.yaml Dateien verwenden. Wer mir also aufYouTube (externer Link) folgt (das solltest du, wenn du am Thema Homelab interessiert bist), wird die neusten Dateien immer mitbekommen.

Eines sei dazu aber noch gesagt: Diese Dateien sind sehr vereinfacht. Viele Dinge lassen sich anders und teils mit mehr Aufwand auch erledigen. Ich habe hier allerdings den kleinsten gemeinsamen Nenner gesucht und wohl auch gefunden. Solltet ihr Fehler entdecken, eröffnet einIssue (externer Link) beiGithub (externer Link) (wenn ihr einen Account habt) oder postet gerade in den entsprechenden Kommentaren.

Wenn dir eine bestimmte Software fehlen sollte, die du unbedingt dabei haben möchtest, bin ich natürlich gerne für Vorschläge offen. Natürlich kannst du auch ein Pull Request beiGitHub (externer Link) einreichen. Nach einer kurzen Überprüfung übernehme ich im Regelfall auch die Vorschläge der Community. So kann das Docker Homelab stetig bei allen wachsen.

Um mehrere Webseiten unter einer IP und einer Domain zu veröffentlichen, ist es am einfachsten, wenn man sich ein sogenannten reverse proxy einrichtet. Die wohl bekannte Variante dazu ist von NGINX. Hierfür gibt es auch diverse Tutorials im Internet.

Meine ganzen Services, die ich extern verfügbar machen möchte, laufen allerdings alsDocker (externer Link) Container. Entsprechend bietet es sich an, auch den reverse proxy Traefik unter Docker als Container laufen zu lassen.

Auch hier gibt es für NGINX – auch in Kombination mit Let’s encrypt Zertifikaten – reichlich Tutorials. Ich hatte mich damals allerdings für einen anderen Weg entscheiden undTraefik (externer Link) als reverse proxy genommen.

Wichtig ist natürlich, dass ihr in eurer Firewall bzw. Router ein NAT auf euren Docker Host einstellt. Port 80 (HTTP) und 443 (HTTPS) sollten entsprechend reichen.

Docker Container mittels Compose

Ich gehe erst mal davon aus, dass ihr Docker in einer der letzten Versionen installiert habt und eure Services, zumindest intern, vollständig funktionieren. Zudem nutze ich Docker Compose zum Verwalten meiner Container. Eine Adaption zu einem docker run command sollte kein Problem darstellen.

---version:'3'services:traefik:image:traefik:latestcontainer_name:traefikrestart:alwaysports:-80:80-443:443-8080:8080volumes:-/var/run/docker.sock:/var/run/docker.sock-./traefik:/etc/traefikenvironment:-"TZ=Europe/Berlin"networks:-traefik_proxy-defaultnetworks:traefik_proxy:external:truedefault:driver:bridge

Ports 80 und 443 werden benötigt, um die entsprechenden Seiten dann auch weiterzuleiten. Port 8080 verwenden wir für das Webfrontend von Traefik. Ihr müsst also aufpassen, dass keine anderen Container diese Ports verwenden. Den Traefik Webport könnt ihr auch durch einen anderen ersetzen.

Zudem mounten wir als Volumes den Docker Socket, um Zugriff auf die laufenden Container zu haben. Als zweites Volume nutzen wir für die Konfigurationsdateien für Traefik.

Netzwerke legen wir an, um Traefik von außen erreichbar zu machen (default Netzwerk) und für das interne Routing zu Containern (traefik_proxy).

Traefik Konfiguration

Im Verzeichnis traefik legen wir nun noch die Datei traefik.toml an, welche folgenden Inhalt bekommt:

logLevel ="INFO"defaultEntryPoints = ["http","https"][web] address =":8080"[docker] domain ="example.com" watch =true exposedbydefault =false# Force HTTPS[entryPoints] [entryPoints.http] address =":80" [entryPoints.http.redirect] entryPoint ="https" [entryPoints.https] address =":443" [entryPoints.https.tls]# Let's encrypt configuration[acme] email="youremail.address@example.com" storage="/etc/traefik/acme/acme.json" entryPoint="https" acmeLogging=true OnHostRule=true [acme.httpChallenge] entryPoint ="http"

Wichtig ist, dass ihr eure Domain unter [docker] und eure Email Adresse unter [acme] richtig anpasst. Die Email Adresse wird für dieLet’s encrypt Zertifikate benötigt.

Im Grundsätzlichen war es das schon für das Setup. Um jetzt Docker Container auch dazu zu bringen, auf die entsprechenden Domains zu hören, müssen wir die Konfiguration der einzelnen Container auch anpassen. Hier mal ein Beispiel von „The Lounge“ (einem IRC Frontend)

---version:'3'services:thelounge:image:thelounge/lounge:latestcontainer_name:theloungevolumes:-/var/docker/thelounge:/home/lounge/datalabels:-"traefik.backend=thelounge"-"traefik.enable=true"-"traefik.frontend.rule=Host:subdomain.example.com"-"traefik.port=9000"-"traefik.docker.network=traefik_proxy"networks:-traefik_proxynetworks:traefik_proxy:external:truedefault:driver:bridge

Folgende Werte müsst ihr pro Container anpassen:

• traefik.backend (Name des Backends – könnt ihr frei vergeben)
• traefik.frontend.rule (die URL, auf dem der Service hören soll)
• traefik.port (der Port, auf dem eure Anwendung hört)

Der Rest kann jeweils übernommen werden. Sollte ihr euren Container schon gestartet haben, solltet ihr diesen beenden, evtl. den Container löschen und neu starten. Ein paar Sekunden später ist der Service dann extern verfügbar.