Ein Leitfaden zu KUBECTL wie nie zuvor

Das Open-Source-Community-Team China machte seine erste Live-Übertragung und erzählte im Namen des Teilens die Geschichte hinter der Open-Source-Community China.“

Was für ein Ingenieur sind Sie? Kann es jemand anhand des Aussehens erraten? Es ist wahrscheinlich unmöglich zu erraten.

Übersetzt aus „Der Leitfaden zu Kubectl, den ich nie hatte“ , Autor Jake Page.

Was wäre, wenn jemand es allein durch einen Blick auf Ihre Tastatur erraten könnte? Wahrscheinlich ist es jetzt etwas einfacher.

Sie wissen, dass Sie es mit einem Kubernetes-Ingenieur zu tun haben, wenn die Taste „k“ auf Ihrer Tastatur abgenutzt ist .

Im Glasskube- Büro finden Sie überall Ersatzschlüssel „k“, für den Fall, dass Sie sie brauchen.

Natürlich mache ich Witze.

Ich bin mir nicht sicher, was eine abgenutzte Tastatur über ihren Besitzer aussagt. Aber ich weiß, wie wichtig kubectl für jeden ist, der ein kompetenter Kubernetes- Administrator werden möchte.

kubectl ist ein CLI-Tool zur Kommunikation mit der Kubernetes-API, was zunächst einfach erscheinen mag, aber schnell komplex werden kann.

Deshalb ist es mein Ziel, in diesem Blogbeitrag den Leitfaden zu schreiben, den ich mir gewünscht habe, als ich gerade angefangen habe . Konzentrieren Sie sich zunächst auf die Befehlssyntax und nützliche Befehle und wenden Sie sich dann dem lebendigen Ökosystem von Plugins und Tools zu, die darauf ausgelegt sind, die Funktionen von kubectl und Kubernetes zu erweitern .

Wir teilen außerdem einige Tipps und Tricks sowie einen hilfreichen Kubectl-Spickzettel.

Lasst uns beginnen.

Haftungsausschluss

Dies ist kein Artikel über Kubernetes. K8s ist eine extrem umfangreiche Technologie, die viele Konzepte abdeckt, beispielsweise verschiedene Arten von Kubernetes-Objekten und deren Interaktionen. Für diese Diskussion gehe ich davon aus, dass Sie mit diesen Konzepten vertraut sind. Stattdessen werde ich mich speziell auf kubectl, seine Verwendung und die darauf aufbauenden Tools konzentrieren.

vor dem Start

Wenn Sie Open-Source-Projekte unterstützen, die die Kubernetes-Paketverwaltung für alle verbessern, dann denken Sie bitte darüber nach, Glasskube zu unterstützen und uns einen Stern auf GitHub zu geben.

Installieren

Um kubectl zu installieren, haben Sie je nach Betriebssystem verschiedene Möglichkeiten. So installieren Sie es auf einigen gängigen Plattformen:

Linux (Ubuntu/Debian)

sudo apt-get update && sudo apt-get install -y kubectl

MacOS mit Homebrew

brew install kubectl

Windows mit Chocolatey

choco install kubernetes-cli

Nach der Installation können Sie überprüfen, ob kubectl korrekt installiert ist, indem Sie den folgenden Befehl ausführen:

kubectl version --client

kubectl-Befehl:

kubectl ist ein Befehlszeilenschnittstellentool (CLI), das zur Kommunikation mit der Kubernetes-API verwendet wird. Es gibt viele Befehle, zu viele, um sie sich zu merken.

Aber keine Sorge, es ist nicht so beängstigend, wie manche Leute es sich vorstellen.

Wir untersuchen Möglichkeiten für den schnellen Zugriff auf Befehlsreferenzen, spezifische Befehle für k8s-Objekte, nützliche Aliase und die Befehlsvervollständigung. Doch zunächst einmal: Wie ist die Befehlszeichenfolge aufgebaut?

Grammatik

Englisch und Chinesisch sind Subjekt-Verb-Objekt- Sprachen (SVO).

Hindi und Koreanisch sind Subjekt-Objekt-Verb- Sprachen (SOV).

Wenn kubectl eine Sprache wäre, wäre es eine **kubectl + verb + object/[name optional] + flag(kvof)**-Sprache

Ähnlich wie bei der Sprache besteht der beste Weg, Grammatik zu lernen und zu verinnerlichen, darin, sie im Kontext zu verwenden, anstatt lange Listen von Verben und Objekten auswendig zu lernen.

Wenn Sie nicht weiterkommen und schnell auf vorhandene Kubernetes-Objekte aus einer beliebigen Kubernetes-Version verweisen möchten, führen Sie kubectl api-resources aus.

Befehle sind Ressourcen-[Objekte], die durch Auswahl der Aktion [Verb] erstellt werden, die auf das gewünschte Kubernetes angewendet werden soll , normalerweise gefolgt vom Namen der Ressource. Darüber hinaus steht Ihnen eine große Anzahl von Filtern [Flags] zur Verfügung , die auf die angewendet werden können Mit diesen Filtern werden der endgültige Umfang und die Ausgabe bestimmt.

Schauen wir uns ein Beispiel für einen Befehlsaufbau an, der das allgemeine Get-Verb verwendet , um alle Ressourcen im Glasskube-System-Namespace abzurufen, mit der Ausgabe im Yaml-Format:

kubectl get all --namespace glasskube-system -o yaml

Wenn Sie auf eine Kubernetes-Ressource stoßen, von der Sie noch nie gehört haben, oder eine Auffrischung benötigen, verwenden Sie kubectl EXPLAIN [Ressourcenname], um eine Terminalbeschreibung und Nutzungsanweisungen zu erhalten.

zwingende Arbeit

Wenn Sie in einer Kubernetes-Umgebung arbeiten, fallen Ihnen viele Aufgaben zu, von der Bereitstellung neuer Anwendungen über die Fehlerbehebung bei ausgefallenen Ressourcen bis hin zur Überprüfung der Nutzung und mehr. Später werden wir untersuchen, wie die Verwendung einer deklarativen Arbeitsweise besser zum Definieren und Bereitstellen von Workloads geeignet ist. Für alles andere haben wir jedoch nützliche imperative Kubernetes-Befehle parat.

Der einfache Befehl zum Einstieg lautet:

# Create a new deployment named "nginx-deployment" with the nginx image
kubectl run nginx-deployment --image=nginx

# Delete a pod named "nginx-deployment" in the default namespace
kubectl delete pod nginx-deployment

Um mit zwingenden Befehlen zum nächsten Schritt überzugehen, beachten Sie, dass Sie den TUI- Editor zum Ändern von Ressourcen verwenden können:

Durch Ausführen von kubectl edit -n [Namespace] [Ressourcenname] wird ein Texteditor ähnlich dem folgenden geöffnet. Bearbeiten und beenden Sie wie vim run ESC + :q!.

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
kind: Pod
metadata:
  annotations:
    kubectl.kubernetes.io/default-container: manager
  creationTimestamp: "2024-04-22T17:07:39Z"
  generateName: glasskube-controller-manager-556ff6fccf-
  labels:
    control-plane: controller-manager
    pod-template-hash: 556ff6fccf
  name: glasskube-controller-manager-556ff6fccf-4qlxz
  namespace: glasskube-system
  ownerReferences:
  - apiVersion: apps/v1
    blockOwnerDeletion: true
    controller: true
    kind: ReplicaSet
    name: glasskube-controller-manager-556ff6fccf
    uid: 430e90e9-32f3-45f6-92dc-4bae26ae1654
"/var/folders/2q/wjmbwg1n5vn8v7vlw17nsz0h0000gn/T/kubectl-edit-1306753911.yaml" 209L, 5898B

Die meisten Befehle funktionieren für alle Arten von Kubernetes-Objekten. Bevor wir weitere spezifische Befehle besprechen, die für bestimmte Kubernetes-Ressourcen nützlich sind, lohnt es sich, einige nützliche Flags zu verstehen, die auf viele verschiedene Objekte angewendet werden können.

Nützliche Flags:

— env:

Mit dem Flag --env können Sie Umgebungsvariablen für den zu erstellenden Container angeben.

kubectl run nginx-deployment --image=nginx --env="ENV_VARIABLE=value"

- Vorlage:

Mit diesem Flag können Sie eine Go-Vorlage für das Ausgabeformat des Befehls kubectl angeben. Dies ist sehr praktisch, wenn Sie die Ausgabestruktur, Filterung oder Präsentation anpassen möchten.

kubectl get pods --template='{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}'

— Feldauswahl:

Mit diesem Flag können Sie Ressourcen nach bestimmten Feldern filtern. Sie können Pods beispielsweise nach ihrem Status oder ihrer Bezeichnung filtern.

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

— Feldauswahltyp=[Normal/Warnung]：

Dies ist eine spezielle Verwendung des Feldauswahlflags, mit dem Sie Ereignisse nach Typ (Normal oder Warnung) filtern können.

kubectl events -n [resource-namespace] — for=[resource-kind]/[resource-name]Dieser Befehl ruft Ereignisse ab, die sich auf eine bestimmte Ressource im angegebenen Namespace beziehen. Es überwacht kontinuierlich neue Ereignisse im Zusammenhang mit einer bestimmten Ressource.

kubectl events -n my-namespace --for=deployment/my-deployment

Old-School- vs. New-School-Überwachungsflaggen:

-o weit gegeben -w:

-o wide: Dies ist ein Flag der „alten Schule“, das ein breites Ausgabeformat bereitstellt und zusätzliche Details zur Ressource anzeigt.

-w: Dies ist ein Flag „Neue Schule“**, das eine kontinuierliche Überwachung von Ressourcenänderungen ermöglicht, ähnlich dem Befehl „watch“.

Verwendung von Pods

Pods sind die kleinste Abstraktion im Kubernetes-Ökosystem. Sie sind logische Einheiten, die Container beherbergen. Pods verbrauchen Ressourcen, können Protokolle ausführen und generieren. Hier sind einige Befehle, die Ihnen bei der Verwaltung von Pods helfen.

# Show resource usage of a pod
kubectl top pod -n [namespace] [pod-name]

# Run a command inside a new pod in the cluster
kubectl run -it ubuntu --image ubuntu --rm -- bash

# Show resource labels as columns
# e.g. kubectl get pods -n [namespace] -L vault-active -L vault-sealed
kubectl get pods -n [namespace] -L vault-active -L vault-sealed

# Execute a command inside a pod
kubectl exec -it [pod-name] -n [namespace] --

# Port forward to a pod
kubectl port-forward [pod-name] [local-port]:[remote-port] -n [namespace]

# Show container logs
kubectl logs -n [namespace] [pod-name]
kubectl logs -n [namespace] /deployment/[deployment-name]  # Use -f flag for continuous streaming

# Run a command inside an existing container
kubectl exec -it -n [namespace] [pod-name] -- [command...]

Knoten verwenden

Knoten sind Basisinstanzen, die Rechenleistung und Speicher bereitstellen, auf denen Kubernetes-Cluster laufen.

# Show node resource utilization
kubectl top node [node-name]  # Node name is optional; without shows table of all nodes

# Get node information
kubectl get node

Verwendung von Bereitstellungen, DaemonSets und StatefulSets

Bereitstellungen, Daemon-Sets und Stateful-Sets sind Abstraktionen auf höherer Ebene in Kubernetes, die zur Verwaltung der Bereitstellung und Skalierung von Anwendungs-Workloads verwendet werden.

# Restart a workload (e.g. deployment, stateful set, daemon set)
kubectl rollout restart -n [namespace] [workload-kind]/[workload-name]  # Triggers a re-creation of all pods for this workload, adhering to the workload configuration

# Check the status of a deployment rollout
kubectl rollout status deployment/[name]

# View rollout history of a deployment
kubectl rollout history deployment/[name]  # View rollout history of a deployment

# Scale a deployment to the specified number of replicas
kubectl scale deployment/ --replicas=[number]  # Scale a deployment to the specified number of replicas

# Watch events related to a deployment
kubectl events -n glasskube-system --for=deployment/glasskube-controller-manager  

#Update Deployment Image
kubectl set image deployment/[deployment-name] [container-name]=new-image:tag

# Delete DaemonSet
kubectl delete daemonset [daemonset-name]

Verwenden Sie Job

Ein Job verwaltet die Ausführung eines Pods zur Ausführung einer bestimmten Aufgabe und stellt den erfolgreichen Abschluss der Aufgabe sicher, bevor sie beendet wird.

# Run a CronJob manually
kubectl create job [job-name] --image=image/name

# Creates a new job from the job template specified in the cronjob
kubectl create job -n [namespace] --from=cronjob/[cron-job-name] [job-name]

Verwenden Sie Geheimnis

Geheimnisse werden verwendet, um vertrauliche Informationen wie Passwörter, OAuth-Tokens und SSH-Schlüssel in Kubernetes sicher zu speichern.

# Create Secret
kubectl create secret generic [secret-name] --from-literal=key1=value1 --from-file=ssh-privatekey=~/.ssh/id_rsa

# Get a value from a secret
kubectl get secrets -n [namespace] [secret-name] --template='{{ .data.[key-name] | base64decode }}'

# Get a value from a secret using jsonpath
kubectl get secrets [secret-name] -o jsonpath="{.data.key1}" | base64 --decode

JSONPath ist eine Abfragesprache, die zum Extrahieren spezifischer Daten aus JSON-Dokumenten verwendet wird. In Kubernetes werden JSONPath-Ausdrücke häufig -o jsonpathmit Flags in kubectl-Befehlen verwendet, um bestimmte Informationen aus der Ausgabe dieser Befehle zu extrahieren.

Shell-Fertigstellung

Möglicherweise ist Ihnen aufgefallen, dass kubectl-Befehle sehr schnell sehr lang werden können. Ein praktisches Shell-Vervollständigungsskript kann zu Ihrer Bash- oder Zshell-Datei hinzugefügt werden, um eine einfache Tag-Vervollständigung zu ermöglichen. Kein Pauken mehr. Um dies über alle Shell-Sitzungen hinweg zu erreichen, fügen Sie Folgendes zu Ihrer ~/.zshrc-Datei hinzu:

source <(kubectl completion zsh)

und starten Sie die Shell neu. Wenn Sie Bash verwenden, befolgen Sie die Anweisungen hier:

# Install bash-completion package
sudo apt-get install -y bash-completion
# Store the output of the completion command in .bashrc
echo "source <(kubectl completion bash)" >> ~/.bashrc
# Activate the completion rules
source ~/.bashrc

deklarativ arbeiten

Die deklarative Verwaltung von Kubernetes-Ressourcen umfasst die Verwendung von YAML-Manifestdateien zur Angabe des gewünschten Status der Ressourcen und die Anwendung dieser Manifeste auf den Cluster.

Erstellen Sie eine YAML-Datei

Unabhängig davon, ob Kubernetes-Objekte von Ihnen oder einer anderen Person geschrieben werden, werden alle Objekte in YAML-Dateien definiert. Die Kubernetes-API verwendet YAML-Dateidefinitionen, um den Clusterstatus zu verstehen:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: glasskube-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: glasskube
      env: prod
  template:
    metadata:
      labels:
        app: glasskube
        env: prod
    spec:
      containers:
      - name: glasskube-container
        image: your-glasskube-image:latest

Um diese Bereitstellung von Grund auf zu erstellen, verwenden Sie den Befehl kubectl create:

kubectl create -f glasskube-deployment.yaml

Anwendungs-YAML-Datei (Clientanwendung)

Die Verwendung von YAML-Dateien ist die Standardmethode zur Verwaltung von Kubernetes-Ressourcen. Sie können den gewünschten Zustand Ihrer Ressourcen im YAML-Format definieren und diese YAML-Dateien auf den Cluster anwenden.

kubectl apply -f manifest.yaml

Serverseitige Anwendung (SSA)

Die serverseitige Anwendung ist eine neuere Methode zum Anwenden von Konfigurationsänderungen auf Kubernetes-Ressourcen. Mit SSA werden Änderungen direkt serverseitig angewendet, was bedeutet, dass der Kubernetes-API-Server dafür verantwortlich ist, sicherzustellen, dass der gewünschte Zustand erreicht wird.

kubectl apply --server-side -f manifest.yaml

Plugins und Tools

Immer wenn ich hin und her Diskussionen über Kubernetes sehe, was genau ist das? Für welche Anwendungsfälle es sich am besten eignet und wie man am besten darüber nachdenkt, fällt mir der gleiche Tweet von Kelsey Hightower ein.

Diese Ansicht ist weithin anerkannt, wie das große Ökosystem von Kubernetes-Plugins und -Tools zeigt, die zur Bewältigung verschiedener Phasen im Kubernetes-Lebenszyklus entwickelt wurden.

Krew Kubernetes Plugin Manager

Ein leistungsstarker Plugin-Manager zum Auffinden neuer Plugins ist krew . Die Installation erfolgt wie folgt. Der Befehl zum Installieren des Kubectl-Plug-Ins über Krew:

kubectl krew install <PLUGIN_NAME>

Lassen Sie uns einige der wichtigsten Debugging- und Tool-Kategorien erkunden und einige der nützlichsten Elemente hervorheben. Da es so viel zu beachten gibt, werde ich für jeden Abschnitt einen Abschnitt mit Ehrungen hinzufügen.

Inhalts- und Namespace-Wechsel

In einer Kubernetes-Umgebung agieren Sie immer in zwei hierarchischen Kontexten, Clustern und Namespaces. Um eine genaue Befehlsausführung sicherzustellen, muss der entsprechende Kontext angegeben werden, um die gewünschte Ausgabe zu erhalten. Das Wechseln von Clusterkontexten oder Namespaces kann lange Befehle erfordern, die schwer zu merken sind. Hier kommen Tools wie Kubectl und Kubens ins Spiel.

Kubectx und Kubens

Hier können Sie ganz einfach verfügbare Cluster und Namespaces anzeigen und zwischen ihnen wechseln.

Siehe Installationsanweisungen hier .

Lobenswert:

kubectl-cf : Eine schnellere Möglichkeit, zwischen kubeconfig-Dateien (anstelle von Kontexten) zu wechseln.

Sichtweite

Kubernetes-Cluster sind komplexe Systeme mit vielen beweglichen Teilen, die voneinander abhängig sind, damit Ihre Anwendung ausgeführt wird. Es ist wichtig, immer ein klares Verständnis davon zu haben, was vor sich geht.

k9s

K9s ist ein praktisches, leichtes interaktives Kubernetes-Dashboard, das im Terminal ausgeführt wird. Zusätzlich zur Visualisierung Ihrer k8s-Ressourcen können Sie ganz einfach in Pods eintauchen, Manifeste bearbeiten und Ihre Arbeitslasten an einem Ort verwalten. Dies ist wahrscheinlich eines meiner liebsten Kubernetes-Verwaltungstools.

Installationsanweisungen finden Sie hier .

Kubectl-Baum

Ein kubectl-Plugin zum Erkunden von Eigentumsverhältnissen zwischen Kubernetes-Objekten über OwnerReferences auf den Objekten.

Installieren :

kubectl krew install tree
kubectl tree --help

kubecolor

KubeColor wird verwendet, um der kubectl-Ausgabe Farbe hinzuzufügen.

Installationsanweisungen finden Sie hier .

Paketverwaltung

Die Cluster-Paketverwaltung mit regulären Paketverwaltungstools kann frustrierend sein und das Aktualisieren von Paketen kann mühsam sein. Die Konfiguration ist umständlich und der für die deklarative Anwendung erforderliche Paketstapel war bisher außer Kontrolle.

Glaswürfel:

Mit Glasskube werden alle Schwachstellen traditioneller Paketmanager wie Helm beseitigt, sodass Sie Zeit für die Verwaltung Ihrer Arbeitslasten haben und sich nicht um die Verwaltung Ihres k8s-Paketstapels kümmern müssen.

Netzwerk

Kubectl-Wimpern:

kubectl-Cilium ist ein Plug-in, das mit Cilium interagiert, einer eBPF-basierten cloudnativen Lösung zur Bereitstellung, Sicherung und Beobachtung von Netzwerkverbindungen zwischen Workloads.

Installieren:

kubectl krew install cilium

Zertifikatsmanager

Cert-manager fügt Zertifikate und Zertifikatsaussteller als Ressourcentypen in Kubernetes-Clustern hinzu und vereinfacht so den Erhalt, die Aktualisierung und die Verwendung dieser Zertifikate.

Eine Installationsanleitung finden Sie hier.

Besondere Erwähnung :

Ksniff : Dies ist ein kubectl-Plugin, das tcpdump und Wireshark nutzt, um die Remote-Erfassung auf jedem Pod in einem Kubernetes-Cluster zu initiieren.

RBAC

Die Cubeologie

Kubelogin ist ein für Kubernetes OpenID Connect (OIDC) zertifiziertes Plug-in, auch bekannt als kubectl oidc-login.

Installationsanweisungen finden Sie hier .

Kube-Policy-Advisor

Kube-policy-advisor erleichtert das Erstellen von K8s-Pod-Sicherheitsrichtlinien (PSP) oder OPA-Richtlinien aus einer aktiven K8s-Umgebung oder einer einzelnen .yaml-Datei mit Pod-Spezifikationen (Bereitstellungen, Daemon-Sets, Pods usw.).

Installieren:

kubectl krew install advise-policy

Lobenswert:

kubectl-who-can : Zeigt an, dass SUBJECTS über RBAC-Berechtigungen für VERB [TYPE | NONRESOURCEURL] verfügt.
Rakkess : Zugriff bewerten – Kubectl-Plugin zur Anzeige der Zugriffsmatrix von Serverressourcen
kubectl-rolesum : Fasst RBAC-Rollen für ein bestimmtes Subjekt (ServiceAccount, Benutzer und Gruppe) zusammen.

Fusseln

Kubectl-neat:

Kubectl-neat : Kubectl-neat beseitigt Unordnung in Kubernetes-Manifesten und macht sie besser lesbar. Es sucht und ignoriert hauptsächlich zwei Kategorien von Inhalten: vom Kubernetes-Objektmodell eingefügte Standardwerte und gängige Mutationscontroller.

Installieren:

kubectl krew install neat

KubeLinter:

KubeLinter analysiert Kubernetes YAML-Dateien und Helm-Charts und vergleicht sie mit verschiedenen Best Practices, wobei der Schwerpunkt auf Produktionsbereitschaft und Sicherheit liegt.

Installationsanleitung: https://github.com/stackrox/kube-linter?tab=readme-ov-file#installing-kubelinter.

Clusterwartung und -sicherheit

KubePug

KubePug lädt die generierte Datendatei data.json herunter, die API-Veraltungsinformationen für eine bestimmte Kubernetes-Version enthält, scannt den laufenden Kubernetes-Cluster, um festzustellen, ob Objekte von der Verwerfung betroffen sind, und zeigt dem Benutzer die betroffenen Objekte an.

Beispiel:

Mit dem folgenden Befehl können Sie den Status eines laufenden Clusters anzeigen.

$ kubepug --k8s-version=v1.22 # Will verify the current context against v1.22 version
[...]
RESULTS:
Deprecated APIs:
PodSecurityPolicy found in policy/v1beta1
     ├─ Deprecated at: 1.21
     ├─ PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container.Deprecated in 1.21.
        -> OBJECT: restrictive namespace: default


Deleted APIs:
     APIs REMOVED FROM THE CURRENT VERSION AND SHOULD BE MIGRATED IMMEDIATELY!!
Ingress found in extensions/v1beta1
     ├─ Deleted at: 1.22
     ├─ Replacement: networking.k8s.io/v1/Ingress
     ├─ Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give servicesexternally-reachable urls, load balance traffic, terminate SSL, offer namebased virtual hosting etc.DEPRECATED - This group version of Ingress is deprecated by networking.k8s.io/v1beta1 Ingress. See the release notes for more information.
        -> OBJECT: bla namespace: blabla

Installieren:

kubectl krew install deprecations

Würfellandschaft:

Kubescape ist eine Open-Source-Kubernetes-Sicherheitsplattform für Ihre Cluster, CI/CD-Pipelines und IDEs, die Sicherheitssignale vom Scannerrauschen trennt.

Installationsanleitung hier .

Es lohnt sich darüber zu reden:

kubectl-watch : Ein weiteres Beobachtungstool zur visuellen Anzeige inkrementeller Änderungen an Kubernetes-Ressourcen.

Fehlerbehebung

Inspektor Gadget:

Inspektor-Gadget ist eine Sammlung von Tools (oder Gadgets) zum Debuggen und Überprüfen von Kubernetes-Ressourcen und -Anwendungen.

Inspektor-Gadget-Tools werden Gadgets genannt. Sie können ein, zwei oder mehrere Gadgets bereitstellen.

K8s-gpt:

k8sgpt ist ein Tool zum Scannen Ihres Kubernetes-Clusters sowie zum Diagnostizieren und Einstufen von Problemen in einfachem Englisch.

Installationsanleitung hier .

Es lohnt sich darüber zu reden:

kubectl node-shell : Starten Sie eine Root-Shell direkt im Host-Betriebssystem eines laufenden Knotens.

Protokollierung

Stern:

Mit Stern können Sie mehrere Pods auf Kubernetes und mehrere Container innerhalb eines Pods verfolgen. Zur schnelleren Fehlerbehebung ist jedes Ergebnis farblich gekennzeichnet.

Installieren:

kubectl krew install stern

Zu den Sicherheitsauswirkungen der Verwendung von kubectl-Plugins gehören mögliche Schwachstellen, Rechteausweitung und unbeabsichtigte Datenoffenlegung. Stellen Sie sicher, dass Sie nur Plugins verwenden, die aktiv gepflegt werden und vorzugsweise über eine aktive Community verfügen.

Alias

Es gibt so viele kubectl-Befehle, die Sie sich merken sollten. Vereinfachen Sie Ihr Leben, indem Sie Tastaturkürzel oder Aliase verwenden.

Hier finden Sie ein Repository , das ein Skript zum Generieren Hunderter praktischer Shell-Aliase für kubectl enthält . Das Problem besteht darin, dass viele Aliase sehr lang sind und schwer zu merken sind. Aber keine Sorge, ich habe diesen sehr nützlichen Blog-Beitrag von Benoit Couetil gefunden , in dem es darum geht, wie man mit den zahlreichen Aliasen umgeht, die das obige Skript generiert.

Kubectl-Spickzettel

Ohne einen Spickzettel ist kein Leitfaden vollständig, oder?

# Basic Commands
# List API Resources
kubectl api-resources

# List Resources
kubectl get [name]

# Explain Resources
kubectl explain

# Working with Pods
# Create a new deployment named "nginx-deployment" with the nginx image
kubectl run nginx-deployment --image=nginx

# Show Resource Usage of a Pod
kubectl top pod -n [namespace] [pod-name]

# Run Command in Pod
kubectl run -it [pod-name] --image [image-name] --rm -- [command]

# Show Resource Labels
kubectl get pods -n [namespace] -L [label1] -L [label2]

# Execute Command in Pod
kubectl exec -it [pod-name] -- [command]

# Port Forwarding
kubectl port-forward [pod-name] [local-port]:[remote-port]

# Filtering Pods by Node Name
kubectl get pods --field-selector spec.nodeName=[node-name]

# Filtering Pods by Phase
kubectl get pods --field-selector status.phase=Running

# Delete a pod named "my-pod" in the default namespace
kubectl delete pod my-pod

# Working with Nodes
# Watch Nodes (Old School)
watch kubectl get nodes -o wide
# Watch Nodes (New School)
kubectl get nodes -w

# Node Resource Utilization
kubectl top node [node-name]

# Get Node Resource
kubectl describe node [node-name]

# Working with Deployments, Daemonsets, and StatefulSets
# Restart Workload
kubectl rollout restart -n [namespace] [kind]/[name]

# Rollout Status
kubectl rollout status [kind]/[name]

# Rollout History
kubectl rollout history [kind]/[name]

# Scale Deployment
kubectl scale deployment/[name] --replicas=[replica-count]

#Update Deployment Image
kubectl set image deployment/[deployment-name] [container-name]=new-image:tag

# Watch events related to a deployment
kubectl events -n glasskube-system --for=deployment/glasskube-controller-manager  

# Delete DaemonSet
kubectl delete daemonset [daemonset-name]

# Working with Jobs
# Run CronJob Manually
kubectl create job -n [namespace] --from=cronjob/[cron-job-name] [job-name]

# Working with Secrets
# Get Value from Secret
kubectl get secret -n [namespace] [secret-name] -o=jsonpath='{.data.[key]}' | base64 --decode

# Create Secret
kubectl create secret generic [secret-name] --from-literal=key1=value1 --from-file=ssh-privatekey=~/.ssh/id_rsa

# Get a value from a secret
kubectl get secrets -n [namespace] [secret-name] --template='{{ .data.[key-name] | base64decode }}'

# Working with Containers
# Show Container Logs
kubectl logs -n [namespace] [pod-name] 
kubectl logs -n [namespace] deployment/[deployment-name]

# Run Command in Container
kubectl exec -it -n [namespace] [pod-name] -- [command]

# Working Imperatively
# Modify Resource
kubectl edit -n [namespace] [resource-kind]/[resource-name]

# Delete Resource
kubectl delete [resource-kind]/[resource-name]

# Create Resource
kubectl create -f [resource-file]

# Working Declaratively
# Use Server-Side Apply (SSA)
kubectl apply --server-side -f [resource-file]

# Events and Logs
# Show Events for Resource
kubectl get events -n [namespace] --field-selector involvedObject.kind=[kind] --field-selector involvedObject.name=[name]

# Filtering Events by Type
kubectl get events --field-selector type=Warning

# Filtering Events by Involved Object Name
kubectl get events --field-selector involvedObject.name=[resource-name]

# Show Resource Usage
kubectl top

Andere Ressourcen

Empfohlene Plugin-Liste: https://github.com/ishantanu/awesome-kubectl-plugins
Alias-Liste: https://github.com/ahmetb/kubectl-aliases
Krew-Plugin-Repository: https://krew.sigs.k8s.io/plugins/

Wenn Ihnen diese Art von Inhalten gefällt und Sie mehr davon sehen möchten, denken Sie bitte darüber nach , uns zu unterstützen , indem Sie uns einen Stern auf GitHub geben.

Dieser Artikel wurde zuerst auf Yunyunzhongsheng ( https://yylives.cc/ ) veröffentlicht, jeder ist herzlich willkommen.