KCNA Practice Test 40 — 15 Questions

Question 1

A team observes that a Pod is stuck in CrashLoopBackOff. The Pod runs a single container with an entrypoint that exits with non-zero code after a few seconds. The team wants to inspect the container's logs to understand why it is crashing. Which command should they use?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

kubectl logs --previous. The `kubectl logs --previous` command retrieves the logs from the previous instance of a crashed container. Since the Pod is in CrashLoopBackOff, the current container has already exited, and the `--previous` flag accesses the logs of the last terminated container, which contains the crash output (e.g., the non-zero exit code and error messages). This is the direct way to see why the entrypoint failed.

Answer

kubectl get pods

Answer

kubectl describe pod <pod-name>

Answer

kubectl exec -it <pod-name> -- sh

Question 2

A pod is stuck in Pending state. You run 'kubectl describe pod' and see the event '0/3 nodes are available: 1 node(s) had taint(s) that the pod didn't tolerate, 2 node(s) had insufficient memory.'. What is the most likely cause?

Accepted Answer

The pod does not have tolerations for the node's taints and memory is insufficient on other nodes. The event '0/3 nodes are available: 1 node(s) had taint(s) that the pod didn't tolerate, 2 node(s) had insufficient memory' directly indicates that the pod failed scheduling because it lacks required tolerations for a tainted node, and the remaining nodes do not have enough memory to satisfy the pod's resource requests. This matches option A, as the pod's tolerations are missing for the tainted node, and memory is insufficient on the other two nodes.

Answer

The kube-scheduler is not running

Answer

The container runtime is not installed on any node

Answer

The pod's resource requests exceed available resources on all nodes

Question 3

A pod in the 'default' namespace has the following YAML snippet:
  securityContext:
    runAsUser: 1000
    runAsGroup: 3000
    fsGroup: 2000
What is the effect of the fsGroup field?

Accepted Answer

It sets the group ID for any volumes mounted into the pod.. The `fsGroup` field in a Pod's security context sets the group ID (GID) that will be used for ownership of any volumes mounted into the pod. When a volume is mounted, Kubernetes recursively changes the group ownership of the volume's files to the specified GID (2000 in this case) and makes them readable and writable by that group. This ensures that processes running in the container, which may have a different primary group (3000 from `runAsGroup`), can still access the volume files if they are members of the fsGroup.

Answer

It restricts the pod to run only on nodes with that group ID.

Answer

It defines the group ID for the pod's service account.

Answer

It sets the group ID for the container's main process.

Question 4

A cluster administrator needs to ensure that a Deployment named 'frontend' in namespace 'web' is updated with a new image version using a rolling update strategy. The current deployment has 4 replicas. The administrator runs: kubectl set image deployment/frontend frontend=nginx:1.21 -n web. Which of the following describes the expected behavior?

Accepted Answer

The Deployment will create a new ReplicaSet and gradually replace old pods with new ones. `kubectl set image deployment/frontend frontend=nginx:1.21 -n web` updates the container image in the Deployment's pod template, triggering a rolling update. The Deployment controller creates a new ReplicaSet with the updated image and gradually scales it up while scaling down the old ReplicaSet, ensuring zero downtime and maintaining the desired replica count of 4.

Answer

All existing pods will be deleted immediately and new pods will be created with the new image

Answer

The command will fail because you cannot update a Deployment using kubectl set image

Answer

The Deployment's image will be updated, but only the container named 'app' will be affected

Question 5

Your organization runs a microservices application on a Kubernetes cluster with 5 worker nodes (each with 4 vCPU, 16GB RAM). The application consists of 20 microservices, each deployed as a Deployment with 3 replicas. Recently, after a new microservice 'inventory' was deployed with resource requests of 2 CPU and 4GB memory per pod, the cluster started experiencing pod scheduling failures. Many existing pods are in 'Pending' state with events indicating 'Insufficient cpu' or 'Insufficient memory'. The cluster has cluster autoscaling enabled (node pool ranging from 3 to 10 nodes), but new nodes are not being added quickly enough, and the existing nodes are heavily utilized. You need to resolve the scheduling failures while ensuring the inventory service can scale. Which course of action should you take?

Accepted Answer

Reduce the CPU request of the inventory deployment to 1 CPU per pod to allow better packing on existing nodes while cluster autoscaler catches up.. Reducing the CPU request of the inventory deployment to 1 CPU per pod allows the scheduler to pack pods more efficiently on existing nodes, alleviating immediate 'Insufficient cpu' and 'Insufficient memory' failures while the cluster autoscaler provisions new nodes. This approach balances short-term scheduling needs with the ability to scale the inventory service later, as requests can be adjusted upward once the cluster has more capacity.

Answer

Increase the cluster autoscaler max nodes to 20 and set a 0-second scale-up delay.

Answer

Set resource limits equal to requests for all microservices to guarantee resources.

Answer

Delete all pending pods and recreate them manually.

Question 6

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

Accepted Answer

Containers share the host OS kernel, whereas VMs each have their own guest OS. The primary difference is that containers share the host operating system kernel, while each virtual machine runs its own complete guest OS. This means containers are lightweight processes with isolated user spaces, whereas VMs include a full OS stack (kernel, drivers, libraries) per instance. This architectural distinction is why containers start in seconds and have minimal overhead, while VMs require booting a guest OS and consume more resources.

Answer

Containers are slower to start than VMs

Answer

Containers require a hypervisor to run

Answer

Containers virtualize hardware, while VMs virtualize the operating system

Question 7

According to the 12-factor app methodology, how should an application store configuration that varies between deployments (e.g., database connection strings)?

Accepted Answer

In environment variables. The 12-factor app recommends strict separation of config from code, storing config in environment variables.

Answer

In a configuration file that is version-controlled

Answer

In a database table

Answer

Hard-coded in the application code

Question 8

What is the smallest deployable unit in Kubernetes that can be created, scheduled, and managed?

Accepted Answer

Pod. A Pod is the smallest and simplest unit in the Kubernetes object model that can be created, scheduled, and managed. It represents a single instance of a running process in the cluster and encapsulates one or more containers with shared storage and network resources. While containers are the underlying runtime, Kubernetes does not schedule containers directly; it schedules Pods as the atomic unit of deployment.

Answer

Deployment

Answer

Node

Answer

Container

Question 9

Which of the following is a benefit of container orchestration?

Accepted Answer

Self-healing of failed containers. Container orchestration platforms like Kubernetes provide self-healing capabilities by automatically restarting failed containers, rescheduling them on healthy nodes, and replacing or terminating containers that fail health checks. This ensures that the desired state of the application is maintained without manual intervention, which is a core benefit of orchestration.

Answer

Elimination of all security vulnerabilities

Answer

Manual scaling of applications

Answer

Guaranteed zero downtime

Question 10

A developer creates a Deployment with replicas: 3 and strategy type: RollingUpdate with maxSurge: 1 and maxUnavailable: 1. During a rolling update, the Deployment controller creates a new ReplicaSet. After the new ReplicaSet has 2 pods ready, the node running one of the original ReplicaSet's pods fails. What is the MOST likely number of total pods running after the node failure, assuming no other actions?

Accepted Answer

2 pods running. Initially, the Deployment has 3 old pods. The rolling update starts: with maxSurge=1, the controller creates a new pod. Once it's ready, it terminates one old pod to keep desired replicas at 3. Then it creates another new pod. After the second new pod is ready, it terminates a second old pod. At this point, the new ReplicaSet has 2 ready pods, and the old ReplicaSet has only 1 pod remaining. The node running that last old pod fails, killing it. Thus, only the 2 new pods are running, giving a total of 2 pods.

Answer

4 pods running

Answer

3 pods running

Answer

1 pod running

Question 11

Which THREE of the following are benefits of using container orchestration? (Choose three.)

Accepted Answer

High availability through automated failover. Container orchestration platforms like Kubernetes implement automated failover by monitoring container health via liveness probes and rescheduling pods on healthy nodes when a node fails. This ensures that applications remain available even when underlying infrastructure components fail, which is a core benefit of orchestration.

Answer

Decomposition of applications into microservices

Answer

Simplified networking with flat network topology

Question 12

A development team is containerizing a monolithic application into microservices. Which practice aligns with cloud-native architecture principles?

Accepted Answer

Design each microservice with its own data store and communicate via APIs.. Cloud-native architecture principles advocate for decentralized data management, where each microservice owns its private data store and exposes functionality via well-defined APIs. This ensures loose coupling, independent scalability, and resilience, as services can evolve without impacting others. The pattern aligns with the Database per Service pattern, a core tenet of microservices design.

Answer

Use a shared database for all microservices to ensure data consistency.

Answer

Use JSON Web Tokens for authentication between microservices in the same cluster.

Answer

Ensure all microservices have identical resource requests and limits.

Question 13

An organization uses GitOps with ArgoCD to manage Kubernetes deployments. What is the PRIMARY advantage of this approach over traditional imperative deployment methods?

Accepted Answer

It provides a single source of truth for cluster state through Git. GitOps uses a Git repository as the single source of truth, enabling declarative configuration, version control, and automated reconciliation. This is the primary advantage over traditional imperative methods. Option A is incorrect because manual approval processes can still be part of a GitOps workflow. Option C is incorrect because GitOps does not eliminate the need for access controls. Option D is incorrect because GitOps does not directly reduce container count.

Answer

It eliminates the need for any manual approval processes

Answer

It allows developers to directly access the Kubernetes cluster

Answer

It reduces the number of containers needed in a deployment

Question 14

A cloud-native application experiences periodic timeouts when calling a downstream service. The downstream service is running in the same Kubernetes cluster. Which design pattern should be implemented to handle this gracefully?

Accepted Answer

Circuit breaker pattern. The Circuit Breaker pattern is correct because it prevents cascading failures by monitoring for failures and, once a threshold is exceeded (e.g., 5 consecutive timeouts), it opens the circuit and immediately fails fast without waiting for the downstream service. This allows the application to handle periodic timeouts gracefully by avoiding wasted resources and providing a fallback response, which is critical for cloud-native resilience in Kubernetes.

Answer

Bulkhead pattern

Answer

Retry with exponential backoff

Answer

Health check endpoint

Question 15

A developer wants to run a stateless web application with 5 replicas and ensure that when a new version is released, Pods are updated one by one with no downtime. Which Kubernetes resource is best suited?

Accepted Answer

Deployment. A Deployment is the correct resource because it is designed for managing stateless, replicated applications with declarative updates. It supports rolling updates (configurable via `strategy.type: RollingUpdate`), which update Pods one by one, ensuring zero downtime by gradually replacing old Pods with new ones while maintaining the desired replica count.

Answer

Job

Answer

DaemonSet

Answer

StatefulSet