Road to Kubestronaut: Ep 1 CKA
Part 1 Certified Kubernetes Administrator (CKA) | Score: 88%
This is the start of my Road to Kubestronaut series. The idea is straightforward: take every Kubernetes certification one at a time, document what I learn, and work through all of them until I earn Kubestronaut. Maybe even Golden Kubestronaut someday.
First stop: the Certified Kubernetes Administrator (CKA). I passed with 88% on my first attempt. Here’s how I prepared, what I used, where I stumbled, and what I’d change.
What the CKA actually is
The CKA is a hands-on exam. No multiple choice. You get a real Kubernetes cluster and real tasks. You have 2 hours, and everything is validated automatically.
The hardest part isn’t the Kubernetes knowledge. It’s time management. You can know exactly how to solve a problem and still burn 15 minutes if you don’t know where to look in the docs or how to navigate the exam environment efficiently.
The exam runs through PSI with remote proctoring. They’re strict about it. Before the exam started, I had to clear my desk completely. During the exam, I rested my hand on my mouth for a second and got a message from the proctor: “You can’t do that.”
They’re watching. But otherwise the experience was smooth enough.
Key facts:
| Detail | Info |
| - -| - -|
| Format | Live Kubernetes cluster, practical tasks |
| Duration | 2 hours |
| Passing score | 67% |
| Cost | ~$395 USD (includes one free retake) |
| Proctoring | Remote via PSI |
| Documentation access | Full access to kubernetes.io |
| Validity | 3 years |My background
I wasn’t starting from zero. I’d been running Kubernetes in production, so I had context. But production experience doesn’t cover everything the CKA touches.
I had clear gaps:
- Storage (StorageClasses, PVs, PVCs)
- Network Policies
- Cluster troubleshooting
- etcd backups
- Some networking concepts I’d never needed in practice
- API Gateway-related topics
These showed up fast once I started doing exam-style labs. That’s the first thing I’d tell anyone: don’t study Kubernetes in general. Find your weak spots first.
Scheduling the exam
I kept pushing the date back. There’s always another topic to review, another lab to do, another page of docs to read. If you wait until you feel ready, you’ll never sit down for it.
So I picked a date and committed. I’d made excuses enough times. Once the clock is ticking, you focus. The nervousness fades after the first few questions.
How I prepared
I didn’t follow one single course. It was a mix of hands-on labs, video courses, documentation, and mock exams. The common thread: I practiced more than I watched.
KubeDojo (main curriculum)
KubeDojo was my primary curriculum. It’s a free, open-source cloud native curriculum with hands-on labs for Kubernetes, Linux, and Platform Engineering. The CKA course has 5 modules and 63 lessonscovering the full exam domain.
Website: https://kubedojo.com
GitHub: https://github.com/kubedojo
All KubeDojo labs are hosted on Killer Coda, so you get the same interactive browser-based environment. The tasks are structured around individual concepts, which makes them great for building foundational skills. You practice things like creating a Deployment, configuring a Service, or setting up a PersistentVolume one at a time.
Killer Coda / Killer Shell
Killer Coda was created by Kim Wuestkamp and provides interactive browser-based Kubernetes environments. It hosts labs for KubeDojo, Chad Crowell’s exercises, and many other community resources.
Killer Coda tasks are noticeably more CKA-heavy than KubeDojo. They combine multiple concepts into single scenarios and put you under time pressure. The free mocks at https://killercoda.com were the closest thing to the real exam I found.
Killer Shell (https://killer.sh) is the paid exam simulator with 17 scenarios per session and detailed solutions. This is what I used for my final mock exams.
Chad Crowell’s CKA Exercises
Chad Crowell (Principal SRE at Akamai) maintains a solid CKA practice exercises repo on GitHub (501 stars). His exercises also run on Killer Coda and map to all 5 CKA domains.
GitHub: https://github.com/chadmcrowell/CKA-Exercises
Omkar Shelke
Omkar Shelke’s CKA content was another resource I referenced during preparation. His materials focus on practical, exam-oriented Kubernetes tasks.
Vim matters more than you think
Small thing, easy to overlook: you need to be comfortable with Vim. The exam environment is a remote desktop. You’re SSHing into servers and editing YAML in a terminal. Nano works too, but Vim is faster once you know the basics.
I already used Vim day-to-day, so this wasn’t a blocker for me. But if you’re not comfortable, spend a few hours learning the basics. You don’t need to master it. You just need to edit config files without fighting the editor.
Vim commands I used constantly during the exam:
| Command | What it does |
| - -| - -|
| `i` | Enter insert mode |
| `Esc` | Back to normal mode |
| `:wq` | Save and quit |
| `:q!` | Quit without saving |
| `dd` | Delete a line |
| `yy` / `p` | Copy and paste a line |
| `/pattern` | Search |
| `:%s/old/new/g` | Find and replace all |
| `G` / `gg` | Jump to end / beginning of file |
| `u` | Undo |What I practiced
The CKA curriculum is broad. Here’s what I drilled:
Deployments, Services, PVs, PVCs, StorageClasses, StatefulSets, Network Policies, CNI configuration, Calico, Horizontal Pod Autoscaling, Ingress, Helm, Kustomize, etcd backups, cluster troubleshooting, node administration.
One thing that mattered more than I expected: troubleshooting broken clusters. The exam doesn’t just ask you to create a resource. A lot of the time, something is already broken and you need to figure out what and fix it. That’s a different skill from writing YAML from scratch.
The CKA exam domains:
| Domain | Weight | Key topics |
| - -| - -| - -|
| Troubleshooting | 30% | Logs, control plane recovery, etcd restore, app debugging |
| Cluster Architecture | 25% | API server, etcd, kubeadm, upgrades |
| Services & Networking | 20% | Services, Ingress, Network Policies, CoreDNS, CNI |
| Workloads & Scheduling | 15% | Deployments, rolling updates, DaemonSets, HPA, resource limits |
| Storage | 10% | PVs, PVCs, StorageClasses, volume modes |
| Security | 10% | RBAC, ServiceAccounts, Secrets, PodSecurityStandards |The last four days
I gave myself four days before the exam for final prep. Mostly mock exams and gap-checking.
Get 0xKatana’s stories in your inbox
Join Medium for free to get updates from this writer.
I started with the free Killer Shell mocks. They put you under time pressure with exam-style environments. My first mock went okay but not great. I made avoidable mistakes with namespaces and cluster context switching. Small things, but they cost time.
CKA-X (self-hosted mocks)
I found Sailor.sh CKA-X on Reddit. It’s a Docker Compose setup that runs mock exam environments locally. They have mocks for CKA, CKAD, and CKS. https://github.com/sailor-sh/CK-X
The hard CKA mock humbled me. These are harder than Killer Coda, which are already harder than KubeDojo. The questions stack multiple concepts together. One task had me create a StorageClass, then a PersistentVolume with node affinity and a host path, then a deployment, then wire them all together through a PVC. Each piece is simple on its own. Under a time limit, with all of them in one question, it’s a different story.
I repeated that mock more than once. Familiarity with the question style made me faster.
The day before
I took the second Killer Shell mock and scored around 90%. That gave me enough confidence to stop cramming. At that point I just wanted to keep my hands warm.
I also ran the PSI system test. Do this. You don’t want your first interaction with the exam interface to happen when the clock is already running.
Exam day
Started at 9 PM. Finished the questions with about 10 minutes left and used the rest to review everything. That review caught a couple of small mistakes. A wrong namespace here, a wrong resource name there. Under pressure, those slip through easily.
Two questions gave me trouble. One involved parsing kubectl output and I rushed the structure. The other was about a dead cluster with a broken scheduler pod. I couldn’t figure out what was wrong in the time I had.
That’s a lesson in itself: if a question is eating too much time, move on. Come back later if you can. Spending 20 minutes on one task while three easier ones wait is a bad trade.
88%
Twenty-four hours later, the result came through. CKA, 88%.
The feeling was mostly relief. After all the prep, the mock exams, the second-guessing, the procrastination it was done.
What I’d recommend
1. Schedule the exam. Stop waiting until you feel ready. Pick a date and work backward from it.
2. Practice more than you watch. The CKA is practical. You need to type commands, read error messages, and troubleshoot under time pressure. Passive learning doesn’t transfer to this exam.
3. Do timed mock exams. This was the single most valuable thing I did. Two hours goes fast when you’re solving problems.
4. Learn to navigate the docs quickly. You don’t need to memorize everything. You need to find things fast. Know the structure of kubernetes.io.
5. Know your weak areas. For me it was storage, network policies, and cluster admin tasks. Once I identified those, I stopped wasting time on things I already knew.
6. Get comfortable with Vim. You don’t need to be an expert. You need to edit YAML without the editor slowing you down.
7. Test the exam environment beforehand. Run the PSI check. Verify your connection. Don’t leave surprises for exam day.
8. Don’t freeze on hard questions. Move on. Come back if you have time. The points from easy questions you skip are worth more than the one you’re stuck on.
Resources and references
Everything below is verified and linked. Resources I personally used are marked with ★.
Official resources
| Resource | Link |
| - -| - -|
| CKA exam page (Linux Foundation) | https://training.linuxfoundation.org/certification/certified-kubernetes-administrator-cka/ |
| Kubernetes documentation | https://kubernetes.io/docs/home/ |
| kubectl cheat sheet | https://kubernetes.io/docs/reference/kubectl/cheatsheet/ |
| kubeadm install guide | https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/ |
| CNCF CKA overview | https://www.cncf.io/certification/cka/ |
| Kubernetes API reference | https://kubernetes.io/docs/reference/kubernetes-api/ |
| PSI system test | https://home.pearsonvue.com/cloud/cncf |
| Linux Foundation K8s Fundamentals (LFS258) | https://training.linuxfoundation.org/training/kubernetes-fundamentals/ |Preparation platforms
Difficulty progression: KubeDojo (foundational) → Killer Coda (exam-heavy) → Killer Shell (exam simulator) → CKA-X (hardest)
| Resource | Creator | Link |
| - -| - -| - -|
| ★ KubeDojo (main curriculum) | Open-source community | https://kubedojo.com |
| ★ KubeDojo (GitHub) | Open-source community | https://github.com/kubedojo |
| ★ Killer Coda (labs) | Kim Wuestkamp | https://killercoda.com |
| ★ Killer Shell (exam simulator) | Kim Wuestkamp | https://killer.sh |
| ★ Chad Crowell CKA Exercises | Chad Crowell | https://github.com/chadmcrowell/CKA-Exercises |
| Omkar Shelke CKA content | Omkar Shelke | |
| KodeKloud CKA course | Mumshad Mannambeth | https://kodekloud.com/courses/certified-kubernetes-administrator-cka/ |
| KodeKloud Kubernetes admin path | Mumshad Mannambeth | https://kodekloud.com/learning-path/kubernetes-administrator/ |
| Sailor.sh CKA-X mocks | Sailor.sh | https://github.com/sailor-sh |Local practice
| Tool | Link |
| - -| - -|
| Minikube | https://minikube.sigs.k8s.io/docs/start/ |
| kind (Kubernetes in Docker) | https://kind.sigs.k8s.io/docs/user/quick-start/ |
| kubeadm | https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/ |Practice exercises (GitHub)
| Repo | Stars | Link |
| - -| - -| - -|
| CKA practice exercises (alijahnas) | 1,367 | https://github.com/alijahnas/CKA-practice-exercises |
| CKA Exercises (chadmcrowell) | 501 | https://github.com/chadmcrowell/CKA-Exercises |
| Kubernetes Exercises (jayendrapatil) | 271 | https://github.com/jayendrapatil/kubernetes-exercises |
| Kubernetes The Hard Way | | https://github.com/kelseyhightower/kubernetes-the-hard-way |
| CNCF Curriculum | | https://github.com/cncf/curriculum |Community
| Resource | Link |
| - -| - -|
| r/kubernetes | https://www.reddit.com/r/kubernetes/ |
| r/CKA | https://www.reddit.com/r/CKA/ |
| Kubernetes Slack | https://slack.k8s.io/ |
| CNCF Slack | https://cloud-native.slack.com/ |YouTube resources
| - -| - -|
| CKA exam prep walkthrough | https://youtu.be/eGv6iPWQKyo |
| CKA exam tips and strategy | https://youtu.be/eGv6iPWQKyo |
| CKA finesse guide | https://youtu.be/8VK9NJ3pObU |Quick reference: kubectl commands for exam day
```bash
# Get everything
kubectl get pods,svc,ns,deploy,nodes,pv,pvc,sc,ingress -A
# Debug a pod
kubectl describe pod <name> -n <ns>
kubectl logs <pod> -n <ns> - previous
kubectl exec -it <pod> - /bin/sh
# Apply and manage
kubectl apply -f <file>
kubectl delete -f <file>
kubectl scale deploy <name> - replicas=N
# Events (often tells you what's wrong)
kubectl get events - sort-by=.metadata.creationTimestamp -n <ns>
# Cluster info
kubectl config use-context <name>
kubectl cluster-info
kubectl get nodes -o wide
# Storage
kubectl get sc
kubectl get pv,pvc - all-namespaces
# Quick pod creation
kubectl run nginx - image=nginx - restart=Never - dry-run=client -o yaml > pod.yaml
# Export existing resource
kubectl get deploy <name> -o yaml - export > deploy.yaml
# etcd backup/restore
ETCDCTL_API=3 etcdctl snapshot status /backup/etcd-snapshot.db - write-out=table
ETCDCTL_API=3 etcdctl snapshot restore /backup/etcd-snapshot.db - data-dir=/var/lib/etcd-restored
```
- -
## Finesse guide: exam day tricks
These are the small things that save minutes during the exam. Minutes add up.
### Mindset
Time is your most valuable resource. Speed is your best friend.
### Imperative first, declarative second
Always try creating resources imperatively before writing YAML. The `-h` flag is your best tool here:
```bash
# This tells you EXACTLY what can be created imperatively, with examples
k create deployment nginx - image=nginx -h
k run pod nginx - image=nginx -h
```
The help output increases in detail with each base command. Use it.
If you need to add things before applying (like labels, annotations, or specific fields), combine ` - dry-run` with YAML output:
```bash
# Generate the base YAML, then edit before applying
k create deployment nginx - image=nginx - dry-run=client -o yaml > deploy.yaml
# now edit the file, then apply
kubectl apply -f deploy.yaml
**Copying YAML from the docs is a last resort.** It’s slow. Imperative commands are faster.
Understanding the Kubernetes docs
You don’t need to memorize everything, but you need to know where things are.
- Mentally bookmark pages with templates that can’t be created imperatively (PersistentVolume, PersistentVolumeClaim, NetworkPolicy, etc.)
- Use `Ctrl+F` and search `kind: <MY RESOURCE>` to quickly find example YAML in any docs page
- The one-pager API reference at `kubernetes.io/docs/reference/kubernetes-api/` is useful for specific field details
Use shortnames
Never type out a full resource name if you can help it:
| Short | Full |
| - -| - -|
| `cm` | `configmap` |
| `pvc` | `persistentvolumeclaim` |
| `pv` | `persistentvolume` |
| `np` | `networkpolicy` |
| `no` | `node` |
| `ns` | `namespace` |
| `sa` | `serviceaccount` |
| `ds` | `daemonset` |
| `rs` | `replicaset` |
| `hc` | `horizontalpodautoscaler` |
Check all shortnames with:
```bash
kubectl api-resources
```What’s next
The CKA isn’t about memorizing commands. It’s about being comfortable working with Kubernetes troubleshooting, reading errors, navigating docs, and managing your time.
The thing I learned wasn’t a kubectl flag. It was that you probably won’t ever feel ready. At some point you schedule the exam, accept that you’ll struggle with some parts, and go anyway.
I did that. Got 88% on my first attempt.
One step done. Next: KCNA
This is the first part of my Road to Kubestronaut series. I’ll keep documenting each certification, how I prepared, what I used, and what I learned. Next up: KCNA.
