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 25

Question 240

A financial cooperative's on-call staff must inspect Events without modifying cluster-wide security settings. What pair of supported action and practical verification should be approved?

  1. Grant operators only required API verbs and resources using RBAC, then test with kubectl auth can-i and separate synthetic identities. Acceptance evidence: With restricted identities, check get pods succeeds while delete secrets and create clusterroles are denied.
  2. Expose appropriately labeled /metrics endpoints or exporters and configure Prometheus scrape targets to collect time-series measurements. Acceptance evidence: Verify a synthetic exporter is listed UP in Prometheus target status and query its request counter after generating traffic.
  3. Use narrowly scoped imagePullSecrets or an approved node identity to authorize the runtime to pull a private image. Acceptance evidence: Deploy a synthetic private image using an approved Secret and confirm unauthorized namespaces cannot reuse a broad registry token.
  4. Observe rollout progression and use a reviewed rollback to a previous ReplicaSet revision when a new application build fails health checks. Acceptance evidence: Change a test image to a known failing build, inspect rollout status and rollback history, then verify the earlier healthy version serves requests.

Explanation

Correct Answer

A:

The situation is that a financial cooperative's on-call staff must inspect Events without modifying cluster-wide security settings. Grant operators only required API verbs and resources using RBAC, then test with kubectl auth can-i and separate synthetic identities. Acceptance evidence: With restricted identities, check get pods succeeds while delete secrets and create clusterroles are denied. This pairing is justified because authentication establishes who calls the API; RBAC authorization checks requested verb, resource and namespace before the API permits it.

Incorrect Answers

B:

This action and check address the distinct objective “Understand Prometheus pull-based metrics collection and exporters” instead of the stated acceptance requirement. The matching action is to grant operators only required API verbs and resources using RBAC, then test with kubectl auth can-i and separate synthetic identities. Its confirming test is to with restricted identities, check get pods succeeds while delete secrets and create clusterroles are denied.

C:

This action and check address the distinct objective “Handle private registry pulls with dedicated credentials instead of embedding secrets in images” instead of the stated acceptance requirement. The matching action is to grant operators only required API verbs and resources using RBAC, then test with kubectl auth can-i and separate synthetic identities. Its confirming test is to with restricted identities, check get pods succeeds while delete secrets and create clusterroles are denied.

D:

The situation is that a financial cooperative's on-call staff must inspect Events without modifying cluster-wide security settings. This action and check address the distinct objective “Use rollout status and undo to validate and recover a Deployment release” instead of the stated acceptance requirement. The matching action is to grant operators only required API verbs and resources using RBAC, then test with kubectl auth can-i and separate synthetic identities. Its confirming test is to with restricted identities, check get pods succeeds while delete secrets and create clusterroles are denied.

Question 241

A hospital dashboard Pod requests more memory than any eligible node can reserve. What technical action should the platform team take in this situation?

  1. Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources.
  2. Grant operators only required API verbs and resources using RBAC, then test with kubectl auth can-i and separate synthetic identities.
  3. Inspect probe configuration, Pod Ready conditions and restart events to identify whether traffic eligibility or container execution is failing.
  4. Run a logging or node monitoring agent as a DaemonSet when every eligible worker needs its own instance.

Explanation

Correct Answer

A:

Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. This resolves the issue because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests. To verify, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Incorrect Answers

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 scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

C:

This option addresses the distinct objective “Investigate readiness failures separately from liveness-related restarts”, not the immediate requirement. A failed readiness probe removes a Pod from ready Service endpoints, while failed liveness checks can restart a process; their operational consequences differ. For the stated case, the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

D:

This option addresses the distinct objective “Select DaemonSet for node-local agents rather than Deployment replica counts”, not the immediate requirement. A DaemonSet controller targets eligible nodes for a Pod each, adapting to node additions and labels rather than maintaining a global arbitrary replica count. For the stated case, the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Question 242

A hospital dashboard Pod requests more memory than any eligible node can reserve. What underlying Kubernetes behavior is most relevant to this technical decision?

  1. The scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.
  2. A NoSchedule taint repels Pods without a matching toleration; tolerance permits consideration but does not force placement on that node.
  3. Pod anti-affinity considers labels on existing Pods and topology keys such as hostname; it does not directly guarantee unlimited nodes.
  4. A rolling Deployment temporarily creates and removes Pods within its surge and unavailable budgets, but readiness is required for new replicas to count as available.

Explanation

Correct Answer

A:

The scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests. It supports this action: Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. To confirm, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Incorrect Answers

B:

That statement explains the distinct objective “Understand taints and tolerations as repulsion controls” rather than the cause in this case. The deciding mechanism here is that the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

C:

That statement explains the distinct objective “Use Pod anti-affinity to reduce correlated replica failure” rather than the cause in this case. The deciding mechanism here is that the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

D:

That statement explains the distinct objective “Configure Deployment rolling updates with availability safeguards” rather than the cause in this case. The deciding mechanism here is that the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Question 243

A hospital dashboard Pod requests more memory than any eligible node can reserve. What acceptance check most directly confirms this requirement is met?

  1. Attempt to create a privileged test Pod in a restricted namespace and inspect the admission rejection message.
  2. Build a test image, run a Pod and recreate it, verifying packaged files remain while an unmounted temporary file disappears.
  3. Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.
  4. Create a synthetic CPU-intensive workload with tight CPU limits and compare throttling metrics with an OOMKilled test Pod.

Explanation

Correct Answer

C:

Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it. This is the relevant test because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Incorrect Answers

A:

This check would help evaluate the distinct objective “Use Pod Security Standards to deny overly privileged Pod configurations”, but not the required result. For this case, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

B:

This check would help evaluate the distinct objective “Distinguish a container image from a running container and its writable layer”, but not the required result. For this case, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

D:

This check would help evaluate the distinct objective “Distinguish memory limits from CPU throttling for scheduling and runtime symptoms”, but not the required result. For this case, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Question 244

A hospital dashboard Pod requests more memory than any eligible node can reserve. The team suggests: “Increase a Pod's limits only while leaving its requests unrealistic, expecting this to make node placement succeed.” Which failure should the reviewer anticipate?

  1. The deployed artifact grows, may leak build credentials and exposes unnecessary packages.
  2. The Pod remains unschedulable because requested capacity and node feasibility did not change.
  3. The scheduler may evaluate an unintended Pod group or fail to spread the intended replicas.
  4. The change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.

Explanation

Correct Answer

B:

The Pod remains unschedulable because requested capacity and node feasibility did not change. The shortcut creates this risk because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Incorrect Answers

A:

That outcome concerns the distinct objective “Build smaller images with multistage builds and remove unnecessary tooling”; it is not the most direct consequence of this shortcut. The relevant consequence is that the Pod remains unschedulable because requested capacity and node feasibility did not change.

C:

That outcome concerns the distinct objective “Spread replicas across failure domains with topologySpreadConstraints”; it is not the most direct consequence of this shortcut. The relevant consequence is that the Pod remains unschedulable because requested capacity and node feasibility did not change.

D:

That outcome concerns the distinct objective “Choose ClusterIP, NodePort and LoadBalancer Service types for appropriate reachability”; it is not the most direct consequence of this shortcut. The relevant consequence is that the Pod remains unschedulable because requested capacity and node feasibility did not change.

Question 245

A hospital dashboard Pod requests more memory than any eligible node can reserve. Which engineering change and test jointly addresses the scenario?

  1. Route a measured fraction of traffic to a canary or switch between separately verified blue and green environments using an appropriate routing controller. Acceptance evidence: In a staging gateway route 5 percent to a canary, inspect version-specific success rates and verify a rollback rule.
  2. Use kubectl get for concise resource lists and kubectl describe for detailed status, conditions and Events when triaging a workload. Acceptance evidence: Compare kubectl get pods -o wide with kubectl describe pod for a test image-pull failure and note which output shows recent Events.
  3. Define meaningful topology keys, matching label selectors and skew limits when balancing eligible replicas across nodes or zones. Acceptance evidence: Deploy a matching replica set across two labeled zones and inspect skew after adding a new Pod.
  4. Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Acceptance evidence: Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Explanation

Correct Answer

D:

Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Acceptance evidence: Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it. This pairing is justified because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Incorrect Answers

A:

This action and check address the distinct objective “Distinguish canary and blue-green delivery strategies from Kubernetes Deployment defaults” instead of the stated acceptance requirement. The matching action is to set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Its confirming test is to set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

B:

This action and check address the distinct objective “Use kubectl get and describe for distinct inspection needs” instead of the stated acceptance requirement. The matching action is to set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Its confirming test is to set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

C:

This action and check address the distinct objective “Spread replicas across failure domains with topologySpreadConstraints” instead of the stated acceptance requirement. The matching action is to set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Its confirming test is to set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Question 246

A small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. Which engineering approach is the most appropriate for this cloud-native case?

  1. Define appropriate HTTP routing through an installed Ingress controller or Gateway API controller rather than expecting the API object alone to provision a proxy.
  2. Put non-sensitive application settings in ConfigMaps and put credentials in Secret objects with RBAC, encryption and external secret-management safeguards where appropriate.
  3. Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources.
  4. Label eligible nodes for a test hardware property and use nodeSelector when a Pod must run only on matching nodes.

Explanation

Correct Answer

C:

The situation is that a small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. This resolves the issue because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests. To verify, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Incorrect Answers

A:

This option addresses the distinct objective “Choose Ingress or Gateway API with an implementing controller for HTTP exposure”, not the immediate requirement. Ingress and Gateway API express routing intent, while an actual controller/dataplane implements TLS termination, listeners and backend forwarding. For the stated case, the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

B:

This option addresses the distinct objective “Distinguish ConfigMaps from Secrets and avoid storing credentials in public configuration”, not the immediate requirement. ConfigMaps are ordinary configuration data; Secret objects have a separate API but base64 encoding alone is not encryption and access requires policy. For the stated case, the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

D:

This option addresses the distinct objective “Use nodeSelector to place a workload on nodes with required labels”, not the immediate requirement. The scheduler enforces required node label matches in addition to resource and other constraints; labels do not create actual hardware capabilities. For the stated case, the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Question 247

A small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. What infrastructure principle makes the correct treatment effective?

  1. The scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.
  2. A DaemonSet controller targets eligible nodes for a Pod each, adapting to node additions and labels rather than maintaining a global arbitrary replica count.
  3. Kubernetes object transitions and application telemetry must be correlated; a healthy rollout condition alone does not prove user-level functionality.
  4. A Deployment creates or manages ReplicaSets, each ReplicaSet owns matching Pods, and selector consistency determines which Pods it counts.

Explanation

Correct Answer

A:

The situation is that a small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. The scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests. It supports this action: Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. To confirm, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Incorrect Answers

B:

That statement explains the distinct objective “Select DaemonSet for node-local agents rather than Deployment replica counts” rather than the cause in this case. The deciding mechanism here is that the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

C:

That statement explains the distinct objective “Correlate application rollout revisions with error spikes” rather than the cause in this case. The deciding mechanism here is that the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

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 scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Question 248

A small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. What verification result would most convincingly distinguish a working solution from a claim?

  1. Taint a lab worker dedicated=training:NoSchedule, then compare placement of Pods with and without the toleration.
  2. Deploy a matching replica set across two labeled zones and inspect skew after adding a new Pod.
  3. Use kubectl auth can-i --as a synthetic student to verify pod get allowed and secret delete denied in the specified namespace.
  4. Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Explanation

Correct Answer

D:

The situation is that a small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it. This is the relevant test because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Incorrect Answers

A:

This check would help evaluate the distinct objective “Understand taints and tolerations as repulsion controls”, but not the required result. For this case, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

B:

This check would help evaluate the distinct objective “Spread replicas across failure domains with topologySpreadConstraints”, but not the required result. For this case, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

C:

This check would help evaluate the distinct objective “Implement namespaced RBAC Roles for least-privilege resource permissions”, but not the required result. For this case, set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Question 249

A small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. The change review contains this proposal: “Increase a Pod's limits only while leaving its requests unrealistic, expecting this to make node placement succeed.” What risk matters most?

  1. Healthy desired-state definitions are lost while the node connectivity or capacity cause remains unresolved.
  2. The Pod remains unschedulable because requested capacity and node feasibility did not change.
  3. The image-pull issue stays unresolved because etcd is not the node component managing container starts.
  4. Priority differentiation is lost and capacity shortages still prevent scheduling or trigger avoidable disruption.

Explanation

Correct Answer

B:

The situation is that a small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. The Pod remains unschedulable because requested capacity and node feasibility did not change. The shortcut creates this risk because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Incorrect Answers

A:

That outcome concerns the distinct objective “Use node conditions and allocatable capacity to diagnose NotReady workloads”; it is not the most direct consequence of this shortcut. The relevant consequence is that the Pod remains unschedulable because requested capacity and node feasibility did not change.

C:

That outcome concerns the distinct objective “Recognize the kubelet role in local Pod lifecycle management”; it is not the most direct consequence of this shortcut. The relevant consequence is that the Pod remains unschedulable because requested capacity and node feasibility did not change.

D:

That outcome concerns the distinct objective “Use PriorityClasses and understand preemption without assuming they guarantee availability”; it is not the most direct consequence of this shortcut. The relevant consequence is that the Pod remains unschedulable because requested capacity and node feasibility did not change.

Question 250

A small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. Which implementation together with matching acceptance evidence best meets this case?

  1. Taint dedicated nodes and grant only intended workloads matching tolerations, combining node affinity when exclusive placement is required. Acceptance evidence: Taint a lab worker dedicated=training:NoSchedule, then compare placement of Pods with and without the toleration.
  2. Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Acceptance evidence: Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.
  3. Run a logging or node monitoring agent as a DaemonSet when every eligible worker needs its own instance. Acceptance evidence: Add a test worker node and inspect the corresponding DaemonSet agent Pod without scaling a Deployment.
  4. Run controlled DNS queries and IP connectivity tests before changing service discovery, CNI routes or application endpoints. Acceptance evidence: Test the same Service from a diagnostic Pod by fully qualified DNS name and known ClusterIP, then inspect CoreDNS logs if only resolution fails.

Explanation

Correct Answer

B:

The situation is that a small university cluster has spare average CPU but a large requested burst prevents one job from scheduling. Set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Acceptance evidence: Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it. This pairing is justified because the scheduler evaluates requests against node allocatable capacity; limits govern runtime ceilings and do not substitute for scheduling requests.

Incorrect Answers

A:

This action and check address the distinct objective “Understand taints and tolerations as repulsion controls” instead of the stated acceptance requirement. The matching action is to set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Its confirming test is to set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

C:

This action and check address the distinct objective “Select DaemonSet for node-local agents rather than Deployment replica counts” instead of the stated acceptance requirement. The matching action is to set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Its confirming test is to set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

D:

This action and check address the distinct objective “Diagnose cluster DNS separately from Pod network reachability” instead of the stated acceptance requirement. The matching action is to set realistic CPU and memory requests for Pods and investigate FailedScheduling when no node has sufficient allocatable resources. Its confirming test is to set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Kubernetes and Cloud Native Associate (KCNA) Practice Tests