beispiele für kubectl-Befehle, die Sie als Systemadministrator kennen sollten

Kubernetes, auch bekannt als K8S, ist ein beliebtes Container-Orchestrierungstool für die Verwaltung und Skalierung containerisierter Infrastrukturen

kubectl ist das gängige CLI-Tool, das wir zur Abfrage und Verwaltung eines Kubernetes-Clusters verwenden. kubectl nutzt die API-Schnittstelle von Kubernetes, um den Cluster anzuzeigen, zu kontrollieren und zu verwalten. Es wird von verschiedenen Plattformen unterstützt und lässt sich leicht für die Verwaltung eines Clusters einrichten

In diesem Artikel werden wir einige gängige kubectl-Befehle behandeln, die bei der täglichen Verwaltung von Kubernetes hilfreich sind

Kubectl erhalten

kubectl ist bereits als Teil der Kubernetes-Cluster-Einrichtung installiert. Falls Sie einen Cluster von einem entfernten System aus verwalten, können Sie es einfach installieren, um mit jeder Cluster-Einrichtung zu arbeiten

Auf einem Linux-System können Sie den folgenden Befehl verwenden, um die neueste Version von kubectl zu erhalten

$ curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Stellen Sie sicher, dass Sie die heruntergeladene Binärdatei an einem festen Ort ablegen, den Ort zu Ihrer PATH-Variablen hinzufügen und sie mit dem Befehl chmod x ausführbar machen

Auf einem Windows-Rechner können Sie die neueste verfügbare Version von kubectl herunterladen, indem Sie zunächst die letzte stabile Version von https://dl.k8s.io/release/stable.txt abrufen

Und dann laden Sie sie herunter, indem Sie {version} durch die neueste Version ersetzen, indem Sie curl verwenden als

$ curl -LO https://dl.k8s.io/release/{version}/bin/windows/amd64/kubectl.exe

Für v 1.20.0 lautet der curl-Befehl wie folgt

$ curl -LO https://dl.k8s.io/release/v1.20.0/bin/windows/amd64/kubectl.exe

Wenn Sie curl nicht auf Ihrem System haben, können Sie die ausführbare Datei von kubectl auch mit Ihrem Browser wie jeden anderen Download herunterladen

Für andere unterstützte Methoden und Plattformen finden Sie hier die offizielle Anleitung, um kubectl zu erhalten

Überprüfen der kubectl-Einrichtung

Um Ihr kubectl-Setup zu überprüfen, können Sie den Befehl version wie folgt ausführen

$ kubectl version --client

Die allgemeine Syntax für die Verwendung von kubectl lautet

$ kubectl <x><x>[Befehl]</x></x> [TYP] [NAME] [Flags]

Kontext und Konfiguration festlegen

Bevor wir kubectl-Befehle in einem Kubernetes-Cluster verwenden können, müssen wir zunächst die Konfiguration und den Kontext festlegen. Dies kann mit dem Befehl kubectl selbst geschehen

Um die aktuelle Konfiguration von kubectl anzuzeigen, verwenden Sie

$ kubectl config view

Um alle verfügbaren Kontexte aufzulisten

$ kubectl config get-contexts

Um den aktuellen Kontext für kubectl zu erhalten

$ kubectl config aktueller-kontext

Wir können den verwendeten Kontext ändern, indem wir verwenden

$ kubectl config use-context [cluster-name]

Um das Hinzufügen eines neuen Benutzers in kubeconf zu autorisieren

$ kubectl config set-credentials NAME [--client-certificate=path/to/certfile] [--client-key=path/to/keyfile] [--token=bearer_token] [--username=basic_user] [--password=basic_password]

Um zum Beispiel nur das Feld “client-key” auf dem “cluster-admin” zu setzen, ohne andere Werte zu verändern, können wir Folgendes verwenden

$ kubectl config set-credentials cluster-admin --client-key=~/.kube/admin.key

Oder, als weiteres Beispiel, um die Basisauthentifizierung für den Eintrag “cluster-admin” festzulegen, können Sie den Benutzernamen und das Passwort wie folgt angeben

$ kubectl config set-credentials cluster-admin --username=[username] --password=[password]

Wenn Sie die Daten des Client-Zertifikats in den Eintrag “cluster-admin” einbetten möchten, ändert sich die Syntax zu

$ kubectl config set-credentials cluster-admin --client-certificate=~/.kube/admin.crt --embed-certs=true

Wenn Sie möchten, dass kubectl einen bestimmten Namespace verwendet und diesen für alle nachfolgenden kubectl-Befehle in diesem Kontext speichert

$ kubectl config set-context --current --namespace=[NAMESPACE]

Erstellen von Objekten

kubectl wird verwendet, um verschiedene Objekte bereitzustellen, die in einem Kubernetes-Cluster unterstützt werden. Das Manifest kann in einer YAML- oder JSON-Datei mit der Erweiterung .yaml oder .yml bzw. .json definiert werden

Anhand der angegebenen Manifestdatei können wir mit dem folgenden Befehl definierte Ressourcen erstellen

$ kubectl apply -f [manifest.yaml]

Oder um mehrere YAML-Dateien anzugeben, verwenden Sie

$ kubectl apply -f [manifest1.yaml] [manifest2.yaml]

Um eine Ressource(n) in allen in einem Verzeichnis vorhandenen Manifestdateien zu erstellen

$ kubectl apply -f ./dir

Oder um Ressourcen aus einer URL zu erstellen

$ kubectl apply -f [URL]

Oder direkt vom Image-Namen aus dem Repository als

$ kubectl create deployment [deployment-name] --image=[image-name]

Um zum Beispiel eine einzelne Instanz des Nginx-Webservers bereitzustellen

$ kubectl create deployment nginx --image=nginx

Wenn Sie schließlich Ressourcen direkt bereitstellen möchten, indem Sie den YAML-Inhalt in die CLI eingeben, ohne auf eine gespeicherte Manifestdatei zu verweisen, versuchen Sie Folgendes

# Erstellen Sie mehrere YAML-Objekte aus stdin
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep
spec:
containers:
- name: busybox
image: busybox
args:
- sleep
- "1000000"
---
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep-less
spec:
containers:

–

 name: busybox
image: busybox
args:

–

 sleep

– “

1000"

EOF

Ressourcen anzeigen/finden

kubectl bietet den Befehl get, um die bereitgestellten Ressourcen aufzulisten, ihre Details abzurufen und mehr über sie zu erfahren

Um alle Dienste im Standard-Namespace aufzulisten, verwenden Sie

$ kubectl get services

Um Pods in allen Namespaces aufzulisten, lautet die Syntax ähnlich

$ kubectl get pods --all-namespaces

Wenn wir mehr Details zu den bereitgestellten Pods auflisten möchten, verwenden Sie das Flag -o wide wie folgt

$ kubectl get pods -o wide

Die Syntax für die Abfrage der Bereitstellungsdetails lautet wie folgt

$ kubectl get deployment [deployment-name]

Um den YAML-Inhalt eines Pods zu erhalten, können wir das Flag -o yaml wie folgt verwenden

$ kubectl get pod [pod-name] -o yaml

Oftmals benötigen wir Details über Kubernetes-Ressourcen. Der Befehl describe von kubectl hilft uns dabei, diese Details zu erhalten

Wir können mehr Details über einen Knoten erhalten

$ kubectl describe nodes [node-name]

Oder ähnlich für Pods wie

$ kubectl describe pods [pod-name]

kubectl ermöglicht die Sortierung der Ausgabe nach einem bestimmten Feld. Um die Dienste nach dem Namen des Dienstes zu sortieren, verwenden Sie

$ kubectl get services --sort-by=.metadata.name

Oder um alle laufenden Pods im Namensraum zu erhalten, können wir versuchen

$ kubectl get pods --field-selector=status.phase=Running

Um nur die externen IPs aller Knoten abzurufen, wenn sie zugewiesen sind, können wir das Flag -o jsonpath mit der folgenden Syntax verwenden

$ kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="ExternalIP")].address}'

Um Labels zu holen, die an eine Ressource, z.B. Pods, angehängt sind, versuchen Sie es

$ kubectl get pods --show-labels

Um eine Liste von Ereignissen zu erhalten, die aber nach Zeitstempel sortiert ist, können wir das Flag -sort-by wie folgt verwenden

$ kubectl get events --sort-by=.metadata.creationTimestamp

Wenn wir den aktuellen Zustand des Clusters mit dem Zustand vergleichen möchten, in dem sich der Cluster befinden würde, wenn das Manifest angewendet würde, verwenden wir den Befehl diff wie folgt

$ kubectl diff -f ./manifest-file.yaml

Ändern von Ressourcen

Eingesetzte Ressourcen werden häufig für Konfigurationsänderungen angepasst

Um ein rollierendes Update von z.B. “www”-Containern von z.B. “frontend”-Deployments durchzuführen, indem wir ihr Image aktualisieren, können wir Folgendes verwenden

$ kubectl set image deployment/frontend www=image:v2

Wir können die Historie der Deployments einschließlich der Revisionen wie folgt überprüfen

$ kubectl rollout history deployment/frontend

Oder um zu einem früheren Einsatz zurückzukehren, verwenden Sie

$ kubectl rollout undo deployment/frontend

Wir können auch zu einer bestimmten Revision zurückkehren, indem wir das Flag --to-revision wie folgt angeben

$ kubectl rollout undo deployment/frontend --bis-zur-Revision=2

Und um den Rolling-Update-Status zu überprüfen, verwenden wir

$ kubectl rollout status -w deployment/frontend

Für einen rollierenden Neustart des Deployments, sagen wir “Frontend”, verwenden Sie

$ kubectl rollout restart deployment/frontend

Wir können ein JSON-Manifest angeben, um einen Pod zu ersetzen, indem wir es wie unten gezeigt an die Standardeingabe übergeben

$ cat pod.json | kubectl replace -f -

Es kann vorkommen, dass Sie eine Ressource zwangsweise ersetzen, löschen und dann neu erstellen müssen (HINWEIS: dies führt ebenfalls zu einem Ausfall des Dienstes). Dies kann wie folgt geschehen

$ kubectl replace --force -f [manifest-datei]

Die Kennzeichnung einer Ressource (die Labels unterstützt) ist einfach und kann wie folgt durchgeführt werden

$ kubectl label pods [pod-name] new-label=[label]

Auf ähnliche Weise können Sie einer Ressource Anmerkungen hinzufügen

$ kubectl annotate pods [pod-name] icon-url=[url]

Die automatische Skalierung einer Bereitstellung ist möglich mit

$ kubectl autoscale deployment [dep-name] --min=[min-val] --max=[max-val]

Hier ist dep-name der Name des Deployments, das automatisch skaliert werden soll, und min-val und max-val bezeichnen den minimalen und maximalen Wert, der für die automatische Skalierung verwendet werden soll

Bearbeitung von Ressourcen

Es ist möglich, eine API-Ressource in Ihrem bevorzugten Editor mit dem Befehl edit zu bearbeiten

$ kubectl edit [api-ressource-name]

Oder um Ihren eigenen alternativen Editor zu verwenden, geben Sie KUBE_EDITOR wie folgt an

KUBE_EDITOR="nano" kubectl edit [api-ressource-name]

Ressourcen skalieren

Die Skalierung von Ressourcen ist eine der von Kubernetes unterstützten Funktionen, und kubectl macht es Ihnen leicht, dies zu tun

Um ein Replikatset mit dem Namen foo auf 3 zu skalieren, verwenden wir

$ kubectl scale --replicas=3 rs/foo

Stattdessen können wir auch auf eine manifestierte YAML-Datei verweisen, um die zu skalierende Ressource zu spezifizieren
$

 kubectl scale --replicas=3 -f foo.yaml

Zusätzlich können wir die Skalierung auf der Grundlage des aktuellen Stands der Bereitstellung durchführen

$ kubectl scale --current-replicas=2 --replicas=3 deployment/nginx

Löschen von Ressourcen

Erstellte Ressourcen müssen irgendwann geändert oder gelöscht werden. Mit kubectl können wir bestehende Ressourcen auf verschiedene Weise löschen

Um einen Pod anhand der Angaben in der JSON-Datei zu löschen, verwenden wir

$ kubectl delete -f ./pod.json

Pods und Dienste mit den gleichen Namen pod-name und service-name können wir wie folgt löschen

$ kubectl delete pod,service [pod-name] [service-name]

Wenn die Ressourcen mit einem Label versehen sind und wir Ressourcen mit einem bestimmten Label, sagen wir label-name, löschen müssen, können wir Folgendes verwenden

$ kubectl delete pods,services -l name=[label-name]

Um alle Pods und Dienste zu löschen, die in einem Namensraum enthalten sind, verwenden Sie

$ kubectl -n <x>[Namespace]</x> delete pod,svc --all

Interaktion mit laufenden Pods

Wir können kubectl verwenden, um Details über laufende Pods zu erhalten, die bei der Verwaltung eines Kubernetes-Clusters helfen

Einer der gebräuchlichsten Befehle ist das Abrufen von Protokollen eines Pods, und zwar wie folgt

$ kubectl logs [pod-name]

Oder um Pod-Protokolle mit einem bestimmten Label auszulesen

$ kubectl logs -l name=[label-name]

Oder um Protokolle für einen bestimmten Container abzurufen als

$ kubectl logs -l name=[label-name] -c [container-name]

Wir können die Logs auch wie mit dem Linux-Befehl tail -f mit dem -f-Flag von kubectl streamen

$ kubectl logs -f [pod-name]

Das interaktive Ausführen eines Pods kann mit kubectl wie folgt durchgeführt werden

$ kubectl run -i --tty busybox --image=busybox -- sh

Oder um einen Pod in einem bestimmten Namensraum zu starten, verwenden Sie

$ kubectl run nginx --image=nginx -n <x>[Namespace]</x>

Sie können ihn mit dem Befehl attach an einen laufenden Container anhängen

$ kubectl attach [pod-name] -i

Die Portweiterleitung kann für einen Pod zur Laufzeit mit dem folgenden Befehl durchgeführt werden

$ kubectl port-forward [pod-name] [local-machine-port]:[pod-port]

Um etwas direkt in einem Pod-Login auszuführen und die Ausgabe zu erhalten, verwenden Sie

$ kubectl exec [pod-name] -- <x><x>[Befehl]</x></x>

Der obige Befehl funktioniert, wenn der Pod einen einzelnen Container enthält. Für Pods mit mehreren Containern verwenden Sie

$ kubectl exec [pod-name] -c [container-name]

— [befehl

 <x><x>]</x></x>

Um die Leistungsdaten eines bestimmten Pods und seiner Container anzuzeigen, können wir Folgendes verwenden

$ kubectl top pod [pod-name] --containers

Wenn Sie die Daten nach einer bestimmten Größe sortieren möchten, z.B. CPU oder Speicher, können Sie dies mit folgendem Befehl tun

$ kubectl top pod [pod-name] --sort-by=cpu

Interaktion mit Knoten und Clustern

kubectl kann mit den Nodes und dem Cluster interagieren. Hier sind einige der Befehle, die kubectl dafür verwendet

Um einen Knoten als nicht planbar zu markieren, verwenden Sie

$ kubectl cordon [Knoten-Name]

Um einen Knoten als Teil der Vorbereitung für die Wartung zu entleeren

$ kubectl drain [Knoten-Name]

Um den Knoten wieder als planbar zu markieren, verwenden Sie

$ kubectl uncordon [node-name]

Um die Leistungsdaten eines Knotens abzurufen, können wir verwenden

$ kubectl top node [node-name]

Um Details über den aktuellen Cluster zu erhalten

$ kubectl cluster-info

Zusätzlich können wir den Zustand des Clusters in die Standardausgabe ausgeben

$ kubectl cluster-info dump

Oder um den Status in eine Datei auszugeben, verwenden Sie

$ kubectl cluster-info dump --output-directory=/path/to/cluster-state

Fazit

Kubernetes ist das Schlagwort in der Branche und zu wissen, wie man es effektiv verwaltet, wird Ihre Karriere immer fördern. kubectl ist die primäre Schnittstelle zur Interaktion mit einem Kubernetes-Cluster und dieser Artikel hat gezeigt, wie leistungsfähig dieses Tool in den Händen eines erfahrenen Benutzers ist

Dennoch können wir nur einen zusammenfassenden Überblick darüber geben, was kubectl noch alles kann. Wenn Sie mehr darüber erfahren möchten und wissen möchten, was es alles unterstützt, lesen Sie die offizielle Dokumentation hier.