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 2

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.

Question 11

A city library designs a cluster recovery plan that must restore deployments as well as its catalog database. 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. Use a ClusterRole for cluster-scoped resources or reusable rule definitions, recognizing that a RoleBinding to a ClusterRole grants those rules only in one namespace for namespaced resources.
  3. Treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC.
  4. Inspect Deployment, ReplicaSet and Pod owner references when verifying which controller maintains replica count.

Explanation

Correct Answer

C:

Treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. This resolves the issue because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd. To verify, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Incorrect Answers

A:

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, etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

B:

This option addresses the distinct objective “Distinguish ClusterRoles from Roles and binding scope”, not the immediate requirement. ClusterRole defines permissions while ClusterRoleBinding makes them cluster-wide; RoleBinding limits effective namespaced scope even when referencing a ClusterRole. For the stated case, etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

D:

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, etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Question 12

A city library designs a cluster recovery plan that must restore deployments as well as its catalog database. What infrastructure principle makes the correct treatment effective?

  1. Containers and Kubernetes APIs reduce some environment differences, but network load balancers, storage drivers and IAM integrations remain provider-specific.
  2. Pod affinity affects scheduler placement relative to labeled Pods in selected topology domains, not application authentication or firewall rules.
  3. ServiceAccounts provide workload identities for Kubernetes API access; human authentication and authorization are separately configured and should not be shared as static image secrets.
  4. etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Explanation

Correct Answer

D:

Etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd. It supports this action: Treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. To confirm, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Incorrect Answers

A:

That statement explains the distinct objective “Apply cloud-native portability and immutable infrastructure principles pragmatically” rather than the cause in this case. The deciding mechanism here is that etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

B:

That statement explains the distinct objective “Use Pod affinity for co-location without assuming it creates networking permissions” rather than the cause in this case. The deciding mechanism here is that etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

C:

That statement explains the distinct objective “Differentiate ServiceAccounts from human kubeconfig identities” rather than the cause in this case. The deciding mechanism here is that etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Question 13

A city library designs a cluster recovery plan that must restore deployments as well as its catalog database. What verification result would most convincingly distinguish a working solution from a claim?

  1. Apply a preferred Pod affinity against a cache Pod label and inspect node placement while testing access policy separately.
  2. Inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.
  3. Create synthetic invalid quota, unschedulable node and missing-image cases and compare their event reasons and assigned node status.
  4. Delete one test Deployment-owned Pod and observe a replacement appear without a new Deployment definition.

Explanation

Correct Answer

B:

Inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup. This is the relevant test because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Incorrect Answers

A:

This check would help evaluate the distinct objective “Use Pod affinity for co-location without assuming it creates networking permissions”, but not the required result. For this case, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

C:

This check would help evaluate the distinct objective “Use describe and Events to distinguish admission, scheduling and execution errors”, but not the required result. For this case, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

D:

This check would help evaluate the distinct objective “Identify reconciliation work performed by kube-controller-manager”, but not the required result. For this case, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Question 14

A city library designs a cluster recovery plan that must restore deployments as well as its catalog database. The change review contains this proposal: “Assume a control-plane etcd snapshot contains all customer files written to an application's mounted data volume.” What risk matters most?

  1. A control-plane restore might recover resource metadata while losing application records that were never backed up.
  2. A workload continues crashing because the root cause is memory exhaustion, not name resolution.
  3. A compromised unrelated Pod may reach protected application ports across trust boundaries.
  4. Independent rollout, scaling and failure isolation become difficult because the services are coupled to one scheduling unit.

Explanation

Correct Answer

A:

A control-plane restore might recover resource metadata while losing application records that were never backed up. The shortcut creates this risk because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Incorrect Answers

B:

That outcome concerns the distinct objective “Distinguish memory limits from CPU throttling for scheduling and runtime symptoms”; it is not the most direct consequence of this shortcut. The relevant consequence is that a control-plane restore might recover resource metadata while losing application records that were never backed up.

C:

That outcome concerns the distinct objective “Limit workload-to-workload access with explicit NetworkPolicy allow rules”; it is not the most direct consequence of this shortcut. The relevant consequence is that a control-plane restore might recover resource metadata while losing application records that were never backed up.

D:

That outcome concerns the distinct objective “Use Pods as the shared network and storage execution unit”; it is not the most direct consequence of this shortcut. The relevant consequence is that a control-plane restore might recover resource metadata while losing application records that were never backed up.

Question 15

A city library designs a cluster recovery plan that must restore deployments as well as its catalog database. Which implementation together with matching acceptance evidence best meets this case?

  1. Use an authorized kubectl debug ephemeral container when an application image lacks troubleshooting tools and policy permits ephemeral containers. Acceptance evidence: In a lab add a read-only debug container, inspect network conditions and verify audit logs record the ephemeral container action.
  2. 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.
  3. Give each workload an appropriate Kubernetes ServiceAccount and narrow RBAC permissions rather than embedding an administrator kubeconfig in its image. Acceptance evidence: Run a synthetic read-only Pod with a restricted ServiceAccount and verify one permitted API read and one forbidden Secret list.
  4. Use container runtime namespaces to isolate views of processes and networks while using cgroups to account for and constrain resources. Acceptance evidence: In a training namespace inspect PID views and a controlled memory limit, noting which mechanism changes identity or resource behavior.

Explanation

Correct Answer

B:

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. This pairing is justified because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Incorrect Answers

A:

This action and check address the distinct objective “Use ephemeral debugging containers only with appropriate permission and safeguards” instead of the stated acceptance requirement. The matching action is to treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. Its confirming test is to inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

C:

This action and check address the distinct objective “Differentiate ServiceAccounts from human kubeconfig identities” instead of the stated acceptance requirement. The matching action is to treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. Its confirming test is to inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

D:

This action and check address the distinct objective “Explain Linux namespaces and cgroups as distinct container isolation mechanisms” instead of the stated acceptance requirement. The matching action is to treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. Its confirming test is to inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Question 16

A regional hospital confuses control-plane state snapshots with backups of its medical application files. Which Kubernetes or cloud-native implementation decision best solves the stated problem?

  1. Give each workload an appropriate Kubernetes ServiceAccount and narrow RBAC permissions rather than embedding an administrator kubeconfig in its image.
  2. Package reusable Kubernetes resource templates in a Helm chart and review rendered manifests and values before installation or upgrade.
  3. Treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC.
  4. Choose a CRI-compatible container runtime on worker nodes and investigate image and container creation separately from API scheduling.

Explanation

Correct Answer

C:

The situation is that a regional hospital confuses control-plane state snapshots with backups of its medical application files. Treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. This resolves the issue because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd. To verify, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Incorrect Answers

A:

The situation is that a regional hospital confuses control-plane state snapshots with backups of its medical application files. 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, etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

B:

This option addresses the distinct objective “Use Helm charts for parameterized application packages without equating them to cluster controllers”, not the immediate requirement. Helm renders and manages chart releases but depends on Kubernetes controllers to maintain actual Pods and networking after the API objects exist. For the stated case, etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

D:

This option addresses the distinct objective “Explain the container runtime interface without conflating it with the control plane”, not the immediate requirement. A supported runtime such as containerd executes container operations requested through kubelet using the Container Runtime Interface. For the stated case, etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Question 17

A regional hospital confuses control-plane state snapshots with backups of its medical application files. Which platform mechanism explains why the suitable approach works?

  1. Image provenance reduces accidental or malicious image substitution; mutable tags alone cannot prove build integrity or content identity.
  2. Each kubelet watches assigned Pod specifications and coordinates the container runtime, volumes and health information on its node.
  3. etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.
  4. Authentication establishes who calls the API; RBAC authorization checks requested verb, resource and namespace before the API permits it.

Explanation

Correct Answer

C:

The situation is that a regional hospital confuses control-plane state snapshots with backups of its medical application files. Etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd. It supports this action: Treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. To confirm, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Incorrect Answers

A:

That statement explains the distinct objective “Use image provenance and policy controls without trusting mutable tags” rather than the cause in this case. The deciding mechanism here is that etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

B:

That statement explains the distinct objective “Recognize the kubelet role in local Pod lifecycle management” rather than the cause in this case. The deciding mechanism here is that etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

D:

That statement explains the distinct objective “Use least-privilege kubectl authentication and authorization during routine administration” rather than the cause in this case. The deciding mechanism here is that etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Question 18

A regional hospital confuses control-plane state snapshots with backups of its medical application files. Which controlled observation would best validate the intended improvement?

  1. Deploy a test sidecar and main container, verify localhost communication and compare their shared Pod IP with a separate Pod.
  2. Inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.
  3. Run kubectl kustomize for development and production overlays and compare the resulting YAML objects before application.
  4. Simulate controlled resource pressure with two priorities and inspect Events for whether a high-priority test Pod can schedule.

Explanation

Correct Answer

B:

The situation is that a regional hospital confuses control-plane state snapshots with backups of its medical application files. Inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup. This is the relevant test because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Incorrect Answers

A:

This check would help evaluate the distinct objective “Use Pods as the shared network and storage execution unit”, but not the required result. For this case, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

C:

This check would help evaluate the distinct objective “Use Kustomize overlays to adapt manifests without copying whole deployments”, but not the required result. For this case, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

D:

This check would help evaluate the distinct objective “Use PriorityClasses and understand preemption without assuming they guarantee availability”, but not the required result. For this case, inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Question 19

A regional hospital confuses control-plane state snapshots with backups of its medical application files. An engineer proposes: “Assume a control-plane etcd snapshot contains all customer files written to an application's mounted data volume.” What adverse outcome would be most direct?

  1. Incident diagnosis confuses placement failures with container startup errors and targets the wrong component.
  2. The service can remain under capacity because a standalone Pod has no ReplicaSet controller to recreate it.
  3. A control-plane restore might recover resource metadata while losing application records that were never backed up.
  4. Untrusted images or privileged settings can enter production without an auditable approval decision.

Explanation

Correct Answer

C:

The situation is that a regional hospital confuses control-plane state snapshots with backups of its medical application files. A control-plane restore might recover resource metadata while losing application records that were never backed up. The shortcut creates this risk because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Incorrect Answers

A:

That outcome concerns the distinct objective “Separate kube-scheduler decisions from kubelet execution”; it is not the most direct consequence of this shortcut. The relevant consequence is that a control-plane restore might recover resource metadata while losing application records that were never backed up.

B:

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 a control-plane restore might recover resource metadata while losing application records that were never backed up.

D:

That outcome concerns the distinct objective “Define secure release governance with staged approvals and policy verification”; it is not the most direct consequence of this shortcut. The relevant consequence is that a control-plane restore might recover resource metadata while losing application records that were never backed up.

Question 20

A regional hospital confuses control-plane state snapshots with backups of its medical application files. What pair of supported action and practical verification should be approved?

  1. Inspect Deployment, ReplicaSet and Pod owner references when verifying which controller maintains replica count. Acceptance evidence: Run kubectl get rs and kubectl describe deployment for a test rollout and verify the expected owner chain.
  2. Select an access mode supported by the actual storage driver and workload placement requirements rather than assuming every volume supports concurrent writes from every node. Acceptance evidence: Use a synthetic two-node workload and compare expected attach behavior for an RWO volume with a documented RWX shared filesystem.
  3. Choose Pod affinity only when co-locating related workloads is beneficial and verify independent network policies still govern traffic. Acceptance evidence: Apply a preferred Pod affinity against a cache Pod label and inspect node placement while testing access policy separately.
  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

D:

The situation is that a regional hospital confuses control-plane state snapshots with backups of its medical application files. 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. This pairing is justified because etcd persists Kubernetes API objects and cluster configuration, while application records ordinarily live in workload-specific storage outside etcd.

Incorrect Answers

A:

This action and check address the distinct objective “Interpret ReplicaSet ownership and selectors in a Deployment” instead of the stated acceptance requirement. The matching action is to treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. Its confirming test is to inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

B:

This action and check address the distinct objective “Choose ReadWriteOnce and ReadWriteMany access modes by backend capability” instead of the stated acceptance requirement. The matching action is to treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. Its confirming test is to inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

C:

This action and check address the distinct objective “Use Pod affinity for co-location without assuming it creates networking permissions” instead of the stated acceptance requirement. The matching action is to treat etcd as Kubernetes control-plane state storage and protect its snapshots, keys, and access separately from an application's database or PVC. Its confirming test is to inspect the cluster backup policy for etcd snapshots and separately restore synthetic application data from its own backup.

Kubernetes and Cloud Native Associate (KCNA) Practice Tests