This CKA guide is built around 31 labs, two mock exams and a kind cluster you start yourself

A practice cluster in one command

The first step of the quick start is the one that makes everything else possible.

If kubectl says connection refused or you do not have a local cluster yet, the README points to `bash scripts/init-cluster.sh`, which creates a kind-based Kubernetes 1.35.1 cluster with one command.

That is the right foundation for the rest of this repository. The CKA is a hands-on, terminal-based exam, 2 hours, roughly 17 to 25 tasks, no multiple choice, so everything here is built to be run rather than read. The labs create and destroy objects, drain nodes, upgrade clusters with kubeadm and break things on purpose in the troubleshooting labs, and none of that is acceptable against a shared environment.

The version match matters too. The repository targets Kubernetes v1.35 and the cluster script pins 1.35.1, so the API surface you practise against is the one the exam covers rather than an older release.

The second quick-start step is `bash scripts/exam-setup.sh`, which the README describes as getting your aliases and vim config right from day one. That is not a trivial detail. The exam runs on a remote desktop, so the environment is unfamiliar, and a candidate who has already aliased kubectl operations and reconfigured vim on their own machine recovers faster in the first minutes of a task.

31 labs mapped to the five exam domains

The exercises/ directory is the centre of the repository, and its folder names are the syllabus.

│   ├── 01-pod-basics/
│   ├── 02-multi-container-pod/
│   ├── 03-configmap-secret/
│   ├── 04-rbac/
│   ├── 05-networkpolicy/
│   ├── 06-deployment-rollout/
│   ├── 07-statefulset/
│   ├── 08-node-drain-cordon/
│   ├── 09-kubeadm-upgrade/
│   ├── 10-static-pod/
│   ├── 11-troubleshoot-cluster/
│   ├── 12-storage-pv-pvc/
│   ├── 13-helm-install-upgrade/
│   ├── 14-kustomize-overlays/
│   ├── 15-gateway-api/
│   ├── 16-hpa/
│   ├── 17-kubectl-debug/
│   ├── 18-cri-dockerd-setup/
│   ├── 19-ingress-classic/
│   ├── 20-pod-security-standards/
│   ├── 21-jobs-cronjobs/
│   ├── 22-priorityclass/
│   ├── 23-resource-requests-tuning/
│   ├── 24-priorityclass-patch/
│   ├── 25-storage-waitforfirstconsumer/
│   ├── 26-cri-dockerd-setup/
│   ├── 27-cni-tigera-install/
│   ├── 28-network-policy-complex/
│   ├── 29-troubleshoot-etcd-endpoint/
│   ├── 30-tls-configuration-update/
│   └── 31-argocd-gitops-setup/

The domain weighting in the README tells you where to spend your hours. Storage is 10%, Troubleshooting is 30%, Workloads and Scheduling is 15%, Cluster Architecture, Installation and Configuration is 25%, and Services and Networking is 20%. Troubleshooting at 30% is the largest single block, which is why labs 11 and 29 are dedicated to it, and it is also why there is a separate troubleshooting/ directory described as a symptom-based lookup playbook.

The lab list also shows the version drift the author was complaining about. There are labs for CRI and dockerd setup, for Gateway API and for classic Ingress, for pod security standards and for ArgoCD GitOps setup, which are all things a guide written for an earlier Kubernetes version would have omitted.

One duplication is visible in the list itself. There are two CRI and dockerd folders, 18 and 26, both named cri-dockerd-setup.

Two mock exams with solutions, and a scoring path

The mock-exams/ directory is described as full practice exams, 15 questions and 2 hours each, which mirrors the real thing closely. There are two of them, and each has a question file and a solutions file with explanations.

│   ├── MOCK-EXAM-01.md               # Practice questions
│   ├── MOCK-EXAM-01-SOLUTIONS.md    # Complete solutions and explanations
│   ├── MOCK-EXAM-02.md
│   └── MOCK-EXAM-02-SOLUTIONS.md

Having the questions and the solutions in separate files is the design detail that matters. You can sit the mock without the answers open, which is the only way a mock is worth doing, and then work through the explanations afterward.

The repository also names its final external step: do killer.sh twice, once two weeks out and once three days before the exam. That is the well-known practice simulator for the CKA and it is treated here as a complement to the author's own mock exams rather than a replacement for them.

Alongside the mocks there are the supporting files that make the practice realistic. TEMPLATES.md holds all YAML templates in collapsible format, with a matching skeletons/ directory of 23 YAML template files, so you can copy, paste and modify rather than typing manifests from memory under time pressure. The cheatsheet/ directory contains cka-cheatsheet.md, described as a one-page printable reference.

There is also a set of top-level documents that go beyond the exam outline. DOMAINS.md, EXAM_STRATEGY.md, GRADING.md, DIAGNOSTICS.md and REDDIT_FEEDBACK.md, the last of which suggests the author collected candidate feedback from elsewhere to shape the material.

Exam day strategy, and the environment you will be dropped into

The repository includes a section on the exam environment, which the README attributes to the PSI Remote Desktop, and a two-pass approach for exam day that it says saved time.

The first sixty seconds section covers aliases, vim and bash, which matches the setup script from the quick start. The general principle is to spend the opening moments making the environment yours, since the exam hands you a remote desktop with a default configuration and no time to explore.

There is also a cheat sheet of imperative commands as a quick reference, which is aimed at the same problem. On a hands-on exam, the bottleneck is often recalling the right command shape rather than understanding the concept, and a one-page reference for the common forms is the cheapest possible insurance.

The README describes the exam as the CKA being a hands-on, terminal-based exam, 2 hours, roughly 17 to 25 tasks, no multiple choice, and says the author prepped for about 4 weeks. The two-pass approach then follows from that shape: with 17 to 25 tasks in 120 minutes, some tasks will be attempted before their prerequisites are visible, so a first pass that identifies and skips hard tasks buys time for a second pass on the ones you can finish.

A study progress tracker is also listed in the table of contents, which is a small touch for a repository that is otherwise a set of practice materials.

What the disclaimer does and does not cover

The disclaimer is the first thing in the README and it is worth reading carefully, because it tells you exactly what this repository is.

It is a study and practice resource containing practice exercises and training materials designed to help prepare for the CKA exam. It does not include, share, or reproduce actual CKA exam questions. All exercises are independently designed training scenarios. Policies are in CONTRIBUTING.md and CODE_OF_CONDUCT.md.

So the 31 labs and the 30 mock questions are original material written to mirror the domains, not leaked exam content. That distinction matters both legally and practically. Legally, it keeps the repository clean of copyrighted certification material. Practically, it means the mock exams are a proxy for the format rather than a rehearsal of the actual content, which is why the author pairs them with killer.sh, a simulator written by a different person.

The repository is explicit about the value it offers over older guides, and the example given is telling: dockershim references in 2026. The container runtime story changed enough that a guide written a few years ago would send you looking for a component that no longer exists, and the presence of a CRI and dockerd lab is the same concern addressed in the exercise set.

The version coverage follows the same logic. The listed releases are v1.35 for 2026, v1.33 from 2025-08-20 and v1.32 from 2025-06-04, so the tags track the Kubernetes version each revision targeted.

Where this guide is the wrong choice

Four cases argue against it.

The first is if you want the official curriculum as written. This is one candidate's study notes, which is a valid and useful thing, but it is not the CNCF syllabus document, and the domain percentages are the author's reading of it rather than a quotation.

The second is if you want a cluster that resembles production. The labs run on kind, a single-node-in-process cluster on your laptop, which is right for practising kubectl syntax and wrong for learning about node draining, scheduling across real nodes or cluster upgrades under load. Lab 08 does cover node drain and cordon, and lab 09 covers kubeadm upgrade, but the scale is not there.

The third is if you have less than a few weeks. The README's own plan is about four weeks, with 31 labs and two full mock exams at 15 questions each. Cramming the labs without the mocks produces someone who knows the commands but has never timed themselves, and time management is a quarter of the exam.

The alternative is the official certification guide from the Linux Foundation, which comes with the labs and the exam vouchers in one package, plus the practice environment that the real exam uses. The difference in approach is that this repository is free, is built by someone who has just taken the exam, and covers exactly the version you will be tested on, while the official kit is aligned with the curriculum and includes the simulator environment but is not written from a recent candidate's memory of what the exam felt like. For someone who has taken the exam once and failed on time management, this repository is likely the better second attempt material. For someone who has never touched Kubernetes at all, it is not the place to start.

Editorial conclusion

The CKA-Certified-Kubernetes-Administrator repository fits a candidate who has about four weeks and wants keyboard practice in a throwaway cluster, since every lab runs against a kind-based Kubernetes 1.35.1 cluster started with `bash scripts/init-cluster.sh` and nothing touches a real environment. It does not fit someone who wants official exam content, since the disclaimer states the exercises are independently designed training scenarios and no actual exam questions are included. Work through the exercises in order, run both mock exams under time pressure, and take killer.sh twice as the README suggests, two weeks out and again three days before.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. theplatformlab/CKA-Certified-Kubernetes-Administrator on GitHub