Installieren und Verwenden von Linkerd mit Kubernetes

Der Autor wählte den Tech Education Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

Einführung

Ein Service Mesh ist eine dedizierte Infrastrukturebene, mit der Administratoren die Kommunikation zwischen Diensten verwalten können. Mit ihren vielen leistungsfähigen Tools können diese Service Meshes Ihr System sicherer, zuverlässiger und auch transparenter machen.

Ein Service Mesh wie zum Beispiel Linkerd kann Verbindungen automatisch verschlüsseln, wiederholte Anfragen und Timeouts verwalten, Telemetriedaten wie Erfolgsraten und Latenz liefern und vieles mehr.

In diesem Tutorial installieren Sie das Linkerd-Service Mesh in Ihrem Kubernetes-Cluster, stellen eine Beispielanwendung bereit und sehen sich dann das Dashboard von Linkerd an. Nachdem Sie sich mit einigen dieser Informationen im Dashboard vertraut gemacht haben, konfigurieren Sie Linkerd, um timeout- und retry-Richtlinien für einen bestimmten Kubernetes-Pod durchzusetzen.

Erkunden Sie alternativ die One-Click-Installationsoption für Linkerd/Kubernetes von DigitalOcean.

Voraussetzungen

• Ein Kubernetes 1.12±Cluster. In diesem Tutorial wird ein DigitalOcean Kubernetes-Cluster mit drei Knoten verwendet, aber Sie können auf Wunsch auch mit einer anderen Methode einen Cluster erstellen.

• Das auf einem Entwicklungsserver installierte Befehlszeilentool kubectl, das zur Verbindung mit Ihrem Cluster konfiguriert ist. Weitere Informationen zur Installation von kubectl finden Sie in der offiziellen Dokumentation.

Schritt 1 — Bereitstellen der Anwendung

Um Linkerd in Aktion zu sehen, müssen Sie eine Anwendung in Ihrem Cluster ausführen. In diesem Schritt stellen Sie eine Anwendung namens emojivoto bereit, die das Linkerd-Team für diesen Zweck erstellt hat.

In diesem Repository können Sie den Code für die vier Dienste, aus denen die Anwendung besteht, sowie die Manifestdatei sehen, die Sie zur Bereitstellung dieser Dienste in Ihrem Kubernetes-Cluster verwenden werden.

Speichern Sie zuerst diese Manifestdatei lokal:

curl https://run.linkerd.io/emojivoto.yml --output manifest.yaml

Sie verwenden curl, um die Datei abzurufen, und übergeben dann die Option --output, um mitzuteilen, wo die Datei gespeichert werden soll. In diesem Fall erstellen Sie eine Datei namens manifest.yaml.

Um besser zu verstehen, was diese Datei tun wird, sehen Sie sich mit cat ihre Inhalte an oder öffnen Sie sie mit Ihrem bevorzugten Editor:

cat manifest.yaml | less

Drücken Sie SPACE, um durch die Anweisungen zu blättern. Sie sehen, dass manifest.yaml einen Kubernetes-Namespace namens emojivoto erstellt, wo alles, was mit dieser Anwendung verbunden ist, ausgeführt wird. Hinzu kommen verschiedene Deployments und Services von Kubernetes.

Wenden Sie als Nächstes das Manifest in Ihrem Kubernetes-Cluster an:

kubectl apply -f manifest.yaml

Auch hier verwenden Sie kubectl apply mit dem Flag -f, um eine Datei zuzuweisen, die Sie anwenden möchten.

Dieser Befehl gibt eine Liste aller Ressourcen aus, die erstellt wurden:

Output
namespace/emojivoto created
serviceaccount/emoji created
serviceaccount/voting created
serviceaccount/web created
service/emoji-svc created
service/voting-svc created
service/web-svc created
deployment.apps/emoji created
deployment.apps/vote-bot created
deployment.apps/voting created
deployment.apps/web created

Überprüfen Sie nun, ob die Dienste ausgeführt werden:

kubectl -n emojivoto get pods

Sie verwenden kubectl, um alle pods aufzulisten, die Sie in Ihrem Cluster ausführen, und übergeben dann das Flag -n, um anzugeben, welche Namespaces Sie verwenden möchten. Sie übergeben den Namespace emojivoto, da Sie dort alle diese Dienste ausführen.

Wenn alle pods den Status Running aufweisen, sind Sie bereit für den nächsten Schritt:

Output
NAME                        READY   STATUS    RESTARTS   AGE
emoji-566954596f-cw75b      1/1     Running   0          24s
vote-bot-85c5f5699f-7dw5c   1/1     Running   0          24s
voting-756995b6fc-czf8z     1/1     Running   0          24s
web-7f7b69d467-2546n        1/1     Running   0          23s

Um die Anwendung abschließend in Ihrem Browser laufen zu sehen, verwenden Sie die integrierte Funktion kubectl, um lokale Anfragen an Ihren Remote-Cluster weiterzuleiten:

kubectl -n emojivoto port-forward svc/web-svc 8080:80

Hier verwenden Sie kubectl erneut in den emojivoto-Namespaces, rufen aber nun den Unterbefehl port-forward auf und weisen ihn an, alle lokalen Anfragen an Port 8080 an den Kubernetes-Dienst web-svc weiterzuleiten``. Das ist eine einfache Möglichkeit, auf Ihre Anwendung zuzugreifen, ohne dass Sie einen richtigen Lastausgleich einrichten müssen.

Besuchen Sie nun http://localhost:8080 und Sie werden die Anwendung emojivoto sehen.

Drücken Sie STRG + C in Ihrem Terminal. Nachdem nun eine Anwendung in Ihrem Cluster ausgeführt wird, sind Sie bereit, Linkerd zu installieren und zu sehen, wie es funktioniert.

Schritt 2 — Installieren von Linkerd

Nachdem Sie über eine ausgeführte Anwendung verfügen, installieren wir nun Linkerd. Zur Installation in Ihrem Kubernetes-Cluster benötigen Sie zuerst die Linkerd-CLI. Sie werden diese Befehlszeilenschnittstelle nutzen, um von Ihrem lokalen Rechner aus mit Linkerd zu interagieren. Danach können Sie Linkerd in Ihrem Cluster installieren.

Installieren wir zuerst die CLI mit dem Skript, das das Linkerd-Team bereitgestellt hat:

curl https://run.linkerd.io/install | sh

Hier verwenden Sie curl zum Herunterladen des Installationsskripts und leiten die Ausgabe dann an sh weiter, wo das Skript automatisch ausgeführt wird. Alternativ können Sie die CLI direkt von der Release-Seite von Linkerd herunterladen.

Wenn Sie das Skript verwenden, wird Linkerd unter ~/.linkerd2/bin installiert. Überprüfen Sie nun, ob die CLI richtig funktioniert:

~/.linkerd2/bin/linkerd version

Der Befehl gibt etwa Folgendes aus:

Output
Client version: stable-2.7.1
Server version: unavailable

Um die Ausführung der CLI einfacher zu gestalten, fügen Sie das Verzeichnis dann Ihrem $PATH hinzu:

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

Sie können die Befehle nun direkter ausführen, wie zum Beispiel den vorherigen:

linkerd version

Abschließend installieren wir Linkerd in Ihrem Kubernetes-Cluster. Der Befehl linkerd install dient der Erstellung aller erforderlichen yaml-Manifeste, die zur Ausführung von Linkerd benötigt werden. Er wendet diese Manifeste jedoch nicht auf Ihren Cluster an. Führen Sie diesen Befehl aus, um die Ausgabe zu überprüfen:

linkerd install

Sie werden eine lange Ausgabe sehen, in der alle yaml-Manifeste für Ressourcen aufgelistet werden, die Linkerd ausführen muss. Um diese Manifeste auf Ihren Cluster anzuwenden, führen Sie Folgendes aus:

linkerd install | kubectl apply -f -

Durch Ausführung von linkerd install werden alle zuvor angezeigten Manifeste ausgegeben. | leitet diese Ausgabe dann direkt an kubectl apply weiter, wo sie angewendet werden.

Nachdem Sie diesen Befehl ausgeführt haben, gibt kubectl apply eine Liste aller Ressourcen aus, die erstellt wurden.

Um zu überprüfen, ob alles in Ihrem Cluster ausgeführt wird, führen Sie linkerd check aus:

linkerd check

Dadurch werden mehrere Prüfungen für Ihren Cluster ausgeführt, um zu sehen, ob alle erforderlichen Komponenten ausgeführt werden:

Output
kubernetes-api
--------------
√ can initialize the client
√ can query the Kubernetes API

[...]

control-plane-version
---------------------
√ control plane is up-to-date
√ control plane and cli versions match

Status check results are √

Führen Sie abschließend diesen Befehl aus, um das integrierte Linkerd-Dashboard in Ihrem Browser zu öffnen (vergessen Sie nicht, das Flag --address 0.0.0.0 anzugeben, wenn Sie es nicht von Ihrem lokalen Rechner ausführen):

linkerd dashboard

Die meisten der Informationen, die Sie im Dashboard sehen, können Sie über die Linkerd-CLI aufrufen. Führen Sie zum Beispiel diesen Befehl aus, um übergeordnete Statistiken für Bereitstellungen anzuzeigen:

linkerd stat deployments -n linkerd

Hier sagen Sie, dass Sie die Statistiken für Bereitstellungen, die im Namespace linkerd ausgeführt werden, abrufen möchten. Das sind die eigenen Komponenten von Linkerd; interessanterweise können Sie Linkerd selbst zu ihrer Überwachung nutzen. Sie können Statistiken wie Anfragen pro Sekunde (RPS), Erfolgsrate, Latenz und mehr anzeigen. Außerdem können Sie eine Meshed-Spalte sehen, in der angegeben wird, wie viele pods Linkerd injiziert hat:

Output
NAME                     MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
linkerd-controller          1/1   100.00%   0.4rps           1ms          87ms          98ms          5
linkerd-destination         1/1   100.00%   0.3rps           1ms           2ms           2ms         13
linkerd-grafana             1/1   100.00%   0.3rps           2ms           3ms           3ms          2
linkerd-identity            1/1   100.00%   0.3rps           1ms           2ms           2ms         10
linkerd-prometheus          1/1   100.00%   0.7rps          35ms         155ms         191ms          9
linkerd-proxy-injector      1/1   100.00%   0.3rps           2ms           3ms           3ms          2
linkerd-sp-validator        1/1   100.00%   0.3rps           1ms           5ms           5ms          2
linkerd-tap                 1/1   100.00%   0.3rps           1ms           4ms           4ms          6
linkerd-web                 1/1   100.00%   0.3rps           1ms           2ms           2ms          2

Probieren Sie diesen Befehl nun in Ihrem Namespace emojivoto aus:

linkerd stat deployments -n emojivoto

Obwohl Sie Ihre vier Dienste sehen können, sind keine der zuvor erstellten Statistiken für diese Bereitstellungen verfügbar. In der Spalte „Meshed“ können Sie sehen, dass 0/1 angegeben ist:

Output
NAME       MESHED   SUCCESS   RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
emoji         0/1         -     -             -             -             -          -
vote-bot      0/1         -     -             -             -             -          -
voting        0/1         -     -             -             -             -          -
web           0/1         -     -             -             -             -          -

Die Ausgabe bedeutet, dass Linkerd immer noch nicht in die Anwendung injiziert wurde. Das ist Ihr nächster Schritt.

Schritt 3 — Injizieren von Linkerd in Ihre Anwendung

Nachdem Sie Linkerd nun in Ihrem Cluster ausführen, sind Sie bereit, es in Ihre emojivoto-Anwendung zu injizieren.

Linkerd funktioniert, indem es einen Sidecar-Container in Ihren Kubernetes pods ausführt. Das heißt, Sie injizieren einen Linkerd-Proxy-Container in jeden pod, der ausgeführt wird. Jede Anfrage, die Ihre pods dann senden oder erhalten, werden über diesen sehr schlanken Proxyserver laufen, der Metriken (wie Erfolgsrate, Anfragen pro Sekunde und Latenz) sammeln und Richtlinien durchsetzen kann (wie für Timeouts und Wiederholungsversuche).

Mit diesem Befehl können Sie den Proxy von Linkerd manuell injizieren:

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

In diesem Befehl verwenden Sie kubectl get zuerst, um alle Kubernetes deployments zu erhalten, die Sie im Namespace emojivoto ausführen, und geben dann an, dass Sie die Ausgabe im yaml-Format wünschen. Dann senden Sie diese Ausgabe an den Befehl linkerd inject. Dieser Befehl liest die yaml-Datei mit den aktuellen Manifesten, die ausgeführt werden, und modifiziert sie, um den linkerd-Proxy mit jedem deployment aufzunehmen.

Schließlich erhalten Sie das modifizierte Manifest und wenden es mit kubectl apply auf Ihren Cluster an.

Nach Ausführung dieses Befehls sehen Sie eine Meldung mit dem Hinweis, dass alle vier emojivoto-Dienste (emoji, vote-bot, voting und web) erfolgreich injiziert wurden.

Wenn Sie jetzt stats für emojivoto abrufen, sehen Sie, dass nun alle Ihre deployments vernetzt sind. Nach ein paar Sekunden sehen Sie die gleichen Statistiken, die für den Namespace linkerd angezeigt wurden:

linkerd stat deployments -n emojivoto

Hier können Sie die Statistiken für alle vier Dienste sehen, aus denen die Anwendung emojivoto besteht, jeweils mit ihrer Erfolgsrate, Anfragen pro Sekunde und Latenz, ohne dass Sie Anwendungscode schreiben oder ändern müssen.

Output
NAME       MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
emoji         1/1   100.00%   1.9rps           1ms           2ms           2ms          2
vote-bot      1/1         -        -             -             -             -          -
voting        1/1    85.96%   0.9rps           1ms           1ms           1ms          2
web           1/1    93.04%   1.9rps           8ms          27ms          29ms          2

Der Dienst vote-bot zeigt keine Statistiken an, da er nur ein Bot ist, der Anfragen an andere Dienste sendet und daher keinen Datenverkehr empfängt. Das ist für sich eine wertvolle Information.

Nun sehen wir uns an, wie Sie über Ihre Dienste zusätzliche Informationen für Linkerd bereitstellen können, um das Verhalten anzupassen.

Schritt 4 — Definieren eines Dienstprofils

Nachdem Sie Linkerd in Ihre Anwendung injiziert haben, können Sie nun wertvolle Informationen darüber abrufen, wie sich Ihre einzelnen Dienste verhalten. Außerdem haben Sie das geschafft, ohne benutzerdefinierte Konfigurationen schreiben oder den Code Ihrer Anwendung ändern zu müssen. Wenn Sie Linkerd jedoch einige zusätzliche Informationen bereitstellen, kann es dann verschiedene Richtlinien durchsetzen, wie z. B. für Timeouts und Wiederholungsversuche. Außerdem kann Linkerd Metriken für einzelne Routen liefern.

Diese Informationen werden über ein Dienstprofil bereitgestellt, das eine benutzerdefinierte Linkerd-Ressource ist, in der Sie die Routen in Ihren Anwendungen beschreiben und festhalten können, wie sich jede von ihnen verhalten wird.

Hier ist ein Beispiel dafür, wie das Manifest eines Dienstprofils aussieht:

apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
  name: my-service.my-namespace.svc.cluster.local
spec:
  routes:
  - name: My Route Name
    isRetryable: true # Define it's safe to retry this route
    timeout: 100ms # Define a timeout for this route
    condition:
      method: GET
      pathRegex: /my/route/path

Das Dienstprofil beschreibt eine Liste von Routen und definiert dann, wie sich Anfragen, die mit der angegebenen condition übereinstimmen, verhalten werden. In diesem Beispiel sagen Sie, dass jede GET-Anfrage, die an /my/route/path gesendet wird, nach 100 ms ablaufen soll (Timeout); wenn sie fehlschlägt, kann es Wiederholungsversuche geben.

Erstellen wir nun ein Dienstprofil für einen Ihrer Dienste. Wenn wir voting-svc als Beispiel nehmen, verwenden Sie zuerst die Linkerd-CLI, um die Routen zu überprüfen, die Sie für diesen Dienst definiert haben:

linkerd routes svc/voting-svc -n emojivoto

Hier verwenden Sie den Befehl linkerd routes, um alle Routen für den Dienst voting-svc im Namespace emojivoto aufzulisten:

Output
ROUTE          SERVICE   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99
[DEFAULT]   voting-svc    83.05%   1.0rps           1ms           1ms           2ms

Sie finden nur eine Route: [DEFAULT]. Hier werden alle Anfragen gruppiert, bis Sie das Dienstprofil definieren.

Öffnen Sie nun nano oder Ihren bevorzugten Editor, um eine service-profile.yaml-Datei zu erstellen:

nano service-profile.yaml

Fügen Sie die folgende Dienstprofildefinition in diese Datei ein:

apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
  name: voting-svc.emojivoto.svc.cluster.local
  namespace: emojivoto
spec:
  routes:
  - name: VoteDoughnut
    isRetryable: true
    timeout: 100ms
    condition:
      method: POST
      pathRegex: /emojivoto.v1.VotingService/VoteDoughnut

Speichern Sie nun die Datei und schließen Sie Ihren Editor.

Hier deklarieren Sie ein Dienstprofil für den Dienst voting-svc im Namespace emojivoto. Sie haben eine Route namens VoteDoughnut definiert, die mit jeder POST-Anfrage an /emojivoto.v1 übereinstimmt. Pfad VotingService/VoteDoughnut. Wenn eine Anfrage, die mit diesen Kriterien übereinstimmt, länger als 100 ms benötigt, wird sie von Linkerd abgebrochen und der Client erhält eine 504-Antwort zurück. Außerdem teilen Sie Linkerd mit, dass für die Anfrage, wenn sie fehlschlägt, Wiederholungsversuche vorgenommen werden dürfen.

Wenden Sie diese Datei nun auf Ihren Cluster an:

kubectl apply -f service-profile.yaml

Nach ein paar Sekunden prüfen Sie die Routen erneut für diesen Dienst:

linkerd routes svc/voting-svc -n emojivoto

Sie sehen nun Ihre neu definierte VoteDoughnut-Route:

Output
ROUTE             SERVICE   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99
VoteDoughnut   voting-svc     0.00%   0.2rps           1ms           1ms           1ms
[DEFAULT]      voting-svc   100.00%   0.8rps           1ms           4ms           4ms

Sie können für diese spezielle Route verschiedene benutzerdefinierte Metriken anzeigen, wie Erfolgsrate, Anfragen pro Sekunde und Latenz. Beachten Sie, dass der Endpunkt VoteDoughnut gezielt so konfiguriert ist, dass er immer einen Fehler zurückgibt und eine Erfolgsrate von 0 % ausgibt, während die Route [DEFAULT] 100 % ausgibt.

Nachdem Linkerd über einige Informationen zu Ihrem Dienst verfügt, haben Sie nun benutzerdefinierte Metriken pro Route sowie zwei Richtlinien, die durchgesetzt werden: für Timeouts und Wiederholungsversuche.

Zusammenfassung

In diesem Artikel haben Sie Linkerd in Ihrem Kubernetes-Cluster installiert und zur Überwachung einer Beispielanwendung verwendet. Sie haben nützliche Telemetriedaten wie Erfolgsrate, Durchsatz und Latenz extrahiert. Außerdem haben Sie ein Linkerd-Dienstprofil konfiguriert, um routenspezifische Metriken abzurufen und zwei Richtlinien in der Anwendung emojivoto durchzusetzen.

Wenn Sie mehr über Linkerd erfahren möchten, können Sie die äußerst hilfreiche Dokumentationsseite konsultieren. Hier sehen sie, wie Sie Ihre Dienste sichern, eine verteilte Verfolgung konfigurieren, Canaryfreigaben automatisieren und vieles mehr erledigen können.

Von hier aus können Sie sich auch Istio ansehen, was ein anderer Service Mesh mit anderen Funktionen sowie Vor- und Nachteilen ist.