kubectl Installation und Nutzungshandbuch für Kubernetes Engine
kubectl, auch bekannt als Kube Control, ist ein Befehlszeilenwerkzeug zur Interaktion mit Kubernetes-Clustern. Es ermöglicht Administratoren und Entwicklern, Anwendungen innerhalb einer Kubernetes-Umgebung bereitzustellen, zu verwalten und zu überwachen. Über die Kubernetes-API kommuniziert kubectl mit der Steuerungsebene des Clusters und führt Verwaltungsaufgaben aus. Mit kubectl lassen sich Ressourcen wie Pods, Services und Deployments direkt über die Befehlszeile erstellen, aktualisieren und löschen.
Dieses Tutorial erklärt, wie man kubectl installiert und verwendet, um einen Kubernetes Engine-Cluster zu verwalten.
Voraussetzungen
- Ein bereitgestellter Kubernetes Engine-Cluster.
kubectl installieren
Das Dienstprogramm kubectl ist auf gängigen Betriebssystemen wie Windows, Linux und macOS verfügbar. In diesem Abschnitt wird beschrieben, wie kubectl installiert wird, um Kubernetes-Cluster zu verbinden und zu verwalten.
Beachten Sie, dass kubectl nicht in den apt– oder dnf-Repositorys von Debian/Ubuntu und CentOS/RHEL verfügbar ist. Sie können kubectl entweder über den Snap-Paketmanager installieren oder das neueste Binary manuell auf Ihr System hinzufügen.
kubectl mit Snap installieren
Unter Linux installieren Sie kubectl mit dem Snap-Paketmanager:
$ sudo snap install kubectl --classic
kubectl Binary unter Linux installieren
Um kubectl manuell zu installieren, laden Sie das neueste Binary herunter:
$ curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
Vergeben Sie Ausführungsrechte:
$ chmod +x kubectl
Verschieben Sie das Binary in das Verzeichnis /usr/local/bin, um kubectl systemweit verfügbar zu machen:
$ sudo cp kubectl /usr/local/bin/
kubectl unter Windows installieren
Unter Windows installieren Sie Chocolatey oder den Windows-Paketmanager, um kubectl zu beziehen. Öffnen Sie das Startmenü, starten Sie eine neue PowerShell-Sitzung und wählen Sie eine der folgenden Methoden:
Mit Chocolatey:
> choco install kubernetes-cli
Mit Windows Package Manager:
> winget install -e --id CNCF.kubectl
Manuelle Installation unter Windows:
Laden Sie das neueste kubectl-Binary herunter:
> Invoke-WebRequest -Uri "http://dl.k8s.io/release/$(Invoke-WebRequest -Uri http://dl.k8s.io/release/stable.txt).txt/bin/windows/amd64/kubectl.exe" -OutFile kubectl.exe
Kopieren Sie die Datei in ein Verzeichnis, das in Ihrem System-PATH enthalten ist:
> copy "C:\path\to\kubectl.exe" "C:\bin"
kubectl auf macOS installieren
Unter macOS installieren Sie zunächst den Homebrew-Paketmanager und verwenden ihn dann, um kubectl zu installieren:
% brew install kubectl
Manuelle Installationsschritte unter macOS:
Laden Sie das neueste Binary herunter:
% curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl"
Vergeben Sie Ausführungsrechte:
% chmod +x kubectl
Verschieben Sie die Datei nach /usr/local/bin, um systemweiten Zugriff zu ermöglichen:
% sudo cp kubectl /usr/local/bin/
kubectl Installation überprüfen
Sobald kubectl als systemweiter Befehl auf Ihrem Verwaltungsrechner verfügbar ist, stellen Sie sicher, dass es korrekt funktioniert, indem Sie die installierte Version prüfen:
$ kubectl version
Die Ausgabe sollte die Client-Version Ihrer kubectl-Installation anzeigen.
Mit einem KE-Cluster per kubectl verbinden
Um kubectl mit einem KE-Cluster zu verbinden, müssen Sie die Cluster-Konfigurationsdatei herunterladen und kubectl so einstellen, dass diese YAML-Datei verwendet wird. Gehen Sie dazu folgendermaßen vor:
- Melden Sie sich im Kundenportal an und navigieren Sie zum Bereich Kubernetes.
- Wählen Sie den Kubernetes-Cluster aus, auf den Sie zugreifen möchten.
- Klicken Sie im Cluster-Dashboard auf Konfiguration herunterladen, um die YAML-Konfigurationsdatei auf Ihrem Computer zu speichern.
Öffnen Sie ein neues Terminal und wechseln Sie in das Verzeichnis, in dem Sie die Konfigurationsdatei gespeichert haben, z. B.:
$ cd ~/Downloads
Erstellen Sie das Verzeichnis .kube in Ihrem Benutzerverzeichnis, falls es noch nicht existiert:
$ mkdir ~/.kube
Sichern Sie die ursprüngliche Konfigurationsdatei und kopieren Sie anschließend Ihre heruntergeladene KE-YAML-Datei in das .kube-Verzeichnis. Benennen Sie sie dabei in config um:
$ cp ~/Downloads/ke.yaml ~/.kube/config
Überprüfen Sie die Verbindung, indem Sie die Knoten in Ihrem KE-Cluster auflisten:
$ kubectl get nodes
Wenn die Verbindung erfolgreich ist, wird eine Liste der Clusterknoten angezeigt.
Sie können außerdem detaillierte Clusterinformationen, einschließlich der Endpunkte der Steuerungsebene, mit folgendem Befehl abrufen:
$ kubectl cluster-info
Damit werden ausführliche Informationen über Ihren Kubernetes Engine-Cluster angezeigt.
kubectl zur Verwaltung eines KE-Clusters verwenden
Mit kubectl sind Ihre Interaktionen mit dem KE-Cluster sicher, authentifiziert und entsprechen den Best Practices für Kubernetes. In diesem Abschnitt nutzen Sie gängige kubectl-Befehle, um Ihren KE-Cluster zu verwalten. Diese Befehle helfen Ihnen dabei, Informationen abzurufen, Ressourcen zu steuern, Anwendungen zu skalieren, den Status von Ressourcen zu prüfen und Cluster-Logs einzusehen.
In Kubernetes sind Ressourcen die grundlegenden Bausteine zum Ausführen und Verwalten containerisierter Anwendungen. Sie bilden die Basis für Workloads und Anwendungen. Nachfolgend finden Sie kubectl-Befehle zur Verwaltung dieser Ressourcen.
Ressourcen im Cluster erstellen
Erstellen Sie ein neues Deployment mit einem Docker-Image:
$ kubectl create deployment <deployment-name> --image=<image-name>
Erstellen Sie eine Ressource mit einer YAML-Manifestdatei:
$ kubectl create -f <filename.yaml>
Aktualisieren Sie das Image eines Containers innerhalb eines Deployments:
$ kubectl set image deployment/<deployment-name> <container-name>=<new-image>
Cluster-Ressourcen auflisten
Kubernetes-Ressourcen umfassen Nodes, Pods, Services, Deployments, ConfigMaps und Secrets. Mit dem Befehl kubectl get können diese Ressourcen angezeigt werden.
Alle Clusterknoten auflisten:
$ kubectl get nodes
Pods im Standard-Namespace auflisten:
$ kubectl get pods
Pods in einem bestimmten Namespace auflisten:
$ kubectl get pods -n <namespace>
Pods über alle Namespaces hinweg auflisten:
$ kubectl get pods --all-namespaces
Alle Deployments im Cluster anzeigen:
$ kubectl get deployments
Alle Services im Cluster auflisten:
$ kubectl get services
Cluster-Ressourcen beschreiben
Verwenden Sie den Befehl kubectl describe, um ausführliche Informationen zu Ressourcen anzuzeigen.
Einen bestimmten Pod untersuchen:
$ kubectl describe pod <pod-name>
Details zu einem bestimmten Node anzeigen:
$ kubectl describe node <node-name>
Ausführliche Informationen zu einem Service abrufen:
$ kubectl describe service <service-name>
Ressourcen im Cluster löschen
Entfernen Sie Ressourcen mit dem Befehl kubectl delete:
Einen Pod löschen:
$ kubectl delete pod <pod-name>
Einen Service löschen:
$ kubectl delete svc <service-name>
Ein Deployment löschen:
$ kubectl delete deployment <deployment-name>
Namespaces erstellen und verwalten
Namespaces teilen einen Kubernetes-Cluster in virtuelle Teilbereiche auf und ermöglichen die Zuweisung von rollenbasiertem Zugriff und Berechtigungen je Namespace.
Einen Namespace erstellen:
$ kubectl create namespace <namespace-name>
Namespaces auflisten:
$ kubectl get namespaces
Einen Namespace löschen:
$ kubectl delete namespace <namespace-name>
ConfigMap- und Secret-Verwaltung
ConfigMaps und Secrets ermöglichen es Kubernetes, Konfigurationsdaten und sensible Werte beim Start in Container einzubringen.
Eine ConfigMap aus einer Datei erzeugen:
$ kubectl create configmap <configmap-name> --from-file=<file-path>:
ConfigMaps auflisten:
$ kubectl get configmaps
Eine ConfigMap löschen:
$ kubectl delete configmap <configmap-name>
Ein Secret aus Literalwerten erstellen:
$ kubectl create secret generic <secret-name> --from-literal=key=value
Secrets auflisten:
$ kubectl get secrets
Ein Secret löschen:
$ kubectl delete secret <secret-name>
Anwendungen skalieren
Deployments mit dem Befehl kubectl scale skalieren:
$ kubectl scale deployment <deployment-name> --replicas=<desired-replicas>
Ein bestehendes Deployment bearbeiten:
$ kubectl edit deployment <deployment-name>
Cluster-Logs ansehen
Verwenden Sie kubectl logs, um Pod-Logs zu prüfen.
Logs für einen bestimmten Pod anzeigen:
$ kubectl logs <pod-name>
Logs eines bestimmten Containers in einem Pod anzeigen:
$ kubectl logs <pod-name> -c <container-name>
Logs in Echtzeit streamen:
$ kubectl logs -f <pod-name>
Logs früherer Instanzen eines Pods anzeigen:
$ kubectl logs --previous <pod-name>
Pod-Logs mit Zeitstempeln anzeigen:
$ kubectl logs --timestamps <pod-name>
Erweiterte kubectl-Befehle
In diesem Abschnitt werden fortgeschrittene kubectl-Befehle behandelt, die mehr Kontrolle und Flexibilität beim Arbeiten mit Kubernetes-Clustern ermöglichen.
Befehle innerhalb von Pods ausführen
Der Befehl kubectl exec erlaubt es, den Status und Inhalte von Containern in Ihrem Kubernetes-Cluster zu überprüfen. Dies ist nützlich, um Anwendungen innerhalb von Pods zu inspizieren und zu beheben.
Grundsyntax für das Ausführen eines Befehls in einem Pod:
$ kubectl exec -it <pod-name> -c <container-name> -- <command>
Erklärung der Parameter:
- -it: Startet eine interaktive Terminal-Shell.
- <pod-name>: Name des Pods.
- -c <container-name>: Gibt den Container im Pod an.
- — <command>: Der auszuführende Befehl innerhalb des Containers.
Beispiel: Eine interaktive Shell in einem Container starten:
$ kubectl exec -it <pod-name> -c <container-name> -- /bin/sh
Dateien in einem Verzeichnis des Containers auflisten:
$ kubectl exec -it <pod-name> -c <container-name> -- ls /app
Portweiterleitung für lokalen Zugriff aktivieren
Portweiterleitung ermöglicht den Zugriff auf Kubernetes-Anwendungen von Ihrem lokalen Rechner aus. Dies ist besonders praktisch für Entwicklung und Tests.
Grundsyntax für die Portweiterleitung:
$ kubectl port-forward <service-name> <local-port>:<service-port>
Beispiel: Weiterleitung von Service my-service Port 8000 auf Port 8080 lokal:
$ kubectl port-forward my-service 8080:8000
Nach Ausführung des Befehls können Sie my-service unter http://localhost:8080 aufrufen.
Ressourcen-Quotas verwalten
Ressourcen-Quotas steuern und begrenzen die Ressourcennutzung innerhalb von Namespaces in einem Kubernetes-Cluster.
Ressourcen-Quotas in einem Namespace anzeigen:
$ kubectl get resourcequota -n <namespace>
Nutzung der Quotas in einem Namespace anzeigen:
$ kubectl describe resourcequota -n <namespace>
Eine bestehende Ressourcen-Quota bearbeiten:
$ kubectl edit resourcequota <resource-quota-name> -n <namespace>
Eine Ressourcen-Quota in einem Namespace löschen:
$ kubectl delete resourcequota <resource-quota-name> -n <namespace>
Nodes für Wartung entlasten
Bei Updates, Patches oder anderen Wartungsarbeiten an einem Node können Sie diesen mit kubectl sicher entlasten.
Cluster-Nodes auflisten:
$ kubectl get nodes
Node als nicht planbar markieren, damit keine neuen Workloads darauf ausgeführt werden:
$ kubectl cordon <node-name>
Node entlasten, um laufende Pods zu entfernen, die dann auf andere Nodes verschoben werden:
$ kubectl drain <node-name>
Gängige Flags für kubectl drain sind:
--force: Erzwingt das Entlasten des Nodes.--timeout: Gibt eine Zeitüberschreitung für den Vorgang an.--ignore-daemonsets: Bezieht DaemonSet-Pods in die Entlastung ein.
Node nach der Wartung wieder planbar machen:
$ kubectl uncordon <node-name>
Fazit
In diesem Leitfaden haben Sie gelernt, wie Sie kubectl auf Ihrem lokalen System installieren und so konfigurieren, dass es sich mit Kubernetes Engine verbindet. Außerdem haben Sie die Verwaltung von Ressourcen, das Skalieren von Anwendungen, das Überwachen von Statusmeldungen und das Anzeigen von Logs in einem Kubernetes-Cluster geübt. Der sichere Umgang mit kubectl ist eine entscheidende Fähigkeit für Systemadministratoren, die mit Kubernetes-Umgebungen arbeiten.
