# CKA Certified Kubernetes Administrator: Exam Format and Study Plan > What the CKA exam involves: format, domain weights, allowed documentation and environment rules from the Linux Foundation, plus an eight-week hands-on study plan. Source: https://www.epifive.com/blog/cka-certified-kubernetes-administrator-study-guide · Published 2026-10-28 · EpiFive ## Key takeaways - The CKA is a 2-hour, online-proctored, hands-on exam made up of 15-20 command-line tasks, with a pass mark of 66%. - Troubleshooting is the largest domain at 30%, followed by Cluster Architecture, Installation and Configuration at 25%. - You may use kubernetes.io/docs, the Kubernetes blog, Helm docs and Gateway API docs during the exam, so practise navigating them quickly. - The exam environment runs the Kubernetes version named on the exam page, so practise on a matching version. - Build a multi-node kubeadm cluster yourself and break it deliberately; reading alone will not prepare you for a timed, practical exam. The Certified Kubernetes Administrator (CKA) exam is a two-hour, online-proctored, performance-based test in which you solve 15-20 tasks on live Kubernetes clusters from a command line. You need 66% or higher to pass. The most reliable way to prepare is to build and repair clusters yourself, practise with `kubectl` until the common commands are automatic, and learn where things live in the Kubernetes documentation, because you may use it during the exam. This guide is for administrators, DevOps engineers and developers who already use containers and want a structured plan. By the end you will know the exam format and rules, the weight of each domain, which skills to practise for each, and how to spread the work over eight weeks. Figures here were checked against the Linux Foundation pages listed in References on 28 October 2026; the exam page and curriculum change with each Kubernetes release, so confirm them before you book. ## CKA exam format at a glance | Item | Detail | |---|---| | Format | Online, proctored, performance-based (tasks solved from a command line) | | Duration | 2 hours | | Number of tasks | 15-20 | | Passing score | 66% or higher | | Kubernetes version | The exam page and tips page both state v1.37 at the time of writing | | Certification validity | 2 years | | Retake | One retake included; 12 months to schedule and take the exam | | Results | Score report emailed within 24 hours of completion | | Price at the time of writing (28 October 2026) | USD 445 for the exam alone; bundles with a subscription or the LFS258 course cost more | The price is quoted from the Linux Foundation certification page and can change, so check it there. Registrations for CKA include access to the killer.sh exam simulator (two attempts, each with 36 hours of access from activation), but the "single" registrations do not. ## Exam domains and what to practise The Linux Foundation lists five domains with these weights. | Domain | Weight | |---|---| | Troubleshooting | 30% | | Cluster Architecture, Installation and Configuration | 25% | | Services and Networking | 20% | | Workloads and Scheduling | 15% | | Storage | 10% | The detailed competencies sit in the CNCF curriculum PDF whose version matches the Kubernetes version (the curriculum repository names it `CKA_Curriculum_v1.37.pdf`). Download the one matching your exam date and treat it as your checklist. The sections below describe how to turn each domain into practice; they are study suggestions, not a restatement of the curriculum. ### Troubleshooting (30%) This is the biggest slice, so it deserves the most lab time. Practise diagnosing problems rather than only creating objects: - Pods stuck in `Pending`, `CrashLoopBackOff` or `ImagePullBackOff`, using `kubectl describe` and `kubectl logs` (including `--previous`). - A worker node showing `NotReady`: check the kubelet with `systemctl status kubelet` and `journalctl -xeu kubelet`, both of which the kubeadm upgrade documentation uses for kubelet health. - Control plane components that fail to start, by reading their static Pod manifests and logs. - Services with no endpoints, caused by selector or port mismatches. A good exercise is to ask a friend, or script yourself, to introduce a fault into a practice cluster and then diagnose it with a time limit. ### Cluster Architecture, Installation and Configuration (25%) Expect cluster lifecycle work. Practise these on a cluster you built with kubeadm: - Installing a cluster with kubeadm and joining worker nodes. - Upgrading a cluster. The Kubernetes documentation describes the order: upgrade `kubeadm`, run `kubeadm upgrade plan` and `kubeadm upgrade apply` on the first control plane node, run `kubeadm upgrade node` on additional control plane nodes and workers, drain each node, upgrade `kubelet` and `kubectl`, restart the kubelet and uncordon the node. - Backing up and restoring etcd. The Kubernetes documentation covers `etcdctl snapshot save` and restoring with `etcdutl`; read the current page rather than relying on memory, because the tooling has changed over the years. - Role-based access control: Roles, ClusterRoles, bindings and `kubectl auth can-i`. - Working with Helm and Kustomize where the curriculum lists them. ### Services and Networking (20%) Practise exposing workloads and controlling traffic: ClusterIP, NodePort and LoadBalancer Services, NetworkPolicies, CoreDNS behaviour, and the Ingress and Gateway API resources. The Gateway API documentation is explicitly allowed for CKA, so learn where its task pages are. ### Workloads and Scheduling (15%) Deployments, rolling updates and rollbacks, ConfigMaps and Secrets, resource requests and limits, autoscaling, and scheduling controls such as node selectors, affinity, taints and tolerations. Practise creating manifests quickly with imperative commands and editing the generated YAML. ### Storage (10%) PersistentVolumes, PersistentVolumeClaims, StorageClasses, access modes, reclaim policies and mounting volumes into Pods. This is the smallest domain, but tasks are often quick marks if you have practised the manifests. ## Rules of the exam environment The Linux Foundation's exam tips page describes the environment. Read it fully before exam day; the points that surprise people are these: - Each task names a host. You SSH to it, work there, then run `exit` to return to the `base` system. Nested SSH is not supported. - On the SSH hosts, `kubectl` already has the alias `k` and Bash autocompletion, and `yq`, `curl`, `wget` and `man` are available. The `base` system does not have these tools, so do the work on the designated hosts. - Use `sudo -i` for elevated privileges, or prefix individual commands with `sudo`. - Do not reboot the `base` node; it will not restart your exam environment. - The terminal is Linux, so copy and paste with Ctrl+Shift+C and Ctrl+Shift+V, or the right-click menu. Use Ctrl+Alt+W instead of Ctrl+W, which would close the browser tab. In `vi`, the Insert key is disabled, so press `i` to insert and Esc to leave insert mode. - You use the PSI Secure Browser, a single monitor, and no virtual machine or other applications. Run the PSI system check beforehand, and use a reliable, preferably wired, connection. Allowed documentation is limited to kubernetes.io/docs, the Kubernetes blog, Helm documentation, task-specific pages linked in the exam's quick reference box and, for CKA only, the Gateway API documentation. Opening external search results is not allowed. Use the search box on kubernetes.io/docs, and spend practice time finding pages such as the kubectl quick reference, the kubeadm upgrade guide and the etcd operations guide so that you can reach them in seconds. ## Shell setup that saves time Because the alias `k` and completion exist on exam hosts, set up the same thing in your lab. The kubectl quick reference gives these Bash lines: ```bash source <(kubectl completion bash) echo "source <(kubectl completion bash)" >> ~/.bashrc alias k=kubectl complete -o default -F __start_kubectl k ``` Beyond that, rely on imperative commands to generate manifests, then edit them. For example: ```bash kubectl create deployment web --image=nginx --dry-run=client -o yaml > web.yaml ``` The `--dry-run=client -o yaml` pair prints the object without creating it. Practise this for Pods, Deployments, Services, Jobs and CronJobs until you do not need to look up the syntax. Use `kubectl explain` (for example `kubectl explain pod.spec.containers`) to check field names offline within the cluster. ## An eight-week study plan Adapt the pacing to your experience. The plan assumes about six to eight hours a week. | Week | Focus | Hands-on goal | |---|---|---| | 1 | Linux, containers and Kubernetes architecture | Read the components overview; build a two-node cluster with kubeadm | | 2 | Workloads and scheduling | Deployments, rollouts and rollbacks, ConfigMaps, Secrets, taints, affinity | | 3 | Services and networking | Services, Ingress or Gateway API, NetworkPolicies, CoreDNS checks | | 4 | Storage and RBAC | PV and PVC lifecycle, StorageClasses, Roles and bindings | | 5 | Cluster lifecycle | kubeadm upgrade of a node, etcd snapshot and restore, node drain and cordon | | 6 | Troubleshooting | Break and fix nodes, Pods, Services and control plane components | | 7 | Timed practice | Run the killer.sh simulator, review every task you missed | | 8 | Final polish | Second simulator attempt, practise documentation navigation, check system requirements | Keep a running list of commands you had to look up. In weeks 7 and 8, turn that list into short drills. ## Practice environments A multi-node cluster you build yourself teaches more than a single-node tool, because the exam includes node-level work. Two or three small virtual machines running a supported Linux distribution are enough. Use the Kubernetes version that matches the exam where you can, since upgrade steps and defaults change between releases. The killer.sh simulator included with a standard CKA registration is useful for timing and for a realistic interface, and it is worth saving until you have completed the earlier weeks. ## Exam day checklist - Confirm the Kubernetes version and curriculum for your exam date. - Run the PSI system check, clear your desk and use a single monitor. - Plan your time: with 15-20 tasks in 120 minutes, you average six to eight minutes a task. Skip a task that stalls and return to it. - Read each task for the host name and the namespace before you type anything. - Verify your work after each task, for example with `kubectl get` and `kubectl describe`. - Remember to `exit` back to `base` between tasks. ## Where to go next For another certification study plan, see [AWS Solutions Architect Associate Study Guide: Domains and Labs](https://www.epifive.com/blog/aws-solutions-architect-associate-study-guide). ## References - Linux Foundation, Certified Kubernetes Administrator (CKA): https://training.linuxfoundation.org/certification/certified-kubernetes-administrator-cka/ - Linux Foundation, CKA and CKAD exam tips: https://docs.linuxfoundation.org/tc-docs/certification/tips-cka-and-ckad - Linux Foundation, CKA, CKAD and CKS FAQ: https://docs.linuxfoundation.org/tc-docs/certification/faq-cka-ckad-cks - Linux Foundation, certification resources allowed: https://docs.linuxfoundation.org/tc-docs/certification/certification-resources-allowed - CNCF curriculum repository: https://github.com/cncf/curriculum - Kubernetes documentation, kubectl quick reference: https://kubernetes.io/docs/reference/kubectl/quick-reference/ - Kubernetes documentation, upgrading kubeadm clusters: https://kubernetes.io/docs/tasks/administer-cluster/kubeadm/kubeadm-upgrade/ - Kubernetes documentation, operating etcd clusters: https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/ ## Frequently asked questions ### What is the passing score for the CKA exam? The Linux Foundation FAQ states that CKA and CKAD require a score of 66% or higher. The exam is scored automatically and a score report is emailed within 24 hours of completion, barring technical difficulties. ### Can I use the Kubernetes documentation during the CKA exam? Yes. You may use kubernetes.io/docs, the Kubernetes blog, Helm documentation, task-specific pages linked in the exam's quick reference box, and the Gateway API documentation (CKA only). You may use the search function on kubernetes.io/docs but must not open external search results. ### How long is a CKA certification valid? CKA certifications are valid for 2 years. Certifications earned before 1 April 2024 were issued with a 3-year validity. You renew by retaking the exam before it expires. ### Do I get a free retake if I fail the CKA? The Linux Foundation exam page lists one retake as included, and its FAQ says a retake is offered to eligible candidates who do not pass the first time. You have 12 months from purchase to schedule and take the exam.