Question 160Only Pods on one worker cannot resolve names and their resolv.conf points at an obsolete cluster DNS IP. What is the most direct consequence if the underlying problem is left unresolved? One malformed DNS configuration can disrupt discovery cluster-wide. Cluster-internal discovery can break while public DNS continues to work. DNS failures appear node-specific even when CoreDNS Pods are healthy. Applications may appear network-isolated because they cannot resolve healthy destinations. ExplanationCorrect Answer C:DNS failures appear node-specific even when CoreDNS Pods are healthy. This directly follows from the failed condition. The preventive correction is: Correct the kubelet clusterDNS configuration or node DNS distribution and restart affected Pods as needed. The governing Kubernetes behavior is: Pod DNS settings may be generated from kubelet node configuration and dnsPolicy.Incorrect Answers A:CoreDNS must parse its plugin chain before it can serve cluster DNS queries. That does not describe the principal exposure from the stated failure. The direct avoidable risk is: DNS failures appear node-specific even when CoreDNS Pods are healthy. B:Cluster-local DNS records depend on CoreDNS observing Service and EndpointSlice resources. That does not describe the principal exposure from the stated failure. The direct avoidable risk is: DNS failures appear node-specific even when CoreDNS Pods are healthy. D:DNS name resolution is a separate network flow from the application connection. That does not describe the principal exposure from the stated failure. The direct avoidable risk is: DNS failures appear node-specific even when CoreDNS Pods are healthy.
Question 161An HTTPRoute remains Accepted=False and clients get 404 while the Gateway address is reachable. Following the proposed change—Inspect route parentRefs, listener compatibility and allowedRoutes conditions before changing the backend—which observation best demonstrates that the particular fault is resolved? A host-header and path-specific test reaches the intended Service through the controller. The route becomes Accepted and requests to the matching host/path receive a valid backend response. The expected number of ready endpoints is present and Service load tests distribute successfully. EndpointSlices list ready Pods and a port-specific request succeeds after selector repair. ExplanationCorrect Answer B:The route becomes Accepted and requests to the matching host/path receive a valid backend response. This validates the stated intervention—inspect route parentRefs, listener compatibility and allowedRoutes conditions before changing the backend.—rather than an unrelated cluster change. The relevant mechanism is: Gateway API status conditions identify attachment or match failures separate from backend Pod readiness.Incorrect Answers A:Ingress routing adds a separate HTTP match layer beyond normal Service reachability. This relates to a separate check and does not verify the specified repair. The relevant acceptance evidence is: The route becomes Accepted and requests to the matching host/path receive a valid backend response. C:Services generally route only to endpoints considered ready, so Pod IP probes do not establish Service capacity. This relates to a separate check and does not verify the specified repair. The relevant acceptance evidence is: The route becomes Accepted and requests to the matching host/path receive a valid backend response. D:DNS resolution and a Service object do not guarantee a valid ready backend endpoint. This relates to a separate check and does not verify the specified repair. The relevant acceptance evidence is: The route becomes Accepted and requests to the matching host/path receive a valid backend response.
Question 162A worker shows MemoryPressure while one batch Pod repeatedly exceeds its memory limit. An engineer recommends: Inspect memory metrics and OOMKilled events, then right-size the Pod and add safe limits or capacity. Which Kubernetes behavior best explains why this correction fits? Node PIDPressure reflects process-ID exhaustion rather than CPU, memory or disk usage. The kernel and kubelet can terminate memory-hungry containers independently of scheduler requests. Kubelet disk-pressure signals can cause eviction and scheduling taints independent of CPU utilization. Scheduler taints are placement constraints distinct from raw allocatable capacity. ExplanationCorrect Answer B:The kernel and kubelet can terminate memory-hungry containers independently of scheduler requests. This explains why the proposed action—inspect memory metrics and OOMKilled events, then right-size the Pod and add safe limits or capacity.—is appropriate. Direct confirmation is: The workload completes under tested memory bounds and node pressure clears.Incorrect Answers A:Node PIDPressure reflects process-ID exhaustion rather than CPU, memory or disk usage. This does not establish the proposed intervention. The governing principle here is: The kernel and kubelet can terminate memory-hungry containers independently of scheduler requests. Apply it by: Inspect memory metrics and OOMKilled events, then right-size the Pod and add safe limits or capacity. C:Kubelet disk-pressure signals can cause eviction and scheduling taints independent of CPU utilization. This does not establish the proposed intervention. The governing principle here is: The kernel and kubelet can terminate memory-hungry containers independently of scheduler requests. Apply it by: Inspect memory metrics and OOMKilled events, then right-size the Pod and add safe limits or capacity. D:Scheduler taints are placement constraints distinct from raw allocatable capacity. This does not establish the proposed intervention. The governing principle here is: The kernel and kubelet can terminate memory-hungry containers independently of scheduler requests. Apply it by: Inspect memory metrics and OOMKilled events, then right-size the Pod and add safe limits or capacity.
Question 163An automation script tries to join a node using a CA hash copied from a different Kubernetes cluster. What is the most direct consequence if the underlying problem is left unresolved? Skipping discovery checks can bind a host to an unintended endpoint. Node additions fail or stale tokens remain in circulation. The cluster may appear multi-master while only one control-plane node functions. Cluster workloads remain unable to communicate across Pod networks. ExplanationCorrect Answer A:Skipping discovery checks can bind a host to an unintended endpoint. This directly follows from the failed condition. The preventive correction is: Regenerate the token-based join command with the expected cluster CA public-key hash. The governing Kubernetes behavior is: kubeadm discovery pins the trust anchor so a worker does not enroll with the wrong control plane.Incorrect Answers B:Bootstrap tokens have limited lifetimes and support authenticated discovery during node enrollment. That does not describe the principal exposure from the stated failure. The direct avoidable risk is: Skipping discovery checks can bind a host to an unintended endpoint. C:Additional control-plane nodes require appropriate cluster certificates and an established shared control-plane endpoint. That does not describe the principal exposure from the stated failure. The direct avoidable risk is: Skipping discovery checks can bind a host to an unintended endpoint. D:kubeadm bootstraps the control plane but does not provision a complete Pod network plugin by default. That does not describe the principal exposure from the stated failure. The direct avoidable risk is: Skipping discovery checks can bind a host to an unintended endpoint.
Question 164Three stacked-etcd control-plane nodes are planned, but the team schedules all of them on one physical hypervisor. An engineer recommends: Distribute control-plane and etcd members across independent failure domains. Which Kubernetes behavior best explains why this correction fits? Quorum and replication do not protect against a common power or hypervisor failure domain. Highly available control planes depend on load-balanced API access and durable quorum-backed state. Etcd commits require a majority of voting members; removal and replacement must preserve quorum. TLS clients verify the endpoint hostname against the presented certificate SANs. ExplanationCorrect Answer A:Quorum and replication do not protect against a common power or hypervisor failure domain. This explains why the proposed action—distribute control-plane and etcd members across independent failure domains.—is appropriate. Direct confirmation is: An entire host outage leaves a majority of etcd voters and API access available.Incorrect Answers B:Highly available control planes depend on load-balanced API access and durable quorum-backed state. This does not establish the proposed intervention. The governing principle here is: Quorum and replication do not protect against a common power or hypervisor failure domain. Apply it by: Distribute control-plane and etcd members across independent failure domains. C:Etcd commits require a majority of voting members; removal and replacement must preserve quorum. This does not establish the proposed intervention. The governing principle here is: Quorum and replication do not protect against a common power or hypervisor failure domain. Apply it by: Distribute control-plane and etcd members across independent failure domains. D:TLS clients verify the endpoint hostname against the presented certificate SANs. This does not establish the proposed intervention. The governing principle here is: Quorum and replication do not protect against a common power or hypervisor failure domain. Apply it by: Distribute control-plane and etcd members across independent failure domains.
Question 165An application uses nslookup for the short name payments from a different namespace and resolves the wrong object. Following the proposed change—Use payments.<namespace>.svc.cluster.local or a valid namespace-qualified name—which observation best demonstrates that the particular fault is resolved? Lookup returns the intended namespace's Service address and an HTTP probe succeeds. A test Pod resolves the target Service FQDN to its intended ClusterIP. New Pods on the worker receive the current cluster DNS IP and resolve known Services. Queries on affected nodes reach the cache and fall back to upstream CoreDNS appropriately. ExplanationCorrect Answer A:Lookup returns the intended namespace's Service address and an HTTP probe succeeds. This validates the stated intervention—use payments.<namespace>.svc.cluster.local or a valid namespace-qualified name.—rather than an unrelated cluster change. The relevant mechanism is: Pod DNS search domains are namespace-relative and short names are not globally unique.Incorrect Answers B:Cluster-local DNS records depend on CoreDNS observing Service and EndpointSlice resources. This relates to a separate check and does not verify the specified repair. The relevant acceptance evidence is: Lookup returns the intended namespace's Service address and an HTTP probe succeeds. C:Pod DNS settings may be generated from kubelet node configuration and dnsPolicy. This relates to a separate check and does not verify the specified repair. The relevant acceptance evidence is: Lookup returns the intended namespace's Service address and an HTTP probe succeeds. D:Node-local DNS caching still requires Pod resolvers to reach the chosen local listener. This relates to a separate check and does not verify the specified repair. The relevant acceptance evidence is: Lookup returns the intended namespace's Service address and an HTTP probe succeeds.
Question 166A namespace maintainer can delete Deployments in every team namespace after a broad ClusterRoleBinding was applied. Which Kubernetes administration action most directly addresses the observed failure? Update the intended ClusterRole rules or its controlled aggregation labels and verify the bound roles. Bind an appropriate namespace-scoped Role to that authenticated user or group after checking the effective identity. Grant the narrowly required pods/attach or pods/exec subresource verbs according to the approved response workflow. Replace the cluster-wide binding with a namespaced RoleBinding granting only needed resource verbs. ExplanationCorrect Answer D:Replace the cluster-wide binding with a namespaced RoleBinding granting only needed resource verbs. This corrects the specific failure because a RoleBinding restricts a Role or referenced ClusterRole to its own namespace; a ClusterRoleBinding grants across namespaces. Verify it by checking: An impersonated authorization check denies deletion in another team's namespace but permits the required local update.Incorrect Answers A:Aggregated ClusterRoles rely on matching labels on source ClusterRoles; ordinary ClusterRoles do not aggregate automatically. That is relevant to a different intervention. For the stated situation, the required action is: Replace the cluster-wide binding with a namespaced RoleBinding granting only needed resource verbs. The governing reason is: A RoleBinding restricts a Role or referenced ClusterRole to its own namespace; a ClusterRoleBinding grants across namespaces. B:Authentication establishes identity while authorization separately decides permitted API verbs and resources. That is relevant to a different intervention. For the stated situation, the required action is: Replace the cluster-wide binding with a namespaced RoleBinding granting only needed resource verbs. The governing reason is: A RoleBinding restricts a Role or referenced ClusterRole to its own namespace; a ClusterRoleBinding grants across namespaces. C:RBAC treats interactive Pod subresources separately from operations on the parent Pod resource. That is relevant to a different intervention. For the stated situation, the required action is: Replace the cluster-wide binding with a namespaced RoleBinding granting only needed resource verbs. The governing reason is: A RoleBinding restricts a Role or referenced ClusterRole to its own namespace; a ClusterRoleBinding grants across namespaces.
Question 167A newly initialized control plane displays NotReady nodes and CoreDNS Pods stay Pending before any CNI is installed. Which Kubernetes administration action most directly addresses the observed failure? Install a compatible CNI after successful kubeadm initialization and validate its daemon components. Use the supported kubeadm control-plane join procedure with securely distributed certificate material. Use a kubeadm configuration that matches the selected CNI address pool and initialize with the intended networking values. Regenerate the token-based join command with the expected cluster CA public-key hash. ExplanationCorrect Answer A:Install a compatible CNI after successful kubeadm initialization and validate its daemon components. This corrects the specific failure because kubeadm bootstraps the control plane but does not provision a complete Pod network plugin by default. Verify it by checking: CNI node agents become healthy and CoreDNS Pods start with working service discovery.Incorrect Answers B:Additional control-plane nodes require appropriate cluster certificates and an established shared control-plane endpoint. That is relevant to a different intervention. For the stated situation, the required action is: Install a compatible CNI after successful kubeadm initialization and validate its daemon components. The governing reason is: kubeadm bootstraps the control plane but does not provision a complete Pod network plugin by default. C:Cluster Pod CIDRs and CNI IPAM assumptions must agree for routable Pod addressing. That is relevant to a different intervention. For the stated situation, the required action is: Install a compatible CNI after successful kubeadm initialization and validate its daemon components. The governing reason is: kubeadm bootstraps the control plane but does not provision a complete Pod network plugin by default. D:kubeadm discovery pins the trust anchor so a worker does not enroll with the wrong control plane. That is relevant to a different intervention. For the stated situation, the required action is: Install a compatible CNI after successful kubeadm initialization and validate its daemon components. The governing reason is: kubeadm bootstraps the control plane but does not provision a complete Pod network plugin by default.
Question 168A team uses kubectl logs against a Pending Pod and assumes no log output proves the image is healthy. An engineer recommends: Inspect Pod events and waiting reasons before expecting a container log stream. Which Kubernetes behavior best explains why this correction fits? Restarted containers can have a previous log stream that is distinct from the current one. kubectl logs primarily reads the container runtime's captured stdout and stderr streams. kubectl log filters help isolate relevant events and reduce diagnostic noise. Containers that never start may have no runtime logs; scheduling and image events carry the relevant diagnosis. ExplanationCorrect Answer D:Containers that never start may have no runtime logs; scheduling and image events carry the relevant diagnosis. This explains why the proposed action—inspect Pod events and waiting reasons before expecting a container log stream.—is appropriate. Direct confirmation is: The exact Pending or waiting reason is found and the first successful start produces log output.Incorrect Answers A:Restarted containers can have a previous log stream that is distinct from the current one. This does not establish the proposed intervention. The governing principle here is: Containers that never start may have no runtime logs; scheduling and image events carry the relevant diagnosis. Apply it by: Inspect Pod events and waiting reasons before expecting a container log stream. B:kubectl logs primarily reads the container runtime's captured stdout and stderr streams. This does not establish the proposed intervention. The governing principle here is: Containers that never start may have no runtime logs; scheduling and image events carry the relevant diagnosis. Apply it by: Inspect Pod events and waiting reasons before expecting a container log stream. C:kubectl log filters help isolate relevant events and reduce diagnostic noise. This does not establish the proposed intervention. The governing principle here is: Containers that never start may have no runtime logs; scheduling and image events carry the relevant diagnosis. Apply it by: Inspect Pod events and waiting reasons before expecting a container log stream.
Question 169A Service resolves to a ClusterIP but curl returns connection refused after a Deployment label change. Which Kubernetes administration action most directly addresses the observed failure? Compare Service selectors, ready EndpointSlices and actual container listener ports. Inspect CoreDNS readiness, Service endpoints and the calling Pod's resolv.conf. Verify node-local DNS listener addresses and Pod resolv.conf propagation on affected nodes. Verify ingressClassName, host/path matches and controller reconciliation for the intended Ingress. ExplanationCorrect Answer A:Compare Service selectors, ready EndpointSlices and actual container listener ports. This corrects the specific failure because dNS resolution and a Service object do not guarantee a valid ready backend endpoint. Verify it by checking: EndpointSlices list ready Pods and a port-specific request succeeds after selector repair.Incorrect Answers B:Pod networking can work while the separate cluster DNS service path is unavailable. That is relevant to a different intervention. For the stated situation, the required action is: Compare Service selectors, ready EndpointSlices and actual container listener ports. The governing reason is: DNS resolution and a Service object do not guarantee a valid ready backend endpoint. C:Per-node DNS cache configuration can produce node-specific resolution failures. That is relevant to a different intervention. For the stated situation, the required action is: Compare Service selectors, ready EndpointSlices and actual container listener ports. The governing reason is: DNS resolution and a Service object do not guarantee a valid ready backend endpoint. D:Ingress routing adds a separate HTTP match layer beyond normal Service reachability. That is relevant to a different intervention. For the stated situation, the required action is: Compare Service selectors, ready EndpointSlices and actual container listener ports. The governing reason is: DNS resolution and a Service object do not guarantee a valid ready backend endpoint.
Question 170A NodePort Service is accessible through worker addresses but an operator expects it to create a cloud load balancer automatically. Which Kubernetes administration action most directly addresses the observed failure? Return to ClusterIP and remove the unnecessary external frontend. Create and maintain appropriate EndpointSlice resources with correct labels and target addresses. Use a LoadBalancer Service with the installed infrastructure integration when a managed external frontend is required. Document and use headless DNS/endpoint discovery for per-Pod identities instead of VIP load balancing. ExplanationCorrect Answer C:Use a LoadBalancer Service with the installed infrastructure integration when a managed external frontend is required. This corrects the specific failure because nodePort exposes a port on nodes, while LoadBalancer depends on provider or local controller provisioning. Verify it by checking: The Service receives the expected load balancer ingress and end-to-end external probes succeed.Incorrect Answers A:ClusterIP is intended for internal service discovery; LoadBalancer requests external integration where supported. That is relevant to a different intervention. For the stated situation, the required action is: Use a LoadBalancer Service with the installed infrastructure integration when a managed external frontend is required. The governing reason is: NodePort exposes a port on nodes, while LoadBalancer depends on provider or local controller provisioning. B:Selectorless Services require explicitly associated endpoints because no controller infers backing Pods. That is relevant to a different intervention. For the stated situation, the required action is: Use a LoadBalancer Service with the installed infrastructure integration when a managed external frontend is required. The governing reason is: NodePort exposes a port on nodes, while LoadBalancer depends on provider or local controller provisioning. D:A headless Service (clusterIP None) publishes endpoint records rather than a normal ClusterIP proxy target. That is relevant to a different intervention. For the stated situation, the required action is: Use a LoadBalancer Service with the installed infrastructure integration when a managed external frontend is required. The governing reason is: NodePort exposes a port on nodes, while LoadBalancer depends on provider or local controller provisioning.