CKAD Exam Questions 2026 – Real Practice Test with Verified Answers

Home / The Linux Foundation / CKAD

CKAD Certified Kubernetes Application Developer Exam Overview


The Certified Kubernetes Application Developer CKAD certification is designed for professionals who build, deploy, and manage cloud-native applications using Kubernetes, which also validates the practical skills required to work effectively as a Kubernetes application developer in today's industry.

The CKAD exam is a performance-based, online proctored test where candidates solve real-world tasks using a command-line interface. Unlike traditional multiple-choice exams, it focuses on hands-on problem-solving in a live Kubernetes environment.

Duration: 2 hours
Exam Format: Performance-based tasks
Kubernetes Version: v1.35
Certification Validity: 2 years
Exam Eligibility: 12 months from purchase

Candidates are expected to have a solid understanding of container runtimes, microservices architecture, and Kubernetes resource management.

Skills Measured in the CKAD Exam


The CKAD exam evaluates your ability across five core domains:

1. Application Design and Build (20%)

This section focuses on designing cloud-native applications and working with container images. Candidates should be comfortable creating, modifying, and managing OCI-compliant container images and understanding application architecture patterns.

2. Application Deployment (20%)

This domain tests your ability to deploy applications in Kubernetes, including configuring deployments, managing rolling updates, and ensuring application availability.

3. Application Observability and Maintenance (15%)

Candidates must demonstrate skills in monitoring applications, troubleshooting issues, and maintaining application health using logs, probes, and debugging techniques.

4. Application Environment, Configuration, and Security (25%)

This is one of the most critical areas, covering ConfigMaps, Secrets, environment variables, and security best practices for containerized applications.

5. Services and Networking (20%)

This section evaluates your understanding of Kubernetes networking concepts, including Services, Ingress, DNS, and communication between application components.

How to Prepare for the CKAD Exam?


Preparing for the CKAD exam requires a hands-on and practical approach. Here are key strategies to help you succeed:

Practice in Real Kubernetes Environments:
Set up your own Kubernetes cluster using tools like Minikube or Kind and practice daily tasks.

Master kubectl Commands:
Speed and accuracy are crucial. Become efficient with kubectl commands and YAML configurations.

Understand Core Concepts Deeply:
Focus on Pods, Deployments, Services, ConfigMaps, Secrets, and Networking.

Use Official Documentation Effectively:
During the exam, you can access Kubernetes documentation. Practice navigating it quickly to find solutions.

Simulate Exam Conditions:
Time yourself while solving real-world scenarios to improve speed and confidence.

Why Choose Our CKAD Practice Questions?


Our CKAD practice questions are designed to closely mirror the actual exam environment, helping you build real confidence. Each question focuses on practical, scenario-based tasks that reflect real Kubernetes challenges.

You’ll benefit from:

● Realistic hands-on scenarios
● Detailed explanations for every solution
● Coverage of all exam domains
● Updated content aligned with the latest Kubernetes version

These practice materials are ideal for reinforcing your knowledge and identifying weak areas before taking the actual exam.

Practice Questions for CKAD Exam


Practice questions play a critical role in CKAD exam preparation. Since the exam is performance-based, simply understanding theory is not enough - you must be able to apply your knowledge in real scenarios. High-quality practice questions help you develop problem-solving skills, improve speed, and gain familiarity with the exam format, significantly increasing your chances of passing on your first attempt.

Question#1

SIMULATION



Context
It is always useful to look at the resources your applications are consuming in a cluster.
Task
• From the pods running in namespace cpu-stress, write the name only of the pod that is consuming the most CPU to file /opt/KDOBG030l/pod.txt, which has already been created.

A. Solution:


Question#2

SIMULATION



Task
Create a new deployment for running.nginx with the following parameters;
• Run the deployment in the kdpd00201 namespace. The namespace has already been created
• Name the deployment frontend and configure with 4 replicas
• Configure the pod with a container image of lfccncf/nginx:1.13.7
• Set an environment variable of NGINX__PORT=8080 and also expose that port for the container above

A. Solution:











Question#3

SIMULATION
You are asked to prepare a canary deployment for testing a new application release.
You must connect to the correct host. Failure to do so may result in a zero score.
[candidate@base] $ ssh ckad00023
Modify the Deployments so that:
a maximum number of 10 Pods run in the moose namespace.
20% of the chipmunk-service 's traffic goes to the canary-chipmunk-deployment Pod (s).



The Service is exposed on NodePort 30000. To test its load- balancing, run
[candidate@ckad00023] $ curl http://localhost:30000/
or open this URL in the remote desktop's browser.

A. ssh ckad00023
You need two outcomes in moose:
At most 10 Pods total (across both Deployments).
About 20% of chipmunk-service traffic goes to canary-chipmunk-deployment.
In Kubernetes Services, traffic distribution is (roughly) proportional to the number of ready endpoints behind the Service .
So the standard canary trick is:
total endpoints = 10
canary endpoints = 2
current endpoints = 8
That gives ~20% to canary.
1) Inspect what exists kubectl -n moose get deploy kubectl -n moose get svc chipmunk-service -o wide kubectl -n moose describe svc chipmunk-service Get the Service selector (important):
kubectl -n moose get svc chipmunk-service -o jsonpath='{.spec.selector}{"\n"}' Check current replicas:
kubectl -n moose get deploy current-chipmunk-deployment -o jsonpath='{.spec.replicas}{"\n"}' kubectl -n moose get deploy canary-chipmunk-deployment -o jsonpath='{.spec.replicas}{"\n"}' List pods + labels (to confirm both Deployments’ pods match the Service selector):
kubectl -n moose get pods --show-labels
2) Ensure both Deployments are behind the Service
This is the key: the pods from BOTH deployments must match the Service selector.
If the Service selector is something like app=chipmunk, then both Deployments’ pod templates must include app: chipmunk.
If one Deployment doesn’t match, patch its pod template labels to match the selector.
2A) Example: selector is app=chipmunk
(Only do this if you see the Service selector contains app=chipmunk and one of the deployments is missing it.)
kubectl -n moose patch deploy current-chipmunk-deployment \
-p '{"spec":{"template":{"metadata":{"labels":{"app":"chipmunk"}}}}}'
kubectl -n moose patch deploy canary-chipmunk-deployment \
-p '{"spec":{"template":{"metadata":{"labels":{"app":"chipmunk"}}}}}'
Wait for rollouts if patches triggered new ReplicaSets: kubectl -n moose rollout status deploy current-chipmunk-deployment kubectl -n moose rollout status deploy canary-chipmunk-deployment Verify endpoints now include pods from both deployments: kubectl -n moose get endpoints chipmunk-service -o wide
3) Set replicas to enforce “max 10 pods” and “20% canary” Set:
current = 8
canary = 2
Total = 10.
kubectl -n moose scale deploy current-chipmunk-deployment --replicas=8
kubectl -n moose scale deploy canary-chipmunk-deployment --replicas=2
Wait until ready:
kubectl -n moose rollout status deploy current-chipmunk-deployment kubectl -n moose rollout status deploy canary-chipmunk-deployment
Confirm total pods is 10 (or less) and all are Running/Ready:
kubectl -n moose get pods kubectl -n moose get pods | tail -n +2 | wc -l
Confirm endpoints count matches 10:
kubectl -n moose get endpoints chipmunk-service -o jsonpath='{.subsets[*].addresses[*].ip}' | wc -w
4) Test load balancing via NodePort 30000 Run several times:
for i in $(seq 1 30); do curl -s http://localhost:30000/; echo; done
You should see canary responses appear roughly ~20% of the time (not exact every run).
If you want a clearer signal, check which pods are endpoints and ensure 2 belong to canary and 8 to current:
kubectl -n moose get pods -l app=chipmunk -o wide kubectl -n moose get endpoints chipmunk-service -o wide

Question#4

SIMULATION



Given a container that writes a log file in format A and a container that converts log files from format A to format B, create a deployment that runs both containers such that the log files from the first container are converted by the second container, emitting logs in format B.
Task:
• Create a deployment named deployment-xyz in the default namespace, that:
• Includes a primary lfccncf/busybox:1 container, named logger-dev
• includes a sidecar Ifccncf/fluentd: v0.12 container, named adapter-zen
• Mounts a shared volume /tmp/log on both containers, which does not persist when the pod is deleted
• Instructs the logger-dev container to run the command



which should output logs to /tmp/log/input.log in plain text format, with example values:



• The adapter-zen sidecar container should read /tmp/log/input.log and output the data to /tmp/log/output.* in Fluentd JSON format. Note that no knowledge of Fluentd is required to complete this task: all you will need to achieve this is to create the ConfigMap from the spec file provided at /opt/KDMC00102/fluentd-configma p.yaml, and mount that ConfigMap to /fluentd/etc in the adapter-zen sidecar container

A. Solution:
















Question#5

SIMULATION



Task:
A Dockerfile has been prepared at -/human-stork/build/Dockerfile
1) Using the prepared Dockerfile, build a container image with the name macque and lag 3.0. You may install and use the tool of your choice.



2) Using the tool of your choice export the built container image in OC-format and store it at - /human stork/macque 3.0 tar

A. Solution:







Disclaimer

This page is for educational and exam preparation reference only. It is not affiliated with The Linux Foundation, Kubernetes Application Developer, or the official exam provider. Candidates should refer to official documentation and training for authoritative information.

Exam Code: CKADQ & A:  48  Q&As Updated:  2026-07-09

  Get All CKAD Q&As