Linux Foundation CKAD Practice Exam Questions & Answers

5 Free Questions · Last reviewed: September 14, 2026 · Prepared & Reviewed by the ValidExamDumps Editorial Team

Exam Facts

Linux Foundation CKAD Exam Details

Key details for this exam, checked against the published exam outline

48 Practice Questions (Our Bank)
120 minutes Exam Duration
66% or above Passing Score
USD 445 Exam Fee
Exam Code
CKAD
Full Name
Certified Kubernetes Application Developer (CKAD)
Issuing Body
Linux Foundation and Cloud Native Computing Foundation (CNCF)
Question Format (Our Bank)
Multiple Choice
Delivery
Online proctored, taken from anywhere in the world via PSI
Eligibility
No prerequisites required. Candidates must assume working knowledge of container runtimes and microservice architecture.
Validity
2 years from the date of passing the exam
Practice Questions

Free CKAD Practice Questions

Each question shows the correct answer and an explanation of why it is right

VA
ValidExamDumps Editorial Team Every question and its answer is checked by our CKAD exam preparation team, who also write the explanation shown with each one. How we research and review these pages

SIMULATION

Context

You must connect to the correct host . Failure to do so may result in a zero score.

[candidate@base] $ ssh ckad00043

A Deployment needs specific RBAC permissions.

Task

First, find the RBAC permissions needed by the scraper Deployment running in the

cute-panda namespace .

it kubectl logs may help you to find the permissions it needs.

Next, create a new ServiceAccount named scraper in the namespace cute-panda.

Correct Answer: A
Explanation

ssh ckad00043

You have two deliverables here:

Figure out what RBAC permissions the scraper Deployment needs (the logs will usually show ''Forbidden'' with the missing verb/resource).

Create a ServiceAccount named scraper in namespace cute-panda (and in practice, you then bind the needed permissions to it and use it in the Deployment so it actually works).

Below is the exact CKAD-style workflow.

1) Find the missing RBAC permissions (use logs + events)

1.1 Identify the pods for the Deployment

kubectl -n cute-panda get deploy scraper

kubectl -n cute-panda get pods -l app=scraper 2>/dev/null || kubectl -n cute-panda get pods

Pick one pod name and check logs:

kubectl -n cute-panda logs deploy/scraper --tail=100

If the pod is crashlooping and logs are short:

POD=$(kubectl -n cute-panda get pods -o jsonpath='{.items[0].metadata.name}')

kubectl -n cute-panda logs '$POD' --previous --tail=200

1.2 Look specifically for ''Forbidden'' lines

Most apps print errors like:

... is forbidden: User 'system:serviceaccount:cute-panda:default' cannot list resource 'pods' in API group '' in the namespace 'cute-panda'

or cannot get resource 'configmaps'...

or cannot watch ...

If you don't see it in logs, check events:

kubectl -n cute-panda get events --sort-by=.lastTimestamp | tail -n 30

1.3 Extract verb/resource/apiGroup from the error

From a typical Kubernetes RBAC ''forbidden'' message, capture:

verb: get/list/watch/create/update/patch/delete

resource: pods, configmaps, secrets, deployments, etc.

apiGroup: '' (core), apps, batch, etc.

namespace: cute-panda (this is a namespaced permission if it's a Role)

You may have multiple ''cannot ...'' lines you need to allow all of them.

2) Create the ServiceAccount scraper (required by the task)

kubectl -n cute-panda create serviceaccount scraper

kubectl -n cute-panda get sa scraper

3) Create the RBAC objects to grant the needed permissions

The task says ''A Deployment needs specific RBAC permissions'' --- in CKAD, that usually means: Role + RoleBinding (namespaced) bound to your new ServiceAccount.

3.1 Create a Role (template you fill from the log output)

Create scraper-role.yaml:

cat <<'EOF' > scraper-role.yaml

apiVersion: rbac.authorization.k8s.io/v1

kind: Role

metadata:

name: scraper-role

namespace: cute-panda

rules:

# EXAMPLE ONLY: replace these rules with what your logs show

- apiGroups: ['']

resources: ['pods']

verbs: ['get','list','watch']

EOF

Apply it:

kubectl apply -f scraper-role.yaml

3.2 Bind the Role to the ServiceAccount

kubectl -n cute-panda create rolebinding scraper-rb \

--role=scraper-role \

--serviceaccount=cute-panda:scraper

Verify:

kubectl -n cute-panda get role scraper-role

kubectl -n cute-panda get rolebinding scraper-rb -o yaml

4) Update the Deployment to use the new ServiceAccount (so it actually works)

Check current SA (likely default):

kubectl -n cute-panda get deploy scraper -o jsonpath='{.spec.template.spec.serviceAccountName}{'\n'}'

Patch it to use scraper:

kubectl -n cute-panda patch deploy scraper -p '{'spec':{'template':{'spec':{'serviceAccountName':'scraper'}}}}'

Rollout:

kubectl -n cute-panda rollout status deploy scraper

Re-check logs to confirm RBAC errors are gone:

kubectl -n cute-panda logs deploy/scraper --tail=100

SIMULATION

Task:

1) First update the Deployment cka00017-deployment in the ckad00017 namespace:

*To run 2 replicas of the pod

*Add the following label on the pod:

Role userUI

2) Next, Create a NodePort Service named cherry in the ckad00017 nmespace exposing the ckad00017-deployment Deployment on TCP port 8888

Correct Answer: A
Explanation

Solution:

SIMULATION

Task:

A pod within the Deployment named buffale-deployment and in namespace gorilla is logging errors.

1) Look at the logs identify errors messages.

Find errors, including User ''system:serviceaccount:gorilla:default'' cannot list resource ''deployment'' [...] in the namespace ''gorilla''

2) Update the Deployment buffalo-deployment to resolve the errors in the logs of the Pod.

The buffalo-deployment 'S manifest can be found at -/prompt/escargot/buffalo-deployment.yaml

Correct Answer: A
Explanation

Solution:

SIMULATION

Task:

1- Update the Propertunel scaling configuration of the Deployment web1 in the ckad00015 namespace setting maxSurge to 2 and maxUnavailable to 59

2- Update the web1 Deployment to use version tag 1.13.7 for the Ifconf/nginx container image.

3- Perform a rollback of the web1 Deployment to its previous version

Correct Answer: A
Explanation

Solution:

SIMULATION

Context

You are asked to deploy an application developed for an older version of Kubernetes on a cluster running a recent version of Kubernetes .

You must connect to the correct host . Failure to do so may result in a zero score.

[candidate@base] $ ssh ckad00026

Task

Fix any API -deprecation issues in the manitest file

/home/candidate/credible-mite/web.yaml

so that the application can be deployed on cluster ckad00026.

The application was developed for Kubernetes v1.15.

The cluster ckad00026 runs Kubernetes 1.29+.

Deploy the application specified in the updated manifest file

/home/candidate/credible-mite/web.yaml in namespace garfish .

Correct Answer: A
Explanation

ssh ckad00026

Your job is to edit /home/candidate/credible-mite/web.yaml so it uses APIs supported on Kubernetes 1.29+, then deploy it into namespace garfish.

Because I can't see your file from here, the most reliable exam approach is:

run a server-side dry-run to reveal the exact deprecated/removed APIs and schema errors

edit the manifest to the modern API versions/fields

re-run dry-run until it passes

apply for real and verify rollout

1) Go to the manifest and run a server-side dry-run

cd /home/candidate/credible-mite

ls -l

sed -n '1,200p' web.yaml

Make sure the namespace exists:

kubectl get ns garfish || kubectl create ns garfish

Now run a server-side dry-run (this catches removed APIs on the cluster):

kubectl apply -n garfish -f web.yaml --dry-run=server

Whatever errors you get here tell you exactly what to fix.

2) Fix the common v1.15 v1.29 API deprecations

Edit the file:

vi web.yaml

Below are the most common objects from older manifests and how to update them for 1.29+.

A) Deployments / DaemonSets / StatefulSets

Old (v1.15 often used):

extensions/v1beta1 or apps/v1beta1 or apps/v1beta2

New:

apiVersion: apps/v1

Also in apps/v1, .spec.selector is required and must match the pod template labels.

Example conversion:

apiVersion: apps/v1

kind: Deployment

metadata:

name: web

spec:

replicas: 2

selector:

matchLabels:

app: web

template:

metadata:

labels:

app: web

spec:

containers:

- name: web

image: nginx

Key rule:

spec.selector.matchLabels must exactly match spec.template.metadata.labels (at least for the keys you select on).

B) Ingress

Old:

apiVersion: extensions/v1beta1 (or networking.k8s.io/v1beta1)

New:

apiVersion: networking.k8s.io/v1

Required changes:

spec.rules.http.paths[].pathType is required (usually Prefix)

backend format changes from serviceName/servicePort to service.name/service.port.number (or .name for named ports)

Old backend:

backend:

serviceName: web

servicePort: 80

New backend:

backend:

service:

name: web

port:

number: 80

Full path example:

apiVersion: networking.k8s.io/v1

kind: Ingress

metadata:

name: web

spec:

rules:

- host: example.local

http:

paths:

- path: /

pathType: Prefix

backend:

service:

name: web

port:

number: 80

C) CronJob

Old:

apiVersion: batch/v1beta1

New:

apiVersion: batch/v1

Most fields stay the same; just update apiVersion.

D) PodDisruptionBudget

Old:

policy/v1beta1

New:

policy/v1

spec.selector/minAvailable/maxUnavailable remain, but apiVersion changes.

E) RBAC

Usually already:

rbac.authorization.k8s.io/v1 (this is fine)

F) Removed APIs you must delete/replace

If you see these in a v1.15-era manifest, they are removed in modern clusters:

PodSecurityPolicy (policy/v1beta1) is removed. You cannot deploy it on 1.29+. Remove it from the manifest (or replace with whatever your environment uses, but for CKAD tasks you usually delete PSP sections from the file).

Some old admission/alpha resources also removed.

If dry-run complains ''no matches for kind ... in version ...'', that's your cue.

3) Re-run dry-run until it succeeds

After you edit:

kubectl apply -n garfish -f web.yaml --dry-run=server

Keep iterating until there are no errors.

4) Deploy for real

kubectl apply -n garfish -f /home/candidate/credible-mite/web.yaml

5) Verify everything in namespace garfish

List what was created:

kubectl -n garfish get all

kubectl -n garfish get ingress 2>/dev/null || true

If there is a Deployment, verify rollout:

kubectl -n garfish get deploy

kubectl -n garfish rollout status deploy --all

Check pods/events if something fails:

kubectl -n garfish get pods -o wide

kubectl -n garfish describe pod

kubectl -n garfish get events --sort-by=.lastTimestamp | tail -n 30

Get Full Access

48 questions covering all exam domains, starting from $20

Study Guide

What the Linux Foundation CKAD Exam Covers

Exam domains verified against: Official Linux Foundation CKAD exam guide, last checked September 2026.

Domain 1: Application Design and Build 20%

You will define, build and modify container images for Kubernetes deployments. This includes choosing appropriate workload resources like Deployments, DaemonSets and CronJobs, and understanding multi-container Pod design patterns including sidecar, init and others. You will also work with persistent and ephemeral volumes to support application storage needs.

Sample question from this domain above: Q2

Domain 2: Application Deployment 20%

You will use Kubernetes primitives to implement deployment strategies such as blue/green and canary releases. This includes understanding how Deployments work and performing rolling updates, as well as using the Helm package manager to deploy existing packages and Kustomize for template management.

Domain 3: Application Environment, Configuration and Security 25%

You will discover and use resources that extend Kubernetes through CRDs and Operators, and demonstrate understanding of authentication, authorization and admission control. You will work with ConfigMaps and Secrets, define resource requests and limits, understand quotas, manage ServiceAccounts and implement Application Security using SecurityContexts and Capabilities.

Sample questions from this domain above: Q1Q5

Domain 4: Services and Networking 20%

You will demonstrate basic understanding of NetworkPolicies to control traffic flow between pods. You will provide and troubleshoot access to applications via Kubernetes Services, and use Ingress rules to expose applications to external traffic.

Sample question from this domain above: Q3

Domain 5: Application Observability and Maintenance 15%

You will understand API deprecations and implement probes and health checks for application reliability. You will use built-in CLI tools to monitor Kubernetes applications, utilize container logs for troubleshooting and debugging, and diagnose issues in Kubernetes environments.

Sample question from this domain above: Q4

FAQ

CKAD Exam FAQ

Common questions about the exam itself

What background do I need before taking the CKAD exam?
The exam assumes working knowledge of container runtimes and microservice architecture, and you should be comfortable working with OCI-compliant container images, applying Cloud Native application concepts and architectures, and validating Kubernetes resource definitions. There are no prerequisites for this exam.
How hard is the CKAD compared to other Kubernetes certifications?
The CKAD is an online, proctored, performance-based test that requires solving multiple tasks from a command line running Kubernetes. It focuses on practical application development skills rather than cluster administration, making it more accessible to developers than the Certified Kubernetes Administrator (CKA) exam, though the time pressure and hands-on nature still make it challenging.
How long should I spend preparing for the CKAD?
Preparation time varies based on your existing Kubernetes experience, but most candidates spend 4 to 12 weeks studying. Once enrolled you will receive access to an exam simulator provided by Killer.sh, allowing you to experience the exam environment with two simulation attempts and 36 hours of access for each attempt from the start of activation.
What is the passing score for the CKAD exam?
For the CKAD Exam, a score of 66% or above must be earned to pass.
How long is the CKAD exam and what does exam day look like?
The exam is an online, proctored, performance-based test that consists of a set of performance-based tasks to be solved in a command line, and candidates have 2 hours to complete the tasks. Exams are delivered online and can be taken from anywhere in the world, and candidates need to make sure they meet system and identification requirements.
How many attempts and retakes do I get for the CKAD exam?
When you purchase the exam, you get 12 months to schedule and take the exam, plus two exam attempts. If you do not pass on your first attempt, you can schedule a second attempt within your 12-month eligibility window.
How long is the CKAD certification valid and what does renewal involve?
The CKAD certification is valid for two years from the date you pass the exam. To renew it, you must pass the current version of the exam again before your certification expires. Passing a higher-level exam like the Certified Kubernetes Administrator (CKA) or Certified Kubernetes Security Specialist (CKS) will automatically renew your CKAD through the CARE program.
Which job roles does the CKAD certification target?
The Certified Kubernetes Application Developer (CKAD) certification is for Kubernetes engineers, cloud engineers and other IT professionals responsible for building, deploying, and configuring cloud native applications with Kubernetes. It is particularly suited for developers transitioning to cloud-native development or DevOps engineers working with containerized applications.
What is the relationship between CKAD and other Kubernetes certifications like CKA?
The CKAD focuses on application development with Kubernetes, while the Certified Kubernetes Administrator (CKA) focuses on cluster administration and operations. For the higher-level Certified Kubernetes Security Specialist (CKS) exam, candidates must have taken and passed the CKA exam prior to attempting it, though CKS may be purchased but not scheduled until CKA certification has been achieved. There are no prerequisites between CKAD and CKA.
Which exam domains do CKAD candidates typically find most challenging?
Application Environment, Configuration and Security is the highest-weighted domain at 25 percent, covering authentication, authorization, ConfigMaps, Secrets and SecurityContexts. This domain often challenges candidates because it requires understanding both Kubernetes security concepts and how to implement them through resource configuration. The Application Deployment domain at 20 percent is also challenging due to the need to quickly implement correct deployment strategies under time pressure.