CKAD Application Design and Build Practice Test 9 — 15 Questions

Question 1

Which TWO of the following are valid ways to expose a container port in a pod spec?

Accepted Answer

spec.containers[].ports[].hostPort. `spec.containers[].ports[].hostPort` is a valid field in the Pod spec that maps a container port to the host node's network interface. This allows external traffic to reach the container via the host's IP address and specified port, though it is typically used for daemon sets or host-networking scenarios rather than general service exposure.

Answer

spec.containers[].hostPort

Answer

spec.containers[].containerPort

Answer

EXPOSE 8080 in Dockerfile

Question 2

You are tasked with containerizing a Go application. The application compiles into a binary. Which Dockerfile best implements a multi-stage build to produce a minimal image?

Accepted Answer

FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp
FROM scratch
COPY --from=builder /app/myapp /myapp
CMD ["/myapp"]. It uses a multi-stage build: the first stage uses the official `golang:1.21` image to compile the Go binary, and the second stage copies only the compiled binary into a `scratch` (empty) image. This produces a minimal image containing only the binary and no build tools, reducing attack surface and image size.

Answer

FROM AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp
FROM scratch
COPY --from=builder /app/myapp /myapp
CMD ["/myapp"]

Answer

FROM ubuntu:latest
RUN apt-get update && apt-get install -y golang
COPY . /app
WORKDIR /app
RUN go build -o myapp
CMD ["./myapp"]

Answer

FROM golang:1.21
WORKDIR /app
COPY . .
RUN go build -o myapp
CMD ["./myapp"]

Question 3

You run 'kubectl run nginx --image=nginx --restart=Never --dry-run=client -o yaml'. What is the output?

Accepted Answer

A Pod manifest with apiVersion: v1. The command `kubectl run nginx --image=nginx --restart=Never --dry-run=client -o yaml` creates a Pod manifest because `--restart=Never` explicitly sets the restart policy to Never, which is a Pod-level field. The `kubectl run` command without `--restart=Never` defaults to creating a Deployment, but with `--restart=Never`, it generates a standalone Pod. The output uses `apiVersion: v1`, which is the correct and stable API version for Pods.

Answer

A Pod manifest with apiVersion: v1beta1

Answer

A Job manifest with apiVersion: batch/v1

Answer

A Deployment manifest with apiVersion: apps/v1

Question 4

Which Dockerfile instruction sets a default command that can be overridden by arguments passed to 'docker run'?

Accepted Answer

CMD. The CMD instruction in a Dockerfile sets a default command that runs when a container starts. This default can be overridden by providing arguments directly to 'docker run' after the image name, making it the correct choice for a command that is intended to be easily replaced.

Answer

ENTRYPOINT

Answer

EXPOSE

Answer

RUN

Question 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

You need to create a Job that runs a single task to completion. Which kubectl command correctly creates a Job named 'data-processor' that runs the image 'myapp/processor:1.0'?

Accepted Answer

kubectl create job data-processor --image=myapp/processor:1.0. `kubectl create job` is the dedicated command to create a Job resource, which runs a pod to completion without restarting the container after success. The Job controller ensures the pod runs exactly once, making it ideal for batch processing tasks.

Answer

kubectl create deployment data-processor --image=myapp/processor:1.0

Answer

kubectl run data-processor --image=myapp/processor:1.0 --restart=Never

Answer

kubectl create cronjob data-processor --image=myapp/processor:1.0

Question 14

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 15

You are designing a Pod that must run a diagnostic tool to collect network logs before the main application starts. The diagnostic tool should run to completion, then the main application starts. Which approach should you use?

Accepted Answer

Add the diagnostic tool as an init container in the Pod. Init containers run sequentially before the Pod's main containers start, and they must complete successfully before the main application container begins. This makes them ideal for setup tasks like running a diagnostic tool to collect network logs that must finish before the main application starts.

Answer

Add the diagnostic tool as a sidecar container in the same Pod

Answer

Add the diagnostic tool as a sidecar container with a postStart hook

Answer

Create a separate Job that runs before the Pod