Kubernetes, auch bekannt als K8S, ist ein beliebtes Tool zur Container-Orchestrierung zum Verwalten und Skalieren der containerisierten Infrastruktur.
kubectl ist das gängige CLI-Tool, mit dem wir einen Kubernetes-Cluster abfragen und verwalten. kubectl verwendet die API-Schnittstelle von Kubernetes, um den Cluster anzuzeigen, zu steuern und zu verwalten. Es wird plattformübergreifend unterstützt und kann einfach für die Verwaltung eines Clusters eingerichtet werden.
In diesem Artikel werden einige gängige kubectl-Befehle behandelt, die bei der täglichen Verwaltung von helfen Kubernetes.
Kubectl bekommen
kubectl ist bereits im Rahmen des Kubernetes-Cluster-Setups installiert. Wenn Sie einen Cluster von einem Remote-System aus verwalten, können Sie ihn problemlos installieren, um mit jedem Cluster-Setup zu arbeiten.
Für ein 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 Speicherort ablegen und den Speicherort zu Ihrem hinzufügen PATH
Variable und machen es ausführbar mit chmod +x
Befehl.
Für ein Windows Box können Sie die neueste verfügbare Kubectl-Version herunterladen, indem Sie zuerst die neueste stabile Release-Version von https://dl.k8s.io/release/stable.txt herunterladen
Und dann laden Sie es durch Ersetzen herunter {version}
mit der neuesten Version mit Curl als:
$ curl -LO https://dl.k8s.io/release/{version}/bin/windows/amd64/kubectl.exe
Für Version 1.20.0 ist hier der Befehl curl:
$ curl -LO https://dl.k8s.io/release/v1.20.0/bin/windows/amd64/kubectl.exe
Wenn Sie kein Curl auf Ihrem System haben, können Sie die ausführbare Datei kubectl wie jeden anderen Download auch mit Ihrem Browser herunterladen.
Für andere unterstützte Methoden und Plattformen finden Sie den offiziellen Leitfaden, um kubectl zu erhalten hier an.
Überprüfen Sie das kubectl-Setup
Um Ihr kubectl-Setup zu überprüfen, können Sie den Versionsbefehl wie folgt ausführen:
$ kubectl version --client
Die allgemeine Syntax für die Verwendung von kubectl lautet:
$ kubectl [command] [TYPE] [NAME] [flags]
Stellen Sie Kontext und Konfiguration ein
Bevor wir kubectl-Befehle in einem Kubernetes-Cluster verwenden können, müssen wir zuerst die Konfiguration und den Kontext festlegen. Dies kann mit dem Befehl kubectl selbst erfolgen.
Verwenden Sie zum Anzeigen der aktuellen Konfiguration von kubectl Folgendes:
$ kubectl config view
So listen Sie alle verfügbaren Kontexte auf:
$ kubectl config get-contexts
So erhalten Sie den aktuellen Kontext für kubectl:
$ kubectl config current-context
Wir können den verwendeten Kontext ändern, indem wir Folgendes verwenden:
$ kubectl config use-context [cluster-name]
So autorisieren Sie einen neuen Benutzer zum Hinzufügen in kubeconf:
$ 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 beispielsweise nur das Feld "Client-Schlüssel" im "Cluster-Administrator" festzulegen, ohne andere Werte zu berühren, können wir Folgendes verwenden:
$ kubectl config set-credentials cluster-admin --client-key=~/.kube/admin.key
Als weiteres Beispiel können Sie den Benutzernamen und das Kennwort wie folgt angeben, um die Basisauthentifizierung für den Eintrag "Cluster-Administrator" festzulegen:
$ kubectl config set-credentials cluster-admin --username=[username] --password=[password]
Wenn Sie Clientzertifikatdaten in den Eintrag "cluster-admin" einbetten möchten, ändert sich die Syntax wie folgt:
$ 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 ihn für alle nachfolgenden kubectl-Befehle in diesem Kontext speichert:
$ kubectl config set-context --current --namespace=[NAMESPACE]
Objekte erstellen
kubectl wird verwendet, um verschiedene Objekte bereitzustellen, die in einem Kubernetes-Cluster unterstützt werden. Sein Manifest kann in a definiert werden YAML
or JSON
Datei mit Erweiterung .yaml
or .yml
und .json
beziehungsweise.
Mit der angegebenen Manifestdatei können wir definierte Ressourcen mit dem folgenden Befehl erstellen:
$ kubectl apply -f [manifest.yaml]
Oder verwenden Sie:, um mehrere YAML-Dateien anzugeben:
$ kubectl apply -f [manifest1.yaml] [manifest2.yaml]
So erstellen Sie eine Ressource in allen Manifestdateien, die in einem Verzeichnis vorhanden sind:
$ kubectl apply -f ./dir
Oder um Ressourcen aus einer URL zu erstellen:
$ kubectl apply -f [URL]
Oder direkt vom Bildnamen aus dem Repository als:
$ kubectl create deployment [deployment-name] --image=[image-name]
So stellen Sie beispielsweise eine einzelne Instanz des Nginx-Webservers bereit:
$ kubectl create deployment nginx --image=nginx
Zum Schluss können Sie Ressourcen direkt bereitstellen, indem Sie das eingeben YAML Inhalt in der CLI, ohne auf eine tatsächlich gespeicherte Manifestdatei zu verweisen, versuchen Sie Folgendes:
# Create multiple YAML objects from 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
Anzeigen / Suchen von Ressourcen
kubectl bietet get
Befehl, um die bereitgestellten Ressourcen aufzulisten, ihre Details abzurufen und mehr über sie zu erfahren.
Verwenden Sie Folgendes, um alle Dienste im Standard-Namespace aufzulisten:
$ kubectl get services
In ähnlicher Weise lautet die Syntax für die Auflistung von Pods in allen Namespaces:
$ kubectl get pods --all-namespaces
Wenn wir weitere Details zu den bereitgestellten Pods auflisten müssen, verwenden Sie -o wide
kennzeichnen als:
$ kubectl get pods -o wide
Die Syntax zum Abrufen von Bereitstellungsdetails lautet wie folgt:
$ kubectl get deployment [deployment-name]
Um den YAML-Inhalt eines Pods zu erhalten, können wir ihn verwenden -o yaml
Flagge wie:
$ kubectl get pod [pod-name] -o yaml
Oft müssen wir Details zu den Ressourcen von Kubernetes erhalten. Der Beschreibungsbefehl von kubectl hilft dabei, diese Details zu erhalten.
Weitere Informationen zu einem Knoten erhalten Sie unter:
$ kubectl describe nodes [node-name]
Oder ähnlich für Pods wie:
$ kubectl describe pods [pod-name]
Mit kubectl können Sie die Ausgabe nach einem bestimmten Feld sortieren. Verwenden Sie zum Auflisten von Diensten, die nach Dienstnamen sortiert sind:
$ kubectl get services --sort-by=.metadata.name
Oder um alle laufenden Pods in den Namespace zu bekommen, können wir versuchen:
$ kubectl get pods --field-selector=status.phase=Running
Um nur die externen IPs aller Knoten abzurufen, können wir diese verwenden, falls sie zugewiesen sind -o jsonpath
Flag mit der folgenden Syntax:
$ kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="ExternalIP")].address}'
Versuchen Sie Folgendes, um an eine Ressource angehängte Beschriftungen abzurufen, z. B. Pods:
$ kubectl get pods --show-labels
Um eine Liste von Ereignissen zu erhalten, die jedoch nach Zeitstempel sortiert ist, können wir verwenden -sort-by
kennzeichnen als:
$ kubectl get events --sort-by=.metadata.creationTimestamp
Wenn wir den aktuellen Status des Clusters mit dem Status vergleichen möchten, in dem sich der Cluster befinden würde, wenn das Manifest angewendet würde, verwenden wir diff
Befehl als:
$ kubectl diff -f ./manifest-file.yaml
Ressourcen ändern
Bereitgestellte Ressourcen werden häufig für Konfigurationsänderungen geändert.
Um ein fortlaufendes Update von beispielsweise "www" -Containern oder "Frontend" -Bereitstellung durch Aktualisieren ihres Images durchzuführen, können wir Folgendes verwenden:
$ kubectl set image deployment/frontend www=image:v2
Wir können den Verlauf von Bereitstellungen einschließlich der Überarbeitung wie folgt überprüfen:
$ kubectl rollout history deployment/frontend
Verwenden Sie zum Zurücksetzen auf eine frühere Bereitstellung Folgendes:
$ kubectl rollout undo deployment/frontend
Wir können auch auf eine bestimmte Revision zurücksetzen, indem wir angeben --to-revision
kennzeichnen als:
$ kubectl rollout undo deployment/frontend --to-revision=2
Und um den Status des fortlaufenden Updates zu überprüfen, verwenden wir:
$ kubectl rollout status -w deployment/frontend
Verwenden Sie für einen fortlaufenden Neustart der Frontend-Bereitstellung Folgendes:
$ 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 das Ersetzen, Löschen und erneute Erstellen einer Ressource erzwingen müssen (HINWEIS: Dies führt auch zu einem Dienstausfall). Dies kann wie folgt erfolgen:
$ kubectl replace --force -f [manifest-file]
Das Beschriften einer Ressource (die Beschriftungen unterstützt) ist einfach und kann folgendermaßen erfolgen:
$ kubectl label pods [pod-name] new-label=[label]
Ebenso können Anmerkungen zu einer Ressource hinzugefügt werden, indem Folgendes verwendet wird:
$ 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 dep-name
ist der Name der Bereitstellung, die automatisch skaliert werden soll, und min-val
und max-val
bezeichnet den minimalen und maximalen Wert, der für die automatische Skalierung verwendet werden soll.
Ressourcen bearbeiten
Es ist möglich, eine API-Ressource in Ihrem bevorzugten Editor mit zu bearbeiten edit
Befehl.
$ kubectl edit [api-resource-name]
Oder geben Sie an, um Ihren eigenen alternativen Editor zu verwenden KUBE_EDITOR
mögen:
KUBE_EDITOR="nano" kubectl edit [api-resource-name]
Skalieren von Ressourcen
Die Skalierung von Ressourcen ist eine der von Kubernetes unterstützten Funktionen, und kubectl macht dies einfach.
Für die Skalierung eines Replikatsatzes mit dem Namen foo auf 3 verwenden wir:
$ kubectl scale --replicas=3 rs/foo
Stattdessen können wir auf eine Manifest-YAML-Datei verweisen, um die zu skalierende Ressource wie folgt anzugeben:
$ kubectl scale --replicas=3 -f foo.yaml
Wir können zusätzlich eine Skalierung basierend auf dem aktuellen Bereitstellungsstatus durchführen als:
$ kubectl scale --current-replicas=2 --replicas=3 deployment/nginx
Ressourcen löschen
Erstellte Ressourcen müssen eventuell geändert oder gelöscht werden. Mit kubectl können wir vorhandene Ressourcen auf verschiedene Arten löschen.
Um einen Pod mithilfe der Spezifikation aus der JSON-Datei zu löschen, verwenden wir:
$ kubectl delete -f ./pod.json
Wir können Pods und Services mit demselben Namen löschen pod-name
und service-name
als:
$ kubectl delete pod,service [pod-name] [service-name]
Wenn die Ressourcen beschriftet sind und wir Ressourcen mit einer bestimmten Beschriftung löschen müssen, sagen wir label-name
, wir können benutzen:
$ kubectl delete pods,services -l name=[label-name]
Verwenden Sie Folgendes, um alle in einem Namespace enthaltenen Pods und Dienste zu löschen:
$ kubectl -n [namespace] delete pod,svc --all
Interaktion mit laufenden Pods
Wir können kubectl verwenden, um Details zum Ausführen von Pods zu erhalten, die helfen Verwalten eines Kubernetes-Clusters.
Einer der häufigsten Befehle besteht darin, Protokolle eines Pods abzurufen, die wie folgt ausgeführt werden können:
$ kubectl logs [pod-name]
Oder um Pod-Protokolle mit einem bestimmten Etikett zu sichern:
$ kubectl logs -l name=[label-name]
Oder um Protokolle für einen bestimmten Container abzurufen:
$ kubectl logs -l name=[label-name] -c [container-name]
Wir können auch Protokolle streamen, wie wir es unter Linux tun tail -f
Befehl mit Kubectl -f
Flagge auch:
$ kubectl logs -f [pod-name]
Das interaktive Ausführen eines Pods kann mit kubectl wie folgt erfolgen:
$ kubectl run -i --tty busybox --image=busybox -- sh
Oder um einen Pod in einem bestimmten Namespace auszuführen, verwenden Sie:
$ kubectl run nginx --image=nginx -n [namespace]
Sie können es mit an einen laufenden Container anhängen attach
Befehl:
$ 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 auszuführen und die Ausgabe zu erhalten, verwenden Sie:
$ kubectl exec [pod-name] -- [command]
Der obige Befehl funktioniert, wenn der Pod einen einzelnen Container enthält. Verwenden Sie für Pods mit mehreren Containern:
$ kubectl exec [pod-name] -c [container-name] -- [command]
Um Leistungsmetriken für einen bestimmten Pod und seine Container anzuzeigen, können wir Folgendes verwenden:
$ kubectl top pod [pod-name] --containers
Oder um es nach einer Kennzahl wie CPU oder Speicher zu sortieren, können wir es erreichen, indem wir:
$ kubectl top pod [pod-name] --sort-by=cpu
Interaktion mit Knoten und Cluster
kubectl kann mit den Knoten und dem Cluster interagieren. Hier sind einige der Befehle, die kubectl für dasselbe verwendet.
Verwenden Sie zum Markieren eines Knotens als nicht planbar:
$ kubectl cordon [node-name]
So entleeren Sie einen Knoten im Rahmen der Wartungsvorbereitung:
$ kubectl drain [node-name]
Verwenden Sie Folgendes, um den Knoten wieder als planbar zu markieren:
$ kubectl uncordon [node-name]
Zum Abrufen von Leistungsmetriken für einen Knoten können wir Folgendes verwenden:
$ kubectl top node [node-name]
So erhalten Sie Details zum aktuellen Cluster:
$ kubectl cluster-info
Wir können den Clusterstatus zusätzlich auf die Standardausgabe sichern, indem wir:
$ kubectl cluster-info dump
Oder um in eine Datei zu kopieren, verwenden Sie:
$ kubectl cluster-info dump --output-directory=/path/to/cluster-state
Fazit
Kubernetes ist das Schlagwort in der Branche und das Wissen, wie man es effektiv verwaltet, wird Ihre Karriere immer fördern. kubectl ist die primäre Schnittstelle für die Interaktion mit einem Kubernetes-Cluster. In diesem Artikel wurde gezeigt, wie leistungsfähig dieses Tool in den Händen eines erfahrenen Benutzers ist.
Dennoch können wir nur eine zusammenfassende Ansicht darüber geben, was Kubectl möglicherweise noch mehr kann. Weitere Informationen finden Sie in der offiziellen Dokumentation hier an.