Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

Prepare for the KCSA: format, domains and study plan

By updated

Improve this page

Logo Kubernetes

The KCSA (Kubernetes and Cloud Native Security Associate) is a 90-minute multiple-choice exam, online and proctored, with no terminal: it checks that you understand the threats and the security controls of a Kubernetes cluster. This page tells you what the exam asks, which lessons of the course prepare each of its six domains, and how to split four weeks of study.

It is aimed at someone who knows the basic Kubernetes objects (Pod, Deployment, Service, Secret) and wants to have their security knowledge recognized. In the certifications module, the KCSA comes right after the KCNA, but its lessons belong to level 5 of the course, the security level: the preparation relies on that level, and a profile of the course path gathers what to follow, basics included (see "What foundation do you need before starting?").

What you will learn

  • Read the exam format, with the date and source of each figure.
  • Name the six domains of the blueprint and their weights.
  • Map each domain to the lessons that teach it.
  • Tell the KCSA apart from the KCNA, the CKA and the CKS.
  • Build a four-week study plan.

What the KCSA validates

The KCSA is the "associate"-level certification devoted to security, delivered by the CNCF and the Linux Foundation. It attests that you understand the fundamentals of Kubernetes and cloud native security: the layers of a platform and the responsibility of each, the security of the cluster components, the basic controls (RBAC, Secrets, network policies, security context), how an attack progresses, platform security (images, admission, PKI, service mesh) and the compliance frameworks.

It asks for no hands-on skill: it is an MCQ, you do not touch any cluster. It is therefore neither the CKA, which administers a cluster, nor the CKS, which hardens a cluster in the command line. It is also more than a variant of the KCNA: where the KCNA only skims security, the KCSA makes it its whole subject.

Why take the KCSA?

The KCSA has a precise role in the certification path: it gives proof that you understand security, without requiring the advanced hands-on practice of the CKS. The table matches a few situations with what the exam brings you.

Your situationWhat the KCSA gives you
You already have the KCNAa security-oriented specialization, at the same associate level
You work in platform engineering or DevSecOpsa structured validation of the security fundamentals
You are aiming for the CKS in the medium terma conceptual foundation before the hands-on practice
You are an architect or a security managerproof that you understand the controls and the threats

What is the KCSA exam format?

The exam lasts 90 minutes, it is taken online under proctoring, and you need 75% of the points to pass. These values were collected on November 14, 2026: if the product page says something different when you read it, the product page prevails.

ItemValue as of November 14, 2026Source
TypeOnline MCQ, proctored, no terminalKCSA product page
Duration90 minutesKCSA product page
Number of questionsnot publishedKCSA product page
Passing score75%, the common rule of multiple-choice examsmultiple-choice exam FAQ
Price250 USDKCSA product page
Certification validity2 yearsKCSA product page
Retakeone retake includedKCSA product page
Time to take the exam after purchase12 monthsKCSA product page
PrerequisitesnoneKCSA product page
Kubernetes versionnot published: the blueprint names no versionKCSA curriculum
Documentation during the examnone, as for any multiple-choice examallowed resources

The FAQ sets 75% for the Linux Foundation multiple-choice exams without naming the KCSA: it is the common rule of this family of exams, the same as for the KCNA. The threshold lets you lose only a quarter of the points. Sacrificing one of the two 22% domains is therefore not an option: you would be left with 78% to earn, almost without a mistake.

Since documentation is forbidden, revision is about memorization and understanding, not about navigating a website. And since the blueprint names no Kubernetes version, it does not tell you which version the exam is aligned with: the course teaches 1.37, but do not assume the exam follows it.

What are the six domains of the KCSA exam?

The official CNCF blueprint splits the KCSA into six domains whose weights total 100%. Two of them are worth 44% together: the security of the cluster components and the Kubernetes security fundamentals.

DomainWeight
Overview of Cloud Native Security14%
Kubernetes Cluster Component Security22%
Kubernetes Security Fundamentals22%
Kubernetes Threat Model16%
Platform Security16%
Compliance and Security Frameworks10%

Source: the CNCF KCSA curriculum, read on November 14, 2026, and the Linux Foundation product page, which publishes the same weights. The blueprint is three pages long: under each domain, it lists topics rather than written objectives. The following sections take up these topics as it words them, and say which lessons of the course teach them.

Overview of Cloud Native Security (14%)

This domain asks you to place each control in the right layer of a cloud native platform. The blueprint cites the 4Cs (cloud, cluster, container and code), provider and infrastructure security, control frameworks, isolation techniques, artifact and image security, and the security of application code.

The 4Cs of cloud native security set the model, then Securing the infrastructure under the cluster covers the provider and the nodes. Control frameworks go through the CIS Kubernetes Benchmark, isolation through the runtime sandboxes, and artifacts through Supply Chain Security, image scanning and images in Kubernetes. The security of code and workloads comes back to the Security Context and the Pod Security Standards.

For each notion, practice answering the question "what does this protect against?" in one sentence. Two cross-cutting notions complete the reading: defense in depth explains the stacking of independent barriers, and workload identity shows how a service authenticates without a shared secret.

Kubernetes Cluster Component Security (22%)

This domain asks you to know what each cluster component protects, because each one is an entry point to the state of the cluster. The blueprint cites the API server, the controller manager, the scheduler, the kubelet, the container runtime, kube-proxy, the Pod, etcd, container networking, client security and storage.

The control plane introduces the API server, the controller manager and the scheduler, the audit logs trace the requests received by the API server, and the worker nodes describe the kubelet and kube-proxy.

etcd details the database that holds the whole state of the cluster, and secrets in Kubernetes (in French) explains why it is sensitive.

For the runtime, read CNI, CSI and CRI and the runtime sandboxes. For the network, the Pod network and the Network Policies. For the API clients, RBAC, and for volumes, the introduction to storage. The Pod topic is found in the lesson on Pods and in the Security Context.

No lesson covers kubelet hardening on its own. The "Common fixes" section of the CIS Kubernetes Benchmark shows its main settings: anonymous authentication turned off, webhook authorization. A common confusion in this domain sets audit, which traces after the fact, against admission, which blocks beforehand: both act on the same request, at different moments.

Kubernetes Security Fundamentals (22%)

This is the domain of the basic controls, and it is best revised layer by layer rather than in a jumble. RBAC and ServiceAccounts act on identity and access to the API, the Security Context and the Pod Security Standards on what the container can do once started, and Network Policies on what it can reach. This grid helps place most controls.

The blueprint cites the Pod Security Standards, Pod Security Admission, authentication, Secrets, isolation and segmentation, audit logging and network policies. The Pod Security Standards cover the first two topics, with the admission controllers (in French) for the admission mechanism.

Authentication and Pod identity go through RBAC and ServiceAccounts. Secrets have two lessons, Secrets and secrets in Kubernetes (in French). Isolation and segmentation rely on Namespaces, Network Policies, resource quotas and the runtime sandboxes. The audit logs cover logging.

Be able to justify each control by the risk it avoids: why cluster-admin is not handed out widely, why a Pod should not run as root without a reason, how to limit communication between namespaces.

Kubernetes Threat Model (16%)

This domain checks that you can reason like a defender: find the entry point of an attack, then the control that would have stopped it. The blueprint cites trust boundaries and data flows, persistence, denial of service, malicious code execution, the network attacker, access to sensitive data and privilege escalation.

Each of these topics has its lesson. Trust boundaries and STRIDE covers boundaries and flows. Attack scenarios in a cluster walks through three attacks (malicious code, privilege escalation, network attacker) and the defense that stops each one. For malicious code, Falco, Seccomp (in French) and AppArmor (in French) detect or restrict execution. For the network attacker, the Network Policies and pod-to-pod mTLS. For sensitive data, the Secrets, and for privilege escalation, the Security Context.

Persistence means the ways an attacker keeps access after a first intrusion: Persistence: what an attacker leaves behind (in French) shows how to spot it and remove it without breaking the application. Denial of service exhausts resources until a service becomes unavailable: Denial of service: exhausting a cluster contains it with quotas and limits, and checks that the other namespaces still respond.

Platform Security (16%)

Here, the exam takes the platform level: what it imposes on all Pods, no longer on a single one. The blueprint cites supply chain security, the image registry, observability, the service mesh, PKI, connectivity and admission control. Sort each item by the moment it acts: before deployment (image, signature), at deployment (admission) or at runtime (runtime, mTLS).

Supply Chain Security and images in Kubernetes cover the chain and the image registry, with Cosign for signing. For security observability, read the audit logs and Falco. The service mesh (in French) and pod-to-pod mTLS cover encryption between services, and the cluster PKI explains the authorities and the certificates of each component. Connectivity relies on the Network Policies and mTLS.

For admission, the admission controllers (in French) give the mechanism, the Validating Admission Policy (in French) the native version, Kyverno and Gatekeeper (in French) the two policy engines, and VAP vs Kyverno vs Gatekeeper helps tell them apart. An image scan is a snapshot at a given moment, whereas vulnerabilities are published continuously: this is why scanning before deployment is not enough.

Compliance and Security Frameworks (10%)

This is the lightest domain, and one of the quickest to revise, because it has few notions. The blueprint cites compliance frameworks, threat modeling methods, supply chain compliance, and automation with its tooling.

The CIS Kubernetes Benchmark is the reference lesson on frameworks. For threat modeling, Trust boundaries and STRIDE applies STRIDE to a flow, and MITRE ATT&CK (in French) describes attack techniques. Supply chain compliance goes through Supply Chain Security, and automation through the CIS Benchmark, image scanning, Kyverno and Gatekeeper (in French).

Do not confuse a benchmark, which is a list of controls to check, with a policy, which is a rule applied automatically to every deployment. A manual quarterly check on a cluster that deploys fifty times a day proves nothing: compliance is only worth what is measured continuously.

What the KCSA does not ask for

To avoid spreading yourself thin, here is what the exam leaves to other certifications. These limits follow from its format: an MCQ with no terminal cannot measure a hands-on skill.

  • Installing and repairing a cluster in the command line belongs to the CKA.
  • Hardening a cluster within the time limit of a hands-on exam belongs to the CKS.
  • Writing a manifest from memory is not assessed in an MCQ: you are asked to recognize the right control, not to type it.

What foundation do you need before starting?

This preparation relies on level 5 of the course, the security level, whose lessons are cited above. These lessons assume you already know the basic objects (Pod, Deployment, Service, Namespace, ConfigMap, Secret) and the general notions of authentication, authorization, encryption and least privilege.

You do not need to follow the whole course to acquire them. In the course path, choose the KCSA profile in the "Profile" selector: it gathers the security lessons and the basic lessons they cite as prerequisites (Deployment, Service, ConfigMap, StatefulSet, StorageClass, kubeadm, Ingress, CoreDNS, Kustomize), in the order to read them. You therefore do not have to go through levels 1 to 4 in full first.

The KCNA is not mandatory, the product page requires no prerequisite. It still helps you avoid discovering the Kubernetes basics and the security basics at the same time: the KCNA mock exam (in French) gives you a benchmark on this foundation.

What four-week study plan should you follow?

This plan does not tackle the domains in the order of the blueprint, but in the order in which they explain each other. Week 1 sets the basic controls, without which the threats of week 2 stay abstract. Week 3 goes up to the platform level, and week 4 is for spotting the gaps. Plan a few hours per week and adjust to your time.

WeekDomainsWhere to readWhat you should be able to explain at the end of the week
1Security Fundamentals (22%) and Overview (14%)RBAC, ServiceAccounts, Secrets, Security Context, Pod Security Standards, 4Cs, defense in depthhow to reduce a workload's privileges without breaking its operation
2Cluster Component Security (22%) and Threat Model (16%)control plane, etcd, worker nodes, audit logs, admission controllers, trust boundaries, attack scenarios, persistence, denial of servicethe main attack surfaces of a cluster and the control that stops each one
3Platform Security (16%) and Compliance (10%)supply chain, scanning, Cosign, Kyverno, Gatekeeper, mTLS, PKI, CIS Benchmarkhow a platform reduces risks before, during and after deployment
4the six domainsquizzes, checklist belowgo back over every box you cannot explain in thirty seconds

Read the right-hand column like a mock oral exam: say the answer out loud before moving on. An explanation that takes you more than thirty seconds points to a domain to go back over.

Week 4 ends with this checklist. For each line, answer without notes.

  • I can tell authentication, authorization and admission apart.
  • I understand RBAC, ServiceAccounts and Secrets.
  • I can explain the Security Context and the Pod Security Standards.
  • I understand the supply chain risks.
  • I know the role of etcd, the API server and the audit logs.
  • I can explain Network Policies, mTLS and segmentation.
  • I know the role of the CIS Benchmark.
  • I can place Kyverno, Gatekeeper, the Validating Admission Policy and Falco in a security strategy.

How to practice before the exam?

The knowledge check at the bottom of this page asks seven questions about the exam itself (format, domains, scope), and each of the security lessons cited above has its own quiz or lab. To test yourself on the six domains at once, take the KCSA mock exam (in French): it draws its questions from the security lessons of the course, returns a result per topic and changes the draw on each attempt. Its practice levels are timed and weighted by the six domains; the Simulation mode (in French) takes the duration and passing score of the real test (90 minutes, 75%) with 60 multiple-choice questions. Since the real number of questions is not published, these 60 questions only set a practice pace. Complete it with the week 4 check and with the practice below.

Even though the exam is an MCQ, handling a cluster helps fix the concepts. Create an isolated namespace, apply a simple Network Policy, observe the effect of a Security Context, read audit logs and test an admission policy: each step gives a concrete example to a notion that the MCQ will never make you type.

On exam day, the costliest mistake is reading too fast: the options look alike, and only one respects the exact wording of the question. Three reflexes limit the losses.

ReflexWhy
Read the terms preciselymany questions play on the difference between authentication, authorization, admission and encryption
Reason by controlalways ask yourself what the mechanism protects
Understand the problem before the toola candidate who can install Kyverno but cannot say what an admission control prevents loses points on several domains

Where does the KCSA sit among CNCF certifications?

The KCSA sits in the "associate" branch devoted to security. The column to look at is the level one: going from Associate to the Developer, Administrator or Specialist levels changes the nature of the exam, which becomes a timed hands-on exam in a terminal. The KCNA and the KCSA are two entry points of the same height, they do not have to be taken in sequence.

CertificationLevelFocus
KCNAAssociateKubernetes and cloud native fundamentals
KCSAAssociateCloud native security fundamentals
CKADDeveloperApplication development
CKAAdministratorKubernetes administration
CKSSpecialistAdvanced Kubernetes security

Three paths follow from this: from the KCNA to the KCSA to consolidate a cloud native security culture, from the KCSA to the CKA to strengthen the platform side, and from the CKA to the CKS to aim for advanced hands-on security. The KCSA replaces neither the CKA, which the CKS requires, nor the CKS: it is the theoretical foundation before the hands-on specialization. The guide to choosing a certification compares the formats if you are still hesitating.

The official sources prevail over any other in case of contradiction, including this page: the CNCF updates its blueprint without notice. Part of the KCSA vocabulary comes from external frameworks, the CIS Benchmarks, the 4Cs model, OWASP: reading them at the source is better than learning summaries of them.

On the site, the guides in the Securing Kubernetes (in French) section often go further than what the KCSA requires: read them in the order of the domains. The comparisons VAP vs Kyverno vs Gatekeeper and Falco vs Tetragon (in French) help place the tools.

Key takeaways

  1. The KCSA is a 90-minute MCQ, online and proctored, with no terminal or documentation: the figures on this page are those of November 14, 2026, to be reconfirmed on the product page before you buy.
  2. You need 75% of the points, the common rule of the Linux Foundation multiple-choice exams, and the price is 250 USD with one retake included.
  3. The six domains weigh 14, 22, 22, 16, 16 and 10%, and two 22% domains are worth 44% together.
  4. Each domain has its lessons in the course, including persistence and denial of service of the threat model.
  5. The KCSA validates a theoretical foundation: it is neither the CKA nor the CKS.
  6. You prepare for it with level 5 of the course and the KCSA profile of the course path, which adds the basic lessons needed, even though the KCSA comes right after the KCNA in the module.
  7. Each control is justified by the risk it avoids, not by the name of the tool.

Knowledge check

Seven questions about the exam itself: its format, the weight of the domains, what it asks and what it leaves to the CKA and the CKS.

Knowledge check

Check what you have learned with this interactive quiz

7 questions
5 min
80% to pass

How it works

  • The timer starts when you click Start
  • Multiple choice, true/false and short answer questions
  • You can move between questions
  • Detailed results are shown at the end

Starts the quiz and the timer