CKS course and practice exam: Certified Kubernetes Security Specialist

This CKS course has 40 video lessons and 104 graded labs, and its CKS practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Harden clusters, supply chains and running workloads

Prepares you for the hands-on CKS exam: cluster setup and hardening, system hardening, microservice security, supply chain security and runtime monitoring.

Advanced · 3 hours · 40 lessons · 116 labs

CKS exam guide

The CKS exam (Certified Kubernetes Security Specialist, by CNCF / The Linux Foundation): 2 hours; questions: 15–20 performance-based tasks; pass mark: 67%; cost: USD 445 (includes one free retake).

  • Format: Performance-based: tasks solved in a live Kubernetes environment from the command line
  • Duration: 2 hours
  • Questions: 15–20 performance-based tasks
  • Pass mark: 67%
  • Cost: USD 445 (includes one free retake)
  • Valid for: 2 years
  • Delivery: Online, proctored (PSI)
  • Prerequisites: Must hold a current Certified Kubernetes Administrator (CKA) certification

Exam domains and weights

  • Cluster Setup: 15%
  • Cluster Hardening: 15%
  • System Hardening: 10%
  • Minimize Microservice Vulnerabilities: 20%
  • Supply Chain Security: 20%
  • Monitoring, Logging and Runtime Security: 20%

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 CKS sample questions with answers: free to read, no account needed.

Common questions

How long is the CKS exam?

The CKS exam lasts 2 hours.

How many questions are on the CKS exam?

15–20 performance-based tasks.

What is the CKS passing score?

The pass mark is 67%.

How much does the CKS exam cost?

USD 445 (includes one free retake).

Is there a free CKS practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: CKS exam page (Linux Foundation Training) (CNCF / The Linux Foundation), checked 2026-09-25.

Who it is for

Advanced level.

For Kubernetes administrators who hold or are close to the CKA and want to harden clusters, supply chains and running workloads for the hands-on CKS exam.

What you don't need yet:

What helps:

No formal prerequisites. The courses under "Take first" cover what helps.

Take first:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

What this exam proves, and what it doesn't

The CKS is a performance-based exam: you secure a live Kubernetes cluster from the command line, so passing shows you can apply the controls. It doesn't replace defending production clusters; our graded labs use a simulated cluster and the tools' real output.

Exam objectives this course teaches

Certified Kubernetes Security Specialist (CKS)

Labs

116 labs, 104 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Start Here

  1. Six Seconds, Every Secret (2 labs): You can answer who read a Secret, which grant allowed it, and what else that person did, from a real API server audit log, in three queries.
  2. Two Hours, Sixteen Tasks: A CKS Plan (3 labs): You can say what makes each kind of security change take effect and how to prove it, order a paper by points per minute with node edits last, and check the blast radius of a change before you make it.

Cluster Setup

  1. NetworkPolicy Truth Tables: One Dash Decides (2 labs): You can predict, source by source, what a NetworkPolicy lets in, tell an AND peer from an OR peer by its dashes, and write a policy that admits exactly the pods and namespaces a task names.
  2. Default Deny, Then Exactly The Doors You Need (2 labs): You can lock a namespace down in both directions with one policy, then open only the paths a workload needs, including DNS, across namespaces, and prove each path is open or closed.
  3. The Metadata Endpoint And The Kubelet's Front Door (3 labs): You can block pods from the cloud metadata endpoint without breaking their other traffic, and check a kubelet's own API for anonymous access, open authorisation and the read-only port.
  4. kube-bench: Ten Failures On A Fresh Cluster (4 labs): You can read a kube-bench report, trace each failure to its audit and remediation, fix it in the right place (a static pod manifest, a file or the kubelet), and prove the fix on a real node with the course kit.
  5. Ingress: Hosts, Paths And The Class That Serves Them (1 lab): You can write an Ingress in one command with hosts, Prefix and Exact paths, a class and TLS, read which backend a URL will reach, and tell a routing mistake from a missing controller.
  6. Ingress TLS: When The Padlock Lies (3 labs): You can put a certificate in front of an Ingress with a TLS Secret, check that a certificate covers the host and matches its key, and find why a controller serves its fake default certificate.
  7. Verify Binaries: A Hash With No Name (3 labs): You can check a Kubernetes binary against the release's published sha512, find and remove files that do not match, and read who signed a release artefact from its keyless certificate.

Cluster Hardening

  1. RBAC: From Everything To Exactly Enough (1 lab): You can read who may do what with auth can-i, spot an over-broad role, and replace it with namespaced roles and bindings that grant exactly the verbs a task lists.
  2. RBAC: Find The Path To Cluster Admin (3 labs): You can find who holds cluster-admin, test escalation paths (create pods, bind, escalate, impersonate, tokens) with kubectl auth can-i, and cut a role down to the verbs a workload needs.
  3. ServiceAccounts And Tokens (2 labs): You can give a workload its own service account, bind it a least-privilege role, set it in the pod template, test it with impersonation, turn off token mounting, and issue a short-lived token on demand.
  4. ServiceAccounts: Take Back The Key (3 labs): You can stop pods from mounting API tokens they do not need, at the ServiceAccount or the pod, and issue short-lived, audience-bound tokens with kubectl create token instead of stored token Secrets.
  5. Authentication, Authorisation And Admission (2 labs): You can place a refusal at authentication, authorisation or admission, grant least privilege with Roles, ClusterRoles and bindings to users, groups and service accounts, and set Pod Security levels per namespace.
  6. Anonymous Access: The Fix That Kills The API Server (4 labs): You can trace a request through authentication, authorisation and admission, tell a 401 from a 403, and restrict anonymous access to the health paths with an AuthenticationConfiguration without breaking the API server's probes.
  7. Upgrades In The Only Order That Works (2 labs): You can upgrade a kubeadm cluster one minor version at a time in the right order, keep every component inside the version skew policy while you do it, and renew certificates with kubeadm when a task asks.
  8. Upgrading For CVEs: Read The Feed, Then Patch (3 labs): You can query the official Kubernetes CVE feed for your minor version, decide which entries apply to your cluster, and plan a patch upgrade in an order the version skew policy allows.

System Hardening

  1. The Host Footprint: Six Doors On A Worker (3 labs): You can read a node's listening sockets, services, packages, login accounts and process users, judge what is outside the node's job, and close it with systemctl, apt and userdel.
  2. Network Exposure: NodePorts, Host Firewalls And Egress (3 labs): You can find Services exposed on node ports and narrow them to ClusterIP, place a host firewall rule where kube-proxy cannot bypass it, and restrict a namespace's egress to DNS and named destinations.
  3. Seccomp: Which Syscalls A Container May Make (5 labs): You can choose between Unconfined, RuntimeDefault and Localhost seccomp profiles, read and check a profile's rules, require profiles with Pod Security, and fix a pod waiting for a missing Localhost profile on a real node.
  4. AppArmor: The Guard Docker Desktop Does Not Have (3 labs): You can write and check an AppArmor profile, load it on a node with apparmor_parser, point a pod at it with appArmorProfile, and know why it cannot be self-graded on Docker Desktop and where to practise it instead.

Minimize Microservice Vulnerabilities

  1. SecurityContexts And Capabilities (2 labs): You can set pod- and container-level security contexts, predict which level wins, harden a container to the restricted standard with non-root, no escalation, dropped capabilities and seccomp, and patch it without leaving old capabilities behind.
  2. Pod Security Admission: Created, Never Started (3 labs): You can choose a Pod Security Standard level and mode with namespace labels, predict which pods are refused or warned, find a workload's silent FailedCreate refusal, and raise a namespace to restricted without breaking a rollout.
  3. Encryption At Rest: What etcd Really Holds (4 labs): You can read how etcd stores a Secret, write and check an EncryptionConfiguration, wire it into the API server, rewrite existing Secrets so they are encrypted, and prove it from etcd.
  4. Secrets In Use: Leaks Through Env, Specs And Images (3 labs): You can find Secrets that leak through literal pod spec values, ConfigMaps, image layers and environment variables, move a value into a Secret mounted as a file, and choose between CSI-mounted and synced external secrets.
  5. Sandboxed Pods: RuntimeClass And gVisor (4 labs): You can explain why sandboxed runtimes reduce shared-kernel risk, create a RuntimeClass for a node's handler, run a pod under it, decide which workloads need a sandbox, and prove a pod is sandboxed on a real node.
  6. Encrypting Pod-to-Pod Traffic: mTLS With Istio And Cilium (3 labs): You can explain why traffic between pods is plain text by default, enforce mutual TLS with Istio's PeerAuthentication, predict which flows are encrypted, refused or plain, and switch on and verify Cilium's WireGuard encryption.

Supply Chain Security

  1. Minimal Base Images: Less To Attack (3 labs): You can compare base images by size, packages and findings from real scans, explain why distroless removes attack surface, lint a Dockerfile with hadolint, and build a minimal, digest-pinned, non-root image in two stages.
  2. SBOMs: Knowing What You Ship (3 labs): You can explain what an SBOM records in SPDX and CycloneDX, compare two tools' SBOMs of one image, query an SBOM for the packages an advisory names, and scan an SBOM instead of the image.
  3. Scan Reports: Triage, Gates And Cleanup (3 labs): You can triage a real vulnerability report by severity, status and package, use Trivy's flags to gate a build on fixable findings, and remove the pods whose images have critical findings from a namespace.
  4. Allowed Registries: Admission That Refuses Images (4 labs): You can restrict the registries a namespace may pull from with a ValidatingAdmissionPolicy and its binding, find and close the init container gap, read where a refusal shows up, and configure ImagePolicyWebhook to fail closed.
  5. Signing And Verifying Images With Cosign (3 labs): You can explain why tags cannot be trusted, sign an image by digest and verify it with a key pair, verify Kubernetes' keyless release signatures by identity and issuer, and admit only verified, digest-pinned images.
  6. Static Analysis: kubesec And KubeLinter (3 labs): You can run kubesec and KubeLinter on manifests, compare their findings, recognise rules that lag the API, and write field checks of your own that find the same risks.

Monitoring, Logging And Runtime Security

  1. Audit Policy: Choosing What The Cluster Remembers (4 labs): You can explain the four audit levels, design a policy whose rule order keeps the right events, predict the level of a request, wire auditing into the API server and verify what it writes.
  2. Falco: Detecting What Happens Inside Containers (4 labs): You can explain what Falco sees that the audit log cannot, read real alerts, write a Falco rule with valid fields, validate it before loading, and prove on a real node that it fires.
  3. Investigating An Attack: One Timeline, Two Logs (3 labs): You can merge audit events and Falco alerts into one timeline, label each step with its attack phase, answer who, what and when from the audit log, and contain an incident while keeping the evidence.
  4. Immutable Containers: Read-Only At Runtime (3 labs): You can make a container immutable with a read-only root filesystem and emptyDir mounts where it must write, find and remove pods that are not immutable, and explain why a privileged container never is.
  5. Detection Review: Which Signal Catches It? (3 labs): You can match a security event to the layer and tool that detects it, measure the noise in a real audit window, write a precise allowlist, and review what remains.

Mock Exam And Review

  1. Mock Exam: Seventeen Security Tasks Against The Clock (2 labs): You can complete seventeen CKS-style tasks under exam time, eight on the simulated cluster and nine on a real kind cluster, using one routine for control plane edits, and turn every miss into a study plan.
  2. Final Review: The Cluster You Would Defend (2 labs): You can map every step of a real attack to the control and lesson that prevents or detects it, plan your final study by exam weight, and walk into the exam with a routine for the day.

Certification courses