The CKA is a hands-on exam. You get a terminal, a set of Kubernetes clusters, and 17 tasks to complete in 2 hours. There are no multiple-choice questions. If you cannot type kubectl commands without looking them up, you will not pass.
Exam facts
- Cost: $445 USD, includes one free retake. Via Linux Foundation / CNCF.
- Format: Performance-based, 2 hours, remotely proctored browser-based terminal
- Kubernetes version: v1.34 (as of 2026)
- Open book: You can use kubernetes.io/docs during the exam. Nothing else.
- Passing score: 66%
The five domains and their weightings
| Domain | Weight |
|---|---|
| Cluster Architecture, Installation and Configuration | 25% |
| Services and Networking | 20% |
| Troubleshooting | 30% |
| Workloads and Scheduling | 15% |
| Storage | 10% |
Troubleshooting is the biggest domain at 30%. Most candidates under-prepare for it. You need to be fast at diagnosing cluster issues: broken kubelet configs, crashlooping pods, misconfigured network policies, and storage mount failures.
Study approach for ops engineers
Ops engineers (sysadmin, SRE, platform engineering background) have an advantage on the troubleshooting domain because they already know how to read logs, diagnose service failures, and work methodically under time pressure. The disadvantage is that most ops engineers are less familiar with Kubernetes-specific objects like NetworkPolicy, PodDisruptionBudget, and CustomResourceDefinitions.
Recommended study path:
- Weeks 1-2: Killer.sh CKA simulator (included free with exam purchase). Do every task, read every explanation. This is the closest thing to the real exam environment.
- Weeks 3-4: Mumshad Mannambeth's CKA course on Udemy is the most complete structured course available. Do the mock exams at the end of each section.
- Week 5-6: Daily practice on a local
kindorminikubecluster. Focus on speed: aim to complete any single task in under 4 minutes.
What trips ops engineers up
The most common failure points for ops engineers taking the CKA:
- NetworkPolicy syntax. The YAML spec for NetworkPolicy is not intuitive. Practice writing NetworkPolicy manifests from scratch, not from copy-paste.
- etcd backup and restore. This appears consistently. Know the
etcdctl snapshot saveandetcdctl snapshot restorecommands with all required flags. - RBAC. ClusterRole vs Role, ClusterRoleBinding vs RoleBinding. The exam will ask you to create both and test them with
kubectl auth can-i. - Node troubleshooting. You will get a broken node. Know how to SSH to it, check
kubeletstatus withsystemctl, and fix common config errors.
Essential kubectl commands to have at muscle memory
# Create a pod imperatively (faster than writing YAML from scratch)
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml
# Check what is wrong with a node
kubectl describe node <node-name>
kubectl get events --sort-by='.lastTimestamp'
# RBAC: create a role and bind it
kubectl create role reader --verb=get,list --resource=pods -n default
kubectl create rolebinding reader-binding --role=reader --user=jane -n default
# Verify RBAC
kubectl auth can-i get pods --as=jane -n default
# etcd backup
ETCDCTL_API=3 etcdctl snapshot save /tmp/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
# Get all nodes and their status
kubectl get nodes -o wide
The open-book strategy
You can use kubernetes.io/docs during the exam. This is not a lifeline for topics you do not know; it is a reference for exact YAML syntax when you need it. If you are spending more than 90 seconds looking something up, you have not studied enough. Use the docs for: PersistentVolume/PersistentVolumeClaim YAML structure, NetworkPolicy examples, and StorageClass spec fields.
Time management
17 tasks, 120 minutes, means roughly 7 minutes per task. Higher-weighted tasks are worth more points. If a task is taking more than 10 minutes, flag it and move on. Come back at the end. Leaving a partially completed high-weight task is worse than leaving it blank and finishing three easier tasks.