CKAD Application Design and Build Practice Test 11 — 15 Questions

Question 1

You are tasked with running a batch job that processes 100 items in parallel, using a Kubernetes Job. The Job should ensure that all items are processed even if some pods fail, and the total number of pod failures should be limited to 3. Which Job configuration is correct?

Accepted Answer

Set spec.parallelism: 100, spec.completions: 100, spec.backoffLimit: 3. Option B is correct. For a Job that runs many parallel tasks, you use a work queue pattern with a fixed completion count. spec.parallelism sets the number of pods to run in parallel, spec.completions sets the total number of successful completions required, and spec.backoffLimit sets the number of retries before considering the Job as failed. The spec.backoffLimit field is the correct way to limit retries; spec.activeDeadlineSeconds is a time limit, not a retry limit.

Answer

Set spec.parallelism: 1, spec.completions: 100, spec.backoffLimit: 3

Answer

Set spec.parallelism: 100, spec.completions: 1, spec.backoffLimit: 3

Answer

Set spec.parallelism: 100, spec.completions: 100, spec.activeDeadlineSeconds: 300

Question 2

You need to schedule a task that runs every day at 2:00 AM. The task should be allowed to run even if a previous instance is still running. Which concurrencyPolicy should you set in the CronJob spec?

Accepted Answer

Allow. Option B is correct. concurrencyPolicy: Allow permits multiple Job instances to run concurrently. Forbid prevents new runs if any is currently running. Replace kills the current run and starts a new one. The default is Allow, but explicitly setting Allow is better for clarity.

Answer

Replace

Answer

Forbid

Answer

Ignore

Question 3

Which of the following commands creates a deployment named 'webapp' that runs the image 'nginx:1.25' with 3 replicas and exposes port 80?

Accepted Answer

kubectl create deployment webapp --image=nginx:1.25 --replicas=3 --port=80. Option B is correct. The kubectl create deployment command creates a deployment with a given name and image. The --replicas flag sets the number of replicas. The --port flag is used to create a Service by default, but for this question, it is used to expose the container port. Option A uses --replicas incorrectly (it should be --replicas, not --replicas). Option C uses the wrong command (kubectl run is for pods, not deployments). Option D has a typo (--replicas instead of --replicas).

Answer

kubectl create deployment webapp --image=nginx:1.25 --replicas=3 --port=80

Answer

kubectl run webapp --image=nginx:1.25 --replicas=3 --port=80

Answer

kubectl create deployment webapp --image=nginx:1.25 --replicas=3 --port=80

Question 4

You have a multi-container pod with a main container and a sidecar container that collects logs. The sidecar container should start before the main container and must complete initialization tasks before the main container starts. Which type of container should you use for this purpose?

Accepted Answer

Init container. Option C is correct. Init containers run sequentially and complete before any regular containers in the pod start. They are ideal for initialization tasks. Sidecar containers (regular containers) run concurrently with the main container. Ephemeral containers are for debugging and do not run at pod startup. Jobs are not containers within a pod.

Answer

Ephemeral container

Answer

Job

Answer

Regular sidecar container

Question 5

You have a pod that runs a single container with the following resource limits: memory: 256Mi, cpu: 500m. The container is consistently using 300Mi of memory and 300m of CPU. The pod is running but you want to avoid OOMKilled. Which change should you make?

Accepted Answer

Increase memory limit to 512Mi. Option A is correct. The memory limit is 256Mi, but the container uses 300Mi, which will cause OOMKilled. Increasing the memory limit to 512Mi avoids the OOM. CPU limit (500m) is fine because usage is 300m. Increasing CPU limit does not help memory. Decreasing memory limit would make the problem worse. Setting requests does not prevent OOM if limit is still low.

Answer

Set memory request to 128Mi and keep limit at 256Mi

Answer

Decrease memory limit to 128Mi

Answer

Increase CPU limit to 1000m

Question 6

Which of the following is the correct apiVersion for a Kubernetes Job in v1.29?

Accepted Answer

batch/v1. In Kubernetes v1.29, the correct apiVersion for a Job is `batch/v1`. The `batch/v1` API version has been stable since Kubernetes 1.21, and Jobs are part of the batch API group. Using `batch/v1` ensures compatibility with the current stable release and provides access to all Job features, including parallelism, completions, and backoff limits.

Answer

apps/v1

Answer

v1

Answer

batch/v1beta1

Question 7

You need to add a debugging container to a running pod named 'app-pod' in the 'dev' namespace. Which command achieves this?

Accepted Answer

kubectl debug pod/app-pod -n dev --image=busybox --ephemeral. Option D is correct. kubectl debug allows adding ephemeral containers to running pods. The syntax kubectl debug pod/app-pod -n dev --image=busybox --ephemeral creates an ephemeral container. Option A (kubectl exec) runs commands in existing containers, not add containers. Option B (kubectl run) creates a new pod, not attach to existing. Option C (kubectl attach) attaches to a running container's stdin/stdout.

Answer

kubectl run debug-pod --image=busybox -n dev --rm -it

Answer

kubectl attach pod/app-pod -n dev

Answer

kubectl exec pod/app-pod -n dev -it -- /bin/sh

Question 8

You have a Job that runs a batch process. The Job YAML is as follows:

apiVersion: batch/v1
kind: Job
metadata:
  name: batch-job
spec:
  parallelism: 4
  completions: 12
  backoffLimit: 2
  template:
    spec:
      containers:
      - name: worker
        image: myapp:latest
      restartPolicy: Never

If one pod fails after 3 successful completions, and the Job has already completed 7 successes, how many pods will be running at that point? Assume no other failures.

Accepted Answer

4. Option B is correct. The Job has parallelism 4, meaning up to 4 pods run concurrently. At the moment, 7 successes have been completed, so the Job still needs 5 more completions. The Job controller will keep running pods up to parallelism to achieve the remaining completions. When one pod fails, a new pod will be created to replace it because backoffLimit is 2 (meaning up to 2 retries allowed). So there will still be 4 pods running (some may be new). The answer depends on assuming the Job controller maintains parallelism. With 12 completions needed and 7 already done, 5 remain. The controller will run up to 4 pods concurrently, so 4 pods will be running.

Answer

3

Answer

7

Answer

5

Question 9

In a Kubernetes pod definition, which field specifies the container image to use?

Accepted Answer

containers.image. Option B is correct. The container image is specified under the 'image' field inside each container definition in the pod spec. 'containers.name' is for naming the container.

Answer

spec.image

Answer

containers.name

Answer

spec.containers.image

Question 10

Which TWO statements about init containers are true?

Accepted Answer

Init containers run to completion before any regular containers start.. Options A and D are correct. Init containers run sequentially (each must complete before the next starts). They run before any regular containers in the pod. Init containers can have different restart policies than regular containers (they always restart until completion). They share the same volumes as regular containers. Init containers are not separate pods.

Answer

Init containers run in parallel with regular containers.

Answer

Init containers must use the same image as the main container.

Answer

Init containers cannot access volumes shared with regular containers.

Question 11

Which TWO commands can be used to create a resource from a YAML file?

Accepted Answer

kubectl create -f pod.yaml. Options B and C are correct. kubectl create -f and kubectl apply -f both create resources from YAML files. kubectl run creates a pod from command-line arguments. kubectl get retrieves resources. kubectl delete deletes resources.

Answer

kubectl delete -f pod.yaml

Answer

kubectl get -f pod.yaml

Answer

kubectl run -f pod.yaml

Question 12

Which THREE statements about Dockerfile CMD and ENTRYPOINT are correct?

Accepted Answer

CMD can be overridden at container runtime by specifying a command after the image name.. Options A, C, and D are correct. If both CMD and ENTRYPOINT are defined, CMD provides default arguments to ENTRYPOINT. CMD can be overridden by providing command-line arguments at container run. ENTRYPOINT can be overridden using --entrypoint flag. If neither is defined, the container starts but exits immediately because there is no command (unless image has default). CMD is not always ignored when ENTRYPOINT is defined; it provides defaults.

Answer

CMD is always ignored if ENTRYPOINT is defined.

Question 13

You are tasked with building a container image for a Node.js application. The Dockerfile must first install system dependencies, then copy application code, and finally run the app. Which of the following Dockerfiles is correct?

Accepted Answer

FROM node:14
RUN apt-get update && apt-get install -y build-essential
COPY . /app
CMD ["node","app.js"]. Option B correctly uses RUN to install dependencies, COPY to add code, and CMD to run the app. Option A uses CMD incorrectly for installation; CMD is only the default command. Option C uses ENTRYPOINT instead of CMD, which would require arguments. Option D uses RUN with a string form which is less efficient and not recommended.

Answer

FROM node:14
CMD apt-get update && apt-get install -y build-essential
COPY . /app
CMD ["node","app.js"]

Answer

FROM node:14
RUN apt-get update && apt-get install -y build-essential
COPY . /app
RUN ["node","app.js"]

Answer

FROM node:14
RUN apt-get update && apt-get install -y build-essential
COPY . /app
ENTRYPOINT ["node","app.js"]

Question 14

Which command is used to create a CronJob in Kubernetes that runs a job every 5 minutes?

Accepted Answer

kubectl create cronjob hello --image=busybox --schedule="*/5 * * * *" -- /bin/sh -c 'date'. The correct command is 'kubectl create cronjob' because CronJob is a standard Kubernetes resource. The --schedule flag defines the schedule.

Answer

kubectl apply -f cronjob.yaml

Answer

kubectl run cronjob --image=busybox --schedule="*/5 * * * *" -- /bin/sh -c 'date'

Answer

kubectl create job hello --image=busybox --schedule="*/5 * * * *" -- /bin/sh -c 'date'

Question 15

A developer wants to run a one-time batch job that processes exactly 10 items, with up to 3 pods running concurrently. The job should retry each pod up to 2 times if it fails. Which YAML snippet correctly configures the Job?

Accepted Answer

.spec.parallelism=3, .spec.completions=10, .spec.backoffLimit=2. Option B sets parallelism to 3 (max concurrent pods) and completions to 10 (total successful pods needed) and backoffLimit to 2 (retries on failure). Option A sets completions to 3 which would only need 3 successful pods, not 10. Option C sets parallelism to 10 and completions to 3, which is opposite. Option D sets backoffLimit to 3 but completions to 2, not matching the requirement.

Answer

.spec.parallelism=3, .spec.completions=2, .spec.backoffLimit=3

Answer

.spec.parallelism=10, .spec.completions=3, .spec.backoffLimit=2

Answer

.spec.parallelism=3, .spec.completions=3, .spec.backoffLimit=2