TL;DR

Die CKA Pruefung (395 USD, inkl. 1 Retake) dauert 2 Stunden mit 15-20 Hands-on-Aufgaben in echten Kubernetes-Clustern und erfordert 66% zum Bestehen
Troubleshooting ist mit 30% die wichtigste Domain, gefolgt von Cluster Architecture (25%) und Services/Networking (20%)
Ein 8-Wochen-Lernplan mit 2-3 Stunden taeglich und mindestens 2 Mock Exams (80%+) bereitet optimal vor
CKA-zertifizierte Professionals verdienen in Deutschland 20-23% mehr Gehalt, mit besonders hoher Nachfrage in Finanz, Automotive und Consulting
Wichtige Pruefungstipps: kubectl-Aliases einrichten, schwierige Aufgaben markieren, kubernetes.io-Dokumentation aktiv nutzen

CKA Zertifizierung 2026: Der ultimative Guide für Kubernetes Administratoren in Deutschland

Die CKA Zertifizierung (Certified Kubernetes Administrator) ist die wichtigste und anerkannteste Zertifizierung für Kubernetes-Administratoren weltweit. In diesem umfassenden Guide erfährst du alles, was du für eine erfolgreiche CKA Prüfung 2026 wissen musst.

Was ist die CKA Zertifizierung?

Die CKA (Certified Kubernetes Administrator) ist eine praxisorientierte Zertifizierung der Linux Foundation und CNCF (Cloud Native Computing Foundation). Sie testet deine Fähigkeiten, Kubernetes-Cluster zu installieren, konfigurieren, verwalten und troubleshooten.

CKA Prüfungsdetails 2026

Eigenschaft	Details
Prüfungsdauer	2 Stunden (120 Minuten)
Anzahl Aufgaben	15-20 praxisbasierte Aufgaben
Mindestpunktzahl	66% zum Bestehen
Prüfungsformat	Hands-on in echten Kubernetes-Clustern
Kosten	395 USD (inkl. 1 Retake)
Gültigkeit	3 Jahre
Sprache	Englisch (Dokumentation während Prüfung erlaubt)
Proctoring	Remote via PSI Secure Browser

CKA vs CKAD vs CKS - Der Unterschied

Zertifizierung	Fokus	Zielgruppe	Voraussetzung	Schwierigkeit
CKA	Cluster Administration	Administratoren, DevOps	Keine	Mittel-Hoch
CKAD	Application Development	Entwickler	Keine	Mittel
CKS	Security	Security Engineers	CKA erforderlich	Hoch
KCNA	Cloud Native Basics	Einsteiger	Keine	Niedrig
KCSA	Security Associate	Security Einsteiger	Keine	Niedrig-Mittel

CKA Prüfungsdomains und Gewichtung 2026

Das aktuelle CKA Curriculum besteht aus 5 Domains mit unterschiedlicher Gewichtung:

Domain 1: Cluster Architecture, Installation & Configuration (25%)

Diese Domain ist die umfangreichste und testet dein Wissen über Kubernetes-Architektur und Cluster-Setup.

Themen:

Kubernetes-Architektur verstehen (Control Plane, Worker Nodes)
kubeadm für Cluster-Installation und Upgrades
RBAC (Role-Based Access Control) konfigurieren
High Availability Cluster aufsetzen
etcd Backup und Restore

Hands-on Beispiel: Cluster mit kubeadm erstellen

# 1. Container Runtime installieren (containerd)
sudo apt-get update
sudo apt-get install -y containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
sudo systemctl restart containerd

# 2. kubeadm, kubelet, kubectl installieren
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# 3. Cluster initialisieren (nur auf Control Plane Node)
sudo kubeadm init --pod-network-cidr=10.244.0.0/16

# 4. kubectl konfigurieren
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# 5. CNI Plugin installieren (z.B. Calico)
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.0/manifests/calico.yaml

RBAC Konfiguration Beispiel:

# ServiceAccount erstellen
apiVersion: v1
kind: ServiceAccount
metadata:
  name: cka-admin
  namespace: default
---
# ClusterRole definieren
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: cka-admin-role
rules:
- apiGroups: [""]
  resources: ["pods", "services", "configmaps", "secrets"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: ["apps"]
  resources: ["deployments", "replicasets", "daemonsets", "statefulsets"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
---
# ClusterRoleBinding erstellen
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: cka-admin-binding
subjects:
- kind: ServiceAccount
  name: cka-admin
  namespace: default
roleRef:
  kind: ClusterRole
  name: cka-admin-role
  apiGroup: rbac.authorization.k8s.io

etcd Backup und Restore:

# 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

# etcd Restore (im Notfall)
ETCDCTL_API=3 etcdctl snapshot restore /tmp/etcd-backup.db \
  --data-dir=/var/lib/etcd-from-backup

Domain 2: Workloads & Scheduling (15%)

Diese Domain testet dein Wissen über Kubernetes Workload-Ressourcen und Scheduling.

Themen:

Deployments, ReplicaSets, DaemonSets, StatefulSets
Pod Scheduling (nodeSelector, nodeAffinity, podAffinity)
Taints und Tolerations
Resource Limits und Requests
Scaling (manual und HPA)

Deployment mit Scheduling-Constraints:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: cka-webapp
  labels:
    app: cka-webapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: cka-webapp
  template:
    metadata:
      labels:
        app: cka-webapp
    spec:
      # Node Affinity - nur auf bestimmten Nodes
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/os
                operator: In
                values:
                - linux
              - key: node-type
                operator: In
                values:
                - worker
        # Pod Anti-Affinity - Pods auf verschiedene Nodes verteilen
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchLabels:
                  app: cka-webapp
              topologyKey: kubernetes.io/hostname
      # Tolerations für Taints
      tolerations:
      - key: "dedicated"
        operator: "Equal"
        value: "webapp"
        effect: "NoSchedule"
      containers:
      - name: webapp
        image: nginx:1.25
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 3

Taints und Tolerations:

# Node mit Taint versehen
kubectl taint nodes worker-node-1 dedicated=webapp:NoSchedule

# Taint entfernen
kubectl taint nodes worker-node-1 dedicated=webapp:NoSchedule-

# Alle Taints eines Nodes anzeigen
kubectl describe node worker-node-1 | grep -A5 Taints

Domain 3: Services & Networking (20%)

Networking ist ein kritischer Bereich der CKA Prüfung.

Themen:

Service Types (ClusterIP, NodePort, LoadBalancer, ExternalName)
Ingress Controller und Ingress Resources
NetworkPolicies
CoreDNS und Service Discovery
Container Network Interface (CNI)

Service-Beispiele:

# ClusterIP Service (Standard)
apiVersion: v1
kind: Service
metadata:
  name: cka-webapp-clusterip
spec:
  type: ClusterIP
  selector:
    app: cka-webapp
  ports:
  - port: 80
    targetPort: 80
---
# NodePort Service
apiVersion: v1
kind: Service
metadata:
  name: cka-webapp-nodeport
spec:
  type: NodePort
  selector:
    app: cka-webapp
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30080
---
# Headless Service (für StatefulSets)
apiVersion: v1
kind: Service
metadata:
  name: cka-webapp-headless
spec:
  clusterIP: None
  selector:
    app: cka-webapp
  ports:
  - port: 80
    targetPort: 80

NetworkPolicy Beispiel:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: cka-webapp-network-policy
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: cka-webapp
  policyTypes:
  - Ingress
  - Egress
  ingress:
  # Erlaube Traffic nur von Pods mit label role=frontend
  - from:
    - podSelector:
        matchLabels:
          role: frontend
    - namespaceSelector:
        matchLabels:
          name: frontend-namespace
    ports:
    - protocol: TCP
      port: 80
  egress:
  # Erlaube Traffic nur zur Datenbank
  - to:
    - podSelector:
        matchLabels:
          app: database
    ports:
    - protocol: TCP
      port: 5432
  # Erlaube DNS
  - to:
    - namespaceSelector: {}
    ports:
    - protocol: UDP
      port: 53

Ingress Resource:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: cka-webapp-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - webapp.example.com
    secretName: webapp-tls-secret
  rules:
  - host: webapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: cka-webapp-clusterip
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: cka-api-service
            port:
              number: 8080

Domain 4: Storage (10%)

Storage ist ein kleinerer aber wichtiger Bereich.

Themen:

PersistentVolumes (PV) und PersistentVolumeClaims (PVC)
StorageClasses und Dynamic Provisioning
Volume Types (emptyDir, hostPath, configMap, secret)
Volume Modes und Access Modes

PV und PVC Beispiel:

# PersistentVolume
apiVersion: v1
kind: PersistentVolume
metadata:
  name: cka-pv-volume
spec:
  capacity:
    storage: 10Gi
  volumeMode: Filesystem
  accessModes:
  - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: manual
  hostPath:
    path: /mnt/data
---
# PersistentVolumeClaim
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: cka-pvc-claim
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
  storageClassName: manual
---
# Pod mit PVC
apiVersion: v1
kind: Pod
metadata:
  name: cka-pvc-pod
spec:
  containers:
  - name: app
    image: nginx:1.25
    volumeMounts:
    - mountPath: /usr/share/nginx/html
      name: cka-storage
  volumes:
  - name: cka-storage
    persistentVolumeClaim:
      claimName: cka-pvc-claim

StorageClass für Dynamic Provisioning:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast-ssd
provisioner: kubernetes.io/aws-ebs  # oder andere Provisioner
parameters:
  type: gp3
  iopsPerGB: "3000"
reclaimPolicy: Delete
allowVolumeExpansion: true
volumeBindingMode: WaitForFirstConsumer

Domain 5: Troubleshooting (30%)

Die wichtigste Domain! 30% der Prüfung fokussiert auf Troubleshooting.

Themen:

Cluster-Komponenten Troubleshooting
Pod und Container Debugging
Node Troubleshooting
Networking Troubleshooting
Application Logs und Events

Wichtige Troubleshooting-Befehle:

# === CLUSTER-EBENE ===
# Cluster-Info und Health
kubectl cluster-info
kubectl get componentstatuses  # (deprecated, aber noch in Prüfung)
kubectl get nodes -o wide

# Control Plane Logs
sudo journalctl -u kubelet -f
sudo crictl ps
sudo crictl logs <container-id>

# etcd Status
ETCDCTL_API=3 etcdctl endpoint health \
  --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

# === POD-EBENE ===
# Pod Status und Events
kubectl get pods -A -o wide
kubectl describe pod <pod-name> -n <namespace>
kubectl get events -n <namespace> --sort-by='.lastTimestamp'

# Pod Logs
kubectl logs <pod-name> -n <namespace>
kubectl logs <pod-name> -c <container-name> -n <namespace>  # Multi-Container
kubectl logs <pod-name> --previous  # Logs vom vorherigen Container

# In Container einloggen
kubectl exec -it <pod-name> -n <namespace> -- /bin/sh

# === NODE-EBENE ===
# Node Status
kubectl describe node <node-name>
kubectl get node <node-name> -o yaml

# Node Conditions prüfen
kubectl get nodes -o custom-columns=NAME:.metadata.name,STATUS:.status.conditions[-1].type,REASON:.status.conditions[-1].reason

# kubelet Status auf Node
sudo systemctl status kubelet
sudo journalctl -u kubelet --since "10 minutes ago"

# === NETWORKING ===
# Service Endpoints prüfen
kubectl get endpoints <service-name>
kubectl describe svc <service-name>

# DNS Test
kubectl run dns-test --image=busybox:1.28 --rm -it --restart=Never -- nslookup kubernetes.default

# NetworkPolicy Test
kubectl run netpol-test --image=busybox:1.28 --rm -it --restart=Never -- wget -qO- http://<service-name>:<port>

Häufige Fehlerszenarien und Lösungen:

Problem	Symptom	Lösung
Pod stuck in Pending	`kubectl describe` zeigt "Insufficient cpu/memory"	Resource Requests reduzieren oder Nodes skalieren
Pod in CrashLoopBackOff	Container startet und crashed	`kubectl logs --previous` prüfen, Entry Point korrigieren
ImagePullBackOff	Image kann nicht geladen werden	Image Name/Tag prüfen, imagePullSecrets konfigurieren
Node NotReady	kubelet läuft nicht	`systemctl restart kubelet`, Logs prüfen
Service nicht erreichbar	Kein Traffic zum Pod	Selector Labels prüfen, Endpoints prüfen

8-Wochen CKA Lernplan

Woche 1-2: Cluster Architecture & Installation

Ziel: Kubernetes-Architektur verstehen und Cluster aufsetzen können

Täglicher Zeitaufwand: 2-3 Stunden

Aktivitäten:

Tag 1-3: Kubernetes-Architektur studieren (Control Plane, Worker Nodes, etcd)
Tag 4-7: kubeadm Cluster Setup üben (mindestens 3x)
Tag 8-10: Cluster Upgrades mit kubeadm
Tag 11-14: etcd Backup/Restore

Praktische Übungen:

# Übung 1: Cluster von Grund auf erstellen
# Verwende Vagrant, Kind, oder Cloud VMs

# Übung 2: Cluster Upgrade durchführen
kubeadm upgrade plan
kubeadm upgrade apply v1.29.x

# Übung 3: etcd Backup und Restore
# Erstelle Backup, lösche Daten, stelle wieder her

Woche 3-4: Workloads, Scheduling & RBAC

Ziel: Workloads deployen und Scheduling beherrschen

Aktivitäten:

Tag 1-4: Deployments, DaemonSets, StatefulSets
Tag 5-8: Scheduling (Affinity, Taints, Tolerations)
Tag 9-12: RBAC konfigurieren
Tag 13-14: Resource Management

Praktische Übungen:

# Übung: Deployment mit allen Scheduling-Features
kubectl create deployment test --image=nginx --dry-run=client -o yaml > deploy.yaml
# Füge nodeAffinity, podAntiAffinity, tolerations hinzu

# Übung: RBAC von Grund auf
# Erstelle ServiceAccount, Role, RoleBinding für spezifische Berechtigungen

Woche 5-6: Services, Networking & Storage

Ziel: Networking und Storage vollständig beherrschen

Aktivitäten:

Tag 1-4: Services (ClusterIP, NodePort, LoadBalancer)
Tag 5-8: Ingress und NetworkPolicies
Tag 9-12: PV, PVC, StorageClasses
Tag 13-14: CNI und DNS

Praktische Übungen:

# Übung: Komplette Netzwerk-Isolation mit NetworkPolicies
# Übung: Ingress mit TLS konfigurieren
# Übung: StatefulSet mit PVC

Woche 7-8: Troubleshooting & Mock Exams

Ziel: Troubleshooting meistern und Prüfungssimulation

Aktivitäten:

Tag 1-5: Systematisches Troubleshooting üben
Tag 6-10: Mock Exams (killer.sh, KodeKloud)
Tag 11-14: Schwachstellen identifizieren und nachbessern

Wichtig:

Mindestens 2 komplette Mock Exams mit Timer
Ziel: 80%+ in Mock Exams vor echter Prüfung
Dokumentation schnell navigieren können

CKA Prüfungstipps

Vor der Prüfung

Technische Vorbereitung:

Stabile Internetverbindung (mindestens 10 Mbps)
Webcam funktioniert
Mikrofon funktioniert
Zweiter Monitor (empfohlen)
PSI Secure Browser installiert und getestet
System Check durchgeführt

Lernvorbereitung:

Alle Domains mindestens 2x durchgearbeitet
2+ Mock Exams mit 80%+ bestanden
kubectl Aliases vorbereitet
Vim/Nano Konfiguration geübt

Während der Prüfung

Zeitmanagement:

2 Stunden = 120 Minuten für ~17 Aufgaben
Durchschnitt: 7 Minuten pro Aufgabe
Schwierige Aufgaben: Markieren und später zurückkommen
Letzte 15 Minuten: Überprüfung

Nützliche Aliases (zu Beginn einrichten):

# Am Anfang der Prüfung einrichten
alias k='kubectl'
alias kn='kubectl config set-context --current --namespace'
alias kgp='kubectl get pods'
alias kgs='kubectl get svc'
alias kgn='kubectl get nodes'
alias kd='kubectl describe'
alias kl='kubectl logs'
alias ke='kubectl exec -it'

# Schnelle YAML-Generierung
export do='--dry-run=client -o yaml'
# Beispiel: kubectl run nginx --image=nginx $do > pod.yaml

Vim Konfiguration:

# ~/.vimrc
set number
set tabstop=2
set shiftwidth=2
set expandtab
set autoindent

Häufige Fehler vermeiden

Falscher Namespace: Immer Namespace prüfen mit kubectl config get-contexts
YAML Indentation: Spaces, keine Tabs! 2 Spaces pro Level
Tippfehler in Namen: Copy-Paste aus der Aufgabenstellung
Zeitverschwendung: Schwierige Aufgaben später bearbeiten
Dokumentation nicht nutzen: kubernetes.io ist während der Prüfung erlaubt

CKA Karrierevorteile in Deutschland

Gehaltsübersicht 2026

Erfahrung	Ohne CKA	Mit CKA	Steigerung
Junior (0-2 J.)	50.000€ - 65.000€	60.000€ - 80.000€	+20%
Mid-Level (3-5 J.)	65.000€ - 85.000€	80.000€ - 105.000€	+23%
Senior (5+ J.)	85.000€ - 110.000€	105.000€ - 135.000€	+22%
Lead/Architect	110.000€+	135.000€+	+23%

Jobmarkt Deutschland

Nachfrage nach CKA-zertifizierten Professionals:

DAX-Konzerne: 90% verlangen Kubernetes-Zertifizierungen
Mittelstand: 70% bevorzugen zertifizierte Bewerber
Startups: 60% zahlen Premium für Zertifizierte
Consulting: Fast 100% verlangen CKA

Branchen mit höchster Nachfrage:

Finanzdienstleistungen (Banken, Versicherungen)
Automotive (OEMs und Zulieferer)
Energie und Utilities
Healthcare und Pharma
E-Commerce und Retail

FAQ - Häufig gestellte Fragen

Wie schwer ist die CKA Prüfung wirklich?

Die CKA Prüfung ist anspruchsvoll, aber mit guter Vorbereitung machbar. Die Bestehensquote liegt bei etwa 50-60% beim ersten Versuch. Mit 8-12 Wochen gezielter Vorbereitung und praktischer Übung steigen deine Chancen auf 80%+.

Wie viel Vorwissen brauche ich für CKA?

Empfohlen:

6-12 Monate Kubernetes-Erfahrung
Linux-Grundkenntnisse (CLI, vim/nano)
Networking Basics (TCP/IP, DNS)
Container-Grundlagen (Docker)

Möglich ohne Erfahrung: Ja, aber plane 16+ Wochen Vorbereitung ein.

Soll ich CKA oder CKAD zuerst machen?

CKA zuerst wenn: Du als Admin/DevOps arbeitest, Cluster verwalten willst, oder Troubleshooting wichtiger ist.

CKAD zuerst wenn: Du als Entwickler arbeitest und primär Anwendungen auf Kubernetes deployen willst.

Tipp: CKA gibt dir ein tieferes Verständnis, das auch für CKAD hilft. Die Überlappung beträgt ca. 40%.

Kann ich die CKA Prüfung auf Deutsch ablegen?

Nein, die CKA Prüfung ist nur auf Englisch verfügbar. Allerdings darfst du während der Prüfung die offizielle Kubernetes-Dokumentation (kubernetes.io) nutzen, die auch auf Deutsch verfügbar ist.

Wie lange ist die CKA Zertifizierung gültig?

Die CKA Zertifizierung ist 3 Jahre gültig. Danach kannst du:

Die CKA Prüfung erneut ablegen
Die CKS Prüfung bestehen (verlängert auch CKA)

Was kostet die CKA Prüfung?

Regulärer Preis: 395 USD
Inklusive: 1 kostenloser Retake (innerhalb 12 Monaten)
Inklusive: 2 killer.sh Mock Exam Sessions
Bundles: CKA + CKAD Bundle für 595 USD (spart 195 USD)

Nächste Schritte

Registrierung: Melde dich bei training.linuxfoundation.org an
Lernplan starten: Beginne mit Woche 1 des 8-Wochen-Plans
Lab-Umgebung: Richte Kind, Minikube, oder Cloud-Cluster ein
Community: Tritt dem Kubernetes Slack bei (#cka-exam)
Mock Exams: Plane killer.sh Sessions für Woche 7-8

Für weiterführende Informationen empfehlen wir auch unsere Guides zu CKAD Zertifizierung, CKS Zertifizierung und Kubernetes Security Hardening.

Dieser umfassende CKA Guide wird regelmäßig aktualisiert. Letzte Aktualisierung: Januar 2026.

CKA Zertifizierung: Der komplette Guide für Administratoren

TL;DR

CKA Zertifizierung 2026: Der ultimative Guide für Kubernetes Administratoren in Deutschland

Was ist die CKA Zertifizierung?

CKA Prüfungsdetails 2026

CKA vs CKAD vs CKS - Der Unterschied

CKA Prüfungsdomains und Gewichtung 2026

Domain 1: Cluster Architecture, Installation & Configuration (25%)

Domain 2: Workloads & Scheduling (15%)

Domain 3: Services & Networking (20%)

Domain 4: Storage (10%)

Domain 5: Troubleshooting (30%)

8-Wochen CKA Lernplan

Woche 1-2: Cluster Architecture & Installation

Woche 3-4: Workloads, Scheduling & RBAC

Woche 5-6: Services, Networking & Storage

Woche 7-8: Troubleshooting & Mock Exams

CKA Prüfungstipps

Vor der Prüfung

Während der Prüfung

Häufige Fehler vermeiden

CKA Karrierevorteile in Deutschland

Gehaltsübersicht 2026

Jobmarkt Deutschland

FAQ - Häufig gestellte Fragen

Wie schwer ist die CKA Prüfung wirklich?

Wie viel Vorwissen brauche ich für CKA?

Soll ich CKA oder CKAD zuerst machen?

Kann ich die CKA Prüfung auf Deutsch ablegen?

Wie lange ist die CKA Zertifizierung gültig?

Was kostet die CKA Prüfung?

Nächste Schritte

Kubernetes-Beratung gesucht?

📖 Verwandte Artikel

CKA Zertifizierung: Kompletter Vorbereitungsguide

Kubernetes Zertifizierung Gültigkeit und Rezertifizierung

Kubestronaut werden: Karriere-Guide für Kubernetes-Engineers

Kubernetes Zertifizierung: Lerngruppe und Community finden

CKA vs CKAD vs CKS: Welche Zertifizierung wählen?