Beispiele für kubectl-Befehle, bekannt als sysadmin (2023)

Kubernetes, auch bekannt als K8S, ist ein beliebtes Container-Orchestrierungstool zum Verwalten und Skalieren von containerisierter Infrastruktur.

kubectl ist das gemeinsame CLI-Tool, das wir zum Abfragen und Verwalten eines Kubernetes-Clusters verwenden. kubectl verwendet die Kubernetes-API-Schnittstelle zum Anzeigen, Steuern und Verwalten des Clusters. Es unterstützt mehrere Plattformen und kann einfach für die Verwaltung eines Clusters konfiguriert werden.

Dieser Artikel behandelt einige gängige kubectl-Befehle, die bei der täglichen Verwaltung von helfenKubernetes.

kubectl bekommen

kubectl ist bereits als Teil des Kubernetes-Cluster-Setups installiert. Wenn Sie einen Cluster von einem Remote-System aus verwalten, können Sie ihn einfach so installieren, dass er mit jeder Cluster-Konfiguration funktioniert.

FürLinuxsystem 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 und den Ort zu Ihrer hinzufügenCAMINOVariable und machen es damit ausführbarchmod +xDomain.

FürFensterBox können Sie die neueste verfügbare kubectl-Version herunterladen, indem Sie zuerst die neueste stabile Version von https://dl.k8s.io/release/stable.txt herunterladen

Und dann laden Sie es herunter, indem Sie es ersetzen{Ausführung}mit der neuesten Version mit Curl wie:

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

Für Version 1.20.0 ist hier der Curl-Befehl:

$ 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 kubectl-Datei wie jeden anderen Download über Ihren Browser herunterladen.

Weitere unterstützte Methoden und Plattformen finden Sie im offiziellen Leitfaden zum Abrufen von kubectlauf hier.

Überprüfen Sie die kubectl-Konfiguration

Um die kubectl-Konfiguration 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 [Befehl] [TYPE] [NAME] [Flags]

Kontext und Einstellungen festlegen

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

Um die aktuelle kubectl-Konfiguration anzuzeigen, verwenden Sie:

Konfigurationsansicht $ kubectl

So listen Sie alle verfügbaren Kontexte auf:

$ kubectl config erhält Kontexte

So erhalten Sie den aktuellen Kontext von kubectl:

$ kubectl config kontextaktuell

Wir können den verwendeten Kontext ändern mit:

$ kubectl config use-context [Clustername]

So autorisieren Sie einen neuen Benutzer zum Hinzufügen von kubeconf:

$ kubectl config set-credentials NAME [--client-certificate=routa/al/archivocertificado] [--client-key=routa/al/archivoclave] [--token=porter_token] [--username=basic_usuario] [-- Passwort=Basispasswort]

Um beispielsweise nur das Feld „Client Key“ im „Cluster Manager“ festzulegen, ohne andere Werte zu berühren, können wir Folgendes verwenden:

$ kubectl config set-credentials clúster-admin --client-key=~/.kube/admin.key

Als weiteres Beispiel können Sie den Benutzernamen und das Kennwort angeben, um die Basisauthentifizierung für die Anmeldung des Cluster-Administrators wie folgt zu definieren:

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

Wenn Sie die Client-Zertifikatsdaten in die Cluster-Manager-Eingabe 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 in diesem Kontext für alle nachfolgenden kubectl-Befehle speichert:

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

Objekte erstellen

kubectl wird verwendet, um verschiedene Objekte bereitzustellen, die mit einem Kubernetes-Cluster kompatibel sind. Ihr Manifest kann in a definiert werdenYAMLÖJSONDatei mit Erweiterung.yamlÖ.ymlmi.jsonbzw.

Mit der angegebenen Manifestdatei können wir mit dem folgenden Befehl definierte Ressourcen 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 für alle in einem Verzeichnis vorhandenen Manifestdateien:

$ kubectl apply -f ./dir

Oder um Ressourcen aus einer URL zu erstellen:

$ kubectl apply -f [URL]

Oder direkt aus dem Repository-Image-Namen wie:

$ kubectl create Deployment [Bereitstellungsname] --image=[Image-Name]

Um beispielsweise eine einzelne Nginx-Webserverinstanz zu implementieren:

$ kubectl create nginx implementierung --image=nginx

Schließlich können Sie Ressourcen direkt bereitstellen, indem Sie Folgendes eingebenYAMLInhalt in der CLI, ohne auf eine tatsächlich gespeicherte Manifestdatei zu verweisen, versuchen Sie Folgendes:

# Erstellen Sie mehrere YAML-Objekte aus stdincat <<EOF | kubectl apply -f -apiVersion: v1kind: Podmetadata:name: busybox-sleepspec:containers:- name: busyboximage: busyboxargs:- sleep- "1000000"---apiVersion: v1kind: Podmetadata:name: busybox-sleep-lessspec:containers :- Name: Busy-Box Bild: Busy-Box Argumente:- sleep- "1000" EOF

Ressourcen anzeigen/finden

kubectl bietetbekommenBefehl, um bereitgestellte Ressourcen aufzulisten, ihre Details abzurufen und mehr über sie zu erfahren.

Verwenden Sie Folgendes, um alle Dienste im Standard-Namespace aufzulisten:

$ kubectl Dienste abrufen

Ähnlich lautet die Syntax zum Auflisten von Pods in allen Namespaces:

$ kubectl get pods --all namespaces

Wenn wir weitere Details zu den bereitgestellten Pods auflisten müssen, verwenden Sie-o langmarkieren als:

$ kubectl get pods -o width

Die Syntax zum Abrufen von Implementierungsdetails lautet wie folgt:

$ kubectl Bereitstellung abrufen [Bereitstellungsname]

Um den YAML-Inhalt eines Pods zu erhalten, können wir dies verwenden-o jamlDie Flagge war:

$cubectl get pod [podname] -oder yaml

Wir benötigen oft Details zu Kubernetes-Funktionen. Der Befehl kubectl describe hilft dabei, diese Details abzurufen.

Weitere Informationen zu einem Knoten finden Sie unter:

$ kubectl beschreiben Knoten [Knotenname]

Ähnliches gilt für Pods wie:

$ kubectl beschreiben Pods [Pod-Name]

Sie können kubectl verwenden, um die Ausgabe nach einem bestimmten Feld zu sortieren. Verwenden Sie zum Auflisten der nach Dienstnamen geordneten Dienste:

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

Oder um alle Pods im Namespace zum Laufen zu bringen, können wir Folgendes versuchen:

$ kubectl obter pods --field-selector=status.phase=Wird ausgeführt

Um nur die externen IPs aller Knoten zu erhalten, können wir sie verwenden, wenn sie zugewiesen sind-o jsonpathMarkieren Sie mit folgender Syntax:

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

So rufen Sie an eine Ressource angehängte Tags ab, z. B. B.Pods:

$ kubectl obter pods --show-labels

Um eine Liste der Ereignisse zu erhalten, die jedoch nach Zeitstempel sortiert sind, können wir verwenden-Sortieren nachmarkieren als:

$ kubectl obter eventos --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 wirUnterschiedBefehl wie:

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

Ressourcenänderung

Bereitgestellte Ressourcen werden häufig durch Konfigurationsänderungen geändert.

Um beispielsweise „www“-Container oder „Frontend“-Implementierungen durch Aktualisierung ihres Images kontinuierlich zu aktualisieren, können wir Folgendes verwenden:

$ kubectl setzt Bildanzeige/Frontend www=image:v2

Wir können den Bereitstellungsverlauf, einschließlich der Überprüfung, wie folgt überprüfen:

$ kubectl-Veröffentlichungsverlauf Bereitstellung/Frontend

Um zu einer früheren Implementierung zurückzukehren, verwenden Sie:

$ kubectl despliegue undeploy/frontend

Wir können auch auf eine bestimmte Revision zurückgehen, indem wir angeben--zur Durchsichtmarkieren als:

$ kubectl despliegue undeploy/frontend --to-revision=2

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

$ kubectl Rollout-Status -w Bereitstellung/Frontend

Verwenden Sie für einen reibungslosen Neustart der Schnittstellenimplementierung:

$ kubectl-Implementierung startet Implementierung/Frontend neu

Wir können ein JSON-Manifest bereitstellen, um einen Pod zu ersetzen, indem wir es wie folgt an stdin übergeben:

$cat pod.json | Ersatz für kubectl -f -

Es kann vorkommen, dass Sie eine Ressource zwangsweise ersetzen, löschen und neu erstellen müssen (HINWEIS: Dies führt auch zu einer Dienstunterbrechung). Dies kann wie folgt erfolgen:

$ kubectl replace --force -f [Manifestdatei]

Das Taggen einer Ressource (die Tags unterstützt) ist einfach und kann wie folgt durchgeführt werden:

$ kubectl Label-Pods [Pod-Name] New-Label=[Etiqueta]

In ähnlicher Weise können Anmerkungen zu einer Ressource hinzugefügt werden, indem Sie Folgendes verwenden:

$ kubectl-Anmerkungs-Pods [Pod-Name] Symbol-URL=[URL]

Die automatische Skalierung einer Bereitstellung ist möglich mit:

$ kubectl-Autoscale-Bereitstellung [dep-name] --min=[Mindestwert] --max=[Maximalwert]

auf hierdep-nameist der Name der Bereitstellung für die automatische Skalierung undminimale AuswahlmiMaximalwertgibt den Mindest- und Höchstwert an, der für die automatische Skalierung verwendet werden soll.

Ressourcenbearbeitung

Es ist möglich, eine API-Ressource in Ihrem bevorzugten Editor zu bearbeitenbearbeitenDomain.

$kubectl edit[API-Ressourcenname]

Geben Sie Ihren eigenen alternativen Editor an oder verwenden Sie ihnZUM HERAUSGEBERHöflichkeit:

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

Ressourcendimensionierung

Ressourcenskalierbarkeit ist eine der Funktionen, die von Kubernetes unterstützt werden, und kubectl macht es einfach.

Um ein Replikat-Set namens foo auf 3 zu skalieren, verwenden wir:

$ escala kubectl --replicas=3 rs/foo

Stattdessen können wir wie folgt auf eine YAML-Manifestdatei verweisen, um die zu skalierende Ressource anzugeben:

$scale cubectl --replicas=3 -f foo.yaml

Außerdem können wir basierend auf dem aktuellen Status der Bereitstellung wie folgt skalieren:

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

ausgenommen Funktionen

Es kann erforderlich sein, die erstellten Ressourcen zu ändern oder zu löschen. Mit kubectl können wir vorhandene Ressourcen auf verschiedene Arten löschen.

So entfernen Sie einen Pod aus der JSON-Datei mit der von uns verwendeten Spezifikation:

$ kubectl delete -f ./pod.json

Wir können Pods und Dienste mit demselben Namen ausschließenPod-NamemiDienstnameUnd ja:

$ kubectl delete pod,service [Pod-Name] [Service-Name]

Wenn die Ressourcen getaggt sind und wir beispielsweise Ressourcen mit einem bestimmten Tag ausschließen müssenVerlinke den Namen, wir können benutzen:

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

Verwenden Sie Folgendes, um alle Pods und Dienste zu entfernen, die in einem Namespace enthalten sind:

$ kubectl -n [Namespace] Pod löschen, svc --all

Interagiere mit den laufenden Kapseln

Wir können kubectl verwenden, um hilfreiche Details zum Ausführen von Pods zu erhaltenVerwalten Sie einen Kubernetes-Cluster.

Einer der häufigsten Befehle ist das Abrufen von Protokollen aus einem Pod, den Sie wie folgt ausführen können:

$ kubectl-Datensätze [Pod-Name]

Oder um die Protokolle des Pods mit einem bestimmten Tag zu sichern:

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

Oder um Protokolle aus einem bestimmten Container abzurufen:

$ kubectl logs -l name=[Tag-Name] -c [Containername]

Wir können auch Protokolle streamen, wie wir es unter Linux tunstehlen -fBefehl mit kubectl-FFlagge auch:

$ kubectl logs -f [Pod-Name]

Die interaktive Ausführung eines Pods kann mit kubectl wie folgt erfolgen:

$ kubectl run -i --tty box busy --image=box busy -- sh

Oder verwenden Sie zum Ausführen eines Pods in einem bestimmten Namespace:

$ kubectl run nginx --image=nginx -n [Namespace]

Sie können es mit einem laufenden Container verbindenbefestigenDomain:

$ kubectl append [Pod-Name] -i

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

$ kubectl port-forward [Pod-Name] [Port des lokalen Computers]:[Pod-Port]

Um etwas direkt in einer Pod-Anmeldung auszuführen und die Ausgabe zu erhalten, verwenden Sie:

$ kubectl exec [Pod-Name] -- [Befehl]

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 [Containername] -- [Befehl]

Um Leistungsmetriken für einen bestimmten Pod und seine Container anzuzeigen, können wir Folgendes verwenden:

$ kubectl main pod [Pod-Name] --containers

Oder um es nach einer Metrik wie CPU oder Speicher zu sortieren, können wir es erreichen, indem wir Folgendes tun:

$ kubectl-Pod-Prinzipal [Name des Pods] --sort-by=cpu

Interagieren Sie mit Knoten und Cluster

kubectl kann mit den Knoten und dem Cluster interagieren. Dies sind einige der Befehle, die kubectl für kubectl verwendet.

Um einen Knoten als nicht programmierbar zu markieren, verwenden Sie:

$ string kubectl [Knotenname]

So entleeren Sie einen Knoten als Teil der Wartungsvorbereitung:

$ kubectl drain [Knotenname]

Verwenden Sie Folgendes, um den Knoten wieder als programmierbar zu markieren:

$ kubectl uncordon [Knotenname]

Um Leistungsmetriken für einen Knoten zu erhalten, können wir Folgendes verwenden:

$ kubectl oberster Knoten [Knotenname]

So erhalten Sie Details zum aktuellen Cluster:

$ kubectl-Clusterinformationen

Außerdem können wir den Clusterstatus auf stdout ausgeben:

$ kubectl-Cluster-Dump

Oder verwenden Sie zum Kopieren in eine Datei:

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

Fazit

KubernetesEs ist das Schlagwort in der Branche und zu wissen, wie man damit effektiv umgeht, wird Ihre Karriere immer voranbringen. kubectl ist die Hauptschnittstelle für die Interaktion mit einem Kubernetes-Cluster. Dieser Artikel hat gezeigt, wie leistungsfähig dieses Tool in den Händen eines erfahrenen Benutzers ist.

Dennoch können wir nur kurz beschreiben, was kubectl noch mehr kann. Weitere Informationen finden Sie in der offiziellen Dokumentation.auf hier.