Veröffentlicht am

kubectl Produktivität: Aliase, Plugins und Tricks

Teilen:
Authors

kubectl Produktivität: Aliase, Plugins und Tricks

TL;DR

  • Shell-Aliase wie k, kgp und kgs sparen bei typischen kubectl-Kommandos hunderte Tastenanschläge pro Tag.
  • krew ist der Plugin-Manager für kubectl und bietet über 200 Erweiterungen wie ctx, ns und neat.
  • kubecolor färbt die kubectl-Ausgabe ein und macht Ressourcen-Status auf einen Blick erkennbar.
  • fzf-Integration ermöglicht interaktive Auswahl von Pods, Namespaces und Kontexten.
  • Shell Completion für bash und zsh vervollständigt Ressourcennamen und Flags automatisch.

Shell Completion einrichten

Bevor es mit Aliasen losgeht: Shell Completion ist die Basis. Ohne Auto-Vervollständigung tippt man Ressourcennamen und Flags manuell ab -- das kostet Zeit und produziert Tippfehler.

# Bash: Completion dauerhaft aktivieren
echo 'source <(kubectl completion bash)' >> ~/.bashrc

# Zsh: Completion dauerhaft aktivieren
echo 'source <(kubectl completion zsh)' >> ~/.zshrc

# Pruefen, ob es funktioniert (Tab-Taste nach kubectl)
kubectl get <TAB>
# pods  services  deployments  configmaps  ...

Die Completion funktioniert auch mit Aliasen. Dafuer muss man die Completion-Funktion auf den Alias mappen. Das kommt im nächsten Abschnitt.

kubectl-Aliase: Die wichtigsten Abkürzungen

Ein durchschnittlicher Kubernetes-Admin tippt kubectl get pods 30-50 Mal am Tag. Mit Aliasen wird daraus kgp. Die kubectl-Cheat-Sheet-Aliase von Ahmet Alp Balkan sind der De-facto-Standard.

# ~/.bashrc oder ~/.zshrc

# Basis-Alias
alias k='kubectl'

# Get-Befehle
alias kgp='kubectl get pods'
alias kgs='kubectl get services'
alias kgd='kubectl get deployments'
alias kgn='kubectl get nodes'
alias kga='kubectl get all'

# Describe und Logs
alias kdp='kubectl describe pod'
alias kl='kubectl logs'
alias klf='kubectl logs -f'

# Namespace-Shortcuts
alias kgpa='kubectl get pods --all-namespaces'
alias kcn='kubectl config set-context --current --namespace'

# Apply und Delete
alias ka='kubectl apply -f'
alias kd='kubectl delete -f'

# Completion fuer den k-Alias aktivieren
complete -o default -F __start_kubectl k

Diese Aliase decken 80% der täglichen kubectl-Nutzung ab. Der kcn-Alias ist besonders nützlich: kcn monitoring wechselt den Default-Namespace, ohne den ganzen config set-context-Befehl zu tippen.

krew: Der Plugin-Manager

krew ist für kubectl, was brew für macOS ist -- ein Paketmanager für Erweiterungen. Über 200 Plugins stehen zur Verfügung.

# krew installieren (macOS/Linux)
(
  set -x; cd "$(mktemp -d)" &&
  OS="$(uname | tr '[:upper:]' '[:lower:]')" &&
  ARCH="$(uname -m | sed -e 's/x86_64/amd64/' -e 's/aarch64/arm64/')" &&
  KREW="krew-${OS}_${ARCH}" &&
  curl -fsSLO "https://github.com/kubernetes-sigs/krew/releases/latest/download/${KREW}.tar.gz" &&
  tar zxvf "${KREW}.tar.gz" &&
  ./"${KREW}" install krew
)

# PATH erweitern
echo 'export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"' >> ~/.bashrc

# Plugin-Liste aktualisieren
kubectl krew update

# Plugins suchen
kubectl krew search ctx

Die fünf wichtigsten krew-Plugins

ctx und ns -- Kontext- und Namespace-Wechsel ohne lange Befehle:

# Installieren
kubectl krew install ctx ns

# Kontext wechseln (zeigt interaktive Liste)
kubectl ctx production-cluster

# Namespace wechseln
kubectl ns monitoring

# Aktuellen Kontext/Namespace anzeigen
kubectl ctx -c
kubectl ns -c

neat -- Entfernt Managed Fields und Status-Bloat aus YAML-Ausgaben:

kubectl krew install neat

# Vorher: 120 Zeilen mit managedFields, status, metadata-Rauschen
kubectl get deployment nginx -o yaml | wc -l
# 120

# Nachher: 35 Zeilen sauberes YAML
kubectl get deployment nginx -o yaml | kubectl neat | wc -l
# 35

tree -- Zeigt Ressourcen-Hierarchien:

kubectl krew install tree

# Deployment mit allen abhaengigen Ressourcen anzeigen
kubectl tree deployment nginx
# NAMESPACE  NAME                              READY  AGE
# default    Deployment/nginx                  3/3    5d
# default    └── ReplicaSet/nginx-7c658794b9   3/3    5d
# default        ├── Pod/nginx-7c658794b9-abc  1/1    5d
# default        ├── Pod/nginx-7c658794b9-def  1/1    5d
# default        └── Pod/nginx-7c658794b9-ghi  1/1    5d

images -- Listet alle Container-Images im Cluster:

kubectl krew install images

# Alle Images im Namespace auflisten
kubectl images -n production

kubecolor: Farbe für die Kommandozeile

kubectl-Ausgaben sind monochrom. Bei langen Pod-Listen übersieht man leicht einen CrashLoopBackOff. kubecolor löst das.

# Installation
# macOS
brew install kubecolor/tap/kubecolor

# Linux (Go)
go install github.com/kubecolor/kubecolor@latest

# Als kubectl-Ersatz einrichten
alias kubectl='kubecolor'

# In ~/.bashrc oder ~/.zshrc
echo 'alias kubectl="kubecolor"' >> ~/.zshrc

kubecolor färbt den Output automatisch ein: Running-Pods grün, Pending gelb, Failed rot. Die Farbcodierung funktioniert mit allen kubectl-Befehlen, weil kubecolor die Ausgabe von kubectl parst und einfärbt.

fzf-Integration: Interaktive Auswahl

fzf ist ein Fuzzy-Finder für die Kommandozeile. In Kombination mit kubectl wird die Pod- und Namespace-Auswahl interaktiv.

# fzf installieren
# macOS
brew install fzf

# Linux
sudo apt-get install fzf

# Interaktive Pod-Auswahl fuer Logs
klog() {
  local pod
  pod=$(kubectl get pods --no-headers | fzf --height 40% | awk '{print $1}')
  [ -n "$pod" ] && kubectl logs -f "$pod"
}

# Interaktiver Namespace-Wechsel
kns() {
  local ns
  ns=$(kubectl get namespaces --no-headers | fzf --height 40% | awk '{print $1}')
  [ -n "$ns" ] && kubectl config set-context --current --namespace="$ns"
}

# Interaktives exec in einen Pod
kexec() {
  local pod
  pod=$(kubectl get pods --no-headers | fzf --height 40% | awk '{print $1}')
  [ -n "$pod" ] && kubectl exec -it "$pod" -- /bin/sh
}

Diese Funktionen in die .bashrc oder .zshrc einfügen. Danach reicht klog, um aus einer gefilterten Liste den richtigen Pod auszuwählen -- kein Copy-Paste von Pod-Namen mehr.

Schnelle YAML-Generierung mit --dry-run

Statt YAML-Dateien von Grund auf zu schreiben, generiert kubectl Vorlagen:

# Pod-YAML generieren
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml

# Deployment-YAML generieren
kubectl create deployment app --image=myapp:1.0 \
  --replicas=3 --dry-run=client -o yaml > deployment.yaml

# Service-YAML generieren
kubectl create service clusterip app --tcp=80:8080 \
  --dry-run=client -o yaml > service.yaml

# ConfigMap aus Datei
kubectl create configmap app-config \
  --from-file=config.yaml --dry-run=client -o yaml > configmap.yaml

Dieser Ansatz ist deutlich schneller als manuelles YAML-Schreiben und vermeidet Einrückungsfehler. Besonders bei CKA/CKAD-Prüfungen spart das wertvolle Minuten.

Die komplette .zshrc-Konfiguration

Alle Tipps zusammengefasst in einem Block zum Kopieren:

# === kubectl Produktivitaets-Setup ===

# Completion
source <(kubectl completion zsh)

# Basis-Aliase
alias k='kubectl'
alias kgp='kubectl get pods'
alias kgs='kubectl get services'
alias kgd='kubectl get deployments'
alias kgn='kubectl get nodes'
alias kga='kubectl get all'
alias kdp='kubectl describe pod'
alias kl='kubectl logs'
alias klf='kubectl logs -f'
alias kgpa='kubectl get pods --all-namespaces'
alias kcn='kubectl config set-context --current --namespace'
alias ka='kubectl apply -f'
alias kd='kubectl delete -f'

# kubecolor
alias kubectl='kubecolor'

# krew PATH
export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"

# fzf-Funktionen
klog() {
  local pod
  pod=$(kubectl get pods --no-headers | fzf --height 40% | awk '{print $1}')
  [ -n "$pod" ] && kubectl logs -f "$pod"
}

kns() {
  local ns
  ns=$(kubectl get namespaces --no-headers | fzf --height 40% | awk '{print $1}')
  [ -n "$ns" ] && kubectl config set-context --current --namespace="$ns"
}

FAQ

Funktionieren die Aliase auch mit kubecolor?

Ja. Da kubecolor als alias kubectl='kubecolor' eingerichtet wird, nutzen alle Aliase, die kubectl aufrufen, automatisch kubecolor. Die Completion funktioniert ebenfalls weiterhin.

Wie viele krew-Plugins kann ich installieren?

Es gibt keine praktische Obergrenze. krew-Plugins sind eigenständige Binaries in ~/.krew/bin. Installiere nur Plugins, die du tatsächlich nutzt -- jedes Plugin belegt Speicherplatz und muss bei Updates aktualisiert werden.

Kann ich eigene kubectl-Plugins schreiben?

Ja. Jede ausführbare Datei mit dem Prefix kubectl- im PATH wird automatisch als Plugin erkannt. Ein Script kubectl-whoami wird mit kubectl whoami aufgerufen. Die Sprache ist beliebig: Bash, Python, Go.

Funktioniert fzf auch in CI/CD-Pipelines?

Nein. fzf ist ein interaktives Tool und braucht ein Terminal. In Pipelines nutzt man stattdessen kubectl get pods -o jsonpath oder jq für automatisierte Auswahl.

Wie bleiben meine Aliase über Rechner hinweg synchron?

Versioniere deine .bashrc oder .zshrc in einem Dotfiles-Repository. Tools wie chezmoi oder GNU stow automatisieren die Synchronisation. So hat jeder Rechner die gleiche kubectl-Konfiguration.

Kubernetes-Expertise gesucht?

Managed Services, Beratung, Training oder Security – wir unterstützen deutsche Unternehmen bei allen Kubernetes-Themen.

Kontakt aufnehmenKontakt aufnehmen
Diskutieren auf Twitter

Kubernetes-Beratung gesucht?

Wir helfen deutschen Unternehmen bei der Kubernetes-Implementierung, Migration und Optimierung. DSGVO-konform und praxiserprobt.

Termin buchenKontakt aufnehmen

📖 Verwandte Artikel

Weitere interessante Beiträge zu ähnlichen Themen

Alle Artikel durchsuchen