🥇So nutzen Sie Kubectl effektiver: eine ausführliche Anleitung

Wenn Sie mit Kubernetes arbeiten, ist kubectl wahrscheinlich eines der Dienstprogramme, die Sie am häufigsten verwenden. Und wenn Sie viel Zeit mit einem bestimmten Werkzeug verbringen, lohnt es sich, es gründlich zu studieren und zu lernen, wie man es effektiv nutzt.

Team Kubernetes aaS von Mail.ru hat einen Artikel von Daniel Weibel übersetzt, in dem Sie Tipps und Tricks für die effektive Arbeit mit kubectl finden. Es wird Ihnen auch helfen, ein tieferes Verständnis von Kubernetes zu erlangen.

Ziel des Artikels ist es laut Autor, die tägliche Arbeit mit Kubernetes nicht nur effizienter, sondern auch angenehmer zu gestalten!

Einführung: Was ist kubectl?

Bevor Sie lernen können, kubectl effektiver zu nutzen, müssen Sie sich ein grundlegendes Verständnis davon aneignen, was es ist und wie es funktioniert.

Aus Benutzersicht ist kubectl ein Bedienfeld, mit dem Sie Kubernetes-Vorgänge ausführen können.

Technisch gesehen ist kubectl ein Kubernetes-API-Client.

Die Kubernetes-API ist eine HTTP-REST-API. Diese API ist die echte Kubernetes-Benutzeroberfläche, über die sie vollständig gesteuert wird. Das bedeutet, dass jeder Kubernetes-Vorgang als API-Endpunkt verfügbar gemacht wird und mit einer HTTP-Anfrage an diesen Endpunkt erfolgen kann.

Daher besteht die Hauptaufgabe von kubectl darin, HTTP-Anfragen an die Kubernetes-API zu stellen:

Kubernetes ist ein vollständig ressourcenorientiertes System. Dies bedeutet, dass der interne Status der Ressourcen beibehalten wird und alle Kubernetes-Vorgänge CRUD-Vorgänge sind.

Durch die Verwaltung dieser Ressourcen haben Sie die vollständige Kontrolle über Kubernetes, und Kubernetes ermittelt anhand des aktuellen Status der Ressourcen, was zu tun ist. Aus diesem Grund ist die Kubernetes-API-Referenz als Liste von Ressourcentypen mit den zugehörigen Vorgängen organisiert.

Schauen wir uns ein Beispiel an.

Angenommen, Sie möchten eine ReplicaSet-Ressource erstellen. Dazu beschreiben Sie das ReplicaSet in einer Datei namentlich replicaset.yaml, und führen Sie dann den Befehl aus:

$ kubectl create -f replicaset.yaml

Dadurch wird eine ReplicaSet-Ressource erstellt. Doch was passiert hinter den Kulissen?

Kubernetes verfügt über einen ReplicaSet-Erstellungsvorgang. Wie jeder andere Vorgang wird er als API-Endpunkt bereitgestellt. Der spezifische API-Endpunkt für diesen Vorgang sieht folgendermaßen aus:

POST /apis/apps/v1/namespaces/{namespace}/replicasets

API-Endpunkte für alle Kubernetes-Vorgänge finden Sie unter API-Referenz (einschließlich der oben genannte Endpunkt). Um eine tatsächliche Anfrage an einen Endpunkt zu stellen, müssen Sie zunächst die API-Server-URL zu den Endpunktpfaden hinzufügen, die in der API-Referenz aufgeführt sind.

Wenn Sie den obigen Befehl ausführen, sendet kubectl daher eine HTTP-POST-Anfrage an den oben genannten API-Endpunkt. Die ReplicaSet-Definition, die Sie in der Datei angegeben haben replicaset.yaml, wird im Hauptteil der Anfrage gesendet.

So funktioniert kubectl für alle Befehle, die mit dem Kubernetes-Cluster interagieren. In all diesen Fällen stellt kubectl einfach HTTP-Anfragen an die entsprechenden Kubernetes-API-Endpunkte.

Bitte beachten Sie, dass Sie Kubernetes vollständig mit einem Dienstprogramm wie verwalten können curldurch manuelles Senden von HTTP-Anfragen an die Kubernetes-API. Kubectl erleichtert einfach die Verwendung der Kubernetes-API.

Dies sind die Grundlagen dessen, was Kubectl ist und wie es funktioniert. Aber es gibt noch etwas anderes über die Kubernetes-API, das jeder kubectl-Benutzer wissen sollte. Werfen wir einen kurzen Blick in die innere Welt von Kubernetes.

Die innere Welt von Kubernetes

Kubernetes besteht aus einer Reihe unabhängiger Komponenten, die als separate Prozesse auf Clusterknoten ausgeführt werden. Einige Komponenten laufen auf Master-Knoten, andere auf Worker-Knoten, wobei jede Komponente ihre eigene spezifische Aufgabe ausführt.

Hier sind die wichtigsten Komponenten auf den Hauptknoten:

Lagerung - speichert Ressourcendefinitionen (normalerweise ist es etcd).
API-Server – stellt eine API bereit und verwaltet den Speicher.
Controller-Manager – Stellt sicher, dass der Ressourcenstatus den Spezifikationen entspricht.
Planer – plant Pods auf Worker-Knoten.

Und hier ist eine der wichtigsten Komponenten auf den Worker-Knoten:

kubelet – verwaltet den Start von Containern auf dem Arbeitsknoten.

Um zu verstehen, wie diese Komponenten zusammenarbeiten, schauen wir uns ein Beispiel an.

Nehmen wir an, Sie haben den Vorgang gerade abgeschlossen kubectl create -f replicaset.yaml, woraufhin kubectl eine HTTP-POST-Anfrage an stellte ReplicaSet-API-Endpunkt (Übergabe der ReplicaSet-Ressourcendefinition).

Was ist im Cluster los?

Danach kubectl create -f replicaset.yaml Der API-Server speichert Ihre ReplicaSet-Ressourcendefinition im Speicher:
Als nächstes wird der ReplicaSet-Controller im Controller-Manager gestartet, der die Erstellung, Änderung und Löschung von ReplicaSet-Ressourcen übernimmt:
Der ReplicaSet-Controller erstellt eine Pod-Definition für jedes ReplicaSet-Replikat (gemäß der Pod-Vorlage in der ReplicaSet-Definition) und speichert sie im Speicher:
Der Scheduler wird gestartet und verfolgt Pods, die noch keinem Worker-Knoten zugewiesen wurden:
Der Scheduler wählt für jeden Pod einen geeigneten Worker-Knoten aus und fügt diese Informationen zur Pod-Definition im Store hinzu:
Auf dem Worker-Knoten, dem der Pod zugewiesen ist, wird Kubelet gestartet. Es verfolgt die diesem Knoten zugewiesenen Pods:
Das Kubelet liest die Pod-Definition aus dem Speicher und weist eine Container-Laufzeitumgebung wie Docker an, Container auf dem Knoten zu starten:

Nachfolgend finden Sie eine Textversion dieser Beschreibung.

Die API-Anfrage an den ReplicaSet-Erstellungsendpunkt wird vom API-Server verarbeitet. Der API-Server authentifiziert die Anfrage und speichert die ReplicaSet-Ressourcendefinition im Speicher.

Dieses Ereignis startet den ReplicaSet-Controller, der ein Unterprozess des Controller-Managers ist. Der ReplicaSet-Controller überwacht die Erstellung, Aktualisierung und Löschung von ReplicaSet-Ressourcen im Store und erhält in diesem Fall eine Ereignisbenachrichtigung.

Die Aufgabe des ReplicaSet-Controllers besteht darin, sicherzustellen, dass die erforderliche Anzahl von ReplicaSet-Pods vorhanden ist. In unserem Beispiel sind noch keine Pods vorhanden, daher erstellt der ReplicaSet-Controller diese Pod-Definitionen (gemäß der Pod-Vorlage in der ReplicaSet-Definition) und speichert sie im Speicher.

Die Erstellung neuer Pods wird durch einen Planer ausgelöst, der Pod-Definitionen verfolgt, die noch nicht für Worker-Knoten geplant sind. Der Scheduler wählt für jeden Pod einen geeigneten Worker-Knoten aus und aktualisiert die Pod-Definitionen im Repository.

Beachten Sie, dass bis zu diesem Zeitpunkt nirgendwo im Cluster Workload-Code ausgeführt wurde. Alles, was bisher getan wurde - Hierbei handelt es sich um die Erstellung und Aktualisierung von Ressourcen im Repository auf dem Masterknoten.

Das letzte Ereignis löst Kubelets aus, die die für ihre Worker-Knoten geplanten Pods überwachen. Das Kubelet des Worker-Knotens, auf dem Ihre ReplicaSet-Pods installiert sind, muss die Container-Laufzeitumgebung, beispielsweise Docker, anweisen, die erforderlichen Container-Images herunterzuladen und auszuführen.

An diesem Punkt wird Ihre ReplicaSet-Anwendung endlich ausgeführt!

Rolle der Kubernetes-API

Wie Sie im vorherigen Beispiel gesehen haben, überwachen Kubernetes-Komponenten (mit Ausnahme des API-Servers und des Speichers) Änderungen an Ressourcen im Speicher und ändern Informationen zu Ressourcen im Speicher.

Natürlich interagieren diese Komponenten nicht direkt mit dem Speicher, sondern nur über die Kubernetes-API.

Betrachten Sie die folgenden Beispiele:

Der ReplicaSet-Controller verwendet den API-Endpunkt ReplicaSets auflisten mit Parameter watch um Änderungen an ReplicaSet-Ressourcen zu überwachen.
Der ReplicaSet-Controller verwendet den API-Endpunkt Pod erstellen (Pod erstellen), um Pods zu erstellen.
Der Scheduler verwendet den API-Endpunkt Patch-Pod (Pod bearbeiten), um Pods mit Informationen über den ausgewählten Worker-Knoten zu aktualisieren.

Wie Sie sehen, ist dies dieselbe API, auf die kubectl zugreift. Die Verwendung derselben API für interne Komponenten und externe Benutzer ist ein grundlegendes Konzept im Kubernetes-Design.

Jetzt können wir zusammenfassen, wie Kubernetes funktioniert:

Der Speicher speichert den Status, also die Kubernetes-Ressourcen.
Der API-Server stellt eine Schnittstelle zum Speicher in Form der Kubernetes-API bereit.
Alle anderen Kubernetes-Komponenten und Benutzer lesen, beobachten und manipulieren den Kubernetes-Status (Ressourcen) über die API.

Wenn Sie diese Konzepte kennen, können Sie kubectl besser verstehen und das Beste daraus machen.

Schauen wir uns nun einige konkrete Tipps und Tricks an, die Ihnen helfen, Ihre Produktivität mit kubectl zu verbessern.

1. Beschleunigen Sie die Eingabe durch Befehlsvervollständigung

Eine der nützlichsten, aber oft übersehenen Techniken zur Verbesserung der Leistung mit kubectl ist die Befehlsvervollständigung.

Mit der Befehlsvervollständigung können Sie Teile von kubectl-Befehlen automatisch mit der Tabulatortaste abschließen. Dies funktioniert für Unterbefehle, Optionen und Argumente, einschließlich komplexer Dinge wie Ressourcennamen.

Sehen Sie, wie die Vervollständigung des Kubectl-Befehls funktioniert:

Die Befehlsvervollständigung funktioniert für Bash- und Zsh-Shells.

Offizieller Leitfaden enthält detaillierte Anweisungen zum Einrichten der automatischen Vervollständigung. Nachfolgend finden Sie jedoch einen kurzen Auszug.

So funktioniert die Befehlsvervollständigung

Die Befehlsvervollständigung ist eine Shell-Funktion, die mithilfe eines Vervollständigungsskripts funktioniert. Ein Erweiterungsskript ist ein Shell-Skript, das das Verhalten einer Erweiterung für einen bestimmten Befehl definiert.

Kubectl generiert und gibt automatisch Erweiterungsskripte für Bash und Zsh mit den folgenden Befehlen aus:

$ kubectl completion bash

Или:

$ kubectl completion zsh

Theoretisch reicht es aus, die Ausgabe dieser Befehle mit der entsprechenden Befehls-Shell zu verbinden, damit kubectl die Befehle ergänzen kann.

In der Praxis ist die Verbindungsmethode für Bash (einschließlich Unterschiede zwischen Linux und MacOS) und Zsh unterschiedlich. Im Folgenden werden wir uns alle diese Optionen ansehen.

Bash unter Linux

Das Bash-Vervollständigungsskript hängt vom Bash-Completion-Paket ab, daher müssen Sie es zuerst installieren:

$ sudo apt-get install bash-completion

Или:

$ yum install bash-completion

Mit dem folgenden Befehl können Sie testen, ob das Paket erfolgreich installiert wurde:

$ type _init_completion

Wenn dadurch Shell-Funktionscode ausgegeben wird, ist die Bash-Vervollständigung korrekt installiert. Wenn der Befehl den Fehler „Nicht gefunden“ ausgibt, müssen Sie die folgende Zeile zu Ihrer Datei hinzufügen ~ / .bashrc:

$ source /usr/share/bash-completion/bash_completion

Ist es notwendig, diese Zeile zur Datei hinzuzufügen? ~ / .bashrc oder nicht, hängt von dem Paketmanager ab, den Sie zur Installation von Bash-Completion verwendet haben. Dies ist für APT notwendig, nicht jedoch für YUM.

Nach der Installation von bash-completion müssen Sie alles so konfigurieren, dass das kubectl-Completion-Skript in allen Shell-Sitzungen aktiviert ist.

Eine Möglichkeit hierfür besteht darin, der Datei die folgende Zeile hinzuzufügen ~ / .bashrc:

source <(kubectl completion bash)

Eine andere Möglichkeit besteht darin, das Kubectl-Erweiterungsskript zum Verzeichnis hinzuzufügen /etc/bash_completion.d (erstellen Sie es, falls es nicht existiert):

$ kubectl completion bash >/etc/bash_completion.d/kubectl

Alle Add-on-Skripte im Katalog /etc/bash_completion.d werden automatisch in die Bash-Vervollständigung einbezogen.

Beide Optionen sind gleichermaßen anwendbar.

Nach dem Neustart der Shell funktioniert die Ausführung des Kubectl-Befehls.

Bash unter MacOS

Unter MacOS ist die Einrichtung etwas komplizierter. Tatsache ist, dass MacOS standardmäßig die Bash-Version 3.2 verwendet und das Kubectl-Autovervollständigungsskript eine Bash-Version von mindestens 4.1 erfordert und in Bash 3.2 nicht funktioniert.

Bei der Verwendung einer veralteten Version von Bash unter MacOS treten Lizenzprobleme auf. Bash Version 4 ist unter GPLv3 lizenziert, was von Apple nicht unterstützt wird.

Um die automatische Vervollständigung von kubectl unter MacOS zu konfigurieren, müssen Sie eine neuere Version von Bash installieren. Sie können auch die aktualisierte Bash als Ihre Standard-Shell festlegen, was Ihnen in Zukunft viele Probleme erspart. Es ist nicht schwierig, Einzelheiten finden Sie im Artikel „Aktualisieren von Bash unter MacOS".

Bevor Sie fortfahren, stellen Sie sicher, dass Sie eine aktuelle Version von Bash verwenden (überprüfen Sie die Ausgabe). bash --version).

Das Bash-Vervollständigungsskript variiert je nach Projekt Bash-Vervollständigung, also müssen Sie es zuerst installieren.

Sie können die Bash-Vervollständigung mit installieren Homebrew:

$ brew install bash-completion@2

Hier @2 steht für Bash-Completion Version 2. Für die automatische Vervollständigung von kubectl ist Bash-Completion Version 2 erforderlich, und für Bash-Completion Version 2 ist mindestens Bash-Version 4.1 erforderlich.

Befehlsausgabe brew-install enthält einen Abschnitt „Vorbehalte“, der angibt, was der Datei hinzugefügt werden muss ~/.bash_profile:

export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . 
"/usr/local/etc/profile.d/bash_completion.sh"

Ich empfehle jedoch, diese Zeilen nicht hinzuzufügen ~/.bash_profileUnd in ~/.bashrc. In diesem Fall ist die automatische Vervollständigung nicht nur in der Haupt-, sondern auch in den untergeordneten Befehls-Shells verfügbar.

Nach dem Neustart der Befehlsshell können Sie mit dem folgenden Befehl überprüfen, ob die Installation korrekt ist:

$ type _init_completion

Wenn Sie in der Ausgabe eine Shell-Funktion sehen, ist alles korrekt konfiguriert.

Jetzt müssen wir sicherstellen, dass die automatische Vervollständigung von kubectl in allen Sitzungen aktiviert ist.

Eine Möglichkeit besteht darin, die folgende Zeile zu Ihrem hinzuzufügen ~/.bashrc:

source <(kubectl completion bash)

Die zweite Möglichkeit besteht darin, dem Ordner ein Autovervollständigungsskript hinzuzufügen /usr/local/etc/bash_completion.d:

$ kubectl completion bash
>/usr/local/etc/bash_completion.d/kubectl

Diese Methode funktioniert nur, wenn Sie die Bash-Vervollständigung mit Homebrew installiert haben. In diesem Fall lädt die Bash-Vervollständigung alle Skripte aus diesem Verzeichnis.

Wenn Sie installiert haben kubectl mit Homebrew, dann muss der vorherige Schritt nicht ausgeführt werden, da das Autovervollständigungsskript automatisch im Ordner abgelegt wird /usr/local/etc/bash_completion.d Während der Installation. In diesem Fall beginnt die automatische Vervollständigung von kubectl zu funktionieren, sobald Sie die Bash-Vervollständigung installieren.

Daher sind alle diese Optionen gleichwertig.

Zsh

Autovervollständigungsskripte für Zsh erfordern keine Abhängigkeiten. Sie müssen sie lediglich aktivieren, wenn Sie die Befehlsshell laden.

Sie können dies tun, indem Sie eine Zeile zu Ihrem hinzufügen ~/.zshrc Datei:

source <(kubectl completion zsh)

Wenn Sie eine Fehlermeldung erhalten not found: compdef Nach dem Neustart Ihrer Shell müssen Sie die integrierte Funktion aktivieren compdef. Sie können es aktivieren, indem Sie es am Anfang Ihrer Datei hinzufügen ~/.zshrc следующее:

autoload -Uz compinit
compinit

2. Sehen Sie sich schnell die Ressourcenspezifikationen an

Wenn Sie YAML-Ressourcendefinitionen erstellen, müssen Sie die Felder und ihre Bedeutung für diese Ressourcen kennen. Eine Anlaufstelle für diese Informationen ist die API-Referenz, die vollständige Spezifikationen für alle Ressourcen enthält.

Allerdings ist es umständlich, jedes Mal zum Webbrowser zu wechseln, wenn Sie etwas suchen müssen. Daher stellt kubectl den Befehl bereit kubectl explain, das die Spezifikationen aller Ressourcen direkt in Ihrem Terminal anzeigt.

Das Befehlsformat ist wie folgt:

$ kubectl explain resource[.field]...

Der Befehl gibt die Spezifikation der angeforderten Ressource oder des angeforderten Felds aus. Die angezeigten Informationen sind identisch mit denen im API-Handbuch.

Standardmäßig kubectl explain zeigt nur die erste Ebene der Verschachtelung von Feldern.

Sehen Sie, wie es aussieht Sie können dann.

Sie können den gesamten Baum anzeigen, wenn Sie die Option hinzufügen --recursive:

$ kubectl explain deployment.spec --recursive

Wenn Sie nicht genau wissen, welche Ressourcen benötigt werden, können Sie sich diese mit dem folgenden Befehl alle anzeigen lassen:

$ kubectl api-resources

Dieser Befehl zeigt Ressourcennamen im Plural an, z. B. deployments statt deployment. Es zeigt beispielsweise auch den Kurznamen an deploy, für die Ressourcen, die es haben. Machen Sie sich über diese Unterschiede keine Sorgen. Alle diese Benennungsoptionen sind für kubectl gleichwertig. Das heißt, Sie können jedes davon verwenden kubectl explain.

Alle folgenden Befehle sind gleichwertig:

$ kubectl explain deployments.spec
# или
$ kubectl explain deployment.spec
# или        
$ kubectl explain deploy.spec

3. Verwenden Sie ein benutzerdefiniertes Spaltenausgabeformat

Standardausgabeformat für Befehle kubectl get:

$ kubectl get pods
NAME                     READY    STATUS    RESTARTS  AGE
engine-544b6b6467-22qr6   1/1     Running     0       78d
engine-544b6b6467-lw5t8   1/1     Running     0       78d
engine-544b6b6467-tvgmg   1/1     Running     0       78d
web-ui-6db964458-8pdw4    1/1     Running     0       78d

Dieses Format ist praktisch, enthält jedoch nur eine begrenzte Menge an Informationen. Im Vergleich zum vollständigen Ressourcendefinitionsformat werden hier nur wenige Felder angezeigt.

In diesem Fall können Sie ein benutzerdefiniertes Spaltenausgabeformat verwenden. Damit können Sie bestimmen, welche Daten ausgegeben werden sollen. Sie können jedes Ressourcenfeld als separate Spalte anzeigen.

Die Verwendung eines benutzerdefinierten Formats wird über die Optionen bestimmt:

-o custom-columns=<header>:<jsonpath>[,<header>:<jsonpath>]...

Sie können jede Ausgabespalte als Paar definieren <header>:<jsonpath>Wo <header> ist der Spaltenname und <jsonpath> – ein Ausdruck, der ein Ressourcenfeld definiert.

Schauen wir uns ein einfaches Beispiel an:

$ kubectl get pods -o custom-columns='NAME:metadata.name'

NAME
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4

Die Ausgabe enthält eine Spalte mit den Namen der Pods.

Der Optionsausdruck wählt die Pod-Namen aus dem Feld aus metadata.name. Dies liegt daran, dass der Name des Pods im Feld „Kindname“ definiert ist metadata in der Ressourcenbeschreibung des Pods. Weitere Details finden Sie in API-Leitfaden oder geben Sie den Befehl ein kubectl explain pod.metadata.name.

Nehmen wir nun an, Sie möchten der Ausgabe eine zusätzliche Spalte hinzufügen, die beispielsweise den Knoten anzeigt, auf dem jeder Pod ausgeführt wird. Dazu können Sie einfach die entsprechende Spaltenspezifikation zur Option „Benutzerdefinierte Spalten“ hinzufügen:

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,NODE:spec.nodeName'

NAME                       NODE
engine-544b6b6467-22qr6    ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8    ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg    ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4     ip-10-0-118-34.ec2.internal

Der Ausdruck wählt den Knotennamen aus spec.nodeName — Wenn ein Pod einem Knoten zugewiesen wird, wird sein Name in das Feld geschrieben spec.nodeName Pod-Ressourcenspezifikation. Genauere Informationen finden Sie in der Ausgabe kubectl explain pod.spec.nodeName.

Bitte beachten Sie, dass bei Kubernetes-Ressourcenfeldern die Groß-/Kleinschreibung beachtet wird.

Sie können jedes Ressourcenfeld als Spalte anzeigen. Sehen Sie sich einfach die Ressourcenspezifikation an und probieren Sie sie mit beliebigen Feldern aus.

Aber werfen wir zunächst einen genaueren Blick auf die Feldauswahlausdrücke.

JSONPath-Ausdrücke

Ausdrücke zur Auswahl von Ressourcenfeldern basieren auf JSONPfad.

JSONPath ist eine Sprache zum Abrufen von Daten aus JSON-Dokumenten. Die Auswahl eines einzelnen Felds ist der einfachste Anwendungsfall für JSONPath. Er hat viel Weitere Möglichkeiten, einschließlich Selektoren, Filter usw.

Kubectl EXPLAIN unterstützt eine begrenzte Anzahl von JSONPath-Funktionen. Nachfolgend werden die Möglichkeiten und Anwendungsbeispiele beschrieben:

# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'

Der []-Operator ist besonders wichtig. Viele Kubernetes-Ressourcenfelder sind Listen, und mit diesem Operator können Sie Mitglieder dieser Listen auswählen. Es wird häufig mit einem Platzhalter wie [*] verwendet, um alle Elemente einer Liste auszuwählen.

Anwendungsbeispiele

Die Möglichkeiten zur Verwendung eines benutzerdefinierten Spaltenausgabeformats sind endlos, da Sie jedes Feld oder jede Kombination von Ressourcenfeldern in der Ausgabe anzeigen können. Hier sind einige Beispiel-Apps, aber Sie können sie gerne selbst erkunden und Anwendungen finden, die für Sie funktionieren.

Containerbilder für Pods anzeigen:

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

NAME                        IMAGES
engine-544b6b6467-22qr6     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-lw5t8     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-tvgmg     rabbitmq:3.7.8-management,nginx
web-ui-6db964458-8pdw4      wordpress

Dieser Befehl zeigt die Container-Image-Namen für jeden Pod an.

Denken Sie daran, dass ein Pod mehrere Container enthalten kann. Die Bildnamen werden dann in einer Zeile angezeigt, durch Kommas getrennt.

Knotenverfügbarkeitszonen anzeigen:
```
$ kubectl get nodes 
  -o 
custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain.beta.kubernetes.io/zone'

NAME                          ZONE
ip-10-0-118-34.ec2.internal   us-east-1b
ip-10-0-36-80.ec2.internal    us-east-1a
ip-10-0-80-67.ec2.internal    us-east-1b
```
Dieser Befehl ist nützlich, wenn Ihr Cluster in einer öffentlichen Cloud gehostet wird. Es zeigt die Verfügbarkeitszone für jeden Knoten an.

Die Verfügbarkeitszone ist ein Cloud-Konzept, das die Replikationszone auf eine geografische Region beschränkt.

Verfügbarkeitszonen für jeden Knoten werden über ein spezielles Label erhalten – failure-domain.beta.kubernetes.io/zone. Wenn der Cluster in einer öffentlichen Cloud ausgeführt wird, wird dieses Label automatisch erstellt und mit den Namen der Verfügbarkeitszonen für jeden Knoten gefüllt.

Beschriftungen sind nicht Teil der Kubernetes-Ressourcenspezifikation, daher finden Sie hier keine Informationen dazu API-Leitfaden. Sie können jedoch (wie alle anderen Labels) gesehen werden, wenn Sie Informationen zu den Knoten im YAML- oder JSON-Format anfordern:
```
$ kubectl get nodes -o yaml
# или
$ kubectl get nodes -o json
```
Dies ist eine großartige Möglichkeit, zusätzlich zu den Lernressourcenspezifikationen mehr über Ressourcen zu erfahren.

4. Wechseln Sie einfach zwischen Clustern und Namespaces

Wenn kubectl eine Anfrage an die Kubernetes-API stellt, liest es zunächst die kubeconfig-Datei, um alle notwendigen Parameter für die Verbindung abzurufen.

Standardmäßig ist die kubeconfig-Datei ~/.kube/config. Typischerweise wird diese Datei durch einen speziellen Befehl erstellt oder aktualisiert.

Wenn Sie mit mehreren Clustern arbeiten, enthält Ihre kubeconfig-Datei Einstellungen für die Verbindung zu allen diesen Clustern. Sie benötigen eine Möglichkeit, dem Befehl kubectl mitzuteilen, mit welchem Cluster Sie arbeiten.

Innerhalb eines Clusters können Sie mehrere Namespaces erstellen – eine Art virtueller Cluster innerhalb eines physischen Clusters. Kubectl bestimmt außerdem anhand der kubeconfig-Datei, welcher Namespace verwendet werden soll. Das bedeutet, dass Sie dem Befehl kubectl auch mitteilen müssen, mit welchem Namespace er arbeiten soll.

In diesem Kapitel erklären wir, wie es funktioniert und wie man es effektiv zum Laufen bringt.

Beachten Sie, dass in der Umgebungsvariablen KUBECONFIG möglicherweise mehrere kubeconfig-Dateien aufgeführt sind. In diesem Fall werden alle diese Dateien zur Laufzeit zu einer gemeinsamen Konfiguration zusammengefasst. Sie können die standardmäßige kubeconfig-Datei auch ändern, indem Sie kubectl mit dem Parameter ausführen --kubeconfig. Sehen offizielle Dokumentation.

kubeconfig-Dateien

Schauen wir uns an, was genau die kubeconfig-Datei enthält:

Wie Sie sehen können, enthält die kubeconfig-Datei eine Reihe von Kontexten. Der Kontext besteht aus drei Elementen:

Cluster – API-URL des Clusterservers.
Benutzer – Anmeldeinformationen für die Benutzerauthentifizierung im Cluster.
Namespace – der Namespace, der beim Beitritt zum Cluster verwendet wird.

In der Praxis verwenden sie in ihrer kubeconfig häufig einen Kontext pro Cluster. Sie können jedoch mehrere Kontexte pro Cluster haben, differenziert nach Benutzer oder Namespace. Diese Multikontextkonfiguration ist jedoch ungewöhnlich, sodass normalerweise eine Eins-zu-Eins-Zuordnung zwischen Clustern und Kontexten besteht.

Zu jedem Zeitpunkt ist einer der Kontexte aktuell:

Wenn kubectl eine Konfigurationsdatei liest, übernimmt es immer Informationen aus dem aktuellen Kontext. Im obigen Beispiel stellt kubectl eine Verbindung zum Hare-Cluster her.

Um zu einem anderen Cluster zu wechseln, müssen Sie dementsprechend den aktuellen Kontext in der kubeconfig-Datei ändern:

Jetzt stellt kubectl eine Verbindung zum Fox-Cluster her.

Um zu einem anderen Namespace im selben Cluster zu wechseln, müssen Sie den Wert des Namespace-Elements für den aktuellen Kontext ändern:

Im obigen Beispiel verwendet kubectl den Prod-Namespace des Fox-Clusters (zuvor wurde der Test-Namespace festgelegt).

Beachten Sie, dass kubectl auch Optionen bietet --cluster, --user, --namespace и --context, mit denen Sie einzelne Elemente und den aktuellen Kontext selbst überschreiben können, unabhängig davon, was in der kubeconfig eingestellt ist. Suchen kubectl options.

Theoretisch können Sie die Einstellungen in der kubeconfig manuell ändern. Aber es ist unbequem. Um diese Vorgänge zu vereinfachen, gibt es verschiedene Dienstprogramme, mit denen Sie Parameter automatisch ändern können.

Verwenden Sie kubectx

Ein sehr beliebtes Dienstprogramm zum Wechseln zwischen Clustern und Namespaces.

Das Dienstprogramm stellt Befehle bereit kubectx и kubens um den aktuellen Kontext bzw. Namespace zu ändern.

Wie bereits erwähnt, bedeutet die Änderung des aktuellen Kontexts eine Änderung des Clusters, wenn Sie nur einen Kontext pro Cluster haben.

Hier ist ein Beispiel für die Ausführung dieser Befehle:

Im Wesentlichen bearbeiten diese Befehle lediglich die kubeconfig-Datei wie oben beschrieben.

installieren kubectx, folgen Sie den Anweisungen auf Github.

Beide Befehle unterstützen die automatische Vervollständigung von Kontext- und Namespace-Namen, sodass diese nicht vollständig eingegeben werden müssen. Anleitung zum Einrichten der Autovervollständigung hier.

Eine weitere nützliche Funktion kubectx ist interaktiver Modus. Es funktioniert in Verbindung mit dem Dienstprogramm fzf, die separat installiert werden muss. Durch die Installation von fzf wird automatisch der interaktive Modus verfügbar kubectx. Interaktiv können Sie Kontext und Namensraum über die interaktive, kostenlose Suchoberfläche von fzf auswählen.

Verwendung von Shell-Aliasnamen

Sie benötigen keine separaten Tools, um den aktuellen Kontext und Namespace zu ändern, da kubectl auch Befehle dafür bereitstellt. Ja, Team kubectl config stellt Unterbefehle zum Bearbeiten von kubeconfig-Dateien bereit.

Hier sind einige von ihnen:

kubectl config get-contexts: alle Kontexte anzeigen;
kubectl config current-context: aktuellen Kontext abrufen;
kubectl config use-context: aktuellen Kontext ändern;
kubectl config set-context: Kontextelement ändern.

Die direkte Verwendung dieser Befehle ist jedoch nicht sehr praktisch, da sie lang sind. Sie können für sie Shell-Aliase erstellen, die einfach auszuführen sind.

Ich habe auf der Grundlage dieser Befehle eine Reihe von Aliasen erstellt, die eine ähnliche Funktionalität wie kubectx bieten. Hier können Sie sie in Aktion sehen:

Beachten Sie, dass Aliase fzf verwenden, um eine interaktive kostenlose Suchschnittstelle bereitzustellen (wie der interaktive Modus von kubectx). Das heißt, Sie brauchen fzf installierenum diese Aliase zu verwenden.

Hier sind die Definitionen der Aliase selbst:

# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/  /;|^  $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'

# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print $5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/|  |;|^  $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'

Um diese Aliase festzulegen, müssen Sie die oben genannten Definitionen zu Ihrer Datei hinzufügen ~/.bashrc oder ~/.zshrc und starten Sie Ihre Shell neu.

Plugins verwenden

Mit Kubectl können Sie Plugins laden, die auf die gleiche Weise wie grundlegende Befehle ausgeführt werden. Sie können beispielsweise das Plugin kubectl-foo installieren und durch Ausführen des Befehls ausführen kubectl foo.

Es wäre praktisch, den Kontext und den Namensraum auf diese Weise zu ändern, beispielsweise durch Ausführen kubectl ctx den Kontext ändern und kubectl ns um den Namensraum zu ändern.

Ich habe zwei Plugins geschrieben, die dies tun:

Die Funktionsweise von Plugins basiert auf Aliasnamen aus dem vorherigen Abschnitt.

So funktionieren sie:

Beachten Sie, dass die Plugins fzf verwenden, um eine interaktive kostenlose Suchoberfläche bereitzustellen (wie der interaktive Modus von kubectx). Das heißt, Sie brauchen fzf installierenum diese Aliase zu verwenden.

Um Plugins zu installieren, müssen Sie Shell-Skripte mit dem Namen herunterladen kubectl-ctx и kubectl-ns in ein beliebiges Verzeichnis in Ihrer PATH-Variablen und machen Sie sie ausführbar, z. B. mit chmod +x. Unmittelbar danach können Sie es verwenden kubectl ctx и kubectl ns.

5. Reduzieren Sie die Eingabe mit Autoaliasen

Shell-Aliase sind eine gute Möglichkeit, die Eingabe zu beschleunigen. Projekt kubectl-Aliase enthält etwa 800 Verknüpfungen für grundlegende Kubectl-Befehle.

Sie fragen sich vielleicht: Wie merken Sie sich 800 Aliase? Aber Sie müssen sich nicht alle merken, denn sie sind nach einem einfachen Schema aufgebaut, das unten angegeben ist:

Zum Beispiel:

kgpooyaml – kubectl holt Pods oyaml
ksysgsvcw – kubectl -n kube-system get svc w
ksysrmcm -kubectl -n kube-system rm cm
kgdepallsl – kubectl erhält die Bereitstellung aller SL

Wie Sie sehen, bestehen Aliase aus Komponenten, von denen jede ein bestimmtes Element des Befehls kubectl darstellt. Jeder Alias kann eine Komponente für den Basisbefehl, die Operation und die Ressource sowie mehrere Komponenten für Parameter haben. Sie „befüllen“ diese Komponenten einfach von links nach rechts entsprechend der obigen Abbildung.

Das aktuelle Detaildiagramm finden Sie unter GitHub. Dort finden Sie auch vollständige Liste der Aliase.

Beispielsweise entspricht der Alias kgpooyamlall dem Befehl kubectl get pods -o yaml --all-namespaces.

Die relative Reihenfolge der Optionen ist nicht wichtig: Befehl kgpooyamlall entspricht dem Befehl kgpoalloyaml.

Sie müssen nicht alle Komponenten als Aliase verwenden. Zum Beispiel k, kg, klo, ksys, kgpo kann auch benutzt werden. Darüber hinaus können Sie Aliase und reguläre Befehle oder Optionen in der Befehlszeile kombinieren:

Zum Beispiel:

Statt kubectl proxy Du kannst schreiben k proxy.
Statt kubectl get roles Du kannst schreiben kg roles (Derzeit gibt es keinen Alias für die Roles-Ressource).
Um Daten für einen bestimmten Pod abzurufen, können Sie den Befehl verwenden kgpo my-pod — kubectl get pod my-pod.

Bitte beachten Sie, dass einige Aliase ein Befehlszeilenargument erfordern. Zum Beispiel Alias kgpol Mittel kubectl get pods -l. Möglichkeit -l erfordert ein Argument – eine Label-Spezifikation. Wenn Sie einen Alias verwenden, sieht es so aus kgpol app=ui.

Da einige Aliase Argumente erfordern, müssen die Aliase a, f und l zuletzt verwendet werden.

Im Allgemeinen können Sie, sobald Sie mit diesem Schema vertraut sind, intuitiv Aliase aus den Befehlen ableiten, die Sie ausführen möchten, und so viel Zeit beim Tippen sparen.

Installation

Um kubectl-aliases zu installieren, müssen Sie die Datei herunterladen .kubectl_aliases von GitHub und fügen Sie es in die Datei ein ~/.bashrc oder ~/.zshrc:

source ~/.kubectl_aliases

Autovervollständigung

Wie bereits erwähnt, fügt man einem Alias häufig in der Befehlszeile zusätzliche Wörter hinzu. Zum Beispiel:

$ kgpooyaml test-pod-d4b77b989

Wenn Sie die Befehlsvervollständigung von kubectl verwenden, haben Sie wahrscheinlich die automatische Vervollständigung für Dinge wie Ressourcennamen verwendet. Aber ist dies möglich, wenn Aliase verwendet werden?

Dies ist eine sehr wichtige Frage, denn wenn die automatische Vervollständigung nicht funktioniert, verlieren Sie einige der Vorteile von Aliasen.

Die Antwort hängt davon ab, welche Shell Sie verwenden:

Für Zsh funktioniert die Alias-Vervollständigung sofort.
Für Bash ist leider einige Arbeit erforderlich, damit die automatische Vervollständigung funktioniert.

Aktivieren der automatischen Vervollständigung für Aliase in Bash

Das Problem mit Bash besteht darin, dass es versucht, den Alias zu vervollständigen (jedes Mal, wenn Sie die Tabulatortaste drücken), und nicht den Befehl, auf den der Alias verweist (wie es beispielsweise Zsh tut). Da Sie nicht für alle 800 Aliase über Vervollständigungsskripts verfügen, funktioniert die automatische Vervollständigung nicht.

Projekt vollständiger Alias bietet eine allgemeine Lösung für dieses Problem. Es stellt eine Verbindung zum Alias-Vervollständigungsmechanismus her, erweitert den Alias intern zu einem Befehl und gibt Vervollständigungsoptionen für den abgeschlossenen Befehl zurück. Das bedeutet, dass sich das Auffüllen für einen Alias genauso verhält wie für einen vollständigen Befehl.

Im Folgenden erkläre ich zunächst, wie man „complete-alias“ installiert und dann wie man es konfiguriert, um die Vervollständigung für alle kubectl-Aliase zu ermöglichen.

Complete-Alias installieren

Zunächst hängt der vollständige Alias davon ab Bash-Vervollständigung. Daher müssen Sie vor der Installation von Complete-Alias sicherstellen, dass Bash-Completion installiert ist. Installationsanweisungen wurden bereits für Linux und MacOS bereitgestellt.

Wichtiger Hinweis für MacOS-Benutzer: Wie das Autovervollständigungsskript kubectl funktioniert auch „complete-alias“ nicht mit Bash 3.2, was unter MacOS die Standardeinstellung ist. Insbesondere hängt der vollständige Alias von der Bash-Vervollständigung v2 ab (brew install bash-completion@2), was mindestens Bash 4.1 erfordert. Das bedeutet, dass Sie zur Verwendung von Complete-Alias unter MacOS eine neuere Version von Bash installieren müssen.

Sie müssen das Skript herunterladen bash_completion.sh von GitHub-Repository und fügen Sie es in Ihre Datei ein ~/.bashrc:

source ~/bash_completion.sh

Nach dem Neustart der Shell wird Complete-Alias vollständig installiert.

Aktivieren der automatischen Vervollständigung für kubectl-Aliase

Technisch gesehen bietet Complete-Alias eine Wrapper-Funktion _complete_alias. Diese Funktion prüft den Alias und gibt Abschlusshinweise für den Alias-Befehl zurück.

Um eine Funktion einem bestimmten Alias zuzuordnen, müssen Sie den integrierten Bash-Mechanismus verwenden abschließen, installieren _complete_alias als Alias-Vervollständigungsfunktion.

Nehmen wir als Beispiel den Alias k, der für den Befehl kubectl steht. installieren _complete_alias Als Ergänzungsfunktion für diesen Alias sollten Sie den folgenden Befehl ausführen:

$ complete -F _complete_alias k

Das Ergebnis ist, dass die Funktion immer dann aufgerufen wird, wenn Sie einen Alias k automatisch vervollständigen _complete_alias, der den Alias überprüft und Abschlusshinweise für den Befehl zurückgibt kubectl.

Als zweites Beispiel nehmen wir den Alias kg, was bedeutet kubectl get:

$ complete -F _complete_alias kg

Genau wie im vorherigen Beispiel erhalten Sie bei der automatischen Vervollständigung von kg die gleichen Vervollständigungshinweise, die Sie auch erhalten würden kubectl get.

Beachten Sie, dass Sie „complete-alias“ für jeden Alias auf Ihrem System verwenden können.

Um die automatische Vervollständigung für alle kubectl-Aliase zu aktivieren, müssen Sie daher für jeden von ihnen den obigen Befehl ausführen. Das folgende Snippet macht genau das, vorausgesetzt, Sie haben kubectl-aliases auf gesetzt ~/.kubectl-aliases:

for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$//' ~/.kubectl_aliases); 
do
  complete -F _complete_alias "$_a"
done

Dieser Code muss in Ihrem platziert werden ~/.bashrc, starten Sie die Befehlsshell neu und die automatische Vervollständigung wird für alle 800 kubectl-Aliase verfügbar.

6. Kubectl mit Plugins erweitern

Seit Version 1.12, unterstützt kubectl Plugin-Mechanismus, mit dem Sie seine Funktionen um zusätzliche Befehle erweitern können.

Wenn Sie vertraut sind mit Git-Plugin-Mechanismen, dann basieren Kubectl-Plugins auf dem gleichen Prinzip.

In diesem Kapitel erfahren Sie, wie Sie Plugins installieren, wo Sie sie finden und wie Sie eigene Plugins erstellen.

Plugins installieren

Kubectl-Plugins werden als einfache ausführbare Dateien mit dem Namen „like“ verteilt kubectl-x. Präfix kubectl- ist erforderlich, gefolgt von einem neuen kubectl-Unterbefehl, mit dem Sie das Plugin aufrufen können.

Beispielsweise wird das Hello-Plugin als Datei mit dem Namen verteilt kubectl-hello.

Um das Plugin zu installieren, müssen Sie die Datei kopieren kubectl-x in ein beliebiges Verzeichnis in Ihrem PATH kopieren und es ausführbar machen, zum Beispiel mit chmod +x. Unmittelbar danach können Sie das Plugin mit aufrufen kubectl x.

Mit dem folgenden Befehl können Sie alle Plugins auflisten, die derzeit auf Ihrem System installiert sind:

$ kubectl plugin list

Dieser Befehl zeigt auch Warnungen an, wenn Sie mehrere Plugins mit demselben Namen haben oder eine Plugin-Datei vorhanden ist, die nicht ausführbar ist.

Plugins mit Krew finden und installieren

Kubectl-Plugins können wie Softwarepakete geteilt oder wiederverwendet werden. Aber wo findet man Plugins, die andere geteilt haben?

Projekt Krew Ziel ist es, eine einheitliche Lösung zum Teilen, Suchen, Installieren und Verwalten von Kubectl-Plugins bereitzustellen. Das Projekt bezeichnet sich selbst als „Paketmanager für Kubectl-Plugins“ (Krew ähnelt Brauen).

Krew ist eine Liste von Kubectl-Plugins, die Sie auswählen und installieren können. Gleichzeitig ist Krew auch ein Plugin für kubectl.

Das bedeutet, dass die Installation von Krew im Wesentlichen wie die Installation jedes anderen Kubectl-Plugins funktioniert. Eine ausführliche Anleitung finden Sie unter Seite GitHub.

Die wichtigsten Krew-Befehle sind:

# Поиск в списке плагинов
$ kubectl krew search [<query>]
# Посмотреть информацию о плагине
$ kubectl krew info <plugin>
# Установить плагин
$ kubectl krew install <plugin>
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove <plugin>

Bitte beachten Sie, dass die Installation von Plugins mit Krew die Installation von Plugins mit der oben beschriebenen Standardmethode nicht beeinträchtigt.

Bitte beachten Sie, dass der Befehl kubectl krew list Zeigt nur Plugins an, die mit Krew installiert wurden, während der Befehl kubectl plugin list listet alle Plugins auf, d. h. diejenigen, die mit Krew installiert wurden, und diejenigen, die mit anderen Methoden installiert wurden.

Plugins anderswo finden

Krew ist ein junges Projekt, derzeit in der Entwicklung Liste von nur etwa 30 Plugins. Wenn Sie nicht finden, was Sie brauchen, können Sie Plugins anderswo finden, beispielsweise auf GitHub.

Ich empfehle einen Blick in den GitHub-Bereich Kubectl-Plugins. Dort finden Sie Dutzende verfügbarer Plugins, die einen Blick wert sind.

Schreiben Sie Ihre eigenen Plugins

Du kannst es selbst Plugins erstellen - Es ist nicht schwer. Sie müssen eine ausführbare Datei erstellen, die das tut, was Sie brauchen, und sie wie folgt benennen kubectl-x und wie oben beschrieben installieren.

Die Datei kann ein Bash-Skript, ein Python-Skript oder eine kompilierte GO-Anwendung sein – das spielt keine Rolle. Die einzige Bedingung ist, dass es direkt im Betriebssystem ausgeführt werden kann.

Lassen Sie uns jetzt ein Beispiel-Plugin erstellen. Im vorherigen Abschnitt haben Sie den Befehl kubectl verwendet, um die Container für jeden Pod aufzulisten. Es ist einfach, diesen Befehl in ein Plugin umzuwandeln, das Sie z. B. mit kubectl img.

Erstellen Sie eine Datei kubectl-img wie folgt:

#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

Machen Sie nun die Datei ausführbar mit chmod +x kubectl-img und verschieben Sie es in ein beliebiges Verzeichnis in Ihrem PATH. Unmittelbar danach können Sie das Plugin nutzen kubectl img.

Wie bereits erwähnt, können kubectl-Plugins in jeder Programmier- oder Skriptsprache geschrieben werden. Wenn Sie Shell-Skripte verwenden, besteht der Vorteil darin, dass Sie kubectl problemlos aus dem Plugin heraus aufrufen können. Sie können jedoch auch komplexere Plugins in echten Programmiersprachen schreiben Kubernetes-Clientbibliothek. Wenn Sie Go verwenden, können Sie auch verwenden CLI-Laufzeitbibliothek, das speziell zum Schreiben von kubectl-Plugins existiert.

So teilen Sie Ihre Plugins

Wenn Sie der Meinung sind, dass Ihre Plugins für andere nützlich sein könnten, können Sie sie gerne auf GitHub teilen. Fügen Sie sie unbedingt zum Thema hinzu Kubectl-Plugins.

Sie können auch die Hinzufügung Ihres Plugins anfordern Krew-Liste. Anweisungen dazu finden Sie hier GitHub-Repositorys.

Befehlsvervollständigung

Plugins unterstützen derzeit keine automatische Vervollständigung. Das heißt, Sie müssen den vollständigen Namen des Plugins und die vollständigen Namen der Argumente eingeben.

Das GitHub kubectl-Repository für diese Funktion hat offene Anfrage. Daher ist es möglich, dass diese Funktion irgendwann in der Zukunft implementiert wird.

Good luck!

Was gibt es sonst noch zum Thema zu lesen?:

Source: habr.com

So nutzen Sie Kubectl effektiver: eine ausführliche Anleitung