• Erledigen Sie die Anwendungssicherheit auf die richtige Weise! Erkennen, schützen, überwachen, beschleunigen und mehr…
  • 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.