KCNA Multiple Select — 50 Questions

Question 1

Which TWO statements about Kubernetes Services are correct?

Accepted Answer

The default Service type is ClusterIP. The default Service type in Kubernetes is ClusterIP, which exposes the Service on a cluster-internal IP address. This means the Service is only reachable from within the cluster, providing a stable internal endpoint for pod-to-pod communication without external exposure.

Answer

A Service can expose only one container port

Answer

A Service can only route traffic to pods on the same node as the Service

Answer

A Service of type NodePort exposes the service only on the node where the pod is running

Question 2

Which TWO statements are true about Kubernetes Deployments?

Accepted Answer

Deployments support rolling updates and rollbacks.. Option A is correct because a Deployment's pod template is versioned, and the Deployment controller performs rolling updates by incrementally replacing old ReplicaSet pods with new ones, while `kubectl rollout undo` reverts to a previous revision. Option C is correct because a Deployment does not manage pods directly; it creates and manages a ReplicaSet, which in turn maintains the desired number of pod replicas and scales them as the Deployment's spec changes. Option B is not correct because StatefulSets, not Deployments, are the recommended controller for stateful applications requiring stable network identities and persistent per-pod storage. Option D is not correct because Deployments provide no built-in external load balancer; external exposure requires a Service of type LoadBalancer, NodePort, or an Ingress. Option E is not correct because running a pod on every node is the job of a DaemonSet, not a Deployment.

Answer

Deployments are the recommended controller for stateful applications.

Answer

Deployments can expose applications externally via a built-in load balancer.

Answer

Deployments are used to run a pod on every node in the cluster.

Question 3

Which TWO of the following are recommended practices for achieving observability in a Kubernetes cluster?

Accepted Answer

Include correlation IDs in structured logs to enable tracing across services.. Including correlation IDs in structured logs is a key observability practice that enables distributed tracing across microservices. In Kubernetes, where requests often traverse multiple pods and services, correlation IDs allow you to link logs from different components into a single transaction flow, which is essential for debugging and understanding system behavior.

Answer

Use a single centralized logging solution to aggregate logs from all components.

Answer

Store all debug logs for a minimum of 90 days for compliance.

Answer

Disable leader election for monitoring components to reduce complexity.

Question 4

Which TWO of the following are required fields when defining a container in a Kubernetes Pod spec? (Choose 2)

Accepted Answer

image. In a Kubernetes Pod spec, the `name` and `image` fields are mandatory for each container definition. The `name` field uniquely identifies the container within the Pod, and the `image` field specifies the container image to run (e.g., `nginx:1.25`). Without these two fields, the Pod creation will fail with a validation error from the Kubernetes API server.

Answer

env

Answer

resources

Answer

ports

Question 5

Which TWO of the following are core principles of cloud native architecture? (Choose two.)

Accepted Answer

Containerization. Containerization (Option D) is a core principle of cloud native architecture because it packages applications and their dependencies into isolated, lightweight containers, enabling consistent deployment across environments and efficient resource utilization. This aligns with the cloud native goal of portability and scalability, as containers can be orchestrated by platforms like Kubernetes to manage dynamic workloads.

Answer

Manual infrastructure provisioning

Answer

Monolithic application design

Answer

Tight coupling between services

Question 6

Which THREE of the following are key characteristics of microservices architecture?

Accepted Answer

Independent deployment of services. Microservices architecture mandates that each service can be independently deployed, updated, and scaled without affecting other services. This is achieved through separate deployment pipelines, containerization (e.g., Docker), and orchestration platforms like Kubernetes that manage service lifecycles independently. Independent deployment enables continuous delivery and reduces the blast radius of changes.

Answer

Single monolithic codebase

Answer

Shared database schema across services

Question 7

Which two of the following are Kubernetes controllers that run inside the kube-controller-manager? (Select TWO)

Accepted Answer

Replication controller. The Replication controller (B) is correct because it is a built-in controller that runs within the kube-controller-manager process, continuously reconciling the desired number of pod replicas with the actual state by creating or deleting pods. The Node controller (D) is also correct because it is another controller embedded in the kube-controller-manager, responsible for monitoring node health, applying taints like node.kubernetes.io/not-ready, and evicting pods from unreachable nodes. The kubelet (A) is not part of the kube-controller-manager; it is a node-level agent that runs on each worker node and manages pod lifecycle via the container runtime. etcd (C) is the distributed key-value store that persists cluster state, not a controller, and it runs as a separate process. The kube-scheduler (E) is a separate control-plane component that assigns pods to nodes and runs independently of the kube-controller-manager.

Answer

kubelet

Answer

etcd

Answer

kube-scheduler

Question 8

Which TWO are characteristics of the microservices architecture that are supported by container orchestration?

Accepted Answer

Independent deployment of each service. Option B is correct because container orchestration platforms such as Kubernetes let each microservice be built, versioned, and rolled out on its own schedule, so a change to one service does not force redeployment of the others. Option C is correct because microservices architecture decomposes an application into small, independently runnable services, and orchestration supports this by scheduling, scaling, and networking each service as a separate workload. Options A, D, and E are not characteristics of microservices supported by orchestration: tight coupling, a monolithic codebase with centralized deployment, and a single shared database all describe monolithic or tightly integrated designs that contradict the independence and loose coupling that orchestration enables.

Answer

Tight coupling between services to ensure performance

Answer

Monolithic codebase with centralized deployment

Answer

Use of a single, shared database for all services

Question 9

Which THREE of the following are benefits of structured logging? (Select three.)

Accepted Answer

Easier querying and filtering. Structured logging emits events as key-value pairs (typically JSON), so option A is correct because fields like level, service, or trace_id can be queried and filtered directly in tools such as Elasticsearch, Loki, or CloudWatch Logs Insights without fragile regex parsing. Option D is correct because that same machine-parseable format lets log processors, SIEMs, and observability pipelines ingest and index records programmatically and reliably. Option E is correct because adopting a shared schema with consistent field names across services enables correlation and aggregation across distributed systems, which is a core goal of structured logging. Option B is not a benefit: structured logs are usually less human-readable than free-form plain text, which is why pretty-printers exist. Option C is not a benefit either: JSON key-value output typically increases log size versus terse plain-text lines due to repeated field names and delimiters, so storage requirements usually grow rather than shrink.

Answer

More human-readable than plain text

Answer

Reduced storage requirements

Question 10

Which THREE of the following are valid use cases for distributed tracing in a microservices architecture?

Accepted Answer

Understanding the dependency graph between microservices. Distributed tracing is designed to follow a single request as it propagates across service boundaries, so option B is correct because the spans and parent-child relationships recorded in a trace directly reveal the dependency graph and call topology between microservices. Option C is correct because a trace correlates spans across services with shared trace IDs, letting you locate the exact failing span and thus the root cause of an error in a distributed transaction. Option D is correct because span durations and timestamps expose per-service latency contributions, making it possible to identify which service adds the most latency to an end-user request. Option A is not a tracing use case; CPU and memory usage per instance are collected by metrics/monitoring tools such as Prometheus or CloudWatch, not by distributed tracing. Option E is also not specific to tracing; detailed error messages and stack traces are typically captured by centralized logging or error-tracking systems, even though traces may carry limited error tags.

Answer

Monitoring CPU and memory usage of each service instance

Answer

Capturing detailed error messages and stack traces

Question 11

Which TWO of the following are functions of the kube-controller-manager?

Accepted Answer

Managing replication and ensuring the desired number of pods are running. Option A is correct because the kube-controller-manager runs the ReplicationController/ReplicaSet controller, which continuously reconciles the actual number of running pods with the desired replica count specified in the resource. Option D is correct because the kube-controller-manager includes the node controller, which monitors node health via heartbeats/leases and responds to node failures by marking nodes NotReady and evicting or rescheduling their pods. Option B is incorrect because cluster state is persisted in etcd, not by the kube-controller-manager. Option C is incorrect because the Kubernetes API is exposed by the kube-apiserver. Option E is incorrect because pod-to-node assignment (scheduling) is performed by the kube-scheduler.

Answer

Storing cluster state

Answer

Exposing the Kubernetes API

Answer

Assigning pods to nodes

Question 12

Which THREE are benefits of using container orchestration platforms like Kubernetes?

Accepted Answer

High availability through automatic container restart and replication. Option A is correct because Kubernetes provides high availability by automatically restarting failed containers and maintaining the desired number of replicas across nodes, ensuring workloads remain available even when individual containers or nodes fail. Option B is correct because Kubernetes supports automatic scaling of container replicas through mechanisms like the Horizontal Pod Autoscaler, which adjusts replica counts based on observed CPU, memory, or custom metrics. Option C is correct because Kubernetes performs self-healing by detecting failed containers, pods, or nodes and replacing or rescheduling them without manual intervention, restoring the declared desired state. Option D is not a benefit of orchestration because Kubernetes manages deployment and runtime concerns, not application source code, so developers still must write and modify code as needed. Option E is incorrect because orchestration platforms do not eliminate monitoring and logging; they integrate with tools like Prometheus, Grafana, and the ELK stack, and observability remains essential for operating containerized workloads.

Answer

Simplified application development by eliminating the need for code changes

Answer

Elimination of the need for monitoring and logging

Question 13

Which THREE are core principles of the Twelve-Factor App methodology?

Accepted Answer

Explicitly declare and isolate dependencies. Option B is correct because Factor II (Dependencies) requires an app to explicitly declare all dependencies via a manifest such as requirements.txt, package.json, or Gemfile, and isolate them using tooling like virtualenv or Bundler so no implicit system-wide packages are assumed. Option D is correct because Factor XI (Logs) states an app should never manage log files itself; instead it writes unbuffered event streams to stdout/stderr, letting the execution environment aggregate and route them. Option E is correct because Factor I (Codebase) mandates exactly one codebase tracked in a version control system such as Git, with many deploys from that same codebase across environments. Option A is wrong because Factor III (Config) requires config to be stored in the environment, not in the codebase, precisely to keep credentials and environment-specific values out of revision control. Option C is wrong because the methodology calls for loosely coupled, interchangeable backing services (Factor IV), attached and detached via config, not tight coupling.

Answer

Store config in codebase for traceability

Answer

Tight coupling to backing services

Question 14

Which TWO of the following are characteristics of microservices architecture? (Choose 2)

Accepted Answer

Services can be deployed independently. Microservices architecture is defined by the ability to deploy each service independently without affecting other services. This independence enables teams to update, scale, and roll back individual components, which is a core principle of container orchestration platforms like Kubernetes that manage these services as separate units.

Answer

All services share the same database

Answer

The entire application is deployed as a single unit

Answer

Services are tightly coupled

Question 15

Which two of the following are valid ways to set resource constraints on a container in a Pod spec?

Accepted Answer

Specify 'resources.limits.memory' for maximum memory. Option B is correct because the Pod spec's container definition uses the 'resources.limits' field to declare the maximum amount of a resource the container may consume, so 'resources.limits.memory' sets a hard memory ceiling that the container cannot exceed. Option D is correct because 'resources.requests.cpu' declares the minimum CPU the container is guaranteed for scheduling purposes, and the kubelet uses this value when allocating CPU shares. The other options are invalid field names: 'resources.guarantees.cpu' (A), 'resources.min.memory' (C), and 'resources.max.cpu' (E) do not exist in the Kubernetes API, which only supports 'requests' and 'limits' under 'resources'.

Answer

Specify 'resources.guarantees.cpu' for CPU guarantees

Answer

Specify 'resources.min.memory' for minimum memory

Answer

Specify 'resources.max.cpu' for CPU limits

Question 16

Which TWO of the following are true about the Open Container Initiative (OCI)?

Accepted Answer

OCI is a Linux Foundation project. The Open Container Initiative (OCI) is a Linux Foundation project that was established to create open industry standards around container formats and runtimes. It operates under the Linux Foundation's governance to ensure vendor-neutral specifications.

Answer

OCI requires the use of containerd

Answer

OCI defines the Dockerfile format

Answer

OCI defines the Container Runtime Interface (CRI)

Question 17

Which TWO of the following are benefits of using containers over virtual machines? (Choose 2)

Accepted Answer

Containers are more lightweight and start faster than VMs. Containers share the host OS kernel and run as isolated processes, making them lightweight and able to start in milliseconds, unlike VMs which require booting a full guest OS. This efficiency stems from container images being mere megabytes compared to gigabytes for VM images, and containers using cgroups and namespaces for resource management rather than a hypervisor.

Answer

Containers require hypervisor software to run

Answer

Containers include a full guest operating system

Answer

Containers provide stronger isolation than VMs

Question 18

Which TWO of the following are benefits of using a container orchestration platform like Kubernetes? (Select 2)

Accepted Answer

Self-healing of failed containers. Option C is correct because Kubernetes continuously reconciles desired state with actual state: its controllers (e.g., ReplicaSet, Deployment) detect crashed or unhealthy pods via liveness/readiness probes and restart or reschedule them, providing self-healing. Option E is correct because Kubernetes supports automatic scaling through the Horizontal Pod Autoscaler (HPA), which adjusts replica counts based on metrics such as CPU utilization or custom metrics, and the Cluster Autoscaler, which adds or removes nodes as demand changes. Option A is wrong because orchestration automates container scheduling and deployment rather than requiring manual placement. Option B is wrong because Kubernetes runs containers via a container runtime (containerd, CRI-O) on each node and does not require a hypervisor. Option D is wrong because orchestration platforms are designed for dynamic, declarative infrastructure that changes as workloads and scaling demands evolve.

Answer

Manual deployment of containers to servers

Answer

Requirement for a hypervisor on every node

Answer

Static infrastructure that never changes

Question 19

Which TWO of the following are valid ways to view the logs of a pod named 'my-pod'?

Accepted Answer

kubectl exec my-pod -- cat /var/log/app.log. Option B is correct because kubectl exec my-pod -- cat /var/log/app.log runs the cat command inside the container of the pod, directly reading the application log file at that path, which is a valid way to view logs when the app writes to a file rather than stdout. Option C is correct because kubectl logs my-pod retrieves the stdout/stderr output captured by the container runtime for the pod's (default) container, which is the standard Kubernetes logging mechanism. Option A is not a log-viewing method: kubectl describe pod my-pod shows metadata, status, events, and container specs, not the application's log stream. Option D is invalid syntax and semantics: kubectl run creates a new pod from an image and does not accept a 'logs' subcommand to read an existing pod's logs. Option E is wrong because kubectl attach my-pod attaches the terminal to a running container's process (stdin/stdout of PID 1), which is interactive and not a log-retrieval command.

Answer

kubectl describe pod my-pod

Answer

kubectl run my-pod -- logs

Answer

kubectl attach my-pod

Question 20

Which TWO statements about containers are true compared to virtual machines? (Select TWO.)

Accepted Answer

Containers are more lightweight and start faster than VMs. Containers share the host OS kernel and run as isolated processes, requiring no hypervisor or full OS boot. This makes them lightweight (megabytes vs gigabytes) and allows them to start in milliseconds, whereas VMs must boot a full guest OS, which takes seconds to minutes.

Answer

Containers include a full guest operating system

Answer

Containers provide stronger isolation than VMs

Answer

Containers require a hypervisor to run