Traefik Kubernetes Ingress Provider mit cert-manager
Der Traefik Kubernetes Ingress Provider ist ein Open-Source Ingress-Controller für Kubernetes. In Kombination mit cert-manager werden TLS-Zertifikate automatisch ausgestellt, sodass interne Kubernetes-Services sicher veröffentlicht werden.
In dieser Anleitung richten Sie den Traefik Ingress Controller in Ihrem Kubernetes-Cluster ein. Zusätzlich integrieren Sie cert-manager zur Bereitstellung von TLS-Zertifikaten, erstellen eine Beispielanwendung, konfigurieren einen Service, veröffentlichen diesen über ein Ingress-Objekt und stellen mit cert-manager ein TLS-Zertifikat aus.
Voraussetzungen
Bevor Sie starten, stellen Sie sicher, dass Sie:
- Zugriff auf einen Kubernetes-Cluster haben.
- kubectl lokal installiert haben.
- den Helm-Client lokal installiert haben.
- einen Domainnamen besitzen. In dieser Anleitung wird
example.comverwendet – ersetzen Sie diesen durch Ihre eigene Domain.
Traefik installieren und konfigurieren
Legen Sie einen eigenen Namespace für die Traefik-Ressourcen an:
$ kubectl create namespace traefik-namespace
Fügen Sie das offizielle Traefik Helm-Repository hinzu:
$ helm repo add traefik https://helm.traefik.io/traefik
Aktualisieren Sie die Helm-Repositories:
$ helm repo update
Installieren Sie den Traefik Ingress Controller mit Helm:
$ helm install --namespace=traefik-namespace traefik traefik/traefik
Der obige Befehl installiert den Traefik Ingress Controller im Namespace traefik-namespace.
Prüfen Sie den Service des Traefik Ingress Controllers, um die externe IP zu ermitteln:
$ kubectl get services -n traefik-namespace
Beispielausgabe solange die externe IP noch aussteht:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE traefik LoadBalancer 10.108.209.185 <pending> 80:30046/TCP,443:30279/TCP 78s
Nach einiger Zeit erhält der Service eine externe IP:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE traefik LoadBalancer 10.107.61.70 192.0.2.10 80:30351/TCP,443:32047/TCP 9m34s
Melden Sie sich anschließend beim DNS-Provider Ihrer Domain an und erstellen Sie einen A-Record, der Ihre Domain auf die externe IP des Traefik LoadBalancers verweist.
cert-manager installieren
cert-manager ist ein Kubernetes-Add-on, das TLS-Zertifikate von verschiedenen Certificate Authorities (CAs) wie Let’s Encrypt, HashiCorp Vault, Venafi und weiteren ausstellen kann. Zudem sorgt es für die rechtzeitige Erneuerung der Zertifikate. In diesem Schritt installieren Sie cert-manager in Ihrem Cluster.
Installieren Sie cert-manager in Version v1.17.2 mit folgendem Befehl:
$ kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.17.2/cert-manager.yaml
Damit wird cert-manager v1.17.2 installiert. Um die neueste Version zu prüfen, besuchen Sie das GitHub-Repository von cert-manager.
Überprüfen Sie, ob alle cert-manager Pods laufen:
$ kubectl get pods --namespace cert-manager
Die Ausgabe sollte Ressourcen mit cert-manager im Namen enthalten.
ClusterIssuer erstellen
Ein ClusterIssuer ist eine clusterweite Ressource von cert-manager, die TLS-Zertifikate für Ingress-Objekte ausstellt. Im nächsten Schritt konfigurieren Sie einen ClusterIssuer für Let’s Encrypt.
Legen Sie eine Datei cluster-issuer.yaml an:
$ nano cluster-issuer.yaml
Fügen Sie folgende Konfiguration ein:
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
name: letsencrypt-prod
spec:
acme:
email: hello@example.com
server: https://acme-v02.api.letsencrypt.org/directory
privateKeySecretRef:
name: letsencrypt-prod-key
solvers:
- http01:
ingress:
class: traefik
Hinweis: Ersetzen Sie hello@example.com durch eine gültige E-Mail-Adresse. Die Verwendung von example.com verhindert die korrekte Funktion des ClusterIssuers.
Erklärung der Konfiguration:
- acme: Legt die ACME-Einstellungen für Let’s Encrypt fest.
- email: Die mit dem Let’s Encrypt-Konto verknüpfte E-Mail-Adresse.
- server: Die ACME-Server-URL.
- privateKeySecretRef: Verweist auf das Kubernetes-Secret, das den privaten Schlüssel speichert.
- solvers: Definiert, wie die ACME-Challenge gelöst wird.
- http01: Nutzt HTTP-01 zur Domainvalidierung.
- ingress: Definiert Traefik als Ingress-Klasse zur Validierung.
Speichern Sie die Datei und wenden Sie diese an:
$ kubectl apply -f cluster-issuer.yaml
Überprüfen Sie den Status des ClusterIssuers:
$ kubectl get clusterissuer
Beispielausgabe:
NAME READY AGE letsencrypt-prod True 2m44s
Der Wert True im Feld READY bestätigt, dass der ClusterIssuer ordnungsgemäß eingerichtet und bereit ist, Zertifikate auszustellen.
Bereitstellung einer Beispielanwendung
In diesem Abschnitt stellen Sie eine Testanwendung auf Basis des Nginx-Webservers bereit. Damit überprüfen Sie Ihre Traefik-Konfiguration sowie die Zertifikatsausstellung durch cert-manager.
Erstellen Sie einen Namespace namens example-app-namespace, der die Ressourcen der Anwendung aufnimmt:
$ kubectl create namespace example-app-namespace
Erstellen Sie eine Deployment-Datei mit dem Namen example-app-deployment.yaml:
$ nano example-app-deployment.yaml
Fügen Sie folgenden Inhalt ein:
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: example-app-namespace
name: example-app-deployment
spec:
replicas: 3
selector:
matchLabels:
app: example-app
template:
metadata:
labels:
app: example-app
spec:
containers:
- name: web-app
image: nginx
ports:
- containerPort: 80
Dieses Deployment mit dem Namen example-app-deployment verwendet das offizielle Nginx-Image und startet drei Replikas.
Erläuterung der Konfiguration:
- replicas: Anzahl der erzeugten Pod-Instanzen.
- selector: Labels, mit denen die vom Deployment verwalteten Pods identifiziert werden.
- template: Vorlage für die Erstellung neuer Pods.
- metadata: Den Pods zugewiesene Labels.
- spec: Spezifikation der Pods.
- containers: Containerdefinitionen innerhalb der Pods.
- name: Name des Containers.
- image: Verwendetes Container-Image (nginx).
- ports: In den Containern geöffnete Ports.
Wenden Sie das Deployment an:
$ kubectl apply -f example-app-deployment.yaml
Prüfen Sie, ob die Pods laufen:
$ kubectl get pods -n example-app-namespace
Sie sollten drei Pods sehen, deren Namen mit example-app-deployment- beginnen.
Ein Ingress-Objekt erstellen
Erstellen Sie nun einen Service für das Deployment und anschließend ein Ingress, um diesen mit einem TLS-Zertifikat extern bereitzustellen.
Legen Sie eine Service-Datei namens example-app-service.yaml an:
$ nano example-app-service.yaml
Fügen Sie folgenden Inhalt ein:
apiVersion: v1
kind: Service
metadata:
namespace: example-app-namespace
name: example-app-service
spec:
selector:
app: example-app
ports:
- protocol: TCP
port: 80
targetPort: 80
Dieser Service example-app-service macht die Pods des Deployments verfügbar.
Erläuterung der Konfiguration:
- spec: Legt die Service-Konfiguration fest.
- selector: Labels, nach denen die Ziel-Pods für den Datenverkehr ausgewählt werden.
- app: Entspricht dem Label
app=example-app. - ports: Vom Service bereitgestellte Ports.
- protocol: Verwendetes Protokoll (TCP).
- port: Vom Service exponierter Port.
- targetPort: Zielport innerhalb der Pods.
Wenden Sie das Service-Manifest an:
$ kubectl apply -f example-app-service.yaml
Überprüfen Sie die Erstellung des Services:
$ kubectl get services -n example-app-namespace
Beispielausgabe:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE example-app-service ClusterIP 10.97.221.68 <none> 80/TCP 81s
Erstellen Sie als Nächstes eine Ingress-Datei namens example-app-ingress.yaml. Ersetzen Sie example.com durch Ihre eigene Domain.
$ nano example-app-ingress.yaml
Fügen Sie die folgende Ingress-Konfiguration ein:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: web-app-ingress
namespace: example-app-namespace
annotations:
traefik.ingress.kubernetes.io/router.entrypoints: websecure
traefik.ingress.kubernetes.io/router.tls: "true"
cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
rules:
- host: example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: example-app-service
port:
number: 80
tls:
- secretName: web-app-cert
hosts:
- example.com
Dieses Ingress veröffentlicht den Service example-app-service unter der Domain example.com.
Erläuterung der Konfiguration:
- annotations: Legen das Verhalten für Traefik und cert-manager fest.
- traefik.ingress.kubernetes.io/router.entrypoints: websecure — Leitet den Traffic über den HTTPS-Einstiegspunkt.
- traefik.ingress.kubernetes.io/router.tls: „true“ — Aktiviert TLS-Terminierung für sicheren Verkehr.
- cert-manager.io/cluster-issuer: letsencrypt-prod — Verknüpft das Ingress mit dem ClusterIssuer zur Zertifikatserstellung.
- rules: Definieren die Weiterleitungsregeln.
- host: Gibt den Domainnamen an.
- paths: Legen Pfade für Anfragen fest.
- backend: Leitet Anfragen an den Service weiter.
- tls: TLS-Konfiguration des Ingress.
- secretName: Secret, das das ausgestellte TLS-Zertifikat enthält.
Wenden Sie das Ingress-Manifest an:
$ kubectl apply -f example-app-ingress.yaml
Prüfen Sie die Erstellung des Ingress:
$ kubectl get ingress -n example-app-namespace
Beispielausgabe:
NAME CLASS HOSTS ADDRESS PORTS AGE web-app-ingress traefik example.com 80, 443 9s
Anfangs ist das Feld ADDRESS leer. Nach kurzer Zeit wird es mit der externen IP des Traefik-Services gefüllt.
Prüfen Sie, ob Let’s Encrypt ein Zertifikat für Ihre Domain ausgestellt hat:
$ kubectl get certificates -n example-app-namespace
Beispielausgabe:
NAME READY SECRET AGE web-app-cert True web-app-cert 41s
Wenn das Feld READY den Wert True hat, wurde das SSL-Zertifikat erfolgreich ausgestellt. Bis ein Zertifikat bereit ist, kann es einige Minuten dauern.
Um die automatische Erneuerung zu bestätigen, beschreiben Sie die Certificate-Ressource:
$ kubectl describe -n example-app-namespace certificate web-app-cert
Suchen Sie in der Ausgabe nach dem Feld Renewal Time:
... Renewal Time: 2023-09-17T15:23:45Z ...
Öffnen Sie abschließend Ihren Browser und rufen Sie Ihre Domain über HTTPS auf:
Sie sollten die standardmäßige Nginx-Willkommensseite sicher angezeigt bekommen.
Fehlerbehebung
Nachfolgend finden Sie einige gängige Tipps zur Fehlerbehebung, um Traefik und die Cluster-Ressourcen effektiv zu verwalten.
Kein Let’s Encrypt Zertifikat erhalten: Wenn die Spalte READY für Ihr Zertifikat den Wert False anzeigt, stellen Sie sicher, dass Ihre Domain korrekt auf die externe IP des Traefik LoadBalancers verweist. Für weitere Details prüfen Sie die Logs von cert-manager mit:
$ kubectl logs deployment/cert-manager -n cert-manager --tail=15 -f
Traefik-Logs überprüfen: Falls Traefik nicht wie erwartet funktioniert, können Sie die Pod-Logs auf Fehlermeldungen oder Warnungen prüfen:
$ kubectl logs -n <namespace> <traefik-pod>
DNS-Konfiguration prüfen: Stellen Sie sicher, dass Ihr Domainname korrekt auf die externe IP-Adresse des Traefik LoadBalancers verweist. Falsche DNS-Einträge verhindern, dass Traefik Anfragen richtig verarbeiten kann.
Ingress-Konfiguration prüfen: Wenn Traefik Anfragen nicht weiterleitet, kontrollieren Sie die Ingress-YAML-Datei. Vergewissern Sie sich, dass alle erforderlichen Annotationen für Traefik und cert-manager vorhanden sind:
$ kubectl get ingress
Traefik-Ressourcen überprüfen: Kontrollieren Sie regelmäßig den Status von Traefik-Ressourcen wie Pods, Services und Ingress-Objekten, um sicherzustellen, dass diese korrekt laufen:
$ kubectl get pods -n traefik-namespace
Fazit
In dieser Anleitung haben Sie den Traefik Ingress Controller installiert, eine Beispielanwendung bereitgestellt und diese mithilfe von Traefik, cert-manager und Let’s Encrypt sicher veröffentlicht. Für weiterführende Informationen und zusätzliche Konfigurationsmöglichkeiten besuchen Sie die offizielle Dokumentation:
