8 Tipps und Tricks zu Kubernetes

Die meisten der unten aufgeführten Tipps verwenden kubectl, ein leistungsstarkes Befehlszeilentool, mit dem Sie Befehle auf einem Kubernetes-Cluster ausführen können.

Falls Sie vor dem Lesen dieser Tipps Hintergrundinformationen zu Kubernetes benötigen, finden Sie diese in den folgenden Ressourcen:

• Was ist Kubernetes?
• VIDEO – Container-Orchestrierung erklärt
• Kubernetes-Cluster: Architektur für schnelle, kontrollierte Cloud-App-Bereitstellung
• Was ist Kubernetes Ingress?
• Erste Schritte mit IBM Cloud Kubernetes Service

Sie können einen Kubernetes-Cluster mithilfe von Namespaces in mehrere Umgebungen unterteilen (z. B. Dev1, Dev2, QA1, QA2 usw.), und jede Umgebung kann von einem anderen Benutzer verwaltet werden. Eine der Unannehmlichkeiten beim Schreiben von kubectl-Befehlen besteht darin, dass Sie jedes Mal, wenn Sie einen Befehl schreiben, am Ende die Option--namespace  angeben müssen. Häufig wird dies vergessen, sodass Objekte (Pods, Dienste, Bereitstellungen) im falschen Namespace erstellt werden. 

Mit diesem Trick können Sie die Namespace-Präferenz festlegen, bevor Sie kubectl-Befehle ausführen. Führen Sie vor der Ausführung der kubectl-Befehle den folgenden Befehl aus, um den Namespace für alle nachfolgenden kubectl-Befehle in Ihrem aktuellen Kontext zu speichern:

kubectl config set-context $(kubectl config current-context) --namespace=mynamespace

Nachfolgend sind einige der gebräuchlichsten und nützlichsten Befehle mit Namespace aufgeführt:

• kubectl get namespaces
• kubectl create namespace mynamespace
• kubectl get pods --all-namespaces (Liste alle Pods mit Status aus allen Namespaces auf.)
• kubectl get po -o wide -n <namspace1> -n <namespace2> -n <namespace3> (Dieser Befehl identifiziert die Pods in jedem Namespace.)
• kubectl describe namespace <namespace>
• kubectl config view --minify | grep namespace (Dieser Befehl stellt sicher, dass Sie den Namespace für Ihren aktuellen Kontext korrekt festlegen.) 

Kubernetes-Befehle können recht lang sein, daher ist die Einrichtung einiger Aliase für die Ausführung von kubectl sehr hilfreich. Sie müssen den vollständigen Befehl nicht mehr immer wieder ausschreiben, was Ihnen die Arbeit erheblich erleichtert, wenn Sie mehrere Kubernetes-Befehle in einer Sitzung ausführen möchten.

Nachfolgend haben wir Aliase für einige häufig verwendete Befehle aufgelistet. Führen Sie diese Befehle vor der Ausführung von kubectl-Befehlen aus, um Zeit zu sparen. Beispiel: Sie müssen lediglich Folgendes eingeben:  K anstatt kubectl:

• Alias k='kubectl'
• alias kc='k config view --minify | grep name'
• alias kdp='kubectl describe pod'
• alias krh='kubectl run --help | more'
• alias ugh='kubectl get --help | more'
• alias c='clear'
• alias kd='kubectl describe pod'
• alias ke='kubectl explain'
• alias kf='kubectl create -f'
• alias kg='kubectl get pods --show-labels'
• alias kr='kubectl replace -f'
• alias kh='kubectl --help | more'
• alias krh='kubectl run --help | more'
• alias ks='kubectl get namespaces'
• alias l='ls -lrt'
• alias ll='vi ls -rt | tail -1'
• alias kga='k get pod --all-namespaces'
• alias kgaa='kubectl get all --show-labels'

Es gibt viele verschiedene Editoren zum Schreiben von YAML-Dateien, aber es gibt viele Situationen, in denen man eine generierte YAML-Datei schnell anpassen muss, während man im Terminal arbeitet. Das ist ein großartiger Ort, um unseren bewährten Vi zu verwenden, den Texteditor, der ursprünglich für das Unix-Betriebssystem entwickelt wurde.

Der vi-Editor ist gut dokumentiert und wird von einer lebendigen Open-Source-Community unterstützt. Eines der Probleme beim Erstellen von YAML-Dateien mit dem vi-Editor ist jedoch das Platzproblem. Wir brauchen eine Möglichkeit zum Einrücken mit Tabulatoren und zum Ausrichten mit Leerzeichen. Die Verwendung von Tabulatoren oder Leerzeichen für Leerzeichen hat beim Schreiben von YAML-Dateien schon immer zu Syntaxproblemen geführt (z. B. wird beim Drücken der Eingabetaste standardmäßig ein YAML mit 2 Leerzeichen verwendet).

Die Lösung? Erstellen Sie eine ~/.vimrc -Datei mit diesen Zeilen, bevor Sie YAML-Dateien mit dem vi-Editor erstellen, um die Bearbeitung zu vereinfachen:

• set smarttab
• set expandtab
• set shiftwidth=4
• set tabstop=4
• set number

Wir können komplexe YAML-Dateien über die Befehlszeile mit kubectl-Befehlen erstellen.

Die meisten Menschen würden zustimmen, dass die Arbeit mit YAML-Dateien keinen Spaß macht, und Kubernetes-YAML-Dateien können sehr ausführlich und schwer von Grund auf neu zu erstellen sein. Es ist wesentlich einfacher, die YAML-Datei mithilfe von kubectl-Befehlen zu erstellen, als sie mit einem Editor auf einer leeren Seite zu beginnen.

Die folgenden Befehle erstellen eine YAML-Datei mit dem Namen  yamlfile . Sobald Sie die YAML-Datei mit diesen Kubectl-Befehlen erstellt haben, können Sie sie an Ihre Anforderungen anpassen und verwenden, anstatt von Grund auf neu zu schreiben:

• kubectl run busybox --image=busybox --dry-run=client -o yaml --
  restart=Never > yamlfile.yaml
  

  kubectl create job my-job --dry-run=client -o yaml --image=busybox -- date>yamlfile.yaml
  

• kubectl get -o yaml deploy/nginx > 1.yaml(Stellen Sie sicher, dass Sie
  eine Bereitstellung namens Nginx haben)
  

• kubectl run busybox --image=busybox --dry-run=client -o yaml 
  --restart=Never -- /bin/sh -c "while true; do echo hello; echo 
  hello again;done" > yamlfile.yaml
  

• kubectl run wordpress --image=wordpress –-expose –-port=8989 -
  -restart=Never -o yaml
  

• kubectl run test --image=busybox --restart=Never --dry -
  run=client -o yaml -- bin/sh -c 'echo test;sleep 100' > 
  yamlfile.yaml(Beachten Sie, dass --bin am Ende steht. Dadurch wird eine YAML-Datei erstellt.)
  

(Hinweis: --bin  kommt am Ende. Dadurch wird eine YAML-Datei erstellt.)

Eine weitere gute Möglichkeit zum Erstellen der YAML-Datei ist das direkte Herunterladen der Datei aus dem Internet mit dem wget Befehl. 

In Tipp 1 haben wir einige nützliche Befehle zur Verwendung von Kubernetes-Namespaces kennengelernt und sie gespeichert, damit Sie nicht jeden Befehl ergänzen müssen. Erweitern wir den Tipp, um den Wechsel zwischen Namespaces und kubectl-Kontexten zu erleichtern.

Es gibt verschiedene Tools, die dabei helfen können, aber wir bevorzugen kubectx und kubens für die Verwaltung von Kontexten bzw. Namespaces. Details zu kubectx und kubens finden Sie hier.

Hier erfahren Sie, wie Sie die Linux-Binärdateien für kubectx und das kubens-Dienstprogramm herunterladen:

• wget https://github.com/ahmetb/kubectx/releases/download/v0.9.0/kubectx_v0.9.0_linux_x86_64.tar.gz
  

• wget https://github.com/ahmetb/kubectx/releases/download/v0.9.0/kubens_v0.9.0_linux_x86_64.tar.gz
  

Anschließend extrahieren Sie sie mit den folgenden Befehlen:

• tar -xvf kubectx_v0.9.0_linux_x86_64.tar.gz
  

• tar -xvf kubens_v0.9.0_linux_x86_64.tar.gz
  

Schließlich verschieben Sie sie auf Ihren PFAD:

• sudo mv kubectx /usr/local/bin
• sudo mv kubens /usr/local/bin

Nach der Installation können Sie einfach kubens verwenden, um die Namespaces aufzulisten und zwischen ihnen zu wechseln:

Bei der Arbeit mit mehreren Clustern macht kubectx das Wechseln zwischen Kontexten ganz einfach:

Wussten Sie, dass kubectl eine automatische Vervollständigung für BASH und ZSH bietet? Dies ist eine optionale Konfiguration.

Nehmen wir an, Sie verstehen die Konzepte von Kubernetes und haben bereits Erfahrung mit kubectl, aber vielleicht fällt es Ihnen schwer, sich Befehle zu merken. Zuerst installieren Sie Bash-Completion und dann aktivieren Sie die automatische Vervollständigung von Kubectl. Alle Details dazu finden Sie auf der Dokumentationsseite „kubectl installieren und einrichten“ für Ihre Umgebung.

Unten sind die Konfigurationsoptionen mit der Autovervollständigungsfunktion aufgeführt:

Jetzt einfach drauflostippen!

Der oberste Befehl ist wahrscheinlich eines der beliebtesten Tools zur Überwachung von Prozessen und Systemressourcen. Er bietet eine einfache, zeichenbasierte Benutzeroberfläche und schnellen Zugriff auf wichtige Informationen.

Sie können die Ressourcen pro Knoten einsehen:

Ressourcennutzung pro Pod:

Und der praktische Watch-Befehl kann Ihnen helfen, den Befehl in einem gewünschten Intervall anzuzeigen, ohne ihn immer wieder ausführen zu müssen. Im folgenden Beispiel wird er alle fünf Sekunden ausgeführt (die Standardeinstellung ist zwei Sekunden): 

watch kubectl top node -n 5

Hinweis: Der Watch-Befehl muss für Ihre Umgebung heruntergeladen werden.

Damit der Befehl „top“ funktioniert, muss auf Ihrem Kubernetes-Cluster auch Heapster ausgeführt werden. Andernfalls erhalten Sie die folgende Fehlermeldung: „Fehler vom Server (NotFound): Der Server konnte die angeforderte Ressource nicht finden (get services http:heapster:)“.

Der Befehl kubectl liefert eine zusammenfassende Ansicht der vom API-Server gespeicherten Ressourcen. Der API-Server speichert noch viele weitere Felder, die hier nicht angezeigt werden. Sie können den Befehl „kubectl get“ mit der Rohdatenausgabe verwenden, um Ihre eigene Visualisierung und Befehle zu erstellen. 

Sie können die Ressourcen in JSON mit folgendem Befehl ausgeben:

kubectl get deployments -o json

Sie können die Ressource auch direkt über den API-Aufruf aufrufen:

kubectl get --raw=/apis/apps/v1/deployments

Sie können die Ausgabe sogar mit Tools wie jq kombinieren, um verschiedene Visualisierungen zu erstellen, die Ausgabe zu filtern oder die Ausgabe an andere Tools zur erweiterten Automatisierung weiterzuleiten. 

Beispielsweise kann es schwierig sein, Probleme in einem Cluster mit mehreren Namespaces und Bereitstellungen zu finden. Das folgende Beispiel verwendet jedoch die Raw-API, um alle Bereitstellungen im Cluster zu scannen und nur die Bereitstellungen mit fehlerhaften Replikaten herauszufiltern:

kubectl get --raw=/apis/apps/v1/deployments | jq '.items[] 
| {name: .metadata.name, replicas: .status.replicas, available:
 (.status.availableReplicas // 0), unavailable:
 (.status.unavailableReplicas // 0)} | select (.unavailable > 0)'

Im Folgenden finden Sie eine kurze Erläuterung des oben genannten Befehls:

• Zuerst rufen wir die Kubernetes-API auf, um alle Bereitstellungen zurückzugeben. Die Standardausgabe erfolgt in JSON. Die Struktur des JSON-Dokuments ist schwer zu visualisieren, aber Sie können es an jq weiterleiten, um einen besseren Überblick zu erhalten, wie im folgenden Beispiel:

  kubectl get --raw=/apis/apps/v1/deployments | jq .
  

• Beachten Sie, dass das Antwortdokument für jede Bereitstellung ein Array von Elementen enthält. Wir möchten das Statusfeld dieses Arrays bis zum Schluss untersuchen. Der folgende Befehl zeigt, wie Sie nur die benötigten Daten und einen Standardwert von 0 ausgeben können, wenn das Feld nicht verfügbar ist:

   

  kubectl get --raw=/apis/apps/v1/deployments | jq '.items[] |
  {name: .metadata.name, replicas: .status.replicas, available:
   (.status.availableReplicas // 0), unavailable: 
  (.status.unavailableReplicas // 0)}'
  
  
  
  
  

• Das letzte Puzzleteil ist die Verwendung der Funktion select, um nur Bereitstellungen mit nicht verfügbaren Replikaten anzuzeigen:

   

  kubectl get --raw=/apis/apps/v1/deployments | jq '.items[] | 
  {name: .metadata.name, replicas: .status.replicas, available:
   (.status.availableReplicas // 0), unavailable: 
  (.status.unavailableReplicas // 0)} | select (.unavailable > 0)'
  

Wir hoffen, dass Ihnen einige dieser Tipps und Tricks bei der Arbeit mit Kubernetes nützlich sein werden. Lassen Sie uns wissen, ob Sie einen Lieblingstipp haben oder einen eigenen Tipp, den Sie gerne teilen möchten.

Vergessen Sie nicht, den IBM Cloud Kubernetes Service auszuprobieren und diese Tipps und Tricks anzuwenden.

Möchten Sie kostenlos praktische Erfahrungen mit Kubernetes sammeln? Profitieren Sie von IBM CloudLab, einer neuen interaktiven Plattform, die Tutorials mit Zertifizierung anbietet – ohne Kosten oder Konfiguration.