KCSA course and practice exam: Kubernetes and Cloud Native Security Associate

This KCSA course has 37 video lessons and 92 graded labs, and its KCSA 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.

Cluster, platform and supply chain security on Kubernetes

Prepares you for KCSA: cloud native security, cluster component security, security fundamentals, threat modelling, platform security and compliance.

Intermediate · 3 hours · 37 lessons · 92 labs

KCSA exam guide

The KCSA exam (Kubernetes and Cloud Native Security Associate, by CNCF / The Linux Foundation): 90 minutes; questions: 60 multiple-choice questions (the Linux Foundation pages do not state a count; 60 is the commonly reported figure); pass mark: 75%; cost: USD 250 (includes one retake and 12 months to schedule).

  • Format: Online, proctored, multiple-choice
  • Duration: 90 minutes
  • Questions: 60 multiple-choice questions (the Linux Foundation pages do not state a count; 60 is the commonly reported figure)
  • Pass mark: 75%
  • Cost: USD 250 (includes one retake and 12 months to schedule)
  • Valid for: 2 years; passing CKS automatically renews KCSA (CARE program)
  • Delivery: Online, proctored (PSI)
  • Prerequisites: None

Exam domains and weights

  • Overview of Cloud Native Security: 14%
  • Kubernetes Cluster Component Security: 22%
  • Kubernetes Security Fundamentals: 22%
  • Kubernetes Threat Model: 16%
  • Platform Security: 16%
  • Compliance and Security Frameworks: 10%

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

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

Common questions

How long is the KCSA exam?

The KCSA exam lasts 90 minutes.

How many questions are on the KCSA exam?

60 multiple-choice questions (the Linux Foundation pages do not state a count; 60 is the commonly reported figure).

What is the KCSA passing score?

The pass mark is 75%.

How much does the KCSA exam cost?

USD 250 (includes one retake and 12 months to schedule).

Is there a free KCSA practice test?

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

Source: KCSA exam page (Linux Foundation Education) (CNCF / The Linux Foundation), checked 2026-10-03.

Who it is for

Intermediate level.

For engineers, security staff and auditors who know the basics of Kubernetes and want to recognise its security risks, the controls that stop them, and pass the KCSA exam.

What you don't need yet:

What helps:

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

Take first:

Take next:

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

KCSA is an online, proctored, multiple-choice exam: passing shows you can recognise Kubernetes security risks and the controls for them. It doesn't test hands-on skill; our graded labs have you work through real configurations in the page.

Exam objectives this course teaches

Kubernetes and Cloud Native Security Associate (KCSA)

Labs

92 labs, 92 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. One Leaked Kubeconfig: How Far Does It Go? (2 labs): You can measure what a leaked identity can reach with can-i, trace it through the four Cs, and contain it to the one namespace its job needs.
  2. Ninety Minutes, Six Domains: Where The Marks Are (3 labs): You can turn the published exam facts into a pacing plan, run three passes through the paper, and cross out options by layer, phase, scope and breadth.

Cloud Native Security Overview

  1. Seven Findings, Two Owners: The 4Cs And Shared Responsibility (2 labs): You can place a finding in one of the four Cs, say whether you or the provider owns it under self-managed and managed Kubernetes, and block pods from the cloud metadata endpoint.
  2. Same Rule, Two Kinds: Controls And Frameworks (2 labs): You can classify a control as preventive, detective or corrective, place it in a lifecycle phase, find the gaps in a control list, and roll out an admission rule as a warning before enforcing it.
  3. How Thick Is The Wall? Isolation Techniques (2 labs): You can order isolation boundaries from namespace to separate cluster, reserve nodes for one workload with a taint and a selector, and run untrusted code in a sandbox through a RuntimeClass.
  4. Pinned For Stability: Images, Registries And Code (2 labs): You can compare image bases from a real scan, explain tags versus digests and what scanners miss, and order the fixes for secrets, dependencies and Dockerfile findings in a source tree.
  5. Overview Sprint: Four Findings Before The Auditor (4 labs): You can find and fix one finding from each overview objective on a cluster, and answer eight exam-style overview questions at the exam's pace.

Cluster Component Security

  1. Eleven Months Of Yes: The API Server (2 labs): You can trace a request through authentication, authorization and admission, audit the API server's flags for the settings the exam names, and remove an anonymous binding.
  2. Open To Every Interface: Controller Manager And Scheduler (2 labs): You can say what the controller manager and scheduler hold and do, check their bind address, profiling and credential flags, and read a real CIS benchmark result for both.
  3. Copied From A Blog Post: The Kubelet (2 labs): You can audit a KubeletConfiguration for anonymous access, authorization mode and the read-only port, explain how the Node authorizer and NodeRestriction limit what one node can do, and name the node-level hardening the exam expects.
  4. A Pod That Mounts The Node: Runtime, Pods And Storage (2 labs): You can explain why the container runtime socket and host paths are node-level access, harden a pod's security context until the restricted standard admits it, and audit a cluster for pods that mount the node.
  5. A Copy Of The Backup: etcd (2 labs): You can audit etcd's TLS and client certificate settings, read an EncryptionConfiguration and say whether Secrets are encrypted, and explain why existing Secrets stay readable until they are rewritten.
  6. Port 30080 On Every Node: kube-proxy, Networking And Clients (2 labs): You can predict what a NodePort or LoadBalancer Service exposes, name kube-proxy's and the CNI's security settings, and audit kubeconfig files for credentials that cannot be revoked or servers that are not verified.
  7. Component Sprint: The Reference Build (4 labs): You can find the findings a default control plane still has, fix one component finding each on a live cluster, and answer eight exam-style component questions at the exam's pace.

Security Fundamentals

  1. Not The Admin Certificate: RBAC And ServiceAccounts (2 labs): You can describe authentication, authorization and admission, grant a ServiceAccount exactly the access it needs with a Role and RoleBinding, prove it with auth can-i and explain how pod tokens work.
  2. Who May Call Payments: Pod Networking And Policy (2 labs): You can describe the Kubernetes network model and the CNI plugin that implements it, isolate pods with a default-deny NetworkPolicy, open one path by label and port, and say what a service mesh adds.
  3. Not As Root, Not In Plain Sight: Pod Security And Secrets (2 labs): You can name the three Pod Security Standards and enforce one on a namespace, write a security context that passes restricted, handle Secrets knowing they are only encoded, and match supply-chain controls to their risks.
  4. Created, But Never Running: Pod Security Admission (2 labs): You can tell the three Pod Security Standards apart, predict which pods a namespace's enforce and warn labels admit, warn about or refuse, and explain why a Deployment can be created while none of its pods are.
  5. There Is No Users Table: Authentication (2 labs): You can name the ways the API server authenticates a request, read the user and groups out of a client certificate, inspect a ServiceAccount token's issuer, audience and lifetime, and stop pods receiving tokens they do not need.
  6. Read-Only, Except Secrets: RBAC In Depth (2 labs): You can predict RBAC answers from a role's rules, explain why list on Secrets is not read-only in any useful sense, find roles that grant wildcards, escalate, bind or impersonate, and narrow a binding without breaking the job it serves.
  7. Encoded Is Not Hidden: Secrets (2 labs): You can explain what a Secret protects and what it does not, choose between environment variables and mounted files, find credentials kept in ConfigMaps or manifests and move them into Secrets, and name the external alternatives.
  8. One Dash Too Many: Segmentation With Network Policy (2 labs): You can read a NetworkPolicy's from list correctly (one item with two selectors versus two items), predict which pods it admits, build default-deny egress that keeps DNS working, and say what network policy cannot do.
  9. Who Read The Gateway Key? Audit Logging (2 labs): You can explain audit stages and levels, find the rule order and level mistakes in an audit policy, keep Secret values out of the log, and answer who-did-what questions from a real audit log.
  10. Fundamentals Sprint: Four Findings, Eight Questions (4 labs): You can fix one finding each from Pod Security, RBAC, ServiceAccounts and network policy on a live cluster, proving each change, and answer eight exam-style fundamentals questions at the exam's pace.

Threat Model

  1. Draw The Boundaries: Trust And Data Flow (2 labs): You can draw the trust boundaries in a cluster, list the data flows that cross them, find crossings with no authentication or encryption, and check which identities reach across a namespace boundary.
  2. What Outlives The Fix: Persistence And Privilege Escalation (2 labs): You can name the Kubernetes objects that let access survive a fix and sweep a cluster for them against a git baseline, list the permissions that lead to more permissions, and show Pod Security capping what a pod-creating identity can reach.
  3. The Report That Ate The Node: Denial Of Service And Malicious Code (3 labs): You can explain how quotas, limit ranges and requests and limits prevent resource exhaustion, predict quota admission and QoS classes, and contain a workload that runs untrusted input so a compromise stays inside it.
  4. One Pod Away: Network Attackers And Sensitive Data (2 labs): You can measure what a compromised pod could reach on a flat network and cut it to an allow list, name the controls against eavesdropping and spoofing inside a cluster, and map every path to sensitive data in a namespace, closing the ones nobody needs.
  5. Threat Model Sprint: Name It, Then Stop It (4 labs): You can place a signal in the right threat category and name its control, fix one persistence, exhaustion and lateral movement finding on a live cluster, and answer eight exam-style threat model questions at the exam's pace.

Platform Security

  1. Who Built This Image? Supply Chain And Registries (3 labs): You can read an SBOM to answer whether an image is affected, verify a signature against the identity you require, and admit only images from a trusted registry pinned by digest.
  2. Four Alerts, One Incident: Observability And The Mesh (2 labs): You can say which observability signal sees which event, group runtime alerts into one incident with the controls that prevent it, and move a namespace from permissive to strict mutual TLS knowing which callers lose access.
  3. A Cluster's First Birthday: PKI And Connectivity (2 labs): You can read a cluster's PKI for issuers, expiry and names, explain why client certificates must be short lived, and protect a public name with TLS from your own CA while only the ingress controller reaches the backend.
  4. Forty Minutes Of Yes: Admission Control (2 labs): You can place a rule in the admission chain, bind one policy to warn in one environment and deny in another, and review admission webhooks for how they behave when they fail.
  5. Platform Sprint: Evidence, Order, Proof (4 labs): You can file platform evidence under the right objective, fix three platform findings in an order that keeps the service running and prove each fix, and answer eight platform questions at exam pace.

Compliance And Frameworks

  1. Which Benchmark, And Who Checked It? Compliance And Frameworks (5 labs): You can say which framework answers which question, read a CIS benchmark report including the checks a person must evidence, find gaps with STRIDE, grade a build pipeline on SLSA, and answer eight compliance questions at exam pace.

Mock And Review

  1. Forty Three Of Sixty: The Mock, And How To Read It (2 labs): You can sit a full KCSA mock under exam conditions, read the result by weighted domain, objective and reason for each miss, and turn it into a short plan of lessons to replay and traps to drill.
  2. Audit Day: Final Review (4 labs): You can tell apart the pairs of ideas the KCSA exam sets against each other, harden a whole namespace in one file and prove it across every domain, and walk into the exam knowing how the day runs.

Certification courses