CKAD Application Design and Build Practice Test 7 — 15 Questions

Question 1

A Job must run exactly 3 Pods in parallel. Which Job manifest field achieves this?

Accepted Answer

.spec.parallelism. `.spec.parallelism` in a Kubernetes Job manifest specifies the maximum number of Pods that should run concurrently. Setting this field to 3 ensures exactly 3 Pods run in parallel, as required by the question.

Answer

.spec.activeDeadlineSeconds

Answer

.spec.completions

Answer

.spec.backoffLimit

Question 2

A CronJob must run a task every day at midnight, but if the previous job is still running, the new job should be skipped. Which concurrencyPolicy should be set?

Accepted Answer

Forbid. B is correct because the `Forbid` concurrency policy ensures that if a previous job instance is still running when the next scheduled trigger fires, the new job is simply skipped. This matches the requirement to avoid overlapping executions without terminating the running job.

Answer

Skip

Answer

Allow

Answer

Replace

Question 3

What is the correct schedule expression for a CronJob that runs every 5 minutes?

Accepted Answer

*/5 * * * *. The CronJob schedule expression `*/5 * * * *` uses the step syntax (`*/5`) in the minute field, which tells the CronJob to run every 5 minutes. In Kubernetes CronJobs, the schedule follows standard cron syntax: minute, hour, day of month, month, day of week. The asterisk means 'every' and the slash with a number means 'every N units', so `*/5` in the minute field triggers the job at minutes 0, 5, 10, 15, etc., effectively every 5 minutes.

Answer

* * * * *

Answer

0 */5 * * *

Answer

5 * * * *

Question 4

Which 'kubectl' command creates a pod named 'test-pod' using the nginx image and outputs the YAML manifest without actually creating it?

Accepted Answer

kubectl run test-pod --image=nginx --dry-run=client -o yaml. `kubectl run test-pod --image=nginx --dry-run=client -o yaml` generates the YAML manifest for a pod named 'test-pod' using the nginx image without actually creating it. The `--dry-run=client` flag simulates the request locally and prevents API server submission, while `-o yaml` formats the output as YAML.

Answer

kubectl apply -f pod.yaml

Answer

kubectl run test-pod --image=nginx --dry-run=server

Answer

kubectl run test-pod --image=nginx --dry-run=client -o json

Question 5

A Pod with an init container and a main container is created. The init container runs a script that takes 10 seconds. The main container's startupProbe has initialDelaySeconds: 5. When does the startupProbe begin?

Accepted Answer

After the init container completes, then plus 5 seconds. The startupProbe does not begin until the Pod's containers are actually running. Init containers must complete successfully before any main containers start. Therefore, the startupProbe's initialDelaySeconds of 5 is counted from the moment the main container starts, which is after the init container finishes its 10-second script. The probe begins 5 seconds after the main container starts, not from Pod creation.

Answer

5 seconds after the pod is created

Answer

10 seconds after the pod is created

Answer

Immediately after the pod is created

Question 6

You have a Dockerfile with 'CMD ["nginx", "-g", "daemon off;"]'. A developer wants to run the container with a different command: 'nginx -t'. How should they run the container?

Accepted Answer

docker run nginx nginx -t. `docker run nginx nginx -t` passes `nginx -t` as the command to override the Dockerfile's `CMD`. The CMD instruction in the Dockerfile is replaced entirely by the command-line arguments after the image name, so the container runs `nginx -t` instead of `nginx -g 'daemon off;'`. This is the standard Docker behavior for overriding the default command.

Answer

docker run nginx ["nginx", "-t"]

Answer

docker run nginx CMD nginx -t

Answer

docker run --entrypoint nginx -t nginx

Question 7

Which TWO statements about init containers are true? (Select 2)

Accepted Answer

Init containers run sequentially in the order they are defined.. Init containers in a Kubernetes Pod are executed sequentially in the exact order they are defined in the `initContainers` array. Each init container must exit successfully (return code 0) before the next one starts, ensuring a strict dependency chain for initialization tasks.

Answer

Init containers support liveness and readiness probes.

Answer

Init containers share the same filesystem as the application containers by default.

Answer

Init containers have a restart policy of Always.

Question 8

Which THREE options are valid fields in a CronJob spec? (Select 3)

Accepted Answer

.spec.successfulJobsHistoryLimit. `.spec.successfulJobsHistoryLimit` is a valid field in a CronJob spec that controls how many completed jobs are retained for inspection. This field defaults to 3 and helps manage cluster resource usage by limiting the number of successful job records kept in the history.

Answer

.spec.jobTemplate.spec.template.spec.restartPolicy

Answer

.spec.jobTemplate.spec.parallelism

Question 9

Which TWO instructions are commonly used to add files to a Docker image during build? (Select 2)

Accepted Answer

COPY. The COPY instruction is used to copy files and directories from the build context into the Docker image filesystem. It is the preferred method for adding local files because it is explicit and does not perform any automatic extraction or URL fetching, making builds more predictable and secure.

Answer

ENTRYPOINT

Answer

RUN

Answer

CMD

Question 10

You have a Dockerfile with a multi-stage build. The first stage is named 'builder' and uses 'golang:1.20' to compile a binary. The second stage uses 'alpine:3.18' and should copy the binary from the first stage. Which COPY instruction is correct?

Accepted Answer

COPY --from=builder /app/myapp /usr/local/bin/myapp. In a multi-stage Docker build, the `COPY --from=<name|index>` instruction copies files from a named previous stage. Option D correctly uses the stage name 'builder' to copy the compiled binary from the first stage into the final Alpine image. This is the standard and most readable approach for multi-stage builds.

Answer

ADD --from=builder /app/myapp /usr/local/bin/myapp

Answer

COPY /app/myapp /usr/local/bin/myapp

Answer

COPY --from=0 /app/myapp /usr/local/bin/myapp

Question 11

Which YAML snippet correctly defines a CronJob that runs a task every 5 minutes?

Accepted Answer

schedule: "*/5 * * * *". The standard cron expression for 'every 5 minutes' is `*/5 * * * *`, which matches the required five fields (minute, hour, day of month, month, day of week). Kubernetes CronJob uses this exact format, where `*/5` in the minute field means 'every 5 minutes' and the four asterisks mean 'every hour, every day, every month, every weekday'.

Answer

schedule: "*/5 * * *"

Answer

schedule: "0 */5 * * *"

Answer

schedule: "* * * * *"

Question 12

You have a CronJob that runs a backup every hour. Due to a network issue, some backups take longer than an hour, causing overlapping executions. You want to ensure that if a new job is scheduled while the previous one is still running, the new job is skipped. Which concurrencyPolicy should you set?

Accepted Answer

ConcurrencyPolicy: Forbid. Setting `concurrencyPolicy: Forbid` on a CronJob prevents a new job from being created if the previous job from the same CronJob is still running. This directly addresses the requirement to skip overlapping executions when a backup takes longer than the scheduled interval.

Answer

ConcurrencyPolicy: Skip

Answer

ConcurrencyPolicy: Allow

Answer

ConcurrencyPolicy: Replace

Question 13

A developer wants to debug a running container in a Pod named 'web-app' in namespace 'dev'. Which command attaches an ephemeral container with the 'nicolaka/netshoot' image for network debugging?

Accepted Answer

kubectl debug web-app -n dev --image=nicolaka/netshoot -c debugger. `kubectl debug` is the dedicated command for adding an ephemeral container to a running Pod for troubleshooting. The `--image=nicolaka/netshoot` flag specifies the network debugging image, and `-c debugger` names the ephemeral container. This allows the developer to attach to the Pod's network namespace without restarting or modifying the original container.

Answer

kubectl run debugger -n dev --image=nicolaka/netshoot --restart=Never

Answer

kubectl attach web-app -n dev -c debugger --image=nicolaka/netshoot

Answer

kubectl exec -n dev web-app --image=nicolaka/netshoot -- /bin/bash

Question 14

You are deploying a Pod that contains two containers: a web server and a file sync agent. The file sync agent needs to run as long as the web server is running and should share the same network namespace. Which design pattern does this represent?

Accepted Answer

Sidecar pattern. The Sidecar pattern (D) is correct because it describes a secondary container that runs alongside a primary container in the same Pod, sharing the same network namespace and lifecycle. In this scenario, the file sync agent is a helper that must run as long as the web server runs and share its network stack, which is exactly what a sidecar container does — it extends or enhances the primary container's functionality without being its own separate Pod.

Answer

Adapter pattern

Answer

Ambassador pattern

Answer

Init container pattern

Question 15

You need to run a batch job that processes 10 items in parallel across 10 Pods, but the job should be considered complete only when all 10 Pods have succeeded. Which Job configuration is correct?

Accepted Answer

spec: completions: 10; parallelism: 10. Setting `completions: 10` and `parallelism: 10` tells Kubernetes to run 10 Pods concurrently (parallelism) and consider the Job successful only after all 10 Pods have completed without error (completions). This matches the requirement of processing 10 items in parallel with a completion condition of all Pods succeeding.

Answer

spec: completions: 10; parallelism: 1

Answer

spec: completions: 1; parallelism: 10

Answer

spec: completions: 10; parallelism: 0