The CKS (Certified Kubernetes Security Specialist) is a two-hour hands-on exam: you harden and diagnose Kubernetes clusters in the command line, with no multiple-choice questions. This page tells you what the exam asks, which lessons of the course prepare each of its six domains, what the course delegates to other paths, and how to split eight weeks of study.
It is aimed at someone who has already passed the CKA and is following level 5 of the course, the security level, of which the CKS is the culmination. It replaces neither the command cheat sheet nor the exercises: it tells you where to go, and in what order.
What you will learn
- Read the exam format, with the date and source of each figure.
- Name the six domains and their weights.
- Map each domain to the lessons that teach it, and spot what the course delegates.
- Set up your work session the way you will on exam day.
- Build an eight-week study plan.
What the CKS validates
The CKS certifies that you can secure the Kubernetes platform and its workloads throughout their whole lifecycle: building the images, deployment and runtime. In practice, you harden the cluster (API server, RBAC, ServiceAccounts), you reduce the attack surface (Seccomp, AppArmor, Security Context), you protect the supply chain (scanning, signing, admission policies) and you detect what happens at runtime (audit logs, Falco).
The CKS is not a first Kubernetes certification: the CKA is a prerequisite. Nor is it a harder CKA, but a full security certification in its own right. And it is not limited to cluster hardening: it covers build, deployment and runtime.
What is the CKS exam format?
The exam lasts 2 hours, it is taken online under proctoring, and you need 67% of the points to pass. These values come from the Linux Foundation. They were collected on November 14, 2026: if one of these pages says something different when you read it, that page prevails.
| Item | Value as of November 14, 2026 | Source |
|---|---|---|
| Nature of the exam | hands-on, in the command line, on Kubernetes clusters | CKS product page |
| Duration | 2 hours | CKA, CKAD and CKS FAQ |
| Number of tasks | 15 to 20 hands-on tasks | official CKS instructions, read on November 15, 2026 |
| Passing score | 67% | CKA, CKAD and CKS FAQ |
| Kubernetes version | 1.37 | CKS product page and CKS v1.37 curriculum |
| Price of the exam alone | 445 USD | CKS product page |
| Certification validity | 2 years | CKS product page |
| Retake | one retake included, when you are eligible | CKS product page |
| Time to take the exam after purchase | 12 months | CKS product page |
| Prerequisite | CKA passed, not necessarily still active | Linux Foundation announcement |
| Killer.sh simulator | two 36-hour sessions, not included in the "exam only" offer (CKS-SINGLE) | CKA, CKAD and CKS FAQ |
Three lines of this table change the way you prepare. The 67% threshold lets you lose 33% of the points, against 34% for the CKA and the CKAD: it is better to finish cleanly the tasks you master than to start more of them without finishing any. With 15 to 20 tasks in 120 minutes, you have 6 to 8 minutes per task on average: get used to moving on to the next one when one resists, after 8 to 10 minutes at most. And the CKA must have been earned, but it does not need to be still valid on the day you register.
Version 1.37 is that of the exam environment, of the blueprint published by the CNCF on November 3, 2026, and of this course: the commands and the fields you learn here are the ones in the exam today. The FAQ states that the environment aligns with the latest minor version of Kubernetes about 4 to 8 weeks after its release. An exam taken in a few months may therefore run on a more recent version: reread the product page before you plan.
The Killer.sh simulator is a case apart. It is not included in the "exam only" offer: check what your offer contains before counting on it.
What can you consult during the exam?
Only a few online resources are allowed, and the Linux Foundation publishes the list in the allowed resources, read on November 13, 2026. For the CKS, they are kubernetes.io/docs, kubernetes.io/blog, falco.org/docs, etcd.io/docs, docs.cilium.io, istio.io/latest/docs, kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/ and kubernetes-sigs.github.io/bom/cli-reference/, the last two limited to the section indicated. The list therefore goes beyond kubernetes.io to cover the websites of the tools the exam queries.
The search of kubernetes.io/docs is allowed, but opening a result that points outside the allowed domains is not. The point is not to memorize the documentation, but to know how to find an example in it in under a minute. Locate in advance where the audit policy manifest and the Pod Security Standards labels are, which you will often copy. Four starting pages: Kubernetes Security, Pod Security Standards, Security Checklist and Audit Logs.
What are the six domains of the CKS exam?
The official CNCF blueprint splits the CKS into six domains whose weights total 100% of the points. Three 20% domains weigh 60% on their own: Minimize Microservice Vulnerabilities, Supply Chain Security, and Monitoring, Logging and Runtime Security.
| Domain | Weight |
|---|---|
| Cluster Setup | 15% |
| Cluster Hardening | 15% |
| System Hardening | 10% |
| Minimize Microservice Vulnerabilities | 20% |
| Supply Chain Security | 20% |
| Monitoring, Logging and Runtime Security | 20% |
Source: the CNCF CKS v1.37 curriculum, published on November 3, 2026 and read on November 14, 2026. It has 26 objectives. The weights describe a share of the points, not a number of tasks. For each domain, here are the lessons of the course that teach it.
Cluster Setup (15%)
This domain asks you to put the basic protections of the cluster in place: network policies, configuration audit, TLS at the entry point, node protection and binary verification. Its objectives are to use network policies to restrict access to the cluster, to review the configuration of the components with the CIS Benchmark, to configure an Ingress with TLS, to protect node metadata and endpoints, and to verify the platform binaries before deploying them.
The Network Policies cover the first objective, and their section on protecting the node metadata endpoint covers the fourth. The CIS Kubernetes Benchmark teaches how to audit compliance with kube-bench, the Ingress lesson covers TLS, and the section of Supply Chain Security on binary verification covers the last objective.
Three reflexes are worth points here. The except field of an ipBlock lets you express "everything but" an address range in a network policy. An egress block denies everything that is not listed in it, DNS included: Pods can thus stop resolving anything after a policy is applied. Finally, you finish with a check, for example kubectl describe netpol, rather than assuming that the policy does what you think.
Cluster Hardening (15%)
This domain asks you to reduce what an account or a client can do on the API. Its objectives are to use RBAC to minimize exposure, to be careful with ServiceAccounts (disable the default ones, limit the rights of new ones), to restrict access to the Kubernetes API and to update Kubernetes to avoid vulnerabilities.
RBAC and ServiceAccounts cover the first two objectives, RBAC and the CIS Kubernetes Benchmark the third (for example --anonymous-auth=false), and the lesson on upgrading a cluster the fourth.
The classic RBAC trap is to create a correct Role but bind it to the wrong subject, or to use a ClusterRoleBinding where a RoleBinding was expected. End every RBAC task with kubectl auth can-i, which answers yes or no to "am I allowed to do this?" and, with --as, for someone else.
System Hardening (10%)
This domain looks around Kubernetes: the host, its identities and its network. It has four objectives, three of which the Kubernetes course deliberately delegates, because they cannot be demonstrated on a cluster in containers, which shares the host kernel.
The only objective taught here is the use of kernel hardening tools: AppArmor (in French) confines a Pod with a profile, and Seccomp (in French) filters its system calls.
The other three belong to other paths of the site:
- reducing the footprint of the host OS, that is, removing the unnecessary services of a node, is learned in the Linux hardening course (in French), on a virtual machine;
- closing unnecessary external network access, that is, spotting and closing the open ports of a node, is learned in the same hardening course;
- least-privilege IAM, that is, the rights of platform identities such as cloud roles, belongs to no Kubernetes lesson: see IAM and least privilege applied (in French) in the Cloud course.
These three objectives are therefore revised outside the Kubernetes course, on a virtual machine. Plan time for them: no manipulation on a kind cluster replaces them.
Minimize Microservice Vulnerabilities (20%)
This domain asks you to limit what a compromised Pod could do. Its objectives are to use suitable Pod Security Standards, to manage Kubernetes Secrets, to understand and implement isolation techniques (multi-tenancy, sandboxed containers) and to encrypt pod-to-pod traffic with Cilium or Istio.
The Pod Security Standards and the Security Context cover the first objective, with the admission labels to remember. The Secrets cover the second. For encryption at rest in etcd, the lesson Protecting the Secrets of a Kubernetes cluster (in French) teaches it, and the cheat sheet keeps the exam gesture. The Namespaces and the runtime sandboxes cover isolation, and pod-to-pod mTLS the encryption between Pods.
The tasks of this domain are worded in varied ways. The reflex to acquire is not to learn the fields by heart, but to know how to start from an existing manifest and harden it field by field: runAsNonRoot, readOnlyRootFilesystem, capabilities, Pod Security admission labels.
Supply Chain Security (20%)
This domain asks you to accept only images whose origin you control. Its objectives are to reduce the footprint of base images, to understand your supply chain (SBOM, CI/CD, artifact repositories), to secure it (allowed registries, signing and validation of artifacts) and to statically analyze workloads and images, with Kubesec or KubeLinter.
Supply Chain Security covers reduced base images, the SBOM and allowed registries. Signing and validating artifacts are learned in Signing and verifying an image with Cosign. The last objective, static analysis, is covered by the section of Supply Chain Security on analyzing Dockerfiles and manifests before applying them. Kyverno and Gatekeeper (in French) make admission reject what is not compliant, and image scanning with Trivy shows what a scanner sees.
These steps form a chain: you scan the image, you sign it, you reference it by digest so that it no longer changes under the same name, and you have an admission controller reject the rest. Knowing how to scan earns no points if nothing prevents the vulnerable image from being deployed anyway.
Monitoring, Logging and Runtime Security (20%)
This domain measures your ability to detect and investigate, not to prevent. Its objectives are behavioral analysis to spot malicious activity, threat detection across the whole platform, investigation of the phases of an attack, runtime container immutability and the use of audit logs to monitor access.
Falco covers behavioral analysis and detection, the audit logs cover investigation and access monitoring, and the Security Context covers immutability (read-only file system). The difficulty lies in the volume more than in the notions. A raw audit log is unreadable without filtering: the exercise is to reduce it to the handful of events that answer the question asked.
What the CKS does not ask for
To avoid spreading yourself thin, here is what the blueprint leaves to other exams. Its 26 objectives contain neither application development nor cluster installation.
The CKS validates an end-to-end view of Kubernetes security, not deep expertise on one specific tool.
How does the CKS differ from the CKA and the CKAD?
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.
| Exam | Angle | Prerequisite | Passing score |
|---|---|---|---|
| CKAD | the application | none | 66% |
| CKA | the cluster | none | 66% |
| CKS | security | CKA passed | 67% |
Source of the passing scores: CKA, CKAD and CKS FAQ. Supply chain and runtime security are full domains here, at 20% each, that the other two exams do not take up as such. This is where the preparation gap lies, not in the RBAC you already know. The guide to choosing a certification compares the formats if you are still hesitating.
What foundation do you need before starting?
This preparation assumes the CKA is passed, and therefore ease with cluster administration: the API server, etcd, the kubelet and the control plane components, with the place where each is configured. You must also be comfortable with Linux, to read configuration files and move around the file system, and with kubectl, whose autocompletion must feel natural.
RBAC and Network Policies, two topics of the CKA, are fundamental here: revise them before starting if needed.
Initial setup on exam day
On the task hosts, kubectl, the k alias and completion are already ready, according to the official instructions cited below: do not waste time setting them up. Only your personal shortcuts are up to you, to be set again after each ssh connection if you want them. The examples on this page use k and $do.
# Personal shortcuts, optionalalias kn='kubectl config set-context --current --namespace'export do="--dry-run=client -o yaml"
# Check where kubectl points on the task hostkubectl config current-contextkubectl config get-contextsEach task is performed on a designated host, and the task text says which host to reach. The official CKS instructions (the Linux Foundation's "Important Instructions: CKS" page, consulted on November 13, 2026) say that these hosts "can be reached via ssh, using a command such as the following: ssh <nodename>". They do not mention kubectl config use-context. So connect with ssh to the requested host, then check with kubectl config current-context where kubectl points.
Most cost-effective commands
This block is not to be learned by heart: it is a list of the verification steps that earn points because they confirm that a task is really finished. Look above all at the check commands (auth can-i, describe netpol, the raw reading of etcd): in a timed exam, forgetting to check what you have just applied costs points even to someone who knows the exercise. The full reference is in the cheat sheet Essential CKS commands.
# RBAC: check permissionsk auth can-i --list --as=system:serviceaccount:ns:sak auth can-i create pods --as=dev-user
# Pod Security: apply PSA on a namespacek label ns production pod-security.kubernetes.io/enforce=restrictedk label ns production pod-security.kubernetes.io/warn=restricted
# SecurityContext: generate a secured Podk run secure-pod --image=nginx:1.30.5@sha256:9bf97bd7714f5e24c1ccd545ecb9eb5435cb6d109c97cebb15e7e455e0239edb $do | \ yq '.spec.containers[0].securityContext = {"runAsNonRoot": true, "readOnlyRootFilesystem": true}'
# Image scantrivy image nginx:1.30.5@sha256:9bf97bd7714f5e24c1ccd545ecb9eb5435cb6d109c97cebb15e7e455e0239edbtrivy k8s --report summary
# Audit: read the policy, then the log (file set by --audit-log-path)cat /etc/kubernetes/audit/policy.yamlsudo tail -n 5 /var/log/kubernetes/audit/audit.log | jq .
# Secrets: check encryption inside etcd (the API always returns the plain value)kubectl -n kube-system exec etcd-<node> -- etcdctl \ --endpoints=https://127.0.0.1:2379 \ --cacert=/etc/kubernetes/pki/etcd/ca.crt \ --cert=/etc/kubernetes/pki/etcd/server.crt \ --key=/etc/kubernetes/pki/etcd/server.key \ get /registry/secrets/default/mysecret
# NetworkPolicies: deny-all then allowk create -f deny-all.yamlk describe netpol -n production
# CIS Benchmarkkube-bench run --targets masterkube-bench run --targets nodeSecret encryption is checked in etcd, not through the API: the API always decrypts the value before returning it. So you read the raw value with etcdctl, run inside the etcd-<node> static Pod (its exact name appears in kubectl -n kube-system get pods), which ships the tool and mounts its certificates. A value that starts with k8s:enc: is encrypted, otherwise it is stored in clear. Exercise 24 walks through the whole procedure.
Among these commands, kubectl auth can-i is the fastest way to check that an RBAC setup does what you think: the API settles it, whereas rereading the Roles forces you to reconstruct mentally what they allow.
Tools to master
None of these tools requires deep expertise, but each must be launched without consulting its documentation. The right-hand column gives the expected action: trivy to spot a vulnerability, kube-bench to place the cluster against the CIS Benchmark, cosign to establish the provenance of an image. kubectl and jq are the two general-purpose tools of the list, and jq saves a lot of time on JSON output.
| Tool | CKS use |
|---|---|
kubectl | Administration, RBAC, inspection |
jq | Parsing JSON output |
trivy | Image and cluster scanning |
kube-bench | CIS Benchmark verification |
cosign | Image signing and verification |
kubesec | Scores a manifest, fails with 2 under the threshold |
kube-linter | Lists the defects of a manifest, fails with 1 |
sha256sum | Verifies a platform binary before deployment |
falco | Runtime detection (depending on the lab) |
What study plan should you follow over eight weeks?
Eight weeks, because the CKS assumes the whole CKA syllabus is acquired, and adds tools that many administrators have never handled, such as Falco, Trivy, AppArmor and Seccomp. End each week with a manipulation, never with reading: an entirely hands-on exam is prepared at the keyboard. The plan gives four of the eight weeks to the three 20% domains.
| Week | Domain | Where to read | To finish during the week |
|---|---|---|---|
| 1 | Cluster Hardening | RBAC, ServiceAccounts, cluster upgrade | create a Role, a binding and a ServiceAccount, then check them with kubectl auth can-i |
| 2 | Cluster Setup | Network Policies, CIS Benchmark, Ingress, binary verification | apply a deny-all, open the necessary traffic, block the metadata endpoint, run kube-bench |
| 3 | Minimize Microservice Vulnerabilities | Security Context, Pod Security Standards, Secrets, runtime sandboxes, mTLS | apply restricted on a namespace and harden an already deployed Pod |
| 4 | System Hardening | AppArmor, Seccomp, Linux hardening, IAM | apply a Seccomp profile and an AppArmor profile, then close ports on a virtual machine |
| 5 | Supply Chain Security | supply chain, image scanning, Cosign, manifest analysis | scan an image, reference it by digest, sign it, then analyze a manifest |
| 6 | Supply Chain Security, admission | admission controllers, Validating Admission Policy, Kyverno, Gatekeeper | have admission reject a non-compliant image |
| 7 | Monitoring, Logging and Runtime Security | audit logs, Falco | write an audit policy and read a Falco alert |
| 8 | Review and simulation | essential commands, timed exercises, hands-on mock exam, Killer.sh | take the hands-on mock exam in 120 minutes, then the simulator sessions if your offer includes them, and redo the tasks you missed |
If your time is shorter, keep the order and shorten each step rather than skipping a domain. Trim System Hardening (10%) first, never the three 20% domains.
Which pitfalls cost points?
Read the "Solution" column rather than the "Pitfall" column: these six lines describe habits to install during practice, not instructions to remember on exam day. Under pressure, you only apply what has become automatic.
| Pitfall | Consequence | Solution |
|---|---|---|
| Not reading the task in full | You miss a security constraint | Read everything, note the requirements |
| Getting stuck on one question | You lose precious time | Move on after 8 to 10 minutes, come back to it at the end |
| Applying a policy without testing it | You block the workload | Use --dry-run=server first |
| Forgetting to check your answers | Undetected errors | A quick kubectl get to confirm |
| Ignoring the audit logs | You cannot investigate | Practice reading the logs |
| Forgetting to connect to the designated host | You work on the wrong cluster | Reread the host given at the start of each task |
How to practice before the exam?
For the hands-on skills, play the timed CKS exercises, which end with a capstone, "opening an enclave to a team that is not trusted", then with a hands-on mock exam of 16 tasks in 120 minutes, graded at the 67% threshold like the real exam. For typing fast, go back to the cheat sheet Essential CKS commands.
To revise knowledge, the multiple-choice CKS mock exam (in French) offers multiple-choice questions on the same domains. It does not measure your speed at the terminal, it checks that you master the notions: use it before the exercises, not in their place.
The Killer.sh simulator is played in two 36-hour sessions, if your offer includes it. Keep them for the end of the preparation: used too early, it mostly reveals what you have not learned yet, and it is by rereading the corrections during those 36 hours that you progress.
For practice, set up a cluster you can break and then recreate with one command, such as a kind cluster, before you even start the syllabus: several objectives, such as restricting access to the API or configuring audit, require changing the API server configuration, and a disposable cluster keeps you from stalling on an API server that no longer restarts. Add kube-bench, Trivy and Falco to that cluster. For System Hardening, work on a virtual machine.
Key takeaways
- The exam is hands-on, lasts 2 hours and requires 67% of the points; the figures on this page are those of November 14, 2026, to be reconfirmed on the product page before you buy.
- The environment version is 1.37, like the course, and a passed CKA is mandatory, without needing to be still active.
- The weights of the six domains are 15, 15, 10, 20, 20 and 20%, and three 20% domains are worth 60% of the points.
- Three System Hardening objectives (host OS, IAM, node ports) are revised outside the Kubernetes course, on a virtual machine.
- The allowed documentation goes beyond
kubernetes.io: learn to find an example in under a minute. - An RBAC task ends with
kubectl auth can-i, and a policy is tested before it is applied. - The Killer.sh simulator is not included in the "exam only" offer, and an eight-week plan ends each week with a manipulation.
- With 15 to 20 tasks in 120 minutes, count 6 to 8 minutes per task and move on after 8 to 10 minutes; the hands-on mock exam of the exercises page lets you experience it.
Knowledge check
Seven questions about the exam itself: its prerequisite, its domains and their weights, the allowed documentation and the checks to make at the terminal.
Knowledge check
Check what you have learned with this interactive quiz
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
Review
(0/0)Score by domain
A domain groups several guides and gets several questions, so its score is more reliable than a per-topic score, which often rests on a single question.
Summary
Strengths
No topic passed at 80% on at least two questions yet.
Weak areas
No topic below the pass mark.
Recommended next
Hints before you try again?
Continue the course: CKS cheat sheet: Kubernetes security commands
A new full quiz with random questions
Work again only on the questions you missed