CKA Exam Tips: How to Clear the CKA Exam

The CKA is 100% hands-on: roughly 15-20 tasks in a real terminal, 2 hours, across several clusters, with a 66% pass mark. People fail not because they lack knowledge but because they are slow — they hand-write YAML, forget to switch context, or waste minutes hunting the docs. The win is speed, discipline, and a repeatable per-task routine.

Solution: Drill the simulator until imperative commands and aliases are muscle memory, always switch context first, copy YAML from the docs instead of typing it, flag hard tasks, and verify every change before moving on.

On exam day at a maritime academy, you do not answer multiple-choice questions, you walk up to real equipment and run timed practical tasks: dock this ship, plot that route, all against the clock. The fastest candidates are drilled, they know exactly which ship's bridge they are standing on before touching a control, and they grab the reference manual off the shelf instead of reciting it from memory. The CKA works the same way: it is a live, performance-based set of tasks across real clusters, you must run the use-context line to stand on the right cluster first, and you may open the kubernetes.io docs tab to copy YAML rather than type it.

Before you drill tactics, know the shape of the test you are walking into. This is the format and what each part means:

The current curriculum is weighted: Cluster Architecture/Install/Config (25%), Workloads & Scheduling (15%), Services & Networking (20%), Storage (10%), and Troubleshooting (30%). Troubleshooting is the single largest bucket — practice it.

The very first thing in the exam: configure the alias, autocompletion, and the do/now shortcuts. They pay for themselves within two tasks.

alias k=kubectl
export do='--dry-run=client -o yaml'      # generate manifests, don't type them
export now='--force --grace-period=0'      # delete pods immediately

source <(kubectl completion bash)
complete -o default -F __start_kubectl k    # tab-complete works on 'k' too

# vim: make YAML painless (~/.vimrc)
#   set expandtab tabstop=2 shiftwidth=2

Every task tells you which cluster/namespace to use. Running a command in the wrong cluster is the most common avoidable failure.

kubectl config get-contexts              # list the clusters the task may use
kubectl config use-context cluster-1     # ALWAYS run the line the task gives you
kubectl config set-context --current --namespace=team-a   # save typing -n

Hand-writing manifests burns time. Scaffold with imperative commands, then edit.

# a Deployment manifest in seconds
k create deploy web --image=nginx --replicas=3 $do > web.yaml

# a pod, a service, a job, a configmap — all imperative
k run nginx --image=nginx --port=80 $do > pod.yaml
k expose deploy web --port=80 --target-port=8080 $do > svc.yaml
k create job pi --image=perl -- perl -Mbignum -wle 'print 2**10' $do > job.yaml
k create configmap app --from-literal=KEY=val $do > cm.yaml

# quick edits and scaling without YAML at all
k set image deploy/web nginx=nginx:1.27
k scale deploy/web --replicas=5
k edit deploy/web

You get ONE browser tab on kubernetes.io. Don't read prose — jump straight to the YAML examples and copy them.

   Bookmark / memorise these doc search terms:
     - "pod spec"            -> volumes, env, securityContext snippets
     - "persistent volume"   -> PV / PVC / StorageClass YAML
     - "network policy"      -> ready-to-edit policy YAML
     - "kubectl cheat sheet" -> alias + completion + jsonpath
     - "static pod"          -> /etc/kubernetes/manifests path
     - "etcd backup"         -> etcdctl snapshot save/restore flags

kubectl explain pod.spec.containers gives field docs without leaving the terminal — often faster than the browser.

These task types show up again and again, so rehearse each until it is automatic:

   - etcd: ETCDCTL_API=3 etcdctl snapshot save/restore (cert flags!)
   - kubeadm upgrade: drain -> upgrade plan/apply -> kubelet -> uncordon
   - RBAC: create Role/RoleBinding, test with `kubectl auth can-i`
   - static pods: drop a manifest in /etc/kubernetes/manifests
   - scheduling: taints/tolerations, nodeSelector, affinity, cordon/drain
   - storage: PV + PVC binding, StorageClass, access modes
   - networking: Services, NetworkPolicy, CoreDNS, Ingress
   - troubleshoot: a failing pod/node, kubelet down, wrong --pod-network-cidr

With only two hours, how you spend time matters as much as what you know. Use this triage routine:

   - first pass: do every EASY high-% task; flag the hard ones and skip
   - never sink >8 min into one task; flag it and return at the end
   - watch the % weight: a 7% task is worth more than a fiddly 2% task
   - leave 10 min at the end to revisit flagged tasks and re-verify
   - partial credit exists -> submit a partial answer rather than nothing

These are the avoidable mistakes that quietly cost candidates points:

   - forgot use-context        -> changes land in the wrong cluster (zero credit)
   - hand-typing YAML          -> slow + indentation errors; use $do instead
   - over-reading the docs     -> jump to the YAML block, copy, edit
   - no verification           -> always describe/get to confirm the task passed
   - ssh stays on a node       -> exit back to the base host before the next task
   - etcdctl without certs     -> snapshot fails; pass --cacert/--cert/--key

• The CKA is hands-on, ~2 hours, 66% to pass, with a free retake.
• Set alias k, completion, and $do/$now in the first minute.
• Always run the task's use-context line before doing anything.
• Generate manifests with imperative commands; never hand-type YAML.
• One docs tab — jump straight to YAML examples and copy them.
• Flag hard tasks, manage the clock by % weight, and verify every change.

• [ ] Configured k alias, bash completion, and $do/$now
• [ ] Practised switching context and namespace before each task
• [ ] Scaffolded a Deployment/Service/Job imperatively with $do
• [ ] Completed both killer.sh sessions end-to-end
• [ ] Drilled etcd backup/restore and a kubeadm upgrade from memory
• [ ] Rehearsed a flag-and-return time-management pass