Traefik Ingress Controller mit cert-manager auf Kubernetes: TLS absichern

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.com verwendet – 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:

https://example.com

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:

• Offizielle Traefik-Dokumentation
• Offizielle cert-manager-Dokumentation