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 46

Question 450

A regional retailer deploys networking add-ons and needs to distinguish CNI setup from Service object configuration. Which engineering change and test jointly addresses the scenario?

  1. Check that a supported CNI plugin assigns reachable Pod addresses across worker nodes before troubleshooting Service routing or DNS names. Acceptance evidence: Deploy two synthetic Pods on different nodes and test direct Pod IP connectivity before testing the Service virtual IP.
  2. Record non-identifying build or audit metadata as annotations and use labels for indexing, grouping and selector-based routing. Acceptance evidence: Annotate a Deployment with release notes and verify its Service still selects Pods using explicit app labels.
  3. Verify that the installed Container Storage Interface driver supports the requested persistent storage and inspect driver controller/node components when mounting fails. Acceptance evidence: Inspect CSI driver registration, test provisioning a claim and review attachment/mount Events for a synthetic workload.
  4. Match a Service's exposed port and targetPort to the actual listening application container, checking protocol and named ports when used. Acceptance evidence: Inspect the container listener, Service port fields and a test Pod connection before changing unrelated firewall settings.

Explanation

Correct Answer

A:

The situation is that a regional retailer deploys networking add-ons and needs to distinguish CNI setup from Service object configuration. Check that a supported CNI plugin assigns reachable Pod addresses across worker nodes before troubleshooting Service routing or DNS names. Acceptance evidence: Deploy two synthetic Pods on different nodes and test direct Pod IP connectivity before testing the Service virtual IP. This pairing is justified because Kubernetes expects a Pod network providing Pod-to-Pod connectivity; the CNI implementation configures networking while Services provide stable virtual access to changing endpoints.

Incorrect Answers

B:

This action and check address the distinct objective “Use annotations for tool metadata rather than workload selection” instead of the stated acceptance requirement. The matching action is to check that a supported CNI plugin assigns reachable Pod addresses across worker nodes before troubleshooting Service routing or DNS names. Its confirming test is to deploy two synthetic Pods on different nodes and test direct Pod IP connectivity before testing the Service virtual IP.

C:

This action and check address the distinct objective “Understand CSI drivers and volume attachment responsibilities” instead of the stated acceptance requirement. The matching action is to check that a supported CNI plugin assigns reachable Pod addresses across worker nodes before troubleshooting Service routing or DNS names. Its confirming test is to deploy two synthetic Pods on different nodes and test direct Pod IP connectivity before testing the Service virtual IP.

D:

This action and check address the distinct objective “Understand ports, targetPort and protocol mapping in a Service” instead of the stated acceptance requirement. The matching action is to check that a supported CNI plugin assigns reachable Pod addresses across worker nodes before troubleshooting Service routing or DNS names. Its confirming test is to deploy two synthetic Pods on different nodes and test direct Pod IP connectivity before testing the Service virtual IP.

Question 451

A transit API needs an internal PostgreSQL endpoint and a separately published public front end. Which supported Kubernetes practice directly addresses the stated requirement?

  1. Combine a default-deny baseline with narrow app-label and namespace-label NetworkPolicy rules for approved traffic.
  2. Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access.
  3. Match a Service's exposed port and targetPort to the actual listening application container, checking protocol and named ports when used.
  4. Recognize Kubernetes for orchestration, Prometheus for metrics, Envoy for data-plane proxying and Fluentd for log collection in the cloud-native landscape.

Explanation

Correct Answer

B:

Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. This resolves the issue because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure. To verify, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Incorrect Answers

A:

This option addresses the distinct objective “Limit workload-to-workload access with explicit NetworkPolicy allow rules”, not the immediate requirement. NetworkPolicies select Pods and define allowed flows; when a Pod becomes isolated, traffic is allowed only as permitted by applicable rules and plugin behavior. For the stated case, service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

C:

This option addresses the distinct objective “Understand ports, targetPort and protocol mapping in a Service”, not the immediate requirement. A Service exposes port to clients and forwards to targetPort on selected endpoints; a mismatched targetPort can break delivery even with valid DNS and selectors. For the stated case, service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

D:

This option addresses the distinct objective “Identify CNCF ecosystem projects by their role rather than assuming all are Kubernetes core”, not the immediate requirement. CNCF projects address different layers of a cloud-native platform and interoperability does not turn them into interchangeable cluster control-plane components. For the stated case, service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Question 452

A transit API needs an internal PostgreSQL endpoint and a separately published public front end. Which causal explanation supports the intended design choice?

  1. Service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.
  2. Kubernetes expects a Pod network providing Pod-to-Pod connectivity; the CNI implementation configures networking while Services provide stable virtual access to changing endpoints.
  3. The scheduler enforces required node label matches in addition to resource and other constraints; labels do not create actual hardware capabilities.
  4. A NotReady or pressure-affected node can stop hosting healthy Pods even when their Deployment and Service definitions remain valid.

Explanation

Correct Answer

A:

Service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure. It supports this action: Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. To confirm, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Incorrect Answers

B:

That statement explains the distinct objective “Distinguish the CNI Pod network from Service discovery and routing” rather than the cause in this case. The deciding mechanism here is that service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

C:

That statement explains the distinct objective “Use nodeSelector to place a workload on nodes with required labels” rather than the cause in this case. The deciding mechanism here is that service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

D:

That statement explains the distinct objective “Use node conditions and allocatable capacity to diagnose NotReady workloads” rather than the cause in this case. The deciding mechanism here is that service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Question 453

A transit API needs an internal PostgreSQL endpoint and a separately published public front end. Which test provides the strongest evidence of a correct implementation?

  1. Deploy a test hostname route, verify a compatible controller exists and inspect the programmed listener and backend status.
  2. Set replicas from two to four, inspect generation and observed generation and watch readyReplicas converge.
  3. Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.
  4. Inspect the container listener, Service port fields and a test Pod connection before changing unrelated firewall settings.

Explanation

Correct Answer

C:

Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration. This is the relevant test because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Incorrect Answers

A:

This check would help evaluate the distinct objective “Choose Ingress or Gateway API with an implementing controller for HTTP exposure”, but not the required result. For this case, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

B:

This check would help evaluate the distinct objective “Explain desired state versus observed status in Kubernetes objects”, but not the required result. For this case, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

D:

This check would help evaluate the distinct objective “Understand ports, targetPort and protocol mapping in a Service”, but not the required result. For this case, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Question 454

A transit API needs an internal PostgreSQL endpoint and a separately published public front end. A shortcut is proposed: “Change an internal database Service to unrestricted NodePort because another Pod cannot resolve its DNS name.” Which technical consequence follows most closely?

  1. The route remains nonfunctional because nothing reconciles it into an application traffic proxy.
  2. Incident diagnosis confuses placement failures with container startup errors and targets the wrong component.
  3. The change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.
  4. The subject receives unnecessary authority to alter privileged resources or unrelated namespaces.

Explanation

Correct Answer

C:

The change unnecessarily exposes a data service externally while the original DNS problem remains unresolved. The shortcut creates this risk because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Incorrect Answers

A:

That outcome concerns the distinct objective “Choose Ingress or Gateway API with an implementing controller for HTTP exposure”; it is not the most direct consequence of this shortcut. The relevant consequence is that the change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.

B:

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 the change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.

D:

That outcome concerns the distinct objective “Implement namespaced RBAC Roles for least-privilege resource permissions”; it is not the most direct consequence of this shortcut. The relevant consequence is that the change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.

Question 455

A transit API needs an internal PostgreSQL endpoint and a separately published public front end. Which combined solution and independent check are most directly justified?

  1. Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Acceptance evidence: Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.
  2. Check EndpointSlices and Pod readiness when a Service exists but connections reach no application backends. Acceptance evidence: Compare a Service's label selector, EndpointSlices and Pod readiness conditions before changing external load-balancer settings.
  3. Define appropriate HTTP routing through an installed Ingress controller or Gateway API controller rather than expecting the API object alone to provision a proxy. Acceptance evidence: Deploy a test hostname route, verify a compatible controller exists and inspect the programmed listener and backend status.
  4. 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.

Explanation

Correct Answer

A:

Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Acceptance evidence: Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration. This pairing is justified because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Incorrect Answers

B:

This action and check address the distinct objective “Use EndpointSlices to connect Service selectors with actual backend Pods” instead of the stated acceptance requirement. The matching action is to use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Its confirming test is to create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

C:

This action and check address the distinct objective “Choose Ingress or Gateway API with an implementing controller for HTTP exposure” instead of the stated acceptance requirement. The matching action is to use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Its confirming test is to create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

D:

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 use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Its confirming test is to create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Question 456

A museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. What technical action should the platform team take in this situation?

  1. Create a Role with only required verbs and resource types, and bind it to the intended subject within the target namespace.
  2. Use the scheduler's node-binding decision to explain initial Pod placement, then inspect the chosen node's kubelet for local container lifecycle status.
  3. Check that a supported CNI plugin assigns reachable Pod addresses across worker nodes before troubleshooting Service routing or DNS names.
  4. Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access.

Explanation

Correct Answer

D:

The situation is that a museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. This resolves the issue because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure. To verify, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Incorrect Answers

A:

This option addresses the distinct objective “Implement namespaced RBAC Roles for least-privilege resource permissions”, not the immediate requirement. RBAC evaluates API verbs, resources and scope; a Role is namespaced and does not grant cluster-wide access merely because the subject can authenticate. For the stated case, service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

B:

This option addresses the distinct objective “Separate kube-scheduler decisions from kubelet execution”, not the immediate requirement. The scheduler selects a suitable node for an unscheduled Pod; kubelet on that node uses the runtime to start and monitor containers. For the stated case, service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

C:

This option addresses the distinct objective “Distinguish the CNI Pod network from Service discovery and routing”, not the immediate requirement. Kubernetes expects a Pod network providing Pod-to-Pod connectivity; the CNI implementation configures networking while Services provide stable virtual access to changing endpoints. For the stated case, service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Question 457

A museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. What underlying Kubernetes behavior is most relevant to this technical decision?

  1. Service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.
  2. Each kubelet watches assigned Pod specifications and coordinates the container runtime, volumes and health information on its node.
  3. EndpointSlices describe endpoint addresses and readiness associated with a Service, allowing its dataplane to route toward matching healthy Pods.
  4. Ingress and Gateway API express routing intent, while an actual controller/dataplane implements TLS termination, listeners and backend forwarding.

Explanation

Correct Answer

A:

The situation is that a museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. Service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure. It supports this action: Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. To confirm, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Incorrect Answers

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 service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

C:

That statement explains the distinct objective “Use EndpointSlices to connect Service selectors with actual backend Pods” rather than the cause in this case. The deciding mechanism here is that service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

D:

That statement explains the distinct objective “Choose Ingress or Gateway API with an implementing controller for HTTP exposure” rather than the cause in this case. The deciding mechanism here is that service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Question 458

A museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. What acceptance check most directly confirms this requirement is met?

  1. Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.
  2. Inspect the container listener, Service port fields and a test Pod connection before changing unrelated firewall settings.
  3. Create a small claim in a test StorageClass, inspect its Bound status and restart the consuming Pod to check data persistence.
  4. Set an intentionally excessive memory request in a lab and inspect Pod Pending Events before adjusting it.

Explanation

Correct Answer

A:

The situation is that a museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration. This is the relevant test because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Incorrect Answers

B:

The situation is that a museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. This check would help evaluate the distinct objective “Understand ports, targetPort and protocol mapping in a Service”, but not the required result. For this case, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

C:

This check would help evaluate the distinct objective “Understand PersistentVolumeClaim binding to persistent storage resources”, but not the required result. For this case, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

D:

This check would help evaluate the distinct objective “Use container resource requests to help the scheduler fit Pods on nodes”, but not the required result. For this case, create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Question 459

A museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. The team suggests: “Change an internal database Service to unrestricted NodePort because another Pod cannot resolve its DNS name.” Which failure should the reviewer anticipate?

  1. Cross-namespace calls can fail or resolve a same-named but unrelated local Service.
  2. The change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.
  3. The command can mutate production objects although the operator intended a disposable laboratory cluster.
  4. The route remains nonfunctional because nothing reconciles it into an application traffic proxy.

Explanation

Correct Answer

B:

The situation is that a museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. The change unnecessarily exposes a data service externally while the original DNS problem remains unresolved. The shortcut creates this risk because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Incorrect Answers

A:

That outcome concerns the distinct objective “Verify CoreDNS resolution and namespace-qualified Service names”; it is not the most direct consequence of this shortcut. The relevant consequence is that the change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.

C:

That outcome concerns the distinct objective “Manage kubectl contexts to avoid changes in the wrong cluster”; it is not the most direct consequence of this shortcut. The relevant consequence is that the change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.

D:

The situation is that a museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. That outcome concerns the distinct objective “Choose Ingress or Gateway API with an implementing controller for HTTP exposure”; it is not the most direct consequence of this shortcut. The relevant consequence is that the change unnecessarily exposes a data service externally while the original DNS problem remains unresolved.

Question 460

A museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. Which engineering change and test jointly addresses the scenario?

  1. Check that a supported CNI plugin assigns reachable Pod addresses across worker nodes before troubleshooting Service routing or DNS names. Acceptance evidence: Deploy two synthetic Pods on different nodes and test direct Pod IP connectivity before testing the Service virtual IP.
  2. 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.
  3. Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Acceptance evidence: Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.
  4. Give clients a Service DNS name rather than hardcoding Pod IP addresses that can change when replicas are replaced. Acceptance evidence: Delete and replace a Deployment Pod and verify a client continues to reach its Service DNS name despite changed backend Pod addresses.

Explanation

Correct Answer

C:

The situation is that a museum accidentally makes its internal cache service accessible on node ports while debugging client resolution. Use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Acceptance evidence: Create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration. This pairing is justified because service type determines how clients can reach a stable Service: ClusterIP is internal, NodePort exposes a port on nodes, and LoadBalancer integrates external infrastructure.

Incorrect Answers

A:

This action and check address the distinct objective “Distinguish the CNI Pod network from Service discovery and routing” instead of the stated acceptance requirement. The matching action is to use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Its confirming test is to create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

B:

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 use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Its confirming test is to create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

D:

This action and check address the distinct objective “Distinguish Pod IPs from stable Services during rescheduling” instead of the stated acceptance requirement. The matching action is to use ClusterIP for internal backends and a properly controlled NodePort or supported LoadBalancer integration for justified external access. Its confirming test is to create a ClusterIP test Service and validate internal access, then compare the reachable endpoints under an authorized LoadBalancer configuration.

Kubernetes and Cloud Native Associate (KCNA) Practice Tests