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

Kubernetes Cluster Component Security practice questions

Kubernetes Cluster Component Security is worth 22% of the KCSA exam — the heaviest of the 6 domains. Securing each component of a Kubernetes cluster: the API server, controller manager, scheduler and etcd on the control plane; the kubelet, container runtime, kube-proxy and Pods on the nodes; and container networking, client access and storage. Official weighting 22%. 6 fully worked examples are further down this page, answers included.

Exam weight
22%
the heaviest of the 6 domains
Questions
87
across 3 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 Cluster Component Security questions, fully explained

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

Question 1Kubernetes Cluster Component Security

A service account can create Pods in its namespace: kubectl auth can-i create pods, run as that service account in that namespace, returns yes. Its request to create a Pod with privileged: true is still rejected with a Forbidden error. Which stage of the API request flow rejected it?

Choose one.

  • a
    The authentication stage, because the service account token was not trusted

    A token the API server could not verify would fail with an Unauthorized (401) error before any Pod spec was examined.

  • b
    The authorization stage, because the Role does not cover privileged Pods

    RBAC decides on verbs and resources such as create on pods; it does not look inside the Pod spec, and can-i has already confirmed that create on pods is allowed.

  • c
    The admission control stage, because a controller validated the Pod spec Correct

    Admission controllers see the object in an authorized request and can reject it on its content, such as a privileged security context.

  • d
    The authorization stage, because another authorizer in the chain denied it

    kubectl auth can-i sends a SelfSubjectAccessReview through the whole authorizer chain, so a yes means authorization as a whole allows create on pods.

The concept

Authorization decides whether an identity may perform a verb on a resource; admission control decides whether the specific object is acceptable.

Why that’s the answer

kubectl auth can-i asks the authorizers, so a yes rules out authorization: it passes through the whole chain, and authorization never inspects the Pod spec anyway. The request was authenticated too, or can-i for this identity would be meaningless and the error would be Unauthorized (401). What remains is admission control, which sees the actual object and can reject it for its content, such as a privileged security context (for example the PodSecurity admission controller).

How to reason it out
  1. Note that can-i confirms the authorizer chain allows create on pods.
  2. Recall that authorization decides on verb and resource, never on the object's fields.
  3. Recall that admission control sees the object and can reject it on its content.
  4. Conclude that admission rejected the privileged Pod.

Exam tip: RBAC answers 'may this identity create Pods?'; admission answers 'is this particular Pod acceptable?'.

KCSA Control Plane Security: API Server, Controller Manager, Scheduler and etcd — the lesson that teaches this.

Question 2Kubernetes Cluster Component Security

A kube-apiserver has anonymous requests enabled. A request arrives with no client certificate and no bearer token. Which identity does the API server assign to it before authorization?

Choose one.

  • a
    The user system:anonymous in the group system:unauthenticated Correct

    When anonymous requests are enabled, a request no authenticator rejects or identifies is treated as system:anonymous in the system:unauthenticated group.

  • b
    The user system:anonymous in the group system:authenticated

    system:authenticated is added only for requests that some authenticator successfully identified; anonymous requests are not in it.

  • c
    The user system:serviceaccount:default:default in its namespace

    The default service account identity requires that service account's token; a request with no credential is not mapped to it.

  • d
    The user system:kube-apiserver in the group system:masters

    Mapping an unauthenticated caller to a privileged group would be a severe flaw; anonymous requests get the least-privileged identity.

The concept

With anonymous authentication enabled, unidentified requests become system:anonymous / system:unauthenticated and are then subject to authorization.

Why that’s the answer

Anonymous access does not bypass authorization: the API server labels the request system:anonymous in group system:unauthenticated, and RBAC decides what that identity may do. The near-twin swaps in system:authenticated, which every successfully authenticated user receives but anonymous callers never do.

How to reason it out
  1. Recall that anonymous requests still get a username and group.
  2. Distinguish system:unauthenticated from system:authenticated.
  3. Remember that authorization then evaluates that identity like any other.

Exam tip: Anonymous = system:anonymous in system:unauthenticated, and RBAC still decides.

KCSA Control Plane Security: API Server, Controller Manager, Scheduler and etcd — the lesson that teaches this.

Question 3Kubernetes Cluster Component Security

A security review finds that a curl request sent to a cluster's kube-apiserver without any credentials can list Pods in every namespace. Anonymous requests are enabled and the authorization mode is Node,RBAC. What is the most likely cause to investigate first?

Choose one.

  • a
    A RoleBinding grants list on pods to the system:serviceaccounts group

    That group contains service accounts, which present tokens; an unauthenticated request is not a member of it.

  • b
    A ClusterRoleBinding grants list on pods to the system:authenticated group

    Anonymous requests are not members of system:authenticated, so this binding alone would not let an unauthenticated caller list Pods.

  • c
    A ClusterRoleBinding grants list on pods to the system:unauthenticated group Correct

    Anonymous requests are evaluated by RBAC as members of system:unauthenticated, so a ClusterRoleBinding to that group grants them cluster-wide access.

  • d
    The Node authorizer grants list on pods to callers in the system:nodes group

    The Node authorizer only serves identities named system:node:<nodeName>; it gives anonymous callers nothing.

The concept

Anonymous requests are authorized like any other identity, so anything bound to system:anonymous or system:unauthenticated is open to the whole network that can reach the API server.

Why that’s the answer

Because RBAC is in force, the anonymous caller can only do what has been bound to its identity. Listing Pods cluster-wide points to a ClusterRoleBinding whose subject is system:unauthenticated (or system:anonymous). The system:authenticated binding is the tempting near-twin, but anonymous callers are not in that group; fix the binding, and consider disabling or restricting anonymous access.

How to reason it out
  1. Recall the identity anonymous requests receive.
  2. Ask which binding subject would include that identity.
  3. Rule out groups anonymous callers never belong to.

Exam tip: Audit every binding to system:anonymous or system:unauthenticated - they are effectively public.

KCSA Control Plane Security: API Server, Controller Manager, Scheduler and etcd — the lesson that teaches this.

Question 4Kubernetes Cluster Component Security

A test cluster's kube-apiserver was started with --authorization-mode=AlwaysAllow. Which risk does this setting create if the cluster is promoted to production?

Choose one.

  • a
    Every request is rejected after authentication, so workloads and controllers stop working

    That describes AlwaysDeny, the opposite mode; AlwaysAllow permits rather than blocks requests.

  • b
    Every request skips authentication, so callers reach the API without presenting credentials

    Authorization mode does not change authentication; callers are still identified (or treated as anonymous) before AlwaysAllow approves them.

  • c
    Every authenticated request is permitted, so any valid credential acts as a cluster administrator Correct

    AlwaysAllow approves every request that reaches authorization, so RBAC roles and bindings are never consulted.

  • d
    Every request skips admission control, so Pod specs are stored without any policy checks

    Admission controllers are configured separately and still run; AlwaysAllow only removes the authorization check.

The concept

--authorization-mode selects the authorizers; AlwaysAllow disables authorization entirely, while production clusters use Node,RBAC.

Why that’s the answer

AlwaysAllow is meant for testing: any request that authenticates (or is accepted as anonymous) is authorized, so RBAC is irrelevant and every credential is effectively cluster-admin. It does not alter authentication or admission, which is where the near-twin distractors go wrong. Production API servers run --authorization-mode=Node,RBAC (or the equivalent AuthorizationConfiguration).

How to reason it out
  1. Identify which pipeline stage --authorization-mode controls.
  2. Recall what AlwaysAllow returns for every request.
  3. Infer that RBAC is bypassed for every authenticated identity.

Exam tip: AlwaysAllow means RBAC is never consulted - use Node,RBAC in production.

KCSA Control Plane Security: API Server, Controller Manager, Scheduler and etcd — the lesson that teaches this.

Question 5Kubernetes Cluster Component Security

An administrator hardens a kube-apiserver by changing --authorization-mode from Node,RBAC to RBAC only. Shortly afterwards, kubelets start receiving forbidden errors when they update their Node status and read Secrets for their Pods. What should the administrator do?

Choose one.

  • a
    Bind the system:nodes group to the cluster-admin ClusterRole

    This would restore access but give every kubelet full control of the cluster, far beyond what a node needs.

  • b
    Restore the Node authorizer in the mode list alongside RBAC Correct

    Kubelet permissions come from the Node authorizer, which scopes each kubelet to its own Node and the Pods bound to it; removing it leaves kubelets without access.

  • c
    Bind the system:nodes group to the system:node ClusterRole

    This restores access, but RBAC cannot limit a kubelet to Secrets of its own Pods, so each node could read every Secret it is granted cluster-wide.

  • d
    Restore the Webhook authorizer in the mode list alongside RBAC

    A webhook authorizer delegates decisions to an external service; it is not what grants kubelets their node-scoped permissions.

The concept

The Node authorizer grants each kubelet only what its own Node and bound Pods need; it is meant to run together with RBAC.

Why that’s the answer

Kubernetes does not bind system:nodes to a role by default, because the Node authorizer handles kubelet requests. Dropping Node from the mode list therefore breaks kubelets. The RBAC bindings would make the errors disappear, but RBAC grants by resource type, not by 'Pods bound to this node', so every kubelet would gain more than it needs. Node,RBAC is the least-privilege combination.

How to reason it out
  1. Recognise that the failing callers are kubelets.
  2. Recall which authorizer serves kubelet identities.
  3. Prefer the fix that keeps node-scoped permissions over a broad RBAC grant.

Exam tip: Run Node,RBAC: Node scopes kubelets to their own node, RBAC handles everyone else.

KCSA Control Plane Security: API Server, Controller Manager, Scheduler and etcd — the lesson that teaches this.

Question 6Kubernetes Cluster Component Security

A self-managed cluster runs a current Kubernetes release. How do clients such as kubectl, kubelets and controllers communicate with the kube-apiserver?

Choose one.

  • a
    Over HTTP on its insecure port, with each request then authenticated and authorized

    The insecure HTTP port was removed from kube-apiserver; it once bypassed authentication and authorization entirely.

  • b
    Over HTTPS on its secure port, with each request then authenticated and authorized Correct

    Current API servers serve only on the TLS-protected secure port (6443 by default), and every request goes through authentication and authorization.

  • c
    Over HTTPS on its secure port, with requests from inside the cluster network trusted

    Network location confers no trust; requests from inside the cluster are authenticated and authorized like any other.

  • d
    Over HTTP on its insecure port, with requests from localhost trusted

    Older releases had a localhost-only insecure HTTP port that skipped authentication and authorization; it has been removed, so this no longer describes a current API server.

The concept

The kube-apiserver serves the Kubernetes API over TLS on its secure port only, and authenticates and authorizes every request regardless of where it comes from.

Why that’s the answer

Older releases had an insecure HTTP port, bound to localhost, that skipped authentication and authorization; it was removed, leaving the TLS-protected secure port as the only listener. Being on the cluster network or on the same host gives no implicit trust - every request is authenticated and authorized. The distractors reintroduce the removed port, implicit trust by source address, or both.

How to reason it out
  1. Recall that the insecure port no longer exists.
  2. Recall that no request is trusted because of its source address.
  3. Choose TLS on the secure port plus authentication and authorization.

Exam tip: One listener, TLS only, and every request is authenticated and authorized.

KCSA Control Plane Security: API Server, Controller Manager, Scheduler and etcd — the lesson that teaches this.

What KCSA domain 2 tests, topic by topic

The official exam guide breaks Kubernetes Cluster Component Security into 3 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 Cluster Component Security
TopicWhat it coversQuestions
Control plane security: API server, controller manager, scheduler and etcdOfficial KCSA competencies (Kubernetes Cluster Component Security): API Server; Controller Manager; Scheduler; Etcd. Scope: API server authentication, authorization and admission settings, TLS between components, protecting service account signing keys, securing the controller manager and scheduler endpoints, and encrypting, isolating and backing up etcd.29
Node security: kubelet, container runtime, kube-proxy and PodsOfficial KCSA competencies (Kubernetes Cluster Component Security): Kubelet; Container Runtime; KubeProxy; Pod. Scope: kubelet authentication and authorization and its read-only and API ports, container runtimes and sandboxing, kube-proxy configuration, and Pod-level settings such as security contexts, service account tokens and host namespaces.29
Container networking, client security and storageOfficial KCSA competencies (Kubernetes Cluster Component Security): Container Networking; Client Security; Storage. Scope: the CNI and Pod-to-Pod traffic, encryption in transit, kubeconfig files and client credentials, and securing volumes, persistent storage and storage classes.29
Total87

Revise Kubernetes Cluster Component Security before you drill it

Other KCSA domains

Kubernetes Cluster Component Security: your questions

Kubernetes Cluster Component Security is domain 2 of the KCSA exam guide and carries 22% of the scored content — the heaviest of the 6 domains. On a 60-question paper that works out to roughly 13 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.