Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

Prepare for the CKA: format, domains and study plan

By updated

Improve this page

Logo Kubernetes

The CKA (Certified Kubernetes Administrator) is a two-hour hands-on exam: you administer and troubleshoot real Kubernetes clusters from the command line, with no multiple-choice questions. This page tells you what the exam asks, how a task runs, which lessons of the course prepare each of the five domains, how to set up your session and how to split eight weeks of study.

It is written for someone who runs or wants to run a cluster, and who has already completed levels 1 to 4 of the course. It does not replace the command cheat sheet or the exercises: it tells you where to go, and in what order.

What you will learn

  • Name the five exam domains and their weights.
  • Map each domain to the lessons that teach it, and spot what the Helm course covers.
  • Read the exam format, with the date and the source of each figure.
  • Tell the CKA apart from the CKAD and the CKS.
  • Set up your working session and follow the "one host per task" flow.
  • Build a study plan that fits the time you have.

What is the CKA exam format?

The exam lasts 2 hours, has 15 to 20 tasks and requires 66% of the points. These values come from the Linux Foundation, which publishes them on the product page, in the FAQ and in its exam tips. They were collected on November 13, 2026: if one of these pages says something different when you read it, that page prevails.

ItemValue as of November 13, 2026Source
Nature of the examonline, proctored, tasks solved from the command lineCKA product page
Duration2 hoursCKA product page
Number of tasks15 to 20CKA and CKAD tips
Passing score66% or moreCKA, CKAD and CKS FAQ
Kubernetes version1.37CKA product page
Price of the exam alone445 USDCKA product page
Second attemptincludedCKA product page
Time allowed to sit the exam12 months after purchaseCKA product page
Certification validity2 yearsCKA product page
Gradingautomatic, score report by email within 24 hoursCKA, CKAD and CKS FAQ

Three rows of this table change how you prepare. The 66% threshold lets you lose 34% of the points, about a third: it is better to finish cleanly the tasks you master than to start more of them without completing any. Version 1.37 is the one this course teaches, so the commands and fields you learn here are the ones from the exam today. And since grading is automatic, assume it looks at the result you obtained, not your intentions: check the state of the cluster before moving on to the next task.

The product page states that the exam environment follows each new minor version of Kubernetes about 4 to 8 weeks after its release. An exam taken in a few months may therefore run on a newer version than the one on this page: reread the product page before you schedule. The "curriculum" link on that product page still pointed, on November 13, 2026, to a PDF for version 1.35, while the exam announces 1.37: check the version printed on the PDF before you rely on it.

As for validity, the FAQ gives 2 years for a CKA earned today (3 years for a CKA earned before April 1, 2024), and renewal means taking and passing the exam again before it expires. There is one exception: a CKS earned or renewed from June 18, 2026 aligns the CKA expiry date with that of the CKS (the Linux Foundation's CARE program, described on its official page and in the guide to choosing your certification).

The Killer.sh exam simulator is a special case: it offers graded practice tasks. The product page announces two sessions of 36 hours each from activation, with 17 questions per session and a different set per session. The FAQ, read on November 13, 2026, states that access to the simulator is not included in the "exam only" CKA-SINGLE offer. Check what your offer contains before you count on it, and keep both sessions for the end of your preparation: they are for spotting your gaps, not for learning.

How does a task work during the exam?

Each task is done on a designated host, which you reach over ssh, and you return to the base machine with exit before the next task. This mechanism is described in the Linux Foundation's tips for the CKA and CKAD, read on November 13, 2026.

base -> ssh <host given in the task box>
host -> kubectl, k and completion are already set up: you work on the task
host -> exit
base -> you are back, ready for the next task

Read this flow as a loop: one task, one host, one exit. The tips page states that nested ssh is not supported. If you forget the exit, your next connection would start from a work host and not from the base machine: that would be nested ssh. Get into the habit of reading the host name in the prompt before you type.

The terminal is a Linux system. On each work host, kubectl is installed with the k alias (a shortcut for kubectl) and Bash autocompletion (the Tab key completes commands), and the yq, curl, wget and man tools are available. The exam runs in the PSI Secure Browser, the dedicated browser for the proctored exam, based on Chrome.

To get used to it before the big day, work the same way: one connection per task, one exit at the end. The routine is simple, but it is easy to lose under the clock.

What can you consult during the exam?

Only a few online resources are allowed, and their list is published in the Linux Foundation's allowed resources, read on November 13, 2026. For the CKA, they are the Kubernetes documentation (kubernetes.io/docs), its blog (kubernetes.io/blog), the Helm documentation (helm.sh/docs) and the Gateway API documentation (gateway-api.sigs.k8s.io), plus the task-specific documentation when it is linked in the "Quick Reference" box.

Searching the site is allowed, but opening an external search result is not, nor is any outside help. Translated versions of the documentation are permitted, with English recommended.

This list changes how you study: the point is not to memorize the documentation but to know where to find what. Practice starting from the kubernetes.io search and note, for each type of object, the page that holds a complete manifest example to copy. The presence of helm.sh/docs in the list also warns you that tasks may ask you to handle a chart, that is, a Helm package: see the section on the Helm course below.

What are the five domains of the exam?

The product page splits the CKA into five domains whose weights add up to 100% of the points. Troubleshooting is the heaviest at 30%, ahead of architecture and installation at 25%.

DomainWeight
Troubleshooting30%
Cluster Architecture, Installation & Configuration25%
Services & Networking20%
Workloads & Scheduling15%
Storage10%

Source: CKA product page, read on November 13, 2026. These weights describe a share of the points, not a number of tasks: a 30% domain may come down to three heavy tasks, and a 10% domain to a single quick one. Use them to decide where to spend your study time, not to guess the make-up of the exam. For each domain, here are the lessons of the course that we associate with it.

Troubleshooting (30%)

This domain asks you to find out why a cluster or an application does not work: it is not about remembering a command but an order of investigation, from the broadest to the finest. The diagnostic method (in French) gives that order, Observe the health of a cluster (in French) and Analyze events (in French) teach you to read the state, and the lesson on reading the cluster state details kubectl get, describe, logs and top.

Three common Pod failures have their own lesson: CrashLoopBackOff, ImagePullBackOff (in French) and Pending Pods. For an application that does not answer, see Debug an application. For the infrastructure, Diagnose a cluster failure covers the control plane, and Troubleshoot a node covers the kubelet and the NotReady state.

Cluster Architecture, Installation & Configuration (25%)

This domain asks you to understand the cluster, install it and maintain it. The architecture, the control plane (the components that drive the cluster) and the worker nodes (the machines that run the Pods) tell you which component does what. The installation options, the CNI, CSI and CRI interfaces for network, storage and container runtime, the installation with kubeadm (the official tool that initializes a cluster and joins nodes to it) and the control plane high availability cover the build.

For maintenance, Administer the cluster (in French) opens the subject, etcd and backup and restore protect the cluster data, Prepare a maintenance (in French) covers draining, and Upgrade a cluster covers the upgrade. Permissions go through RBAC, and extension resources through operators. Kustomize customizes manifests without copying them. For Helm, see the dedicated section below.

Services & Networking (20%)

This domain asks you to give access to an application and to troubleshoot that access. The network model and Pod communication give the basics, Services expose the application, CoreDNS provides the internal DNS, Ingress routes HTTP traffic and the Gateway API succeeds it. Network Policies limit who can talk to whom.

Workloads & Scheduling (15%)

This domain covers how workloads are deployed, updated and placed on nodes. Deployments and rolling updates and rollbacks cover the update cycle, ConfigMaps and Secrets cover configuration, and probes cover container health.

For placing Pods on nodes, Assign nodes to Pods covers affinities and taints, advanced scheduling covers priority and preemption, and requests and limits cover requested resources. Autoscaling and the HPA vary the number of replicas, and StatefulSets and DaemonSets cover workloads that are not plain Deployments.

Storage (10%)

This domain weighs the least, and it can be reviewed quickly if you have understood the link between a storage request and the volume that satisfies it. The introduction to storage presents persistent volumes (PersistentVolume) and their claims (PersistentVolumeClaim), the StorageClass covers dynamic provisioning, and the application volumes cover their use in a Pod.

What does the Helm course teach?

Helm, the Kubernetes package manager, is taught by its own course, not by this one. Since helm.sh/docs is one of the allowed resources, plan to know at least how to search for and install a chart (a Helm package), change one of its values, inspect a release (an installation of a chart in the cluster) and roll back.

The Helm course (in French) gives the full path. For the CKA, the Helm commands (in French) and the installation of releases (in French) cover installation, the values (in French) cover changing a value, and the release lifecycle (in French) covers the rollback. You do not need to write a chart for these steps.

How does the CKA differ from the CKAD and the CKS?

The three exams share the same hands-on format, but they look at the cluster from three angles. The CKA administers it, the CKAD deploys applications on it and the CKS hardens it.

ExamAngleQuestion it asks
CKAthe cluster"Can you install, maintain and troubleshoot this cluster?"
CKADthe application"Can you deploy, configure and diagnose an application on it?"
CKSsecurity"Can you harden this cluster and what runs on it?"

Read the table by asking yourself what you do every day. If installing, upgrading and repairing a cluster is not part of your job, the CKAD is a better fit. The CKS requires having passed the CKA before you sit it: the Linux Foundation page, read on November 13, 2026, does not say whether that CKA must still be valid. The guide to choosing your certification compares the formats and suggests a path for your profile.

Two other pages complement this one. The CKA essential commands cheat sheet gathers the commands to know, and the timed CKA exercises train you task by task.

How do you set up your session on exam day?

What the Linux Foundation has already prepared is not to be redone: on each work host, kubectl, the k alias and Bash autocompletion are in place. What remains is deciding what you add, and checking in the simulator whether your settings carry over from one host to the next. Since you change host on every task, set them again after each ssh connection if they do not carry over, or leave them aside.

The next two settings are candidate habits, not official instructions. The first shortens the generation of a starter manifest: the do variable is then written $do at the end of a command. The second configures vim (~/.vimrc is its settings file) to replace tabs with two spaces, which YAML requires:

Terminal window
export do="--dry-run=client -o yaml"
printf 'set expandtab tabstop=2 shiftwidth=2\n' >> ~/.vimrc

Check the first one with a command that writes nothing to the cluster. Type it in a Bash shell, as on the exam hosts: under Zsh, an unquoted $do is not split into words and the command fails.

Terminal window
kubectl create namespace demo $do

The output must be a YAML manifest that starts with apiVersion: v1 and kind: Namespace, with name: demo. No namespace is created, since --dry-run=client stops before sending anything to the API. You get the skeleton of an object that you complete, instead of writing it from scratch. The second setting assumes the host editor is vim: check in the simulator which editor is available, and adapt the setting if it is another one.

One last habit saves points: set the task namespace in your kubectl context with kubectl config set-context --current --namespace=<namespace>. The context is the cluster, user and namespace set that kubectl uses by default; the command only changes its namespace. Then reread the task statement before you validate: the requested namespace may sit at the end of a sentence, where the eye does not stop. The commands to know and how to type them fast are in the CKA essential commands.

What foundation do you need before you start?

This preparation assumes you have completed levels 1 to 4 of the course: the basic resources (Pods, Deployments, Services, ConfigMaps, Secrets), writing manifests, networking, scheduling and installing a cluster. The CKA does not re-explain any of that, and neither does this page.

Before you plan eight weeks, compare the five domains above with the lessons you have completed: every domain for which you have completed no lesson is a gap to fill first. Be comfortable with Linux too, in particular journalctl (the command that reads systemd logs) to read those of the kubelet, the agent that runs on each node. It is also better to have already built a cluster, even with kubeadm on virtual machines: it is a valuable head start on the 25% domain.

Which cluster should you practice on?

The lessons of the course are played on kind (Kubernetes in Docker: each node is a container), a deliberate choice that is enough to learn Kubernetes. But the "Cluster Architecture, Installation & Configuration" domain is about kubeadm: building a cluster, upgrading it, adding a node, renewing its certificates. These steps cannot be learned on kind, which does them for you.

For this domain specifically, practice on a cluster built with kubeadm, on virtual machines, that you are allowed to break. Then use that cluster as a failure playground: stop the kubelet service on a node, delete a configuration file, and time how long it takes you to get back to a healthy cluster. For the other domains, kind is enough.

What eight-week study plan should you follow?

End each week with a hands-on exercise, never with reading: an entirely practical exam is prepared at the keyboard. The plan follows the order in which the skills are built, from architecture to troubleshooting: the first six weeks build the skills, the seventh puts them under pressure and the eighth measures the result.

WeekDomainWhere to readTo finish the week
1Architecture and installationarchitecture, control plane, worker nodes, kubeadmbuild a multi-node kubeadm cluster and name the role of each component
2Architecture and installationhigh availability, RBAC, Kustomize and the Helm coursecreate a Role and its binding, then install a chart and change a value
3Architecture and installationetcd, backup, maintenance preparation, upgradeback up etcd, drain a node, upgrade the cluster
4Workloads & SchedulingDeployments, rolling updates, taints, requests and limits, HPAupdate a Deployment, roll back, then force a Pod onto a node
5Services & Networking and StorageServices, Ingress, Gateway API, Network Policies, CoreDNS, StorageClassexpose an application, isolate it, then mount a persistent volume on it
6Troubleshooting, first halfdiagnostic method, events, failing Podsrepair three failing Pods, following the order from broadest to finest
7Troubleshooting, second halfcluster failure, node troubleshootingdeliberately break your kubeadm cluster and repair it, with a timer
8Review and simulationessential commands, timed exercises, Killer.shtake the simulator sessions if your offer includes them, then redo the tasks you missed

If your time is shorter, keep the order and shorten each step rather than skipping a domain. Trim Storage (10%) and Workloads & Scheduling (15%) first, never troubleshooting: Troubleshooting weighs 30% and is prepared by repetition, not by reading. With four weeks, merge weeks 1 to 3 into two, keep one week for Workloads, Services and Storage, and a last one for troubleshooting and the simulator.

Which pitfalls cost points?

Several exam pitfalls are not about technique: they cost points even when you know how to do the exercise. They are fixed by habits, not by more study.

The first is not reading the task statement to the end. The statement gives the host, the namespace, precise names and sometimes labels. A detail placed at the end of a sentence is easy to miss when you have already started typing. A task done in the wrong namespace or on the wrong host may leave nothing in the place that the automatic grading inspects.

The second is spending too long on one task. With 15 to 20 tasks in 2 hours, the average comes down to 6 to 8 minutes per task. If you get stuck, move on to the next one and come back to it later: the 66% threshold allows it.

The third is not checking after creation. A kubectl apply that answers created only proves that the API accepted the object: the Pod may stay Pending, the container may loop, the Service may route to nobody. Always check that the resource works.

Terminal window
kubectl get <resource> -n <namespace>
kubectl describe <resource> <name> -n <namespace>

Read the state in get, and the reason for an anomaly in the Events section of describe. Practice these two readings as much as creation itself.

The fourth is underestimating troubleshooting. We naturally practice creating resources, rarely repairing someone else's. For a failing node, journalctl -u kubelet -n 50 gives the last kubelet messages, and kubectl get events --sort-by=.metadata.creationTimestamp sorts events from oldest to newest.

Key takeaways

  1. The exam lasts 2 hours, has 15 to 20 tasks and requires 66% of the points: these figures are those of November 13, 2026, to be reconfirmed on the product page before you buy.
  2. The five domains weigh 30% (Troubleshooting), 25% (Cluster Architecture, Installation & Configuration), 20% (Services & Networking), 15% (Workloads & Scheduling) and 10% (Storage).
  3. Each task is done on a designated host, over ssh, and ends with exit back to the base machine: nested ssh is not supported. On these hosts, kubectl, the k alias and Bash completion are already configured; check in the simulator whether your personal settings carry over from one host to the next.
  4. The only sites you can consult are kubernetes.io/docs, kubernetes.io/blog, helm.sh/docs and gateway-api.sigs.k8s.io, with the documentation linked to the task.
  5. The CKA administers the cluster, the CKAD deploys applications on it, the CKS hardens it and requires having passed the CKA.
  6. Helm is taught by the Helm course; know how to install a chart, change a value and roll back.
  7. Practice on a kubeadm cluster on virtual machines for the 25% domain: kind hides these steps from you.
  8. A plan ends each week with a hands-on exercise, then with the simulator, if your offer includes it, and the timed exercises.

Test your knowledge

Seven questions on the exam format, the five domains, the allowed resources, the exam-day pitfalls and how to practice.

Knowledge check

Check what you have learned with this interactive quiz

7 questions
5 min
80% to pass

How it works

  • The timer starts when you click Start
  • Multiple choice, true/false and short answer questions
  • You can move between questions
  • Detailed results are shown at the end

Starts the quiz and the timer