Practice Exams:

Linux Foundation KCNA Dumps

EXAM: Kubernetes and Cloud Native Associate
Verified By Experts
Premium Bundle
$40.00
$59.97 $99.97

KCNA Premium Bundle


  • Premium File 333 Questions & Answers
  • Training Course 54 Lectures
  • Study Guide 410 Pages

Linux Foundation KCNA Practice Test 1

Question 1

A university lab wants to register a new training workload through the supported Kubernetes control-plane interface. Which Kubernetes or cloud-native implementation decision best solves the stated problem?

  1. Inspect Deployment, ReplicaSet and Pod owner references when verifying which controller maintains replica count.
  2. Read Pod Events and node assignment to distinguish a Pod that cannot be scheduled from a scheduled Pod whose image cannot be pulled.
  3. Give each workload an appropriate Kubernetes ServiceAccount and narrow RBAC permissions rather than embedding an administrator kubeconfig in its image.
  4. Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly.

Explanation

Correct Answer

D:

Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. This resolves the issue because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state. To verify, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Incorrect Answers

A:

This option addresses the distinct objective “Interpret ReplicaSet ownership and selectors in a Deployment”, not the immediate requirement. A Deployment creates or manages ReplicaSets, each ReplicaSet owns matching Pods, and selector consistency determines which Pods it counts. For the stated case, the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

B:

This option addresses the distinct objective “Separate Pending scheduling failures from ImagePullBackOff errors”, not the immediate requirement. FailedScheduling occurs before node binding; ImagePullBackOff occurs when a node's kubelet cannot obtain the container image. For the stated case, the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

C:

This option addresses the distinct objective “Differentiate ServiceAccounts from human kubeconfig identities”, not the immediate requirement. ServiceAccounts provide workload identities for Kubernetes API access; human authentication and authorization are separately configured and should not be shared as static image secrets. For the stated case, the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Question 2

A university lab wants to register a new training workload through the supported Kubernetes control-plane interface. Which platform mechanism explains why the suitable approach works?

  1. The kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.
  2. etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.
  3. A namespace scopes many API object names and administrative boundaries, but merely creating it does not deny network communication across namespaces.
  4. A Service name may resolve successfully while its selector yields no ready endpoints, and both differ from a backend listening on the wrong port.

Explanation

Correct Answer

A:

The kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state. It supports this action: Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. To confirm, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Incorrect Answers

B:

That statement explains the distinct objective “Distinguish etcd persistence from running workload data” rather than the cause in this case. The deciding mechanism here is that the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

C:

That statement explains the distinct objective “Use namespaces as organizational scopes without treating them as firewalls” rather than the cause in this case. The deciding mechanism here is that the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

D:

That statement explains the distinct objective “Distinguish a failed Service selector from broken DNS or a failing backend” rather than the cause in this case. The deciding mechanism here is that the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Question 3

A university lab wants to register a new training workload through the supported Kubernetes control-plane interface. Which controlled observation would best validate the intended improvement?

  1. Read the cluster networking configuration, find a test Service and verify backend connectivity using the installed dataplane.
  2. Verify a synthetic exporter is listed UP in Prometheus target status and query its request counter after generating traffic.
  3. Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.
  4. Inspect synthetic ConfigMap and Secret manifests, then test that an unprivileged ServiceAccount cannot read the private Secret.

Explanation

Correct Answer

C:

Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required. This is the relevant test because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Incorrect Answers

A:

This check would help evaluate the distinct objective “Understand service proxy implementations without assuming kube-proxy is mandatory”, but not the required result. For this case, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

B:

This check would help evaluate the distinct objective “Understand Prometheus pull-based metrics collection and exporters”, but not the required result. For this case, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

D:

This check would help evaluate the distinct objective “Distinguish ConfigMaps from Secrets and avoid storing credentials in public configuration”, but not the required result. For this case, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Question 4

A university lab wants to register a new training workload through the supported Kubernetes control-plane interface. An engineer proposes: “Edit runtime files on an arbitrary worker to declare a new cluster resource while bypassing admission and authorization.” What adverse outcome would be most direct?

  1. The Pod remains unschedulable because requested capacity and node feasibility did not change.
  2. A control-plane restore might recover resource metadata while losing application records that were never backed up.
  3. A trusted community label is misused as a substitute for secure configuration and maintenance.
  4. The edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.

Explanation

Correct Answer

D:

The edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it. The shortcut creates this risk because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Incorrect Answers

A:

That outcome concerns the distinct objective “Use container resource requests to help the scheduler fit Pods on nodes”; it is not the most direct consequence of this shortcut. The relevant consequence is that the edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.

B:

That outcome concerns the distinct objective “Distinguish etcd persistence from running workload data”; it is not the most direct consequence of this shortcut. The relevant consequence is that the edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.

C:

That outcome concerns the distinct objective “Understand CNCF project maturity stages without equating them to security approval”; it is not the most direct consequence of this shortcut. The relevant consequence is that the edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.

Question 5

A university lab wants to register a new training workload through the supported Kubernetes control-plane interface. What pair of supported action and practical verification should be approved?

  1. Group tightly coupled containers that require the same Pod networking identity and optionally shared volumes into one Pod while keeping independently scalable services separate. Acceptance evidence: Deploy a test sidecar and main container, verify localhost communication and compare their shared Pod IP with a separate Pod.
  2. Apply ingress and egress NetworkPolicy to selected Pods and verify both permitted and denied synthetic flows under a network plugin that implements policy. Acceptance evidence: Check CNI capabilities, establish a default-deny test policy and verify one allowed and one denied connection.
  3. Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Acceptance evidence: Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.
  4. Resolve an object's apiVersion, kind, metadata namespace and name before applying or deleting it. Acceptance evidence: List Deployments with --all-namespaces and inspect one manifest's apiVersion and kind to target a specific test object.

Explanation

Correct Answer

C:

Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Acceptance evidence: Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required. This pairing is justified because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Incorrect Answers

A:

This action and check address the distinct objective “Use Pods as the shared network and storage execution unit” instead of the stated acceptance requirement. The matching action is to send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Its confirming test is to create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

B:

This action and check address the distinct objective “Recognize NetworkPolicy isolation only when the CNI enforces it” instead of the stated acceptance requirement. The matching action is to send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Its confirming test is to create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

D:

This action and check address the distinct objective “Read the API resource model using namespaces and names rather than guessing ownership” instead of the stated acceptance requirement. The matching action is to send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Its confirming test is to create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Question 6

A logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. Which engineering approach is the most appropriate for this cloud-native case?

  1. Give each workload an appropriate Kubernetes ServiceAccount and narrow RBAC permissions rather than embedding an administrator kubeconfig in its image.
  2. Grant operators only required API verbs and resources using RBAC, then test with kubectl auth can-i and separate synthetic identities.
  3. Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly.
  4. Combine RBAC, Pod security policies, NetworkPolicy and resource quotas for teams that share a Kubernetes control plane.

Explanation

Correct Answer

C:

The situation is that a logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. This resolves the issue because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state. To verify, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Incorrect Answers

A:

The situation is that a logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. This option addresses the distinct objective “Differentiate ServiceAccounts from human kubeconfig identities”, not the immediate requirement. ServiceAccounts provide workload identities for Kubernetes API access; human authentication and authorization are separately configured and should not be shared as static image secrets. For the stated case, the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

B:

This option addresses the distinct objective “Use least-privilege kubectl authentication and authorization during routine administration”, not the immediate requirement. Authentication establishes who calls the API; RBAC authorization checks requested verb, resource and namespace before the API permits it. For the stated case, the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

D:

This option addresses the distinct objective “Separate multi-tenant namespace governance from actual isolation guarantees”, not the immediate requirement. Namespaces alone partition naming but do not provide complete security isolation, capacity governance or protection from privileged node-level workloads. For the stated case, the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Question 7

A logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. What infrastructure principle makes the correct treatment effective?

  1. A rollout can be API-valid yet degrade business behavior; measured acceptance signals and a preserved prior revision make controlled rollback possible.
  2. kube-proxy can maintain node networking rules for Services, but supported network implementations may replace this function.
  3. The kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.
  4. A Deployment creates or manages ReplicaSets, each ReplicaSet owns matching Pods, and selector consistency determines which Pods it counts.

Explanation

Correct Answer

C:

The situation is that a logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. The kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state. It supports this action: Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. To confirm, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Incorrect Answers

A:

That statement explains the distinct objective “Design a release rollback trigger from measurable service signals” rather than the cause in this case. The deciding mechanism here is that the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

B:

That statement explains the distinct objective “Understand service proxy implementations without assuming kube-proxy is mandatory” rather than the cause in this case. The deciding mechanism here is that the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

D:

That statement explains the distinct objective “Interpret ReplicaSet ownership and selectors in a Deployment” rather than the cause in this case. The deciding mechanism here is that the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Question 8

A logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. What verification result would most convincingly distinguish a working solution from a claim?

  1. Induce a temporary readiness failure in staging and verify traffic stops without a restart; then separately test controlled liveness failure.
  2. Scale a test Deployment and inspect its ReplicaSet and owned Pods, then compare deleting a standalone Pod.
  3. Create matching Service names in two namespaces and test separately configured RBAC and NetworkPolicy access boundaries.
  4. Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Explanation

Correct Answer

D:

The situation is that a logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required. This is the relevant test because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Incorrect Answers

A:

This check would help evaluate the distinct objective “Investigate readiness failures separately from liveness-related restarts”, but not the required result. For this case, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

B:

This check would help evaluate the distinct objective “Distinguish Deployment desired state from a manually created Pod”, but not the required result. For this case, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

C:

This check would help evaluate the distinct objective “Use namespaces as organizational scopes without treating them as firewalls”, but not the required result. For this case, create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Question 9

A logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. The change review contains this proposal: “Edit runtime files on an arbitrary worker to declare a new cluster resource while bypassing admission and authorization.” What risk matters most?

  1. The edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.
  2. The operator may deploy unsupported changes without release provenance or a responsible maintenance path.
  3. A later registry push can change deployed bits unexpectedly, defeating reproducible approval and rollback.
  4. The service can remain under capacity because a standalone Pod has no ReplicaSet controller to recreate it.

Explanation

Correct Answer

A:

The situation is that a logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. The edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it. The shortcut creates this risk because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Incorrect Answers

B:

That outcome concerns the distinct objective “Use open community governance and contribution processes for sustainable cloud-native projects”; it is not the most direct consequence of this shortcut. The relevant consequence is that the edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.

C:

That outcome concerns the distinct objective “Use an immutable image digest for exact deployment provenance”; it is not the most direct consequence of this shortcut. The relevant consequence is that the edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.

D:

That outcome concerns the distinct objective “Identify reconciliation work performed by kube-controller-manager”; it is not the most direct consequence of this shortcut. The relevant consequence is that the edit is invisible to the API and controller reconciliation, so subsequent node restarts or scheduling can discard it.

Question 10

A logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. Which implementation together with matching acceptance evidence best meets this case?

  1. Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Acceptance evidence: Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.
  2. Review requests, limits, QoS class and termination reasons rather than interpreting every restart as a scheduler failure. Acceptance evidence: Create a synthetic CPU-intensive workload with tight CPU limits and compare throttling metrics with an OOMKilled test Pod.
  3. Choose service boundaries around business capabilities and operational needs, documenting communication cost, ownership and fault tolerance. Acceptance evidence: Model a synthetic two-service checkout dependency and compare rollout independence with failure and latency overhead against a single service.
  4. Treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. Acceptance evidence: Inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Explanation

Correct Answer

A:

The situation is that a logistics company has two worker machines but wants one authenticated entry point for declaring cluster objects. Send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Acceptance evidence: Create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required. This pairing is justified because the kube-apiserver validates authorized API requests and exposes the declarative resource interface; kubelets and controllers subsequently reconcile the saved desired state.

Incorrect Answers

B:

This action and check address the distinct objective “Distinguish memory limits from CPU throttling for scheduling and runtime symptoms” instead of the stated acceptance requirement. The matching action is to send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Its confirming test is to create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

C:

This action and check address the distinct objective “Contrast cloud-native microservices with a monolith without treating either as inherently superior” instead of the stated acceptance requirement. The matching action is to send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Its confirming test is to create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

D:

This action and check address the distinct objective “Distinguish etcd persistence from running workload data” instead of the stated acceptance requirement. The matching action is to send cluster changes through the authenticated Kubernetes API and inspect the object returned by the API server rather than changing node processes directly. Its confirming test is to create a namespaced ConfigMap with kubectl, read it back through the API, and confirm no manual edit of a worker-node process was required.

Kubernetes and Cloud Native Associate (KCNA) Practice Tests