LevelUpWith

Explore / Cloud & Compute

Exam Prep for the Certified Kubernetes Security Specialist (CKS)

Harden Kubernetes clusters, nodes, workloads and the software supply chain, and catch threats at runtime, working at the command line against the CNCF CKS curriculum v1.37. Every lesson is a timed terminal task with a worked solution, ending in a full mock exam. Independent of the Linux Foundation.

Read lesson 1 free →Try 10 practice questions free →

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed.

Photographic 3D course artwork for Exam Prep for the Certified Kubernetes Security Specialist (CKS)

Expert · 42 levels · 4 free · Created Nov 2026 · Professionally curated by levelupwith.com

What's inside

  1. Level 1: CKS Exam Terms, Ground Rules and Your LabsFree
    [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.
    • 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
  2. Level 2: Network Policies: Default Deny and Allow RulesFree
    [Cluster Setup] Shows how unrestricted pod-to-pod traffic lets an attacker move sideways, then uses Network security policies to restrict cluster level access by applying a default-deny policy and allowing only named ingress flows by podSelector, namespaceSelector and port.
    • Write default-deny ingress and egress NetworkPolicies for a namespace
    • Allow only specific pod-to-pod and namespace-to-namespace ingress on named ports
    • Prove a policy works with test pods and kubectl exec within a timed practice task
  3. Level 3: Egress Policies and Protecting Node Metadata
    [Cluster Setup] Uses egress NetworkPolicies with ipBlock and except, plus DNS allowances, to protect node metadata and endpoints by stopping pods from reaching the cloud metadata service at 169.254.169.254 and other node addresses.
    • Write egress policies that allow DNS and approved CIDRs while blocking 169.254.169.254
    • Explain how a stolen metadata credential leads to a cloud account takeover and which pods to restrict
    • Check metadata blocking from inside a pod in a timed practice task
  4. Level 4: CIS Benchmark with kube-bench: kubeapi and etcd
    [Cluster Setup] Uses the CIS benchmark to review the security configuration of Kubernetes components by running kube-bench against the control plane, then fixes failed checks for kubeapi (kube-apiserver) flags and etcd TLS and file permissions in the static Pod manifests.
    • Run kube-bench for master/control-plane targets and read its FAIL, WARN and remediation output
    • Fix kube-apiserver and etcd findings by editing static Pod manifests and confirm the components restart healthy
    • Re-run kube-bench to confirm the fixes within a timed practice task
  5. Level 5: CIS Benchmark with kube-bench: kubelet and kubedns
    [Cluster Setup] Continues the CIS benchmark review on worker nodes, hardening the kubelet config file (anonymous auth off, Webhook authorization, read-only port 0, client CA) to protect node endpoints, and reviewing the kubedns (CoreDNS) deployment's configuration and privileges.
    • Run kube-bench node checks and fix kubelet findings in /var/lib/kubelet/config.yaml, then restart the kubelet
    • Confirm that anonymous and read-only kubelet endpoints on ports 10250/10255 are closed
    • Review CoreDNS's Deployment, ConfigMap and RBAC against benchmark guidance
  6. Level 6: Properly Set Up Ingress Objects with TLS
    [Cluster Setup] Shows how to properly set up Ingress objects with TLS: create a kubernetes.io/tls Secret, reference it in the Ingress tls section, and force HTTPS redirects using ingress-nginx annotations.
    • Create a TLS Secret from a certificate and key and attach it to an Ingress host
    • Configure ingress-nginx to redirect HTTP to HTTPS and confirm with curl -kv
    • Fix a broken TLS Ingress within a timed practice task
  7. Level 7: Verify Platform Binaries Before Deploying
    [Cluster Setup] Explains the risk of tampered Kubernetes binaries and how to verify platform binaries before deploying by comparing kubelet, kubeadm, kubectl and kube-apiserver binaries with the published SHA512 checksums for the release.
    • Download the official checksum for a Kubernetes v1.37 binary and verify it with sha512sum
    • Find which binary on a node, or inside a running container image, has been altered
    • Replace a tampered binary safely within a timed practice task
  8. Level 8: RBAC: Least-Privilege Roles and RoleBindings
    [Cluster Hardening] Uses Role Based Access Controls to minimize exposure, building namespaced Roles and RoleBindings with only the verbs and resources a subject needs and checking them with kubectl auth can-i.
    • Create Roles and RoleBindings imperatively and in YAML with exact verbs and resources
    • Audit a user's or group's effective rights with kubectl auth can-i --list and --as
    • Narrow an over-broad Role within a timed practice task
  9. Level 9: RBAC: ClusterRoles and Privilege Escalation Risks
    [Cluster Hardening] Extends Role Based Access Controls to ClusterRoles and ClusterRoleBindings, and covers dangerous grants (wildcards, secrets get/list, pods/exec, bind, escalate, impersonate, nodes/proxy) that lead to privilege escalation.
    • Choose correctly between ClusterRole with RoleBinding and ClusterRole with ClusterRoleBinding
    • Find bindings that grant wildcard or escalation verbs and remove them
    • Replace a cluster-admin binding with a least-privilege ClusterRole in a timed practice task
  10. Level 10: Service Accounts: Disable the Defaults
    [Cluster Hardening] Exercises caution in using service accounts by explaining how a compromised pod uses its mounted token, then disabling automountServiceAccountToken on the default ServiceAccount and on Pods that do not need API access.
    • Turn off token automounting on ServiceAccounts and in Pod specs, and know which setting wins
    • Show from inside a pod whether a token is mounted and what it can do
    • Move workloads off the default ServiceAccount in a timed practice task
  11. Level 11: Service Accounts: Minimize Permissions and Tokens
    [Cluster Hardening] Minimizes permissions on newly created service accounts with dedicated ServiceAccounts, narrow RoleBindings, short-lived bound tokens from kubectl create token, and cleanup of legacy long-lived Secret-based tokens.
    • Create a dedicated ServiceAccount bound only to the access its workload needs
    • Issue time-limited tokens with kubectl create token and explain projected token volumes
    • Find and remove long-lived service-account token Secrets
  12. Level 12: Restrict Access to the Kubernetes API
    [Cluster Hardening] Shows how to restrict access to the Kubernetes API with kube-apiserver settings (anonymous-auth=false, authorization-mode Node,RBAC, NodeRestriction admission plugin), network exposure limits, and managing user certificates through CertificateSigningRequests.
    • Harden kube-apiserver authentication, authorization and admission flags safely in the static Pod manifest
    • Issue and approve a user certificate via a CSR and build a kubeconfig for it
    • Check that anonymous and unauthorized requests are refused, using curl against the API server
  13. Level 13: Upgrade Kubernetes to Avoid Vulnerabilities
    [Cluster Hardening] Explains why you upgrade Kubernetes to avoid vulnerabilities (supported versions and CVE fixes) and runs a kubeadm upgrade of the control plane and then the workers, one minor version at a time with drain and uncordon.
    • Plan and apply a kubeadm control-plane upgrade with kubeadm upgrade plan and apply
    • Upgrade kubelet and kubectl on a worker with drain, package update and uncordon
    • Finish a one-minor-version upgrade within a timed practice task
  14. Level 14: Minimize Host OS Footprint and External Access
    [System Hardening] Shows how to minimize the host OS footprint to reduce attack surface by removing unneeded packages, services and kernel modules, and how to minimize external access to the network by finding listening ports and closing them with a host firewall.
    • Find and disable unnecessary services and packages with systemctl and apt
    • Find listening processes with ss or netstat and close ports with ufw or iptables
    • Blacklist unneeded kernel modules and confirm the reduced attack surface on a VM
  15. Level 15: Least-Privilege Identity and Access Management
    [System Hardening] Applies least-privilege identity and access management to nodes: OS users, groups and sudo rights, SSH key-only access, non-root container users, and narrow cloud IAM roles for node instances.
    • Remove excess OS users, sudo rights and shells on a node and enforce SSH key-only login
    • Explain why node instance IAM roles must be minimal and how pods inherit them through metadata
    • Set runAsUser and runAsGroup so containers do not run as root on the host
  16. Level 16: Kernel Hardening with AppArmor
    [System Hardening] Appropriately uses AppArmor as a kernel hardening tool: load a profile with apparmor_parser on every node, check it with aa-status, and apply it to containers through the securityContext appArmorProfile field.
    • Load and check AppArmor profiles in enforce mode on a worker node
    • Apply a Localhost AppArmor profile to a Pod or container via securityContext
    • Fix a Pod that will not start because its AppArmor profile is missing, in a timed practice task
  17. Level 17: Kernel Hardening with seccomp
    [System Hardening] Appropriately uses seccomp as a kernel hardening tool by applying RuntimeDefault and custom Localhost profiles from the kubelet seccomp directory through securityContext seccompProfile, to limit the syscalls a container can make.
    • Apply RuntimeDefault seccomp to Pods and explain its effect
    • Place a custom profile under /var/lib/kubelet/seccomp and reference it as Localhost
    • Find and fix seccomp-related Pod start failures in a timed practice task
  18. Level 18: Pod Security Standards with Pod Security Admission
    [Minimize Microservice Vulnerabilities] Shows how to use appropriate pod security standards (Privileged, Baseline, Restricted) by labelling namespaces with Pod Security Admission enforce, audit and warn modes and pinned versions.
    • Label namespaces to enforce, audit or warn at a chosen Pod Security Standard level
    • Predict which Pod specs each level rejects, and read the admission warnings
    • Roll out Restricted safely with a dry-run server-side label check
  19. Level 19: Making Workloads Pass the Restricted Standard
    [Minimize Microservice Vulnerabilities] Completes the pod security standards work by rewriting failing Pods to meet Restricted: runAsNonRoot, allowPrivilegeEscalation false, drop ALL capabilities, no hostPath, hostNetwork or hostPID, and a seccomp profile.
    • Write a securityContext that passes the Restricted Pod Security Standard
    • Explain the risks of privileged, hostPID, hostNetwork and hostPath settings
    • Fix a Deployment rejected by Pod Security Admission within a timed practice task
  20. Level 20: Manage Kubernetes Secrets Safely
    [Minimize Microservice Vulnerabilities] Shows how to manage Kubernetes secrets by explaining that base64 is not encryption, choosing volume mounts over environment variables, limiting Secret access with RBAC, and reading a Secret directly from etcd with etcdctl to show the exposure.
    • Create Secrets and use them as read-only volume mounts rather than environment variables
    • Restrict who can get or list Secrets, and find over-broad Secret access
    • Read a Secret's stored value from etcd with etcdctl and certificates to show it is unencrypted by default
  21. Level 21: Encrypting Secrets at Rest in etcd
    [Minimize Microservice Vulnerabilities] Serves 'Manage kubernetes secrets': the learner writes an EncryptionConfiguration, connects it to kube-apiserver with --encryption-provider-config, checks the stored data in etcd with etcdctl, and re-encrypts existing Secrets, ending with a timed practice task and its solution.
    • Write an EncryptionConfiguration with an aescbc or aesgcm provider ahead of identity, mount it into the kube-apiserver static Pod and confirm the API server restarts cleanly
    • Use etcdctl get on /registry/secrets/... to prove a Secret is stored encrypted rather than in plain text
    • Re-encrypt every existing Secret with kubectl get secrets -A -o json | kubectl replace -f - and verify the result inside a timed task
  22. Level 22: Multi-Tenancy Isolation with Namespaces
    [Minimize Microservice Vulnerabilities] Serves 'Understand and implement isolation techniques (multi-tenancy …)': the learner builds a tenant boundary from a namespace, its own RBAC, a default-deny policy, ResourceQuota and LimitRange, and enforced Pod Security Admission labels, ending with a timed practice task.
    • Provision a tenant namespace with namespace-scoped RBAC, default-deny ingress and egress NetworkPolicies, a ResourceQuota and a LimitRange in one pass
    • Use kubectl auth can-i --as and test Pods to prove one tenant cannot reach or change another tenant's workloads
    • Explain what namespace-based soft multi-tenancy cannot isolate (the shared kernel, cluster-scoped resources) and when sandboxing is needed
  23. Level 23: Sandboxed Containers with gVisor and RuntimeClass
    [Minimize Microservice Vulnerabilities] Serves 'Understand and implement isolation techniques (… sandboxed containers)': the learner sets up the gVisor runsc handler in containerd on a real node, creates a RuntimeClass and runs workloads in the sandbox, ending with a timed practice task.
    • Create a RuntimeClass whose handler matches the containerd runsc runtime, and schedule Pods onto it with spec.runtimeClassName
    • Show a Pod is sandboxed by comparing dmesg and uname output inside the Pod with the host's
    • Fix the usual failures (wrong handler name, runtime missing on the node) from Pod events within a time limit
  24. Level 24: Pod-to-Pod Encryption with Cilium
    [Minimize Microservice Vulnerabilities] Serves 'Implement Pod-to-Pod encryption (Cilium …)': the learner turns on Cilium transparent encryption (WireGuard or IPsec) in a kind cluster and confirms that traffic between nodes is encrypted, ending with a timed practice task.
    • Install or reconfigure Cilium with transparent encryption enabled, using the Cilium documentation
    • Check encryption status with the cilium CLI or the agent's status output, and confirm traffic is encrypted on the wire
    • Contrast Cilium's node-level transparent encryption with service-mesh mTLS when choosing between them in a scenario
  25. Level 25: Pod-to-Pod mTLS with Istio PeerAuthentication
    [Minimize Microservice Vulnerabilities] Serves 'Implement Pod-to-Pod encryption (… Istio)': the learner turns on sidecar injection for a namespace and enforces mutual TLS with a STRICT PeerAuthentication, then proves that plain-text clients are refused, ending with a timed practice task.
    • Label a namespace for Istio sidecar injection and restart its workloads so they receive the proxy
    • Apply PeerAuthentication in PERMISSIVE and then STRICT mode at mesh, namespace or workload scope
    • Show that a Pod without a sidecar can no longer reach a STRICT workload while meshed Pods still can
  26. Level 26: Minimizing Base Image Footprint
    [Supply Chain Security] Serves 'Minimize base image footprint': the learner rewrites a bloated Dockerfile using multi-stage builds, distroless or scratch bases, a non-root USER and a pinned digest, then measures how much smaller the image and its attack surface are, ending with a timed practice task.
    • Turn a single-stage Dockerfile into a multi-stage build whose final stage is a distroless or scratch image
    • Remove shells, package managers and build tools from the runtime image, and pin the base image by digest rather than a mutable tag
    • Compare image size and package count before and after hardening
  27. Level 27: Understanding Your Supply Chain: CI/CD and Registries
    [Supply Chain Security] Serves 'Understand your supply chain (e.g. … CI/CD, artifact repositories)': the learner follows an image from source through the CI/CD pipeline to the artifact repository and into the cluster, and identifies where each stage can be tampered with.
    • Map the stages of a container supply chain (source, build, artifact repository, deploy) and name a control for each stage
    • Explain why image digests, not tags, identify an artifact, and find the digest a running Pod actually uses with kubectl and crictl
    • Choose the best control for a supply chain attack scenario in a scenario-style question
  28. Level 28: Generating and Reading SBOMs with bom
    [Supply Chain Security] Serves 'Understand your supply chain (e.g. SBOM …)': the learner uses the Kubernetes SIG Release tool bom to produce SPDX software bills of materials for images and directories, then examines them to answer questions about what an artifact contains, ending with a timed practice task.
    • Run bom generate against a container image and a source directory, and write SPDX output to a file
    • Use bom document outline, or search the SPDX file, to find a package and its version inside an SBOM
    • Describe how an SBOM supports vulnerability response and checks on provenance
  29. Level 29: Scanning Images for Vulnerabilities with Trivy
    [Supply Chain Security] Serves 'Perform static analysis of … container images': the learner scans images and SBOMs with Trivy, filters the results by severity, and finds and replaces the workloads running vulnerable images, ending with a timed practice task.
    • Run trivy image with --severity HIGH,CRITICAL and read the findings by package, CVE and fixed version
    • List the images running in a namespace, scan each one, and scale down or delete the workloads that use vulnerable images
    • Scan an SBOM with Trivy instead of pulling the image
  30. Level 30: Permitted Registries with ImagePolicyWebhook
    [Supply Chain Security] Serves 'Secure your supply chain (permitted registries …)': the learner turns on the ImagePolicyWebhook admission plugin on kube-apiserver with an AdmissionConfiguration and a kubeconfig for the webhook backend, and sets fail-closed behaviour, ending with a timed practice task.
    • Add ImagePolicyWebhook to --enable-admission-plugins and point --admission-control-config-file at a correct AdmissionConfiguration
    • Set up the webhook kubeconfig, the TTLs and defaultAllow: false, mounting every file into the static Pod
    • Show that Pods using images from registries outside the allowed list are rejected, and recover a broken API server from its container logs
  31. Level 31: Permitted Registries with ValidatingAdmissionPolicy
    [Supply Chain Security] Serves 'Secure your supply chain (permitted registries …)': the learner enforces an allowed-registry rule inside the cluster using a ValidatingAdmissionPolicy written in CEL and a ValidatingAdmissionPolicyBinding, with no external webhook, ending with a timed practice task.
    • Write a CEL expression that requires every container and initContainer image to start with an approved registry prefix
    • Bind the policy to selected namespaces with validationActions such as Deny, and check it by trying to create Pods that break the rule
    • Compare in-cluster CEL policies with ImagePolicyWebhook for a given scenario
  32. Level 32: Signing and Validating Artifacts with cosign
    [Supply Chain Security] Serves 'Secure your supply chain (… sign and validate artifacts)': the learner creates a key pair with cosign, signs an image by digest in a local registry, verifies the signature, and attaches and verifies an SBOM attestation, ending with a timed practice task.
    • Run cosign generate-key-pair, then cosign sign --key on an image digest pushed to a local registry
    • Run cosign verify --key to accept a correctly signed image and reject an unsigned or tampered one
    • Attach an SBOM as an attestation and verify it, linking signing to the bom output from level 28
  33. Level 33: Static Analysis of Workloads: Kubesec and KubeLinter
    [Supply Chain Security] Serves 'Perform static analysis of user workloads … (e.g. Kubesec, KubeLinter)': the learner scans Kubernetes manifests with kubesec scan and kube-linter lint, reads their scores and findings, and fixes the manifests until they pass, ending with a timed practice task.
    • Run kubesec scan on a Deployment, read its score and the critical and advisory items, and fix the YAML to improve the score
    • Run kube-linter lint on a directory of manifests and fix findings such as run-as-non-root, no-read-only-root-fs and unset resources
    • Spot insecure instructions in a Dockerfile, such as root USER, ADD from URLs and secrets in ENV, by reading it manually
  34. Level 34: Behavioral Analytics with Falco: Install and Read Alerts
    [Monitoring, Logging and Runtime Security] Serves 'Perform behavioral analytics to detect malicious activities': the learner installs Falco on a real node, sets off its default rules with typical malicious behaviour, and reads alerts from the journal or the log output, ending with a timed practice task.
    • Install Falco on a VM node, find its configuration and rules files, and confirm the service is running
    • Set off default rules (a shell in a container, reads of sensitive files) and read the resulting alerts with journalctl or the configured outputs
    • Explain how syscall-based behavioral detection differs from static scanning
  35. Level 35: Writing and Tuning Falco Rules
    [Monitoring, Logging and Runtime Security] Serves 'Perform behavioral analytics to detect malicious activities': the learner writes and overrides Falco rules in the local rules file using conditions, macros, lists, output fields and priorities, as exam tasks require, ending with a timed practice task.
    • Write a custom rule with a condition, an output that includes container and process fields, and a priority
    • Override or append to a default rule in falco_rules.local.yaml without editing the upstream file, then reload Falco
    • Change the output format to a required field layout and send alerts to a file, using the Falco documentation
  36. Level 36: Detecting Threats Across Infrastructure and Workloads
    [Monitoring, Logging and Runtime Security] Serves 'Detect threats within physical infrastructure, apps, networks, data, users and workloads': the learner links Falco alerts to crictl, kubectl and host evidence to find which container, Pod, user or network action caused a detection, ending with a timed practice task.
    • Trace a Falco alert's container ID to its Pod and namespace with crictl inspect and kubectl
    • Classify detections by domain (host, app, network, data, user, workload) and choose the right evidence source for each
    • Contain an offending workload by scaling it to zero or isolating it with a NetworkPolicy, while keeping the evidence
  37. Level 37: Phases of Attack and Bad Actors
    [Monitoring, Logging and Runtime Security] Serves 'Investigate and identify phases of attack and bad actors within the environment': the learner follows a staged compromise from initial access through execution, persistence, privilege escalation and lateral movement, and names the bad actor and the phase from the evidence, ending with a timed practice task.
    • Map observed events to attack phases using a Kubernetes threat-matrix approach
    • Use Falco alerts, process listings and Pod specs to find the compromised workload and the identity it used
    • Choose the best response for each phase in scenario-style questions
  38. Level 38: Ensuring Immutability of Containers at Runtime
    [Monitoring, Logging and Runtime Security] Serves 'Ensure immutability of containers at runtime': the learner makes containers immutable with readOnlyRootFilesystem, emptyDir volumes for writable paths, non-root users and no privilege escalation, and finds and replaces mutable workloads, ending with a timed practice task.
    • Set readOnlyRootFilesystem: true and add emptyDir mounts only for the paths the app must write to, keeping it running
    • Audit a namespace for privileged, root or writable-root Pods with kubectl and jq, and redeploy them as immutable
    • Show that writes and installed tools do not survive inside an immutable container
  39. Level 39: Configuring Kubernetes Audit Logging
    [Monitoring, Logging and Runtime Security] Serves 'Use Kubernetes audit logs to monitor access': the learner writes an audit Policy with None, Metadata, Request and RequestResponse rules, and enables it on kube-apiserver with the log path, retention flags and volume mounts, ending with a timed practice task.
    • Write an audit policy whose rules are in the right order, for example Secrets at Metadata, chosen resources at RequestResponse, and everything else excluded
    • Set --audit-policy-file, --audit-log-path, --audit-log-maxage, --audit-log-maxbackup and --audit-log-maxsize, plus hostPath mounts, in the static Pod
    • Recover a kube-apiserver that will not start after an audit change, using crictl and the kubelet logs
  40. Level 40: Investigating Access with Audit Logs
    [Monitoring, Logging and Runtime Security] Serves 'Use Kubernetes audit logs to monitor access': the learner searches audit log JSON with jq to find who read, created or deleted sensitive resources, from which source IP and with what result, and ties the findings to an RBAC fix, ending with a timed practice task.
    • Filter audit events by user.username, verb, objectRef.resource and responseStatus.code with jq
    • Find which service account or user accessed Secrets and remove the excess permission with RBAC
    • Combine audit log and Falco evidence to rebuild an incident timeline
  41. Level 41: Exam-Craft Drill: Docs Lookup, Speed and Triage
    [Exam craft, all six CKS curriculum domains] A timed drill that rehearses how to work through 15 to 20 terminal tasks in 2 hours: switching context on every task, finding YAML quickly in the allowed docs (kubernetes.io, Falco, bom, etcd, ingress-nginx, Cilium, Istio), checking each fix, and triaging tasks by their weight and the time they cost; it reminds the learner that original practice checks do not replace hands-on work or the two simulator sessions, and that no course can promise a pass.
    • Set kubectl context and namespace correctly at the start of every task, and use aliases, kubectl explain, --dry-run=client -o yaml and bookmarked doc pages to finish routine YAML within the time budget
    • Triage a set of mixed-domain tasks: do the quick wins first, flag slow ones for later, and back up manifests (for example kube-apiserver.yaml) before editing static Pods
    • Check each fix the way a grader would (kubectl auth can-i, crictl, kube-bench re-runs, the Falco output, the audit log) before moving to the next task
  42. Level 42: Timed Mock Exam (50 questions, 75 minutes) Timed mock
    [All domains, weighted as in the CKS curriculum v1.37] A timed mock exam of 50 original scenario-based multiple-choice questions in 75 minutes, with a 67% pass mark, covering all six domains in proportion to their weightings: Cluster Setup, Cluster Hardening, System Hardening, Minimize Microservice Vulnerabilities, Supply Chain Security, and Monitoring, Logging and Runtime Security.
    Free 10 questions from the bank behind this course's timed mock are free to try, no account needed. Read all 10 with their answers →

Access

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Read lesson 1 free →Try 10 practice questions free →

More like this