KCNA Practice Test 32 — 15 Questions

Question 1

What is the primary purpose of Kubernetes?

Accepted Answer

To orchestrate containers across a cluster. Kubernetes is a container orchestration platform designed to automate the deployment, scaling, and management of containerized applications across a cluster of nodes. Its primary purpose is to abstract the underlying infrastructure and provide a declarative way to run and manage containers, ensuring desired state and self-healing. This directly corresponds to orchestrating containers across a cluster, not compiling code, running VMs, or managing physical servers.

Answer

To compile source code

Answer

To run virtual machines

Answer

To manage physical servers

Question 2

A developer wants to monitor the health of a Kubernetes deployment by checking if the number of ready replicas matches the desired replicas. Which metric from kube-state-metrics should they query?

Accepted Answer

kube_deployment_status_replicas_ready. `kube_deployment_status_replicas_ready` directly exposes the number of ready replicas for a Deployment, which can be compared against `kube_deployment_spec_replicas` to determine if the desired state matches the actual healthy state. This metric is emitted by kube-state-metrics, which generates Prometheus-compatible metrics from Kubernetes API objects, making it the standard choice for monitoring Deployment health.

Answer

kube_deployment_spec_replicas

Answer

kube_node_status_condition

Answer

kube_pod_container_status_running

Question 3

Which kubectl command would you use to view detailed information about a specific pod, including events and container status?

Accepted Answer

kubectl describe pod . `kubectl describe pod ` provides a comprehensive view of a pod's metadata, spec, status, conditions, container resource usage, and a chronological list of events (e.g., scheduling, pulling images, container restarts). This command aggregates information from the Kubernetes API server, including the pod's current state and lifecycle events, which is essential for debugging pod failures or unexpected behavior.

Answer

kubectl explain pod

Answer

kubectl get pod <pod-name>

Answer

kubectl logs pod <pod-name>

Question 4

What is the difference between a liveness probe and a readiness probe?

Accepted Answer

Liveness probe indicates if the container is alive; if it fails, the container is restarted. A liveness probe determines if a container is still running (alive). If the liveness probe fails, Kubernetes restarts the container based on the `restartPolicy`. This is distinct from a readiness probe, which checks if a container is ready to accept traffic and removes it from Service endpoints if it fails.

Answer

Liveness probe checks if the container is ready to serve traffic

Answer

Readiness probe indicates if the container is healthy; liveness indicates if it should be restarted

Answer

Both probes serve the same purpose but with different endpoints

Question 5

Which of the following are core components of the Flux GitOps toolkit?

Accepted Answer

Helm Controller. The core components of the Flux GitOps toolkit include Source Controller, Helm Controller, and Kustomize Controller. These controllers manage sources, Helm releases, and Kustomize overlays respectively. Helm (option B) is a standalone tool, and ArgoCD (option D) is a different GitOps tool.

Answer

Helm

Answer

ArgoCD Application Controller

Question 6

Which component of the control plane is the only one that directly interacts with etcd?

Accepted Answer

kube-apiserver. The kube-apiserver is the only component of the Kubernetes control plane that directly interacts with etcd. It acts as the front-end for the control plane, exposing the Kubernetes API, and all reads and writes to the cluster's state stored in etcd must go through the API server. Other components like the kube-controller-manager and kube-scheduler only communicate with etcd indirectly via the kube-apiserver, never directly.

Answer

kube-controller-manager

Answer

kube-scheduler

Answer

kubelet

Question 7

You need to run a one-time batch job that processes data and then exits. The job should run to completion and not be restarted. Which Kubernetes resource should you use?

Accepted Answer

Job. A Kubernetes Job is designed for one-time batch processing tasks that run to completion and are not restarted. It creates one or more Pods and ensures they successfully terminate, making it the correct choice for a non-repeating, finite workload.

Answer

DaemonSet

Answer

Deployment

Answer

StatefulSet

Question 8

An organization wants to adopt a cloud-native approach for its new application. Which characteristic is most important for the application to be considered cloud-native?

Accepted Answer

It is designed to be resilient, scalable, and manageable in a dynamic environment.. Cloud-native applications are fundamentally defined by their ability to operate in dynamic, distributed environments. They leverage principles like microservices, containerization, and orchestration (e.g., Kubernetes) to achieve resilience, scalability, and manageability. This characteristic is the core tenet of cloud-native architecture as defined by the CNCF, enabling the app to handle failures gracefully and scale on demand.

Answer

It stores all state in local files on the container filesystem.

Answer

It runs as a single monolithic process for simplicity.

Answer

It is deployed exclusively on on-premises infrastructure.

Question 9

A Service of type ClusterIP has been created, but pods in the same namespace cannot reach it by its DNS name. The Service selector matches the pods. What is a likely cause?

Accepted Answer

The kube-dns or CoreDNS pod is not running. The DNS name resolution for a ClusterIP Service relies on the cluster's DNS service (kube-dns or CoreDNS). If the DNS pod is not running, the Service's DNS record (e.g., ..svc.cluster.local) cannot be resolved, even if the Service itself is properly configured and the pods match the selector. Without DNS, pods must use the Service's ClusterIP directly, which is not the expected behavior for name-based access.

Answer

The Service YAML does not specify a port

Answer

The Service is not exposed on a node port

Answer

The pods are using an incorrect container runtime

Question 10

Which Kubernetes object should you use to store non-sensitive configuration data that can be consumed by Pods as environment variables or mounted files?

Accepted Answer

ConfigMap. ConfigMap is the correct Kubernetes object for storing non-sensitive configuration data, such as key-value pairs or configuration files. It is designed to decouple configuration artifacts from container images, allowing Pods to consume this data as environment variables, command-line arguments, or mounted files in a volume. Unlike Secrets, ConfigMaps do not provide encryption or base64 encoding by default, making them suitable only for non-sensitive information.

Answer

Secret

Answer

PersistentVolume

Answer

Service

Question 11

Which of the following is true about Kubernetes Namespaces?

Accepted Answer

Namespaces allow you to divide cluster resources between multiple users. Kubernetes Namespaces provide a mechanism for partitioning a single cluster into multiple virtual clusters, enabling resource quota management and access control for different users or teams. This allows administrators to divide cluster resources (e.g., CPU, memory, storage) among multiple users via ResourceQuotas and Role-Based Access Control (RBAC), ensuring isolation of resource usage without requiring separate physical clusters.

Answer

Objects in different namespaces cannot communicate with each other

Answer

Namespaces are global across all clusters

Answer

Namespaces provide network isolation by default

Question 12

What is the primary difference between a container and a virtual machine (VM)?

Accepted Answer

Containers share the host OS kernel, whereas VMs include a full guest OS. The primary difference is that containers share the host operating system kernel and run as isolated user-space processes, while virtual machines include a full guest OS with its own kernel. This architectural distinction means containers are lightweight and start in seconds, whereas VMs require booting a complete OS. Option D correctly captures this fundamental difference.

Answer

Containers are slower to start than VMs

Answer

Containers provide stronger isolation than VMs

Answer

VMs are more portable than containers

Question 13

Which of the following is a key benefit of container orchestration compared to running containers manually?

Accepted Answer

Automatic scaling and self-healing. Container orchestration platforms like Kubernetes provide automatic scaling and self-healing capabilities that are not available when running containers manually. Self-healing automatically restarts failed containers, reschedules them when nodes fail, and replaces containers that fail health checks, while scaling adjusts the number of replicas based on CPU/memory metrics or custom metrics. Manual container management requires operators to monitor and intervene for each failure or load change, making orchestration essential for production-grade reliability and elasticity.

Answer

Containers use less memory

Answer

Orchestration eliminates the need for container images

Answer

Containers run faster when orchestrated

Question 14

In OpenTelemetry, which component is responsible for receiving, processing, and exporting telemetry data from multiple sources?

Accepted Answer

OpenTelemetry Collector. The OpenTelemetry Collector is a vendor-agnostic agent that receives, processes, and exports telemetry data.

Answer

OpenTelemetry SDK

Answer

OpenTelemetry Exporter

Answer

OpenTelemetry API

Question 15

What is the purpose of the Container Runtime Interface (CRI)?

Accepted Answer

To allow kubelet to communicate with different container runtimes. The Container Runtime Interface (CRI) is a plugin interface that enables the kubelet to use a variety of container runtimes without needing to recompile the Kubernetes components. It defines the API for creating, starting, stopping, and deleting containers, allowing the kubelet to communicate with runtimes like containerd, CRI-O, or Docker (via dockershim, now deprecated). Option D is correct because the CRI's primary purpose is to abstract the runtime implementation from the kubelet, enabling interoperability.

Answer

To manage container networking

Answer

To define a standard for container images

Answer

To orchestrate multi-container pods