LevelUpWith

Explore / Exam Prep for the Certified Kubernetes Security Specialist (CKS) / Lesson 1

Lesson 1: CKS Exam Terms, Ground Rules and Your Labs

[Exam orientation] Covers the exam terms: you must pass the CKA first; the exam is 2 hours of 15 to 20 command-line tasks on Kubernetes v1.37 with a 67% pass mark, one retake and two simulator sessions, and the certificate is valid for two years. It also explains that the curriculum is CNCF's (CC BY 4.0), that this course is independent of and not endorsed by the Linux Foundation or CNCF, that the knowledge checks are original practice scenarios rather than real exam questions and no substitute for hands-on practice, that no pass is promised, and then you build a kind cluster plus kubeadm VMs for node, audit and AppArmor work.

Free to read, no account needed. Part of Exam Prep for the Certified Kubernetes Security Specialist (CKS).

By the end of this level you'll be able to

  • Explain the CKS prerequisite, format, duration, 67% pass mark, retake, simulator and two-year validity rules, and the six curriculum domains with their weights
  • Build a multi-node kind cluster with a CNI that enforces NetworkPolicy, plus a kubeadm VM cluster for host-level tasks
  • Find pages fast in the allowed documentation (kubernetes.io, Falco, bom, etcd, ingress-nginx, Cilium, Istio) during a timed task

Before You Start: The Ground Rules

You already know Kubernetes from the CKA. The CKS tests something different: whether you can find and fix security weaknesses at the command line, against the clock. This level sets the rules, builds your labs, and has you practise the most underrated exam skill there is: finding the right documentation page fast.

Disclaimers (read these first):

  • The curriculum outline used here is published by the Cloud Native Computing Foundation (CNCF) under the CC BY 4.0 licence.
  • This course is independent. The Linux Foundation and CNCF have not endorsed it and are not connected to it.
  • The knowledge checks are original practice scenarios. They are not real exam questions, and they are no substitute for hands-on practice.
  • No course can promise you a pass, and this one doesn't. What gets you through is the practice you put in.

Task 1: Know the Exam Terms

  1. Prerequisite: you must have taken and passed the CKA before you attempt the CKS.
  2. Format: 15 to 20 performance-based tasks in a live terminal. You do the work; you don't pick answers.
  3. Duration: 2 hours.
  4. Version: Kubernetes v1.37.
  5. Pass mark: 67%. The CKA's pass mark is 66%, so don't mix the two up.
  6. Retake: one free retake is included, giving you two attempts within the 12-month eligibility window.
  7. Simulator: two simulator sessions, each with 36 hours of access and its own set of graded questions. Save them for when you have covered the whole curriculum.
  8. Validity: the certification lasts two years.

DO: Write these eight facts on one card. If you can't state them from memory, go over them again.

Task 2: Map the Six Domains (Curriculum v1.37)

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%

Three domains at 20% make up 60% of the marks. Plan your revision time to match those weights.

Task 3: Build a Multi-Node kind Cluster with Cilium

You'll use kind for most workload-level tasks. Recent kind releases (v0.24.0 and later) include basic NetworkPolicy support in the default kindnetd CNI. This course installs Cilium instead, because later domains need Cilium features such as Pod-to-Pod encryption, and docs.cilium.io is one of the allowed documentation sites.

  1. Create kind-cks.yaml:
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
networking:
  disableDefaultCNI: true
  1. Create the cluster on a v1.37 node image:
kind create cluster --name cks --config kind-cks.yaml --image kindest/node:v1.37.0
kubectl get nodes   # NotReady is expected: there is no CNI yet
  1. Install Cilium with Helm. Check docs.cilium.io for the current chart version.
helm repo add cilium https://helm.cilium.io/
helm install cilium cilium/cilium --namespace kube-system \
  --set image.pullPolicy=IfNotPresent --set ipam.mode=kubernetes
kubectl -n kube-system rollout status ds/cilium
kubectl get nodes   # all nodes should now be Ready

DO: Confirm all three nodes show Ready before you move on.

Task 4: Build a kubeadm VM Cluster for Host-Level Work

kind nodes are containers. Some tasks need a real host: editing kube-apiserver flags for audit logging, loading AppArmor profiles, running kube-bench against node files. For those, build two Ubuntu VMs: one control plane with at least 2 CPUs and 2 GB RAM, and one worker.

  1. On both VMs, disable swap (sudo swapoff -a, then remove it from /etc/fstab) and install containerd.
  2. Add the v1.37 package repository:
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.37/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.37/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update && sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable --now kubelet
  1. On the control plane, run sudo kubeadm init, then copy /etc/kubernetes/admin.conf to ~/.kube/config.
  2. On the worker, run the kubeadm join command that init printed.
  3. Install Cilium as in Task 3 and check that both nodes are Ready.
  4. Take a VM snapshot. You'll break this cluster on purpose in later levels.

Task 5: Navigate the Allowed Documentation

In the exam you may open only these sites:

  • kubernetes.io/docs and kubernetes.io/blog
  • falco.org/docs
  • The bom CLI reference: kubernetes-sigs.github.io/bom/cli-reference/
  • etcd.io/docs
  • The ingress-nginx configuration documentation
  • docs.cilium.io
  • istio.io/latest/docs

You can use each site's own search box, but you must not open external search results.

Speed tips:

  1. Search by the YAML kind or field name, for example NetworkPolicy or auditPolicy, rather than by a vague phrase.
  2. Copy the YAML from the page, then trim it. Don't type manifests from memory.
  3. Learn the URL paths you'll use often, such as kubernetes.io/docs/concepts/security/.

Timed Practice Task (5 minutes)

Using only the allowed sites, find:

  1. A NetworkPolicy example manifest.
  2. The page describing Kubernetes auditing.
  3. Falco's documentation on rules.

Solution:

  1. On kubernetes.io, search "Network Policies". The concepts page (/docs/concepts/services-networking/network-policies/) has a full example.
  2. On kubernetes.io, search "Auditing". It's at /docs/tasks/debug/debug-cluster/audit/.
  3. On falco.org/docs, open the Rules section from the navigation menu.

If it took you longer than 5 minutes, repeat the drill tomorrow.

What the Exam Asks About This

None of these facts is tested directly. But every task assumes you can switch contexts, work on the right cluster, and pull correct YAML from the allowed docs in under a minute. That speed decides whether you get through 15 to 20 tasks in 2 hours.

Key Takeaways

  • You must pass the CKA first. The CKS is 2 hours of 15 to 20 terminal tasks on v1.37, with a 67% pass mark, one retake, two simulator sessions, and a certificate valid for two years.
  • Domain weights: 15 / 15 / 10 / 20 / 20 / 20. The three 20% domains make up 60% of the marks.
  • kind with disableDefaultCNI: true plus Cilium gives you a fast lab where NetworkPolicy is enforced.
  • kubeadm VMs cover host-level work: audit logs, AppArmor, kube-bench.
  • Only the allowed documentation sites may be opened in the exam. Practise searching them.
  • This course is independent, and its checks are practice scenarios, not exam questions.

A 6-question knowledge check follows this lesson in the app, free and without an account.

More like this