CKA Prüfung bestehen: 10 Praxis-Tipps

TL;DR

• kubectl-Aliase und Bash-Autocompletion sparen in der CKA-Pruefung bis zu 15 Minuten -- richtet sie als Erstes ein.
• Nutzt --dry-run=client -o yaml fuer jede Ressource, statt YAML von Hand zu schreiben.
• Zeitmanagement ist der wichtigste Faktor: 2 Stunden fuer ca. 17 Aufgaben, also maximal 7 Minuten pro Task.
• Die offizielle Kubernetes-Dokumentation (kubernetes.io/docs) ist euer einziges Hilfsmittel -- lernt, darin schnell zu navigieren.
• Uebt mindestens zweimal mit killer.sh unter realistischen Bedingungen, bevor ihr die echte Pruefung ablegt.

Warum diese Tipps den Unterschied machen

Die CKA (Certified Kubernetes Administrator) hat eine Bestehensquote von ca. 60-65%. Das bedeutet: Rund ein Drittel aller Kandidaten faellt durch -- oft nicht wegen fehlendem Wissen, sondern wegen schlechtem Zeitmanagement, fehlenden Shortcuts oder mangelnder Pruefungsstrategie.

Die folgenden 10 Tipps stammen aus der Erfahrung zertifizierter Kubernetes-Administratoren und helfen euch, die CKA-Pruefung beim ersten Anlauf zu bestehen.

Wenn ihr noch am Anfang eurer Vorbereitung steht, lest zuerst unseren CKA Zertifizierungs-Guide 2026 fuer den vollstaendigen Ueberblick.

Tipp 1: kubectl-Aliase und Autocompletion einrichten

Das Erste, was ihr in der Pruefung tun solltet -- noch bevor ihr die erste Aufgabe lest -- ist eure Shell einrichten. Diese Aliase sparen pro Aufgabe 30-60 Sekunden:

# Sofort nach Pruefungsstart ausfuehren
alias k=kubectl
alias kgp='kubectl get pods'
alias kgs='kubectl get svc'
alias kgn='kubectl get nodes'
alias kgd='kubectl get deployments'
alias kga='kubectl get all'
alias kd='kubectl describe'
alias kaf='kubectl apply -f'
alias kdel='kubectl delete'

# Dry-Run und YAML-Output als Variable
export do="--dry-run=client -o yaml"
export now="--force --grace-period=0"

# Autocompletion aktivieren (fuer bash)
source <(kubectl completion bash)
complete -o default -F __start_kubectl k

Tipp: Schreibt euch diese Zeilen auf einen Zettel und tippt sie in den ersten 2 Minuten ab. Die Zeitinvestition zahlt sich ueber die gesamte Pruefung aus.

Tipp 2: .vimrc fuer YAML konfigurieren

In der Pruefungsumgebung ist vim der Standard-Editor. YAML ist extrem empfindlich bei Einrueckungen. Richtet vim so ein, dass Tabs automatisch in Spaces umgewandelt werden:

# ~/.vimrc fuer die Pruefung
cat << 'EOF' > ~/.vimrc
set tabstop=2
set shiftwidth=2
set expandtab
set number
set autoindent
set cursorcolumn
EOF

Was diese Einstellungen bewirken:

• tabstop=2 und shiftwidth=2: Tabs werden zu 2 Spaces (YAML-Standard).
• expandtab: Echte Spaces statt Tab-Zeichen.
• number: Zeilennummern helfen beim Debugging von YAML-Fehlern.
• autoindent: Die naechste Zeile uebernimmt die Einrueckung der aktuellen.
• cursorcolumn: Zeigt eine vertikale Linie an der Cursorposition -- hilfreich bei verschachteltem YAML.

Wichtige vim-Shortcuts fuer die Pruefung:

dd        - Zeile loeschen
yy        - Zeile kopieren
p         - Einfuegen
:set paste - Paste-Modus (verhindert Auto-Indent beim Einfuegen)
u         - Undo
Shift+G   - Ans Dateiende springen
gg        - An den Dateianfang springen
/suchtext - Suchen

Tipp 3: Die Kubernetes-Dokumentation effektiv nutzen

Waehrend der Pruefung duerft ihr auf kubernetes.io/docs, kubernetes.io/blog und github.com/kubernetes zugreifen. Das ist ein riesiger Vorteil -- wenn ihr wisst, wo ihr was findet.

Die wichtigsten Doku-Seiten, die ihr vorab kennen solltet:

• Tasks-Bereich: Praktische Anleitungen fuer etcd-Backup, kubeadm-Upgrades, Zertifikat-Erneuerung
• Reference: API-Referenz fuer exakte YAML-Felder
• Concepts: Erklaerungen fuer NetworkPolicies, RBAC, PV/PVC

Suchtechnik: Nutzt die Suchfunktion auf kubernetes.io. Sucht nach dem Ressourcentyp plus der Aktion, z.B. "etcd backup" oder "networkpolicy example".

# Beispiel: Ihr braucht ein NetworkPolicy-Template
# Sucht auf kubernetes.io/docs nach "network policy"
# Kopiert das YAML-Beispiel und passt es an

# Alternativ: kubectl explain nutzen
kubectl explain networkpolicy.spec.ingress
kubectl explain pod.spec.containers.resources

kubectl explain ist Gold wert. Es zeigt euch die exakte Struktur jeder Ressource direkt im Terminal, ohne den Browser oeffnen zu muessen.

Tipp 4: Zeitmanagement -- der entscheidende Faktor

Die Pruefung hat ca. 17 Aufgaben in 120 Minuten. Das sind im Schnitt 7 Minuten pro Aufgabe. Nicht jede Aufgabe ist gleich schwer oder gleich viele Punkte wert.

Strategie:

1. Erster Durchlauf (90 Minuten): Geht alle Aufgaben durch. Loest zuerst die einfachen und mittleren. Ueberspring Aufgaben, die auf den ersten Blick komplex aussehen.
2. Flaggen nutzen: Markiert uebersprungene Aufgaben mit dem Flag-Button in der Pruefungsumgebung.
3. Zweiter Durchlauf (30 Minuten): Geht zurueck zu den schwierigen Aufgaben.

Faustregel fuer die Zeitverteilung:

Wenn ihr nach 7 Minuten bei einer Aufgabe nicht weiterkommt: Flaggen und weiter. Ein Punkt bei einer einfachen Aufgabe ist genauso viel wert wie ein Punkt bei einer schweren.

Tipp 5: tmux und mehrere Terminals nutzen

Die Pruefungsumgebung bietet ein Terminal. Mit tmux koennt ihr es in mehrere Bereiche aufteilen:

# tmux starten
tmux

# Horizontal splitten: Ctrl+B, dann "
# Vertikal splitten: Ctrl+B, dann %
# Zwischen Panels wechseln: Ctrl+B, dann Pfeiltaste
# Panel schliessen: exit oder Ctrl+D

Praktischer Nutzen in der Pruefung:

• Panel 1: Hauptterminal fuer kubectl-Befehle
• Panel 2: vim zum Editieren von YAML-Dateien
• Panel 3: kubectl get pods -w zum Beobachten von Aenderungen

Nicht jeder nutzt tmux gern. Alternativ koennt ihr einfach mehrere Terminal-Tabs nutzen, die in der Pruefungsumgebung verfuegbar sind. Wichtig ist, dass ihr effizient zwischen Kontexten und Dateien wechseln koennt.

Tipp 6: Context-Switching beherrschen

Jede Aufgabe in der Pruefung gibt euch einen bestimmten Cluster-Kontext vor. Vergesst ihr, den Kontext zu wechseln, arbeitet ihr am falschen Cluster -- einer der haeufigsten Gruende fuer Punktverlust.

# Kontext wechseln (steht in jeder Aufgabe)
kubectl config use-context k8s-cluster1

# Namespace setzen (wenn die Aufgabe einen bestimmten Namespace vorgibt)
kubectl config set-context --current --namespace=production

# Aktuellen Kontext pruefen
kubectl config current-context

# Alle verfuegbaren Kontexte anzeigen
kubectl config get-contexts

Macht es zur Gewohnheit: Lest den Kontext-Hinweis in jeder Aufgabe und wechselt ihn als Erstes. Kein Befehl ohne vorherigen Kontext-Check.

Tipp 7: Dry-Run und Output-Umleitung nutzen

Schreibt YAML nie von Grund auf. Generiert es mit imperativen Befehlen und passt es dann an:

# Pod-YAML generieren
kubectl run nginx --image=nginx:1.27 --port=80 \
  --dry-run=client -o yaml > pod.yaml

# Deployment-YAML generieren
kubectl create deployment webapp --image=nginx:1.27 --replicas=3 \
  --dry-run=client -o yaml > deployment.yaml

# Service-YAML generieren
kubectl expose deployment webapp --port=80 --target-port=8080 \
  --type=NodePort --dry-run=client -o yaml > service.yaml

# Job-YAML generieren
kubectl create job backup --image=busybox \
  --dry-run=client -o yaml -- /bin/sh -c "echo backup" > job.yaml

# CronJob-YAML generieren
kubectl create cronjob backup --image=busybox \
  --schedule="0 2 * * *" \
  --dry-run=client -o yaml -- /bin/sh -c "echo backup" > cronjob.yaml

# ConfigMap aus Literal
kubectl create configmap app-config \
  --from-literal=DB_HOST=postgres \
  --from-literal=LOG_LEVEL=info \
  --dry-run=client -o yaml > configmap.yaml

Mit dem vorher definierten Alias $do geht es noch schneller:

k run nginx --image=nginx:1.27 $do > pod.yaml
k create deploy webapp --image=nginx:1.27 $do > deploy.yaml

Danach oeffnet ihr die Datei in vim, passt sie an und wendet sie mit kubectl apply -f an. Das ist schneller und fehlerfreier als YAML von Hand zu schreiben.

Tipp 8: Imperative Befehle fuer haeufige Aufgaben

Viele Pruefungsaufgaben lassen sich komplett imperativ loesen, ohne eine einzige YAML-Datei zu erstellen:

# Pod mit Labels und Limits erstellen
kubectl run nginx --image=nginx:1.27 \
  --labels="app=web,tier=frontend" \
  --port=80

# Service per Expose erstellen
kubectl expose pod nginx --port=80 --name=nginx-svc --type=ClusterIP

# Scale Deployment
kubectl scale deployment webapp --replicas=5

# Rolling Update
kubectl set image deployment/webapp nginx=nginx:1.28

# Rollback
kubectl rollout undo deployment/webapp

# Taint setzen und entfernen
kubectl taint nodes node1 key=value:NoSchedule
kubectl taint nodes node1 key=value:NoSchedule-

# Label setzen
kubectl label nodes node1 disktype=ssd
kubectl label pods nginx env=production

# Annotate
kubectl annotate pod nginx description="web server"

Fuer eine umfassende Vorbereitung auf alle Pruefungsdomains empfehlen wir unseren CKA Lernplan fuer 8 Wochen.

Tipp 9: PSI-Browser und Pruefungsumgebung

Die Pruefung wird ueber den PSI Secure Browser abgelegt. Hier die wichtigsten Dinge, die ihr vorab wissen solltet:

Vor der Pruefung:

• Testet den PSI-Browser mindestens einen Tag vorher mit dem System-Check.
• Schliesst alle anderen Anwendungen. Der Browser braucht exklusiven Zugriff auf eure Kamera und euer Mikrofon.
• Raeume: Sauberer Schreibtisch, keine Zettel, keine zweiten Monitore.
• Ausweis bereithalten (Reisepass oder Personalausweis).

Waehrend der Pruefung:

• Copy/Paste funktioniert im Terminal: Ctrl+Shift+C und Ctrl+Shift+V (nicht Ctrl+C!).
• Die Pruefungsumgebung hat einen eingebauten Notepad. Nutzt ihn, um Aufgaben-Nummern zu notieren, die ihr uebersprungen habt.
• Ihr duerft nur einen Monitor verwenden und keine externen Tools.
• Der Browser hat einen Tab fuer die Aufgaben und einen fuer das Terminal. Ihr duerft einen zusaetzlichen Browser-Tab fuer kubernetes.io oeffnen.

Technische Probleme:

• Bei Verbindungsproblemen: Der Timer wird angehalten, bis die Verbindung steht.
• Wenn der Browser abstuerzt: Neustart und Session-Recovery sind moeglich. Die Zeit wird nicht zurueckgesetzt, aber eure Antworten bleiben erhalten.

Tipp 10: Mit killer.sh unter Pruefungsbedingungen ueben

killer.sh ist im CKA-Kauf enthalten (2 Sessions). Es ist der realistischste Simulator fuer die Pruefung.

So nutzt ihr killer.sh optimal:

1. Erste Session: Frueh in der Vorbereitung (ca. 2 Wochen vor der Pruefung). Ziel: Schwaechen identifizieren.
2. Schwaechen gezielt ueben: Die naechsten Tage die Themen wiederholen, bei denen ihr in der Simulation gescheitert seid.
3. Zweite Session: 2-3 Tage vor der Pruefung. Ziel: Unter realistischem Zeitdruck bestehen.

Wichtig bei killer.sh:

• Die Aufgaben sind schwerer als in der echten Pruefung. Wenn ihr bei killer.sh 60-70% erreicht, seid ihr fuer die echte Pruefung gut vorbereitet.
• Haltet euch strikt an die 2 Stunden. Kein Googeln, keine zusaetzliche Doku.
• Nach der Session zeigt killer.sh die Loesungen. Arbeitet jede falsch beantwortete Aufgabe gruendlich durch.

# Typische killer.sh-Aufgabe: etcd-Backup erstellen
ETCDCTL_API=3 etcdctl snapshot save /tmp/etcd-backup.db \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key

# Backup verifizieren
ETCDCTL_API=3 etcdctl snapshot status /tmp/etcd-backup.db --write-table

Mehr zu den Pruefungsinhalten und der Gewichtung der einzelnen Domains findet ihr in unserem CKAD Zertifizierungs-Guide.

Bonus: Checkliste fuer den Pruefungstag

Geht diese Liste am Pruefungstag durch:

• System-Check mit PSI-Browser bestanden
• Ausweis griffbereit
• Schreibtisch aufgeraeumt, keine Zettel oder Buecher
• Alle Anwendungen geschlossen (besonders VPN, Messaging-Apps)
• Stabile Internetverbindung verifiziert
• Webcam und Mikrofon funktionieren
• Plan fuer die ersten 2 Minuten: Aliase und .vimrc einrichten
• Strategie: Einfache Aufgaben zuerst, schwere flaggen

Haeufige Fehler, die zum Durchfallen fuehren

1. Kontext nicht gewechselt. Jede Aufgabe hat einen Cluster-Kontext. Vergesst ihr den Wechsel, loest ihr die Aufgabe im falschen Cluster.
2. YAML von Hand geschrieben. Tippfehler in YAML sind der Hauptgrund fuer verlorene Punkte. Nutzt --dry-run=client -o yaml.
3. Zu lange an einer Aufgabe haengen geblieben. Nach 7 Minuten ohne Loesung: Flaggen und weiter.
4. Kein Namespace angegeben. Wenn die Aufgabe namespace: production vorgibt und ihr im default-Namespace arbeitet, gibt es null Punkte.
5. Autocompletion nicht eingerichtet. Ohne Autocompletion tippt ihr 5-10 Minuten laenger fuer die gleiche Arbeit.

Vertieft euer Wissen mit unserem Artikel zur Kubernetes Security Hardening, wenn ihr nach der CKA die CKS anstreben wollt.

Fazit

Die CKA-Pruefung ist machbar, wenn ihr systematisch vorgeht. Technisches Wissen ist die Basis, aber Pruefungstechnik entscheidet ueber Bestehen oder Durchfallen. Richtet eure Umgebung in den ersten 2 Minuten ein, arbeitet mit imperativen Befehlen, nutzt die Dokumentation gezielt und bleibt beim Zeitmanagement diszipliniert.

Wer diese 10 CKA-Pruefung-Tipps konsequent umsetzt, hat die besten Chancen, beim ersten Anlauf zu bestehen.

Verwandte Artikel

• CKA-Zertifizierung 2026: Vorbereitung, Pruefungsinhalte und praktische Tipps
• CKS Zertifizierung 2026: Der haerteste Kubernetes-Test
• CKAD Zertifizierung 2026: Pruefungsvorbereitung und Karrierechancen
• Kubernetes Zertifizierung Vorbereitung Guide

Ihr wollt euer Team strukturiert auf die CKA vorbereiten? Wir bieten Hands-on-Workshops und individuelle Trainingsplaene. Kontaktiert uns unter /kontakt.