SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
KCSA · Domain 4

Kubernetes Threat Model practice questions

Kubernetes Threat Model is worth 16% of the KCSA exam — the 3rd-heaviest of the 6 domains. How attackers move through a Kubernetes cluster: trust boundaries and data flow, persistence, denial of service, malicious code in containers, network attackers, access to sensitive data and privilege escalation. Official weighting 16%. 6 fully worked examples are further down this page, answers included.

Exam weight
16%
the 3rd-heaviest of the 6 domains
Questions
62
across 2 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 6 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Kubernetes Threat Model questions, fully explained

Questions from the KCSA bank mapped to domain 4, with the answer key and the reasoning behind every option. None of them repeat the examples on the main KCSA practice page.

Question 1Kubernetes Threat Model

A security review maps the path of a kubectl request that creates a Pod. Which crossing is a trust boundary that the cluster itself must defend with authentication, authorization and admission checks?

Choose one.

  • a
    The scheduler reading the new Pod's details from the API server

    The scheduler is a trusted control plane component; its reads are authenticated, but the main untrusted-to-trusted crossing is the client's request.

  • b
    The API server writing the accepted Pod object into etcd storage

    By this point the request is already accepted; the API server to etcd hop is a trusted internal link protected with TLS and network isolation.

  • c
    The client's create call arriving at the API server Correct

    The client is outside the control plane's trust, so the API server authenticates the caller, authorizes the verb and runs admission before anything is stored.

  • d
    The kubelet pulling the Pod's container image from a registry

    Image pulls cross a boundary to the registry, but the cluster defends that with image policy and pull credentials, not the API request chain.

The concept

The API server is the gate where external requests enter the trusted control plane.

Why that’s the answer

Every request from a user or workload is untrusted until the API server has authenticated it, authorized it and passed it through admission control. Later hops (API server to etcd, scheduler watching the API server) are internal flows between components that already trust each other and are protected with TLS. Image pulls cross a different boundary defended by registry credentials and image policy.

How to reason it out
  1. Trace the request: client, API server, etcd, scheduler, kubelet.
  2. Find where an untrusted caller first meets a trusted component.
  3. Match it to the authentication, authorization and admission chain.

Exam tip: Client to API server is the front door: authenticate, authorize, admit.

KCSA Kubernetes Trust Boundaries, Persistence and Denial of Service — the lesson that teaches this.

Question 2Kubernetes Threat Model

In a standard Kubernetes architecture, which component reads and writes the cluster state stored in etcd directly?

Choose one.

  • a
    The kubelet on each node, for the Pods it runs

    The kubelet talks to the API server, never to etcd; this keeps node credentials away from the cluster's datastore.

  • b
    The kube-controller-manager, for the objects it reconciles

    Controllers watch and update objects through the API server rather than reading etcd themselves.

  • c
    The kube-scheduler, for the Pods it binds to nodes

    The scheduler watches unscheduled Pods and writes bindings through the API server, not into etcd.

  • d
    The kube-apiserver, on behalf of the other components Correct

    The API server is the only component that talks to etcd; controllers, the scheduler, kubelets and clients all go through it.

The concept

The API server is the hub of every data flow in the cluster.

Why that’s the answer

Kubernetes funnels all reads and writes through the kube-apiserver, which is the only client of etcd. That makes the API server the single place where authentication, authorization, admission and audit logging apply, and it is why direct access to etcd is so dangerous: it bypasses all of those checks.

How to reason it out
  1. Recall the hub-and-spoke design of the control plane.
  2. Note which component the kubelet, scheduler and controllers each call.
  3. Identify the only etcd client.

Exam tip: Only the API server talks to etcd; everything else talks to the API server.

KCSA Kubernetes Trust Boundaries, Persistence and Denial of Service — the lesson that teaches this.

Question 3Kubernetes Threat Model

An attacker obtains network access to the cluster's etcd endpoint and a client certificate that etcd accepts. Why is this more damaging than stealing an ordinary user's kubeconfig?

Choose one.

  • a
    Direct etcd access skips the API server's authorization, admission and audit checks Correct

    Reading or writing etcd directly bypasses RBAC, admission controllers and audit logging, and exposes every stored object, including Secrets.

  • b
    Direct etcd access lets the attacker log in to the nodes' operating system over SSH

    etcd stores cluster objects; it does not hold node OS credentials or open SSH access.

  • c
    Direct etcd access decrypts Secrets even when encryption at rest is configured on the API server

    With encryption at rest the values in etcd are encrypted with keys the API server holds; etcd access alone exposes ciphertext for those resources.

  • d
    Direct etcd access bypasses the Pod Security Standards but still applies the cluster's RBAC rules

    RBAC is enforced by the API server too, so direct etcd access skips it along with Pod Security admission.

The concept

etcd sits behind the API server's trust boundary.

Why that’s the answer

Every control the API server applies (authentication, RBAC, admission such as Pod Security, and audit logging) happens before data reaches etcd. Whoever can talk to etcd directly reads and writes cluster state with none of those checks and without leaving API audit events. Encryption at rest still protects the resources it covers, which is why the encryption keys must be kept away from etcd.

How to reason it out
  1. Recall which component enforces RBAC, admission and audit.
  2. Note that etcd is downstream of all of them.
  3. Check each option's claim about what etcd access does and does not give.

Exam tip: Protect etcd like the cluster itself: it bypasses every API server check.

KCSA Kubernetes Trust Boundaries, Persistence and Denial of Service — the lesson that teaches this.

Question 4Kubernetes Threat Model

By default, the kube-apiserver does not verify the serving certificate of the kubelet it connects to for kubectl logs and exec. Which attack does this leave open on an untrusted network?

Choose one.

  • a
    A denial of service that fills the node's disk with exec and log output

    Log and exec output volume is a resource problem on the node, unrelated to how the API server checks the kubelet's identity.

  • b
    A container escape that gives the attacker root on the kubelet's node

    Escaping a container depends on the workload's privileges and the kernel, not on the API server's TLS checks.

  • c
    A replay of stolen service account tokens against the API server endpoint

    Token replay targets the API server's authentication, not the API server to kubelet connection.

  • d
    A man-in-the-middle that reads or alters the traffic between the two Correct

    Without verifying the kubelet's certificate, the API server cannot tell it is talking to the real kubelet, so an attacker on the path can intercept or tamper with the stream.

The concept

Control plane to node traffic is a trust boundary that needs mutual verification.

Why that’s the answer

The Kubernetes documentation warns that the API server's connection to the kubelet does not verify the kubelet's serving certificate by default, which makes it subject to man-in-the-middle attacks and unsafe over untrusted or public networks. Supplying a CA bundle with --kubelet-certificate-authority closes that gap; an SSH tunnel or the Konnectivity service is the alternative when the networks cannot be trusted.

How to reason it out
  1. Identify the connection: API server to kubelet, used for logs, exec and port-forward.
  2. Ask what an unverified server certificate allows.
  3. Pick the attack that sits on the network path.

Exam tip: Unverified kubelet certificate = MITM risk; fix with --kubelet-certificate-authority.

KCSA Kubernetes Trust Boundaries, Persistence and Denial of Service — the lesson that teaches this.

Question 5Kubernetes Threat Model

A platform team runs worker nodes in a network segment it does not fully trust. They need the API server's connections to each kubelet to reject an impostor endpoint. What should they configure?

Choose one.

  • a
    Set --kubelet-client-certificate on the kube-apiserver to a certificate issued by the cluster's CA

    This authenticates the API server to the kubelet; it does nothing to check that the kubelet endpoint is genuine.

  • b
    Set --kubelet-certificate-authority on the kube-apiserver to the kubelets' serving CA Correct

    This gives the API server a root bundle to verify each kubelet's serving certificate, so an impostor without a valid certificate is rejected.

  • c
    Set --client-ca-file on each kubelet to the CA that signs the API server's client certificates

    This lets the kubelet authenticate callers such as the API server; it is the reverse direction of the check required.

  • d
    Set --anonymous-auth=false on each kubelet so unauthenticated callers are rejected

    Disabling anonymous kubelet access is good hardening, but it protects the kubelet from callers rather than proving the kubelet's identity to the API server.

The concept

Each direction of the control plane to node link is verified by a different setting.

Why that’s the answer

The kubelet authenticates the API server with --client-ca-file and the API server authenticates itself with --kubelet-client-certificate and key. Neither proves the kubelet endpoint is genuine. Only --kubelet-certificate-authority makes the API server verify the kubelet's serving certificate, which is what defeats an impostor on an untrusted network.

How to reason it out
  1. Name the direction: the API server must check the kubelet.
  2. Separate client authentication flags from server verification flags.
  3. Choose the API server flag that verifies the kubelet's serving certificate.

Exam tip: Who checks whom: --kubelet-certificate-authority lets the API server verify kubelets.

KCSA Kubernetes Trust Boundaries, Persistence and Denial of Service — the lesson that teaches this.

Question 6Kubernetes Threat Model

Why do threat models treat the boundary between a container and its node as weaker than the boundary between two virtual machines?

Choose one.

  • a
    Containers on a node share one IP address, so their traffic is not separable

    Each Pod gets its own IP, and NetworkPolicy can separate traffic; shared addressing is not the reason.

  • b
    Containers on a node share one root filesystem, so they can read each other's files

    Each container has its own root filesystem from its image; files are shared only through volumes that are mounted on purpose.

  • c
    Containers on a node share one host kernel, so a kernel flaw can cross it Correct

    Containers are processes isolated by kernel namespaces and cgroups; a kernel vulnerability or excessive privileges can let a process break out to the host.

  • d
    Containers on a node share one service account, so they hold the same API rights

    Service accounts are assigned per Pod; Pods on the same node can use different accounts.

The concept

The container-to-host boundary is enforced by a shared kernel.

Why that’s the answer

A container is a process confined by Linux namespaces, cgroups, capabilities and seccomp, and every container on a node runs on the same kernel. A kernel vulnerability, a privileged container or a sensitive hostPath mount can carry an attacker across that boundary to the node. A virtual machine has its own kernel behind a hypervisor, which is why sandboxed runtimes add that kind of layer for untrusted code.

How to reason it out
  1. Recall what a container actually is on the host.
  2. Compare that with a VM's separate kernel.
  3. Check the other options against per-Pod IPs, filesystems and service accounts.

Exam tip: Containers share the host kernel; that is the boundary attackers aim at.

KCSA Kubernetes Trust Boundaries, Persistence and Denial of Service — the lesson that teaches this.

What KCSA domain 4 tests, topic by topic

The official exam guide breaks Kubernetes Threat Model into 2 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published KCSA practice questions per topic in Kubernetes Threat Model
TopicWhat it coversQuestions
Trust boundaries, data flow, persistence and denial of serviceOfficial KCSA competencies (Kubernetes Threat Model): Kubernetes Trust Boundaries and Data Flow; Persistence; Denial of Service. Scope: where trust changes between users, control plane, nodes and workloads, how an attacker keeps a foothold (for example static Pods, DaemonSets, cron jobs or stolen credentials), and resource exhaustion with the limits, quotas and rate limits that counter it.31
Compromised containers, network attackers, sensitive data and privilege escalationOfficial KCSA competencies (Kubernetes Threat Model): Malicious Code Execution and Compromised Applications in Containers; Attacker on the Network; Access to Sensitive Data; Privilege Escalation. Scope: container escape paths, lateral movement across the Pod network, exposed Secrets and service account tokens, and escalation through privileged Pods, host mounts and over-broad RBAC.31
Total62

Revise Kubernetes Threat Model before you drill it

Other KCSA domains

Kubernetes Threat Model: your questions

Kubernetes Threat Model is domain 4 of the KCSA exam guide and carries 16% of the scored content — the 3rd-heaviest of the 6 domains. On a 60-question paper that works out to roughly 10 questions, though CNCF does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official KCSA exam guide.