CKAD Zertifizierung 2026: Prüfungsvorbereitung, Kosten und Karrierechancen

TL;DR

• Die CKAD (Certified Kubernetes Application Developer) ist eine praxisbasierte Prüfung, 2 Stunden, 66% zum Bestehen
• Kosten: 395 USD inkl. einem Wiederholungsversuch und killer.sh-Simulator
• Empfohlene Vorbereitungszeit: 6-8 Wochen bei vorhandener Kubernetes-Grundkenntnis
• Gehaltssteigerung von 15-25% realistisch, besonders in Kombination mit Projekterfahrung
• Fokus auf schnelles Arbeiten mit kubectl -- YAML aus dem Kopf schreiben ist Pflicht

Was ist die CKAD?

Die CKAD wird von der CNCF (Cloud Native Computing Foundation) vergeben und testet, ob Sie Anwendungen auf Kubernetes entwerfen, deployen und debuggen koennen. Im Gegensatz zur CKA (Administrator) geht es nicht um Cluster-Setup, sondern um das Arbeiten auf einem bestehenden Cluster.

Die Pruefung ist vollstaendig praxisorientiert: Sie loesen Aufgaben in einer echten Kubernetes-Umgebung ueber ein Browser-Terminal. Es gibt keine Multiple-Choice-Fragen.

Kubernetes-Zertifizierungen im Vergleich

Falls Sie sich fuer den Security-Pfad interessieren, lesen Sie unseren CKS Zertifizierungs-Guide. Einen breiteren Ueberblick ueber den Zertifizierungsweg bietet unser Artikel zur Kubernetes Zertifizierung Vorbereitung.

CKAD Exam Domains (Curriculum 2026)

Die Pruefung gliedert sich in fuenf Domains mit unterschiedlicher Gewichtung:

Domain 4 hat mit 25% das groesste Gewicht. Wer hier unsicher ist, verliert die Pruefung.

Praxis: Die wichtigsten kubectl-Befehle

In der CKAD-Pruefung zaehlt Geschwindigkeit. Sie muessen Manifeste imperative erzeugen und nur bei Bedarf anpassen. Hier die Befehle, die Sie im Schlaf beherrschen sollten:

# Pod schnell erzeugen
kubectl run nginx --image=nginx:1.27 --port=80

# Deployment erzeugen
kubectl create deployment webapp --image=nginx:1.27 --replicas=3

# Service exponieren
kubectl expose deployment webapp --port=80 --target-port=80 --type=ClusterIP

# YAML-Vorlage generieren (statt von Hand schreiben)
kubectl run nginx --image=nginx:1.27 --dry-run=client -o yaml > pod.yaml

# ConfigMap aus Literalen
kubectl create configmap app-config \
  --from-literal=DB_HOST=postgres \
  --from-literal=LOG_LEVEL=info

# Secret erzeugen
kubectl create secret generic db-creds \
  --from-literal=username=admin \
  --from-literal=password=s3cret

# Namespace anlegen und Pod darin starten
kubectl create namespace exam-practice
kubectl run nginx --image=nginx:1.27 -n exam-practice

Tipp: Richten Sie sich zu Beginn der Pruefung Aliase ein:

alias k=kubectl
alias kgp='kubectl get pods'
alias kgs='kubectl get svc'
alias kd='kubectl describe'
export do='--dry-run=client -o yaml'

# Damit erzeugen Sie Vorlagen blitzschnell:
k run nginx --image=nginx:1.27 $do > pod.yaml

YAML-Beispiele fuer die Pruefung

Multi-Container Pod mit Shared Volume

apiVersion: v1
kind: Pod
metadata:
  name: log-aggregator
spec:
  volumes:
    - name: shared-logs
      emptyDir: {}
  containers:
    - name: app
      image: busybox:1.36
      command: ['sh', '-c', 'while true; do echo "$(date) App running" >> /var/log/app.log; sleep 5; done']
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log
    - name: sidecar
      image: busybox:1.36
      command: ['sh', '-c', 'tail -f /var/log/app.log']
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log

Deployment mit Probes und Resource Limits

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
        - name: webapp
          image: nginx:1.27
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: 100m
              memory: 64Mi
            limits:
              cpu: 250m
              memory: 128Mi
          livenessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 10
            periodSeconds: 5
          readinessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 5
            periodSeconds: 3

NetworkPolicy: Nur Frontend darf auf Backend zugreifen

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-allow-frontend
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080

Weitere Infos zu NetworkPolicies finden Sie in unserem Artikel zu Kubernetes Network Policies.

8-Wochen-Lernplan

Wochen 1-2: Grundlagen festigen

• Pods, Deployments, ReplicaSets, Services verstehen
• kubectl-Befehle ueben (imperativ und deklarativ)
• YAML-Syntax sicher beherrschen
• Namespaces, Labels und Selectors

Ressourcen: Offizielle Kubernetes-Dokumentation (kubernetes.io/docs), die Sie auch in der Pruefung nutzen duerfen.

Wochen 3-4: Konfiguration und Storage

• ConfigMaps und Secrets erstellen und einbinden
• Persistent Volumes und PersistentVolumeClaims
• SecurityContexts und ServiceAccounts
• Resource Requests und Limits

Wochen 5-6: Networking und Observability

• Service-Typen (ClusterIP, NodePort, LoadBalancer)
• Ingress-Ressourcen konfigurieren
• NetworkPolicies schreiben
• Liveness-, Readiness- und Startup-Probes
• kubectl logs, kubectl describe, kubectl exec fuer Debugging

Wochen 7-8: Pruefungssimulation

• killer.sh-Simulator durcharbeiten (im Pruefungspreis enthalten)
• Zeitmanagement trainieren: max. 6-7 Minuten pro Aufgabe
• Schwaechen identifizieren und gezielt nacharbeiten
• Weitere Mock Exams (KodeKloud, KillerCoda)

Kosten und Pruefungsdetails

Die Pruefung wird online abgelegt mit Webcam-Proctoring. Sie benoetigen einen ruhigen Raum, eine stabile Internetverbindung und einen aufgeraeumten Schreibtisch.

Lohnt sich die Investition?

Die reine Pruefungsgebuehr von ca. 370 EUR plus eventuell 50-150 EUR fuer Kursmaterial ist ueberschaubar. In Stellenausschreibungen fuer Kubernetes-Rollen wird die CKAD haeufig als "Nice to have" oder sogar als Anforderung genannt. Erfahrungsgemaess liegt die Gehaltssteigerung bei:

• Junior-Entwickler: 5.000-10.000 EUR/Jahr mehr
• Mid-Level (3-5 Jahre): 10.000-15.000 EUR/Jahr mehr
• Senior: Weniger direkte Gehaltswirkung, aber bessere Verhandlungsposition und Zugang zu anspruchsvolleren Projekten

Die Zertifizierung allein macht niemanden zum Experten -- aber in Kombination mit Projekterfahrung ist sie ein starkes Signal an Arbeitgeber und Kunden.

Tipps fuer den Pruefungstag

1. Starten Sie mit den einfachen Aufgaben. Ueberspringen Sie alles, was laenger als 8 Minuten dauert, und kommen Sie spaeter zurueck.
2. Nutzen Sie --dry-run=client -o yaml konsequent. Tippen Sie keine Manifeste von Hand, wenn kubectl sie generieren kann.
3. Bookmarken Sie wichtige Docs-Seiten vorab. Sie duerfen kubernetes.io offen haben -- bereiten Sie Lesezeichen fuer ConfigMaps, NetworkPolicies, Ingress etc. vor.
4. Achten Sie auf den Namespace. Viele Aufgaben geben einen spezifischen Namespace vor. Ein vergessenes -n kostet Punkte.
5. Validieren Sie Ihre Loesung. Ein schnelles kubectl get oder kubectl describe nach dem Apply zeigt, ob alles laeuft.

Debugging in der Pruefung

# Pod startet nicht? Zuerst Events pruefen:
kubectl describe pod <name> | tail -20

# Container-Logs analysieren:
kubectl logs <pod-name> -c <container-name>

# In den Container springen:
kubectl exec -it <pod-name> -- /bin/sh

# Service-Erreichbarkeit testen:
kubectl run tmp --image=busybox:1.36 --rm -it -- wget -qO- http://service-name:80

Nach der CKAD: Wie weiter?

Die CKAD ist ein solider Einstieg. Fuer eine umfassende Kubernetes-Karriere bieten sich danach an:

• CKA (Certified Kubernetes Administrator) -- wenn Sie auch Cluster aufsetzen und betreiben wollen
• CKS (Certified Kubernetes Security Specialist) -- fuer den Security-Fokus, setzt CKA voraus
• Spezialisierungen in Helm, ArgoCD/GitOps oder Service Mesh (Istio, Cilium)

Wer den kompletten Pfad CKAD + CKA + CKS absolviert, gehoert zu den wenigen, die alle drei Kubernetes-Zertifizierungen vorweisen koennen. Mehr dazu in unserem Artikel Wie wird man Kubestronaut?.

Fazit

Die CKAD ist eine faire, praxisorientierte Pruefung, die tatsaechlich relevante Faehigkeiten testet. Wer regelmaessig mit Kubernetes arbeitet, kann sich in 6-8 Wochen solide vorbereiten. Der Schluessel liegt nicht im Auswendiglernen, sondern im schnellen, sicheren Umgang mit kubectl und YAML.

Sie moechten Ihr Team auf die CKAD vorbereiten oder benoetigen Unterstuetzung beim Aufbau einer Kubernetes-Plattform? Erfahren Sie mehr ueber unsere Kubernetes Schulungen und Consulting-Angebote.