OnCallReadyStart learning

KubernetesSecurity · 6 min read

The CKS exam in 2026: domains, weights and what the tasks look like

The Certified Kubernetes Security Specialist in 2026: format, the six domains and their weights, the exam environment, and a typical task for each domain.

The Certified Kubernetes Security Specialist (CKS) is the Linux Foundation and CNCF's hands-on Kubernetes security exam. Nobody asks you to pick an answer from four: you get a terminal, real clusters and a list of tasks. Here is what it is in October 2026, from the Linux Foundation's own pages, and what the tasks in each domain ask you to do.

The facts

Formatonline, proctored, performance-based: tasks solved on the command line
Tasks15-20
Time2 hours
Kubernetes versionv1.35 (the environment follows the newest minor release within about 4 to 8 weeks)
Pass mark67% (the CKA and CKAD need 66%)
Prerequisitea passed CKA ("must have taken and passed the CKA exam prior to attempting the CKS exam")
Price$445, exam only (bundles with a course cost more)
Includedone retake, 12 months to take the exam, two killer.sh simulator sessions
Valid for2 years

Sources: the CKS page, the FAQ (pass marks, version, validity) and the "Important Instructions: CKS" page (the 15-20 tasks), all checked on 21 October 2026. Re-check them before you book: the version and sometimes the curriculum change with Kubernetes releases.

Two details people miss. Each killer.sh session has 17 questions with a 120-minute countdown, and the environment stays open for 36 hours after you start it, so you can work through the solutions afterwards. The CKA only has to have been passed at some point: killer.sh's CKS page says even an expired one counts. And under the Linux Foundation's CARE program, passing or renewing the CKS on or after 18 June 2026 also extends your CKA to the new CKS expiry date.

The environment

The current exam is not "one terminal with six kubeconfig contexts" any more. Each task names a host. You start on a base machine, ssh to the task's host, do the work there and exit back to base. Nested ssh (from one task host to another) is not supported. On the task hosts you get kubectl with the k alias and bash completion, yq, curl, wget and man pages. The base host has none of them, so k: command not found means you forgot to ssh. sudo -i gives you root on any host.

The remote desktop has a few keyboard traps: copy and paste in the terminal are Ctrl+Shift+C / Ctrl+Shift+V, use Ctrl+Alt+W instead of Ctrl+W (which closes the browser tab), and the Insert key is disabled (press i in vim).

During the exam you may open the documentation of Kubernetes (docs and blog), Falco, etcd, Cilium, Istio, bom and the ingress-nginx configuration page, plus whatever a task links in its "Quick Reference" box (Resources Allowed). Trivy, Kyverno, kubesec and kube-linter are not on that list. Unless a task's Quick Reference links their docs, --help is what you have, so learn the flags before the exam.

The six domains, and what a task looks like

The weights and competencies below are the ones on the CKS page. The example tasks are the kind each competency turns into on a hands-on exam. The real wording is not public: it is covered by the Linux Foundation's confidentiality agreement.

DomainWeightWhat it covers
Cluster Setup15%NetworkPolicies, the CIS benchmark (kube-bench), Ingress with TLS, node metadata, verifying platform binaries
Cluster Hardening15%RBAC, ServiceAccounts, restricting API access, upgrading Kubernetes
System Hardening10%a smaller host OS, least-privilege IAM, less external network access, AppArmor and seccomp
Minimize Microservice Vulnerabilities20%Pod Security Standards, Secrets, isolation (sandboxed containers), pod-to-pod encryption (Cilium, Istio)
Supply Chain Security20%smaller base images, SBOMs, permitted registries, signing and validating artifacts, static analysis (kubesec, KubeLinter)
Monitoring, Logging and Runtime Security20%behavioural analytics, threat detection, attack phases, immutable containers, audit logs

Cluster Setup: fix what the benchmark flags

A typical task: "fix the FAILs that kube-bench reports for the API server, controller manager and scheduler". On the control plane host:

terminal
$ ssh cp-1 sudo kube-bench run --targets master --check 1.2.15,1.3.2,1.4.1
[INFO] 1 Control Plane Security Configuration
[INFO] 1.2 API Server
[FAIL] 1.2.15 Ensure that the --profiling argument is set to false (Automated)
[INFO] 1.3 Controller Manager
[FAIL] 1.3.2 Ensure that the --profiling argument is set to false (Automated)
[INFO] 1.4 Scheduler
[FAIL] 1.4.1 Ensure that the --profiling argument is set to false (Automated)

== Remediations master ==
1.2.15 Edit the API server pod specification file /etc/kubernetes/manifests/kube-apiserver.yaml
on the control plane node and set the below parameter.
--profiling=false
...

The remediation tells you which static pod manifest to edit. Save it, wait for the kubelet to restart the pod, then run the same check again. The other classics in this domain: a default-deny NetworkPolicy plus the one path that must stay open, an egress rule that keeps pods away from 169.254.169.254, and sha256sum --check against the release's .sha256 file to find a tampered binary.

Cluster Hardening: least privilege, then prove it

Trim a wildcard Role down to what the workload needs, stop a ServiceAccount from mounting its token (automountServiceAccountToken: false), and prove the result with kubectl auth can-i:

terminal
$ kubectl auth can-i create pods/exec --as=system:serviceaccount:default:default -n default
no

System Hardening: profiles that live on the node

Load an AppArmor profile on the right node (apparmor_parser, then aa-status to check), or copy a seccomp profile under /var/lib/kubelet/seccomp/, and run a pod that uses it through securityContext. The trap is that the profile has to exist on the node the pod lands on. If it does not, the container is not created.

Minimize Microservice Vulnerabilities

Label a namespace for Pod Security Admission (pod-security.kubernetes.io/enforce=restricted) and fix the workloads it now rejects. Create a RuntimeClass for gVisor (handler: runsc) and move an untrusted pod onto it. And Secrets: encryption at rest is in this domain. If you have not done it before, read rotating the etcd encryption key first: the order of the keys is the whole trick.

Supply Chain Security

Find which running images have HIGH or CRITICAL vulnerabilities:

terminal
$ trivy image --severity HIGH,CRITICAL registry.lab/shop/legacy-api:1.0
...
registry.lab/shop/legacy-api:1.0 (debian 12.1)
==============================================
Total: 2 (HIGH: 2, CRITICAL: 0)

┌──────────┬────────────────┬──────────┬────────┬───────────────────┬───────────────────┬───────────────────────────────────┐
│ Library  │ Vulnerability  │ Severity │ Status │ Installed Version │ Fixed Version     │ Title                             │
├──────────┼────────────────┼──────────┼────────┼───────────────────┼───────────────────┼───────────────────────────────────┤
│ libc6    │ CVE-2023-4911  │ HIGH     │ fixed  │ 2.36-9+deb12u1    │ 2.36-9+deb12u3    │ glibc: buffer overflow in ld.s... │
│ libcurl4 │ CVE-2023-38545 │ HIGH     │ fixed  │ 7.88.1-10+deb12u1 │ 7.88.1-10+deb12u4 │ curl: heap based buffer overfl... │
└──────────┴────────────────┴──────────┴────────┴───────────────────┴───────────────────┴───────────────────────────────────┘

Then allow only permitted registries with a ValidatingAdmissionPolicy in CEL, and scan a manifest with kubesec or kube-linter and fix what they report. The two tools work very differently: see kubesec vs kube-linter. If your cluster runs Kyverno, image signatures are now an ImageValidatingPolicy, see moving to Kyverno 1.19's policy types.

Monitoring, Logging and Runtime Security

Turn on API audit logging with a given policy (the policy file and the log directory each need a hostPath volume and a volumeMount in the kube-apiserver manifest: without the first the API server cannot read its policy and does not start, without the second it writes the log inside its own container), find which pod a Falco alert is about and stop it, and make a container immutable: readOnlyRootFilesystem: true, with an emptyDir for the paths it really has to write.

How to spend the two hours

At 15-20 tasks you have 6-8 minutes each. Three habits score the points:

  1. Go where the task says, every time. The right fix on the wrong host scores zero.
  2. Verify before you move on. Grading looks only at the state you leave behind, never at your commands: a get, a can-i, a denied kubectl run, a kube-bench re-run.
  3. Flag and skip. A task that is still fighting you after about 10 minutes goes to the end of the list. A task's weight is the same however hard it is.

Practise it

The Kubernetes Security (CKS) chapter teaches each competency in a lesson and a lab, then drills the exam's task types one at a time. Each drill is rebuilt with new names every round. The block drill gives you five random tasks against a 40-minute clock. The same tasks are the CKS exam mode, which works on the phone too. Start with The CKS map: what a cluster attacker goes after and finish with The CKS exam: how the tasks run, and the drills.

OnCallReady is free, with no ads and no tracking. RSS · All posts