Linkerd auf Kubernetes installieren und konfigurieren

Linkerd ist ein leichtgewichtiges, quelloffenes Service Mesh für Kubernetes, das Funktionen wie Beobachtbarkeit, Sicherheit und effizientes Traffic-Management bietet. Es nutzt ein Sidecar-Proxy-Modell, bei dem kleine Proxys die Kommunikation zwischen den Pods übernehmen, während eine zentrale Steuerungsebene (Control Plane) die Konfiguration und das Routing verwaltet.

Diese Schritt-für-Schritt-Anleitung zeigt, wie du Linkerd auf einem Kubernetes Cluster installierst. Außerdem wird erklärt, wie du eine Beispielanwendung bereitstellst, Ingress für externen Zugriff einrichtest und Funktionen für das Traffic-Management aktivierst.

Voraussetzungen

Bevor du beginnst, stelle sicher, dass du folgende Anforderungen erfüllst:

• Einen aktiven Kubernetes Cluster.
• Eine Domain mit einem A-Record, der auf die Load-Balancer-IP deines Clusters zeigt (z. B. linkerd.example.com).
• Zugriff auf einen Ubuntu-basierten Server oder eine lokale Workstation zur Verwaltung deines Clusters und zur Verwendung der Linkerd-CLI.
• Kubectl installiert und so konfiguriert, dass es mit deinem Kubernetes-Cluster kommuniziert.
• Helm auf deiner Workstation installiert.

Linkerd-CLI installieren

Installiere die Linkerd-Kommandozeilenschnittstelle (CLI) auf deiner Workstation, um dein Service Mesh zu verwalten.

Systempakete aktualisieren

$ sudo apt update

Linkerd-CLI herunterladen und installieren

$ curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/install-edge | sh

Linkerd zum PATH hinzufügen

$ export PATH=$PATH:$HOME/.linkerd2/bin

PATH-Änderung dauerhaft speichern

$ echo 'export PATH=$PATH:$HOME/.linkerd2/bin' >> ~/.bashrc
$ source ~/.bashrc

CLI-Installation überprüfen

$ linkerd version --client

Beispielausgabe:

Client version: edge-25.10.3

Die Serverversion ist derzeit nicht verfügbar, da die Control Plane noch nicht installiert wurde.

Kubernetes-Cluster validieren

Überprüfe vor der Installation, ob dein Kubernetes-Cluster die Anforderungen von Linkerd erfüllt.

Vorab-Überprüfung durchführen

$ linkerd check --pre

Alle Tests sollten mit der Meldung Status check results are √ abgeschlossen werden. Behebe eventuelle Fehler, bevor du fortfährst.

Linkerd-Control-Plane installieren

Installiere die Kernkomponenten von Linkerd, die den Service-Mesh-Traffic und die Sicherheit im Cluster verwalten.

Gateway API CRDs installieren

$ kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.3.0/standard-install.yaml

Linkerd-CRDs installieren

$ linkerd install --crds | kubectl apply -f -

Control Plane installieren

$ linkerd install | kubectl apply -f -

Installation überprüfen

$ linkerd check

Control-Plane-Pods prüfen

$ kubectl get pods -n linkerd

Beispielausgabe:

NAME                                     READY   STATUS    RESTARTS   AGE
linkerd-destination-7b4657cfd8-btqdv     4/4     Running   0          4m40s
linkerd-identity-5584896d84-6pmdm        2/2     Running   0          4m40s
linkerd-proxy-injector-995fcbf47-dv6qr   2/2     Running   0          4m40s

Linkerd-Viz-Erweiterung installieren

Die Viz-Erweiterung fügt Beobachtungsfunktionen hinzu und stellt ein webbasiertes Dashboard zur Überwachung deiner Linkerd-Umgebung bereit.

Viz-Erweiterung installieren

$ linkerd viz install | kubectl apply -f -

Viz-Installation überprüfen

$ linkerd viz check

Linkerd-Dashboard bereitstellen

Du kannst das Linkerd-Dashboard sicher über Kubernetes Ingress mit TLS-Verschlüsselung bereitstellen, um einen geschützten Zugriff über den Browser zu ermöglichen.

Nginx Ingress Controller installieren

Installiere den Nginx Ingress Controller, um eingehenden Datenverkehr zu verarbeiten.

Nginx Ingress Helm-Repository hinzufügen

$ helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

Helm aktualisieren

$ helm repo update

Nginx Ingress Controller installieren

$ helm install ingress-nginx ingress-nginx/ingress-nginx \
    --create-namespace --namespace ingress-nginx

Warten, bis der LoadBalancer eine externe IP erhält

$ kubectl get service -n ingress-nginx ingress-nginx-controller

Beispielausgabe:

NAME                       TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)                      AGE
ingress-nginx-controller   LoadBalancer   10.99.177.190   192.0.20.11       80:31460/TCP,443:32364/TCP   3m51s

Notiere den Wert der EXTERNAL-IP. Weise den A-Record deiner Domain dieser IP zu, um den externen Zugriff zu aktivieren.

Nginx Ingress Controller-Pods überprüfen

$ kubectl get pods -n ingress-nginx

Auf das Dashboard zugreifen

Greife über deinen Browser auf das gesicherte Linkerd-Dashboard zu, indem du die konfigurierte Domain aufrufst.

https://linkerd.example.com

Melde dich mit dem zuvor erstellten Benutzernamen und Passwort an. Erkunde das Dashboard, um Cluster-Metriken, die Service-Mesh-Topologie und den Datenverkehrsfluss zu überwachen.

Bereitstellung einer Beispielanwendung

Stelle die Emojivoto-Anwendung bereit, um die Funktionen von Linkerd zu testen und die Integration in das Service Mesh zu überprüfen.

Emojivoto-Anwendung bereitstellen

$ curl -sL https://run.linkerd.io/emojivoto.yml | kubectl apply -f -

Bereitstellung überprüfen

$ kubectl get pods -n emojivoto

Anwendung in das Mesh integrieren

$ kubectl get -n emojivoto deploy -o yaml | linkerd inject - | kubectl apply -f -

Meshed-Anwendung anzeigen

$ linkerd viz -n emojivoto stat deploy

Traffic-Splitting konfigurieren

Implementiere Canary-Deployments, indem du eine HTTPRoute verwendest, um den Datenverkehr zwischen verschiedenen Anwendungsversionen aufzuteilen.

Zweite Version der Web-Bereitstellung erstellen

$ kubectl get deploy web -n emojivoto -o yaml | \
    sed 's/name: web/name: web-v2/' | \
    kubectl apply -f -

Service für die neue Version erstellen

$ cat <

$ cat <

Neue Bereitstellung zum Mesh hinzufügen

$ kubectl get deploy web-v2 -n emojivoto -o yaml | \
    linkerd inject - | \
    kubectl apply -f -

Manifest für Traffic-Splitting erstellen

$ nano traffic-split.yaml

Füge die folgende Konfiguration ein:

apiVersion: policy.linkerd.io/v1beta2
kind: HTTPRoute
metadata:
  name: web-route
  namespace: emojivoto
spec:
  parentRefs:
    - name: web-svc
      kind: Service
      group: core
      port: 80
  rules:
    - backendRefs:
        - name: web-svc
          port: 80
          weight: 80
        - name: web-v2
          port: 80
          weight: 20

Manifest anwenden

$ kubectl apply -f traffic-split.yaml

Datenverkehrsverteilung überprüfen

$ linkerd viz -n emojivoto stat --from deploy/vote-bot deploy

Fazit

Du hast erfolgreich Linkerd auf einem Kubernetes Cluster installiert, das Dashboard sicher über Nginx Ingress mit TLS-Verschlüsselung und Authentifizierung bereitgestellt und eine Beispielanwendung mit Traffic-Splitting implementiert. Weitere Informationen zu erweiterten Funktionen findest du in der offiziellen Linkerd-Dokumentation.