KCNA Kubernetes Fundamentals Practice Test 18 — 15 Questions

Question 1

You want to create a new Namespace called 'staging' and apply a ResourceQuota to it. Which of the following YAML snippets correctly defines a ResourceQuota that limits total memory to 10Gi and total CPU to 5 cores in namespace 'staging'?

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

Accepted Answer

apiVersion: v1
kind: ResourceQuota
metadata:
  name: staging-quota
  namespace: staging
spec:
  hard:
    limits.cpu: "5"
    limits.memory: 10Gi. It defines a ResourceQuota with `limits.cpu` and `limits.memory` under `spec.hard`, which restricts the total CPU and memory that all pods in the namespace can consume. The values are specified as strings ("5" for CPU and 10Gi for memory), which is the correct format for ResourceQuota resources in Kubernetes.

Answer

apiVersion: v1
kind: ResourceQuota
metadata:
  name: staging-quota
  namespace: staging
spec:
  hard:
    requests.cpu: "5"
    requests.memory: 10Gi

Answer

apiVersion: v1
kind: LimitRange
metadata:
  name: staging-limits
  namespace: staging
spec:
  limits:
  - default:
      cpu: 5
      memory: 10Gi
    defaultRequest:
      cpu: 1
      memory: 1Gi

Answer

apiVersion: v1
kind: ResourceQuota
metadata:
  name: staging-quota
spec:
  hard:
    cpu: 5
    memory: 10Gi

Question 2

Which two of the following are benefits of using Kubernetes for container orchestration? (Select TWO.)

Accepted Answer

Self-healing: automatically restarts failed containers. Kubernetes provides self-healing capabilities through controllers like ReplicaSets and Deployments, which monitor pod health via liveness probes. If a container fails or becomes unresponsive, the controller automatically terminates the unhealthy pod and creates a replacement to maintain the desired replica count, ensuring application resilience without manual intervention.

Answer

Integrated continuous integration pipeline

Answer

Automatic code compilation

Answer

Built-in database management

Question 3

Which two components are part of the Kubernetes control plane? (Select TWO.)

Accepted Answer

kube-apiserver. The Kubernetes control plane manages the cluster and makes global decisions. kube-apiserver is the front-end for the control plane, exposing the Kubernetes API for all interactions. etcd is a consistent and highly-available key-value store used as Kubernetes' backing store for all cluster data, making it a core control plane component.

Answer

container runtime

Answer

kube-proxy

Answer

kubelet

Question 4

Which three of the following are valid ways to interact with the Kubernetes API? (Select THREE.)

Accepted Answer

Using a Kubernetes client library (e.g., client-go). Client-go is an official Kubernetes client library that provides Go developers with programmatic access to the Kubernetes API. It handles authentication, serialization, and API version negotiation, allowing applications to create, read, update, and delete Kubernetes resources directly via the API server.

Answer

Using the 'kubeadm' command

Answer

Using the Docker CLI

Question 5

A pod in the 'production' namespace is in a CrashLoopBackOff state. The pod has been running successfully for several days. You run 'kubectl describe pod app-pod -n production' and see the message: 'OOMKilled'. What is the MOST appropriate action to resolve this issue?

Accepted Answer

Increase the memory limit in the pod's container resource specification. The OOMKilled status indicates the container was terminated because it exceeded its memory limit. Increasing the memory limit in the pod's container resource specification allows the container to use more memory without being killed, directly addressing the root cause of the CrashLoopBackOff.

Answer

Delete the namespace and redeploy all workloads

Answer

Delete and recreate the pod to clear the crash loop

Answer

Increase the CPU request for the container

Question 6

Which Kubernetes control plane component is responsible for maintaining the desired state of the cluster by running controller loops?

Accepted Answer

kube-controller-manager. The kube-controller-manager is the control plane component that runs controller loops, which are continuous processes that watch the shared state of the cluster through the kube-apiserver and make changes to drive the current state toward the desired state. Each controller (e.g., ReplicaSet, Node, Deployment) is a separate loop that handles a specific aspect of cluster management, ensuring that the actual cluster state matches the desired configuration defined in the API objects.

Answer

etcd

Answer

kube-apiserver

Answer

kube-scheduler

Question 7

You need to run a stateless web application with three replicas, and you want to ensure that if a pod fails, it is automatically replaced. Which Kubernetes resource should you use?

Accepted Answer

Deployment. A Deployment is the correct resource because it manages a ReplicaSet to ensure the desired number of pod replicas (three) are running at all times. If a pod fails, the Deployment's controller automatically creates a replacement pod, maintaining the stateless application's availability.

Answer

DaemonSet

Answer

Job

Answer

StatefulSet

Question 8

You want to view the logs of a container named 'app' inside a pod named 'web-pod-7d4f8'. Which kubectl command should you use?

Accepted Answer

kubectl logs web-pod-7d4f8 -c app. The `kubectl logs` command is the standard way to retrieve container logs in Kubernetes. The `-c` flag specifies the container name within the pod, which is necessary when a pod contains multiple containers. Here, the container is named 'app' inside the pod 'web-pod-7d4f8', so `kubectl logs web-pod-7d4f8 -c app` correctly fetches its logs.

Answer

kubectl exec web-pod-7d4f8 -c app -- logs

Answer

kubectl log web-pod-7d4f8 --container app

Answer

kubectl logs web-pod-7d4f8 app

Question 9

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 10

Which of the following is a worker node component responsible for ensuring that containers are running in a pod as specified in the pod's spec?

Accepted Answer

kubelet. The kubelet is the primary node agent that runs on each worker node. It receives PodSpecs (via the API server or a file) and ensures that the containers described in those PodSpecs are running and healthy. It does this by interacting with the container runtime (e.g., containerd or CRI-O) to start, stop, and monitor containers as required.

Answer

kube-scheduler

Answer

kube-proxy

Answer

etcd

Question 11

You need to create a ConfigMap from a file named 'app.properties'. Which kubectl command should you use?

Accepted Answer

kubectl create configmap my-config --from-file=app.properties. `kubectl create configmap` with the `--from-file` flag creates a ConfigMap from a file, using the filename as the key and its content as the value. This is the standard way to import a properties file into a ConfigMap in Kubernetes.

Answer

kubectl create configmap my-config --from-literal=app.properties

Answer

kubectl create configmap my-config --file=app.properties

Answer

kubectl create configmap my-config --from-env-file=app.properties

Question 12

A pod has resource requests: cpu: 250m, memory: 512Mi and limits: cpu: 500m, memory: 1Gi. If the container tries to use 600m CPU and 700Mi memory, what will happen?

Accepted Answer

The container will be throttled for CPU, but will not be killed because memory is within limits. CPU is a compressible resource: exceeding the CPU limit (500m) causes throttling, not termination. Memory is a non-compressible resource, and since the container's memory usage (700Mi) is below its limit (1Gi), it will not be killed. The container will be CPU-throttled but allowed to continue running.

Answer

The container will be allowed to use the extra resources because limits are only soft constraints

Answer

The container will be throttled for CPU and may be terminated if it continues to exceed the limit

Answer

The container will be killed immediately because it exceeded its CPU limit

Question 13

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 14

You have a Namespace 'team-a' and you want to see all Pods in that namespace, including those that are not ready. Which command should you use?

Accepted Answer

kubectl get pods -n team-a. `kubectl get pods -n team-a` retrieves all Pods in the specified namespace, regardless of their readiness or status. By default, `kubectl get pods` shows all Pods, including those that are not ready, and the `-n` flag targets the namespace. No additional filters are needed to include non-ready Pods.

Answer

kubectl get pods -n team-a -l app=myapp

Answer

kubectl get pods --namespace=team-a --field-selector=status.phase!=Running

Answer

kubectl get pods --all-namespaces

Question 15

Which TWO components are part of the Kubernetes control plane?

Accepted Answer

etcd. C (etcd) is correct because it is the distributed key-value store that holds all cluster data, including configuration, state, and metadata. D (kube-apiserver) is correct because it is the front-end for the control plane, exposing the Kubernetes API and handling all RESTful requests for cluster operations.

Answer

kube-proxy

Answer

kubelet

Answer

container runtime