
CKS (Certified Kubernetes Security Specialist) is the Linux Foundation and CNCF's hands-on Kubernetes security exam. You must hold a current CKA before you take it. In 2 hours on a live command line you harden clusters, restrict workloads, secure the supply chain and detect threats at runtime. DevSecOps, cloud security and platform teams in Hyderabad's banks, product companies and GCCs value it highly, because it proves you can secure Kubernetes, not just run it.
This guide follows the official CKS exam page. It covers the exam facts, the six domains and their weightings, the security controls to practise, a 6-week plan and 15 original practice tasks.
Quick facts (Linux Foundation, November 2026)
| Item | Detail |
|---|---|
| Format | Online, proctored, performance-based tasks on a command line |
| Duration | 2 hours |
| Kubernetes version | v1.37 |
| Price | US$445 for the exam; bundles with the LFS260 course or a THRIVE-ONE subscription cost more |
| Prerequisite | You must have passed CKA before attempting CKS |
| Included | One free retake and two Killer.sh simulator sessions (36 hours each, 17 questions) |
| Validity | 2 years; you have 12 months from purchase to take the exam |
Read the official CKS exam page. The linked curriculum PDF may show an older Kubernetes version than the exam itself, so practise on the current release.
Domains and weightings
| Domain | Weight | Competencies |
|---|---|---|
| Cluster Setup | 15% | Network policies; CIS benchmark review of etcd, kubelet, kube-dns and API server; Ingress with TLS; protecting node metadata and endpoints; verifying platform binaries |
| Cluster Hardening | 15% | Least-privilege RBAC; careful service account use; restricting API access; upgrading Kubernetes to fix vulnerabilities |
| System Hardening | 10% | Smaller host OS footprint; least-privilege IAM; limiting external network access; AppArmor and seccomp |
| Minimize Microservice Vulnerabilities | 20% | Pod Security Standards; Kubernetes secrets; multi-tenancy and sandboxed containers; pod-to-pod encryption (for example Cilium or Istio) |
| Supply Chain Security | 20% | Smaller base images; SBOMs, CI/CD and artifact repositories; allowed registries, signing and verifying artifacts; static analysis with tools such as Kubesec and KubeLinter |
| Monitoring, Logging and Runtime Security | 20% | Behavioural analytics; threat detection; investigating attack phases; immutable containers; Kubernetes audit logs |
Security controls to practise
# Pod Security Standards: enforce "restricted" on a namespace
kubectl label ns payments pod-security.kubernetes.io/enforce=restricted
# CIS benchmark check on a node
kube-bench run --targets node
# image scanning and SBOM
trivy image --severity HIGH,CRITICAL nginx:1.27
trivy image --format cyclonedx -o sbom.json registry.example.com/api:1.4
# verify a signed image
cosign verify --key cosign.pub registry.example.com/api:1.4
# find who did what in the audit log
jq 'select(.objectRef.resource=="secrets")' /var/log/kubernetes/audit/audit.log
A hardened pod spec:
apiVersion: v1
kind: Pod
metadata:
name: api
spec:
automountServiceAccountToken: false
securityContext:
runAsNonRoot: true
seccompProfile: {type: RuntimeDefault}
containers:
- name: api
image: registry.example.com/api:1.4
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
capabilities: {drop: ["ALL"]}
appArmorProfile: {type: Localhost, localhostProfile: k8s-api-deny-write}
A minimal audit policy (pass it to the API server with --audit-policy-file):
apiVersion: audit.k8s.io/v1
kind: Policy
rules:
- level: Metadata
resources:
- group: ""
resources: ["secrets", "configmaps"]
- level: None
users: ["system:kube-proxy"]
- level: Request
verbs: ["create", "update", "patch", "delete"]
Practise editing /etc/kubernetes/manifests/kube-apiserver.yaml safely: back it up first, then wait for the API server to restart and check it with crictl ps.
6-week study plan
| Week | Focus | Lab (kubeadm cluster you can break) |
|---|---|---|
| 1 | Network policies, Ingress TLS, blocking node metadata access, kube-bench, checking binary hashes | Default-deny every namespace, then allow only what is needed |
| 2 | RBAC review, service accounts and token automount, API server flags, cluster upgrades | Remove unnecessary cluster-admin bindings |
| 3 | AppArmor and seccomp profiles, minimal host packages and ports | Load an AppArmor profile on a node and apply it to a pod |
| 4 | Pod Security Standards, secrets and encryption at rest, RuntimeClass with gVisor, Cilium or Istio mTLS | Run one pod in a sandbox RuntimeClass |
| 5 | Image scanning, SBOMs, signing with Cosign, allowed registries, Kubesec and KubeLinter | Block images from unapproved registries with an admission policy |
| 6 | Falco rules, audit logs, immutable containers; both Killer.sh sessions | Detect a shell opened in a container; book the exam |
15 practice tasks with solutions
These are original tasks written for this guide, not exam questions.
1. Stop a service account token being mounted into a pod.
Set automountServiceAccountToken: false on the pod or the service account.
2. Enforce the restricted Pod Security Standard in a namespace.
Label it pod-security.kubernetes.io/enforce=restricted.
3. Which tool checks a cluster against the CIS Kubernetes Benchmark?
kube-bench.
4. Stop pods reaching the cloud metadata endpoint 169.254.169.254.
Use an egress NetworkPolicy that allows 0.0.0.0/0 except 169.254.169.254/32.
5. Apply the container runtime's default seccomp profile.seccompProfile: {type: RuntimeDefault} in the securityContext.
6. How do you reference an AppArmor profile loaded on the node?appArmorProfile: {type: Localhost, localhostProfile: <name>} in the securityContext.
7. Make a container's filesystem immutable.readOnlyRootFilesystem: true, with an emptyDir mounted wherever the app must write.
8. Run a pod with a gVisor sandbox.
Create a RuntimeClass with handler runsc and set runtimeClassName on the pod.
9. Encrypt Secrets in etcd.
Write an EncryptionConfiguration (for example with aescbc or a KMS provider), pass it with --encryption-provider-config, then rewrite existing secrets.
10. Scan an image for high and critical CVEs.trivy image --severity HIGH,CRITICAL <image>.
11. Check that an image was signed with your key.cosign verify --key cosign.pub <image>.
12. Which tools statically analyse Kubernetes manifests for risky settings?
Kubesec and KubeLinter.
13. Which audit level records request metadata but not bodies?Metadata.
14. Which tool detects a shell spawned inside a container at runtime?
Falco, using behavioural rules.
15. Why upgrade Kubernetes as a security task?
Each release includes security fixes, and only recent minor versions receive patches.
Before and after CKS
- Pass CKA first; KCSA is a good theory warm-up.
- Go deeper into the tools with Cilium (CCA), Istio (ICA) and Kyverno (KCA).
- Learn it hands-on in our Kubernetes course and Cyber Security course; see live DevSecOps and cloud security jobs.
Cloud Soft Solutions in Ameerpet, Hyderabad teaches Kubernetes, DevSecOps and cloud security with real-time projects. See the APEX program and all courses.
📞 Call +91 96660 19191 · WhatsApp · Flat No. 513, 5th Floor, Nilagiri Block, Aditya Enclave, Ameerpet, Hyderabad
Frequently Asked Questions
What is the CKS exam?
The Certified Kubernetes Security Specialist exam from the Linux Foundation and CNCF: 2 hours of hands-on security tasks on live clusters.
Do I need CKA before CKS?
Yes. You must have passed CKA before attempting CKS.
How much does CKS cost?
US$445 for the exam, including one retake and two Killer.sh simulator sessions.
What are the CKS domains?
Cluster Setup 15%, Cluster Hardening 15%, System Hardening 10%, Minimize Microservice Vulnerabilities 20%, Supply Chain Security 20%, Monitoring, Logging and Runtime Security 20%.
Which Kubernetes version does CKS use?
v1.37 as of November 2026.
How long is CKS valid?
2 years.



