Im Werkzeugkasten jedes Kubernetes-Administrators steht kubectl ganz vorne – die leistungsstarke Kommandozeile, mit der sich Kubernetes-Cluster effizient verwalten lassen.
Kubectl (ausgesprochen "kube-control" oder "kube-C-T-L") ist Ihre direkte Verbindung zum Kubernetes-API-Server. Damit deployen Sie Anwendungen, prüfen Ressourcen, sehen Logs ein und führen praktisch jede Operation in Ihrem Cluster aus. Egal, ob Sie als DevOps-Engineer, Plattform-Administrator oder Entwickler an containerisierten Anwendungen arbeiten – wer kubectl beherrscht, hat die Grundlage für ein effektives Kubernetes-Management im Cloud Computing.
Dieses praktische Cheat Sheet bündelt die nützlichsten kubectl-Befehle – inklusive konkreter Beispiele und Tipps, mit denen Sie Ihre täglichen Kubernetes-Aufgaben deutlich schneller erledigen.
Was sind die zentralen Kategorien von kubectl-Befehlen?
Kubectl-Logo
Kubectl-Befehle lassen sich in drei Hauptkategorien einteilen, die jeweils unterschiedliche Aspekte des Cluster-Managements abdecken:
1. Befehle für Cluster-Informationen
Diese Befehle geben Ihnen Einblick in Zustand und Konfiguration Ihres Kubernetes-Clusters:
- Informationen zu Cluster-Komponenten abrufen
- Node-Status und -Ressourcen einsehen
- Zustand des apiservers prüfen
- Komponenten der Control Plane inspizieren
2. Befehle für das Ressourcen-Management
Mit diesen Befehlen erstellen, ändern, löschen und prüfen Sie Kubernetes-Ressourcen:
- Ressourcen erstellen und aktualisieren
- Ressourcen auflisten und beschreiben
- Ressourcen löschen
- Ressourcen hoch- und herunterskalieren
- Ressourcen in Echtzeit bearbeiten
3. Befehle für das Deployment von Anwendungen
Schließlich erleichtern Deployment-Befehle die Bereitstellung und das Lifecycle-Management Ihrer Anwendungen:
- Anwendungen aus YAML oder JSON deployen
- Deployments und Rollouts verwalten
- Autoscaling konfigurieren
- Anwendungs-Konfigurationen aktualisieren
- Networking von Anwendungen steuern
Mit diesen drei Kategorien im Hinterkopf werfen wir nun einen genaueren Blick auf konkrete kubectl-Befehle, die Ihnen auf Ihrem Kubernetes-Weg regelmäßig begegnen werden.
Tiefer eintauchen: das kubectl-Cheat-Sheet
person coding on laptop
Hier ist ein Cheat Sheet zum Griffbereithalten: Es listet die kubectl-Befehle auf, die Sie im Alltag am häufigsten brauchen – inklusive Beispielen, mit denen Sie Ihre Kubernetes-Workflows verschlanken.
Pods
Pods sind die kleinsten deploybaren Einheiten in Kubernetes. Sie bestehen aus einem oder mehreren Containern, die sich Storage- und Netzwerkressourcen teilen.
Alle Pods auflisten:
kubectl get pods
Pods mit mehr Details auflisten:
kubectl get pods -o wide
Detaillierte Informationen zu einem bestimmten Pod abrufen:
kubectl describe pod
Pod aus einer YAML-Datei erstellen:
kubectl apply -f pod.yaml
Pod löschen:
kubectl delete pod
Befehl im Container eines Pods ausführen:
kubectl exec -it --
Pod-Logs abrufen:
kubectl logs
Pod-Logs in Echtzeit streamen:
kubectl logs -f
Logs eines bestimmten Containers in einem Multi-Container-Pod abrufen:
kubectl logs -c
Port-Forwarding zu einem Pod:
kubectl port-forward :
Dateien zu/von einem Pod kopieren:
kubectl cp :/path/to/file /local/path
kubectl cp /local/path :/path/in/pod
Services
Services stellen ein stabiles Netzwerk für Pods bereit und erleichtern als Abstraktionsschicht die Kommunikation zwischen verschiedenen Komponenten.
Alle Services auflisten:
kubectl get services
Detaillierte Informationen zu einem Service abrufen:
kubectl describe service
Service aus einer YAML-Datei erstellen:
kubectl apply -f service.yaml
Ein Deployment als Service exposen:
kubectl expose deployment --port= --target-port=
Service löschen:
kubectl delete service
Endpoints eines Services anzeigen:
kubectl get endpoints
ClusterIP-Service erstellen:
kubectl create service clusterip --tcp=:
NodePort-Service erstellen:
kubectl create service nodeport --tcp=:
Einen LoadBalancer-Service erstellen:
kubectl create service loadbalancer --tcp=:
Deployments
Deployments liefern deklarative Updates für Pods und ReplicaSets und ermöglichen einfaches Skalieren sowie Anwendungs-Updates.
Alle Deployments auflisten:
kubectl get deployments
Detaillierte Informationen zu einem Deployment abrufen:
kubectl describe deployment
Deployment aus einer YAML-Datei erstellen:
kubectl apply -f deployment.yaml
Deployment direkt über die Kommandozeile erstellen:
kubectl create deployment --image=
Deployment skalieren:
kubectl scale deployment --replicas=
Container-Image eines Deployments aktualisieren:
kubectl set image deployment/ =
Deployment auf eine vorherige Revision zurücksetzen:
kubectl rollout undo deployment/
Status eines Deployment-Rollouts anzeigen:
kubectl rollout status deployment/
Verlauf eines Deployment-Rollouts anzeigen:
kubectl rollout history deployment/
Deployment-Rollout pausieren:
kubectl rollout pause deployment/
Deployment-Rollout fortsetzen:
kubectl rollout resume deployment/
ConfigMaps und Secrets
ConfigMaps und Secrets dienen zum Speichern von Konfigurationsdaten bzw. sensiblen Informationen.
Wichtiger Sicherheitshinweis: Sowohl ConfigMaps als auch Secrets werden standardmäßig unverschlüsselt in etcd abgelegt. Beim Umgang mit sensiblen Daten sollten Sie daher Encryption at Rest aktivieren.
ConfigMaps auflisten:
kubectl get configmaps
ConfigMap aus literalen Werten erstellen:
kubectl create configmap --from-literal=key1=value1 --from-literal=key2=value2
ConfigMap aus einer Datei erstellen:
kubectl create configmap --from-file=
Detaillierte Informationen zu einer ConfigMap abrufen:
kubectl describe configmap
ConfigMap löschen:
kubectl delete configmap
Secrets auflisten:
kubectl get Secrets
Secret aus literalen Werten erstellen:
kubectl create secret generic --from-literal=key1=value1 --from-literal=key2=value2
Secret aus einer Datei erstellen:
kubectl create secret generic --from-file=
Detaillierte Informationen zu einem Secret abrufen:
kubectl describe secret
Secret löschen:
kubectl delete secret
Profi-Tipps für den Einsatz von kubectl
person looking at phone while coding
Das Kommandozeilen-Tool kubectl ist ein Muss, wenn Sie mit Kubernetes-Clustern arbeiten und deren Ressourcen verwalten. Wer den Dreh raus hat, spart sich im Alltag viel Aufwand und kann effizienter deployen, skalieren und Probleme beheben. Mit kubectl edit passen Sie Ressourcen wie Pods und Deployments direkt über die Kommandozeile an.
Namespaces effektiv nutzen
Namespaces sind eine Kernfunktion in Kubernetes: Mit ihnen unterteilen Sie Ihren Cluster in virtuelle Sub-Cluster. Das ist besonders praktisch in Multi-Tenant-Setups oder beim Betrieb komplexerer Anwendungen.
Ressourcen in einem bestimmten Namespace auflisten:
kubectl get -n
Ressource in einem bestimmten Namespace erstellen:
kubectl apply -f <file.yaml> -n
Standard-Namespace für alle kubectl-Befehle setzen:
kubectl config set-context --current --namespace=
Ressourcen über alle Namespaces hinweg anzeigen:
kubectl get --all-namespaces
Neuen Namespace erstellen:
kubectl create namespace
Es lohnt sich, zusammengehörige Ressourcen in eigene Namespaces zu bündeln und so klare Grenzen zwischen Apps oder Teams zu ziehen. Verwenden Sie sprechende Namen wie dev-frontend, prod-backend oder monitoring.
Label-Selektoren zum Filtern von Ressourcen
Labels sind Schlüssel-Wert-Paare, die Kubernetes-Objekten zugeordnet werden. Damit lassen sich Gruppen von Ressourcen einfach organisieren, auswählen und verwalten.
Ressourcen mit einem bestimmten Label auflisten:
kubectl get -l key=value
Ressourcen mit mehreren Label-Bedingungen auflisten:
kubectl get -l ‘key1=value1,key2=value2’
Ressourcen mit einem bestimmten Label-Schlüssel auflisten (unabhängig vom Wert):
kubectl get -l ‘key’
Ressourcen ohne ein bestimmtes Label auflisten:
kubectl get -l ‘!key’
Label zu einer bestehenden Ressource hinzufügen:
kubectl label key=value
Label von einer Ressource entfernen:
kubectl label key-
Eine konsistente Labeling-Strategie ist der Schlüssel zu effektivem Ressourcen-Management. Setzen Sie auf Labels wie app, environment, tier, version und owner, um Ordnung und Übersicht in Ihre Ressourcen zu bringen.
Rolling Updates umsetzen
Kubernetes macht es einfach, Anwendungen ohne Downtime per Rolling Update zu aktualisieren. Bei dieser Strategie werden Instanzen der alten Version schrittweise durch die neue ersetzt.
Deployment mit neuem Image aktualisieren (löst Rolling Update aus):
kubectl set image deployment/ =:
Rollout-Status prüfen:
kubectl rollout status deployment/
Update-Strategie in einem Deployment-YAML konfigurieren:
spec:
strategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 25%
maxSurge: 25%
Bei Problemen auf die vorherige Version zurückrollen:
kubectl rollout undo deployment/
Deployment-Rollout pausieren:
Copykubectl rollout pause deployment/
Das ist besonders praktisch für gestaffelte Deployments: Sie rollen zunächst auf eine Teilmenge der Pods aus, prüfen die Funktionalität und setzen den Rollout nach erfolgreicher Validierung fort.
Deployment-Rollout fortsetzen:
Copykubectl rollout resume deployment/
Bei kritischen Anwendungen empfiehlt sich der --record-Flag bei Deployment-Änderungen. Damit wird der ausgeführte Befehl notiert und Sie können die Änderungs-Historie später leicht nachvollziehen:
kubectl apply -f deployment.yaml --record
Resource Quotas und Limits sorgfältig verwalten
Das Ressourcen-Management spielt im Kubernetes-Betrieb eine zentrale Rolle. Die richtigen Resource Requests und Limits zu setzen, ist entscheidend, um den Cluster stabil zu halten und Ressourcen fair zu verteilen.
Resource Quotas in einem Namespace anzeigen:
kubectl get resourcequota -n
Resource Quota für einen Namespace erstellen:
kubectl create quota --hard=cpu=1,memory=1G,pods=10 -n
Ressourcennutzung von Pods prüfen:
kubectl top pods
Ressourcennutzung von Nodes prüfen:
kubectl top nodes
Definieren Sie in Container-Spezifikationen immer Resource Requests und Limits:
resources:
requests:
memory: "64Mi"
cpu: "250m"
limits:
memory: "128Mi"
cpu: "500m"
Wichtig zu wissen: Resource Requests helfen dem Scheduler bei der Entscheidung, wo der Pod platziert wird, während Limits die Maximalnutzung definieren, ab der Container terminiert werden können. Eine gute Faustregel: Setzen Sie Requests anhand der erwarteten Steady-State-Nutzung und Limits auf das, was zu Spitzenzeiten akzeptabel ist.
Debugging mit kubectl meistern
Debugging ist entscheidend, damit Ihre Kubernetes-Apps reibungslos laufen. Glücklicherweise bringt kubectl viele Befehle mit, die Ihnen das Troubleshooting erleichtern.
Container-Logs abrufen:
kubectl logs -c
Interaktives Debugging mit einem temporären Pod:
kubectl run debug --rm -it --image=busybox -- sh
Debug-Container an einen bestehenden Pod anhängen:
kubectl debug -it --image=busybox --share-processes --copy-to=
Events in einem Namespace anzeigen:
kubectl get events -n
Pod-Conditions und Statusdetails prüfen:
Copykubectl describe pod
Damit erhalten Sie eine strukturierte Ausgabe der Pod-Conditions inklusive vollständiger Übergangs-Historie und aktuellem Zustand in einem gut lesbaren Format.
Konnektivität zwischen Pods mit einem Network-Debugging-Container prüfen:
kubectl run test-connectivity --rm -it --image=nicolaka/netshoot -- bash
Bei hartnäckigen Problemen lohnt sich der --previous-Flag, um Logs zuvor abgestürzter Container einzusehen:
kubectl logs --previous
Security Best Practices mit kubectl
two people coding on laptop
Die Sicherheit Ihres Kubernetes-Clusters ist enorm wichtig – und kubectl spielt dabei eine zentrale Rolle. Hier sind einige Best Practices, mit denen Sie in Sachen Sicherheit den Überblick behalten:
Zugriffskontrollen mit RBAC verwalten
Role-Based Access Control (RBAC) ist der Standard für Autorisierung in Kubernetes. Damit definieren Sie detaillierte Berechtigungen für Benutzer und Service Accounts.
Roles in einem Namespace anzeigen:
kubectl get roles -n
Cluster Roles anzeigen:
kubectl get clusterroles
Role Bindings anzeigen:
kubectl get rolebindings -n
Cluster Role Bindings anzeigen:
kubectl get clusterrolebindings
Role mit spezifischen Berechtigungen erstellen:
kubectl create role developer --verb=get,list,watch --resource=pods,deployments -n
Role an einen User binden:
kubectl create rolebinding dev-user-binding --role=developer --user=dev-user -n
Setzen Sie wann immer möglich auf RoleBindings statt ClusterRoleBindings, um Berechtigungen auf einen bestimmten Namespace zu begrenzen. Das folgt dem Principle of Least Privilege: Zugriff erhalten nur die Namespaces, die ihn tatsächlich brauchen – das verringert die Auswirkungen kompromittierter Anmeldedaten.
Halten Sie sich an das Principle of Least Privilege und geben Sie Benutzern und Service Accounts nur die Berechtigungen, die sie wirklich brauchen. Machen Sie es sich zur Gewohnheit, Role Bindings regelmäßig zu überprüfen, damit sie auch bei wechselnden Rollen und Verantwortlichkeiten weiterhin passen.
Sicherer Umgang mit Secrets
Kubernetes Secrets erfordern einen sorgfältigen Umgang, denn sie enthalten sensible Informationen wie API-Schlüssel, Passwörter und Zertifikate.
Secret sicher aus einer Datei erstellen:
kubectl create secret generic db-credentials --from-file=./username.txt --from-file=./password.txt
TLS-Secret erstellen:
kubectl create secret tls tls-secret --cert=path/to/cert --key=path/to/key
Secrets als Umgebungsvariablen einbinden:
env:
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: db-credentials
key: password
Secrets als Dateien einbinden:
volumes:
- name: secret-volume
secret:
secretName: ssl-certificates
Für mehr Sicherheit lohnt sich der Blick auf externe Secret-Management-Tools wie HashiCorp Vault, AWS Secrets Manager oder Sealed Secrets. Sie bieten nützliche Funktionen wie Secret-Rotation, Audit Trails und Verschlüsselung.
kubectl mit sicherem Context nutzen
Vergewissern Sie sich immer, dass Sie im richtigen Context arbeiten – sonst verändern Sie womöglich aus Versehen den falschen Cluster.
Alle verfügbaren Contexts anzeigen:
kubectl config get-contexts
Zu einem bestimmten Context wechseln:
kubectl config use-context
Aktuellen Context anzeigen:
kubectl config current-context
Namespace für den aktuellen Context setzen:
kubectl config set-context --current --namespace=
In kritischen Produktionsumgebungen empfiehlt es sich, mit visuellen Hinweisen wie Shell-Prompts zu arbeiten, die den aktuellen Cluster und Namespace anzeigen. So vermeiden Sie versehentliche Aktionen auf den falschen Ressourcen.
Network Policies einsetzen
Network Policies wirken wie Firewalls innerhalb Ihres Kubernetes-Clusters und steuern die Kommunikation zwischen Pods.
Network Policies auflisten:
kubectl get networkpolicies
Network Policy erstellen, die standardmäßig allen Ingress-Traffic blockiert:
kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-ingress
spec:
podSelector: {}
policyTypes:
- Ingress
EOF
Network Policy erstellen, die bestimmten Traffic erlaubt:
kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-frontend-to-backend
spec:
podSelector:
matchLabels:
app: backend
ingress:
- from:
- podSelector:
matchLabels:
app: frontend
ports:
- port: 8080
EOF
Beginnen Sie mit einer "Deny-all"-Network-Policy als Basislinie und erlauben Sie dann gezielt nur den Traffic, den Sie wirklich brauchen. So bleiben Sie dem Principle of Least Privilege treu und halten Ihre Angriffsfläche so klein wie möglich.
Kubernetes-Management mit kubectl-Befehlen und Best Practices meistern
Kubectl ist das unverzichtbare Tool in der Welt der Kubernetes-Befehle und Ihre zentrale Schnittstelle, um Kubernetes-Cluster zu verwalten und mit ihnen zu arbeiten. Wer diese Run-Befehle beherrscht und die Best Practices aus diesem Cheat Sheet beherzigt, ist bestens gerüstet, um die Herausforderungen containerisierter Anwendungen souverän zu meistern.
Denken Sie daran: Kubernetes entwickelt sich stetig weiter – und kubectl ebenso. Bleiben Sie bei neuen Features und Updates am Ball, um Ihre Cluster-Management-Skills laufend auszubauen.
Wenn Sie tiefer in fortgeschrittene Themen eintauchen möchten, etwa das Erweitern von Kubernetes-Service-IP-Ranges, lesen Sie unseren ausführlichen Leitfaden dazu, wie Sie Service-IP-Ranges nahtlos erweitern.
Je größer und komplexer Ihr Kubernetes-Setup wird, desto wichtiger werden die richtigen Tools und das passende Know-how. Genau hier kommt DoiT ins Spiel. Unser globales Team aus Cloud-Architekten unterstützt Unternehmen dabei, kosteneffiziente, skalierbare und resiliente Cloud-Infrastrukturen aufzubauen. Wir helfen Ihnen, anspruchsvolle Kubernetes-Konfigurations- und Integrationsthemen zu lösen, beim Troubleshooting und dabei, die operative Effizienz zu steigern.
Sprechen Sie mit uns und erfahren Sie, wie wir Ihre Container-Orchestrierung für mehr Performance und niedrigere Kosten optimieren.