195+ Free CKAD Practice Questions

Pass your Certified Kubernetes Application Developer (CKAD) exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately

~60-70% Pass Rate

195+ Questions

100% Free

1 / 195

Question 1

Score: 0/0

Which Kubernetes object is the smallest deployable unit that can be created and managed in Kubernetes?

Deployment

ReplicaSet

Pod

Container

to track

2026 Statistics

Key Facts: CKAD Exam

~60-70%

Est. Pass Rate

Industry estimate

66%

Passing Score

CNCF

80-120 hrs

Study Time

Recommended

2 years

Cert Valid

CNCF

15-20 tasks

Exam Format

Performance-based

$375

Exam Fee

CNCF

The Certified Kubernetes Application Developer (CKAD) requires a 66% passing score. The exam consists of 15-20 performance-based tasks to be completed in 2 hours. Environment, Configuration & Security is the largest domain at 25%, followed by Application Design & Build (20%), Application Deployment (20%), Services & Networking (20%), and Observability & Maintenance (15%). CKAD certification is valid for 2 years.

Sample CKAD Practice Questions

Try these sample questions to test your CKAD exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 195+ question experience with AI tutoring.

1Which Kubernetes object is the smallest deployable unit that can be created and managed in Kubernetes?

A.Deployment

B.ReplicaSet

C.Pod

D.Container

Explanation: A Pod is the smallest deployable unit in Kubernetes. It represents a single instance of a running process in your cluster and can contain one or more containers that share storage and network resources. While containers are the runtime entities, Kubernetes does not manage individual containers directly—it manages Pods. Deployments and ReplicaSets are higher-level controllers that manage Pods.

2You need to create a Pod named "web-server" running nginx with a resource constraint of 256Mi memory limit. Which YAML snippet correctly defines this?

A.apiVersion: v1 kind: Pod metadata: name: web-server spec: containers: - name: nginx image: nginx resources: limits: memory: 256Mi

B.apiVersion: v1 kind: Pod metadata: name: web-server spec: containers: - name: nginx image: nginx limits: memory: 256Mi

C.apiVersion: apps/v1 kind: Pod metadata: name: web-server spec: resources: limits: memory: 256Mi

D.apiVersion: v1 kind: Container metadata: name: web-server spec: image: nginx memoryLimit: 256Mi

Explanation: The correct YAML uses apiVersion: v1 and kind: Pod. Resources must be specified under the containers[].resources.limits path with the memory key. Option B is incorrect because limits should be under resources, not directly under the container spec. Option C has the wrong apiVersion (apps/v1) and misplaced resources. Option D uses an invalid kind (Container is not a Kubernetes API resource).

3Which kubectl command creates a Pod named "debug" that runs an interactive busybox shell?

A.kubectl create pod debug --image=busybox --interactive

B.kubectl run debug --image=busybox -it --rm -- /bin/sh

C.kubectl exec -it debug --image=busybox -- /bin/sh

D.kubectl apply -f debug-pod.yaml --interactive

Explanation: The "kubectl run" command creates a Pod with the specified image. The -it flags allocate a pseudo-TTY and keep stdin open for interactive use. The --rm flag removes the Pod after exit. Option A is incorrect because "kubectl create pod" does not exist. Option C requires an existing Pod. Option D applies a YAML file but does not make it interactive by itself.

4You need to create a Pod with two containers: a main application container and a sidecar container that processes logs. What is the correct approach?

A.Create two separate Pods and use a Service to connect them

B.Define both containers in the same Pod spec under spec.containers[]

C.Use a Deployment with two replicas

D.Create a DaemonSet with two containers

Explanation: A multi-container Pod is created by defining multiple containers in the spec.containers array of a single Pod spec. These containers share the same network namespace (localhost), storage volumes, and lifecycle. This pattern is commonly used for sidecars, adapters, and ambassadors. Creating separate Pods would not provide shared storage or localhost networking. A Deployment with replicas creates multiple Pod instances, not multi-container Pods.

5In a multi-container Pod with an app container and a log-aggregator sidecar, which volume type allows both containers to share log files?

A.PersistentVolumeClaim

B.emptyDir

C.hostPath

D.configMap

Explanation: emptyDir is the ideal volume type for sharing files between containers in the same Pod. It is created when the Pod is assigned to a node and exists as long as the Pod runs on that node. Both containers can mount the same emptyDir volume to share files. While PersistentVolumeClaim and hostPath can share data, emptyDir is designed for ephemeral, intra-Pod sharing. ConfigMap is for configuration data, not log files.

6Which statement correctly describes the behavior of init containers in a Pod?

A.Init containers run in parallel with app containers

B.Init containers must complete successfully before app containers start

C.Init containers restart automatically when they fail

D.Init containers share the same lifecycle as app containers

Explanation: Init containers run sequentially and must all complete successfully before any app containers start. If an init container fails, Kubernetes restarts the Pod (depending on restartPolicy) until the init container succeeds. They are useful for setup tasks like waiting for services, database migrations, or generating configuration files. They do not run in parallel with app containers and have separate resource limits.

7You have a Pod with an init container that needs to wait for a database service to be available before starting the main application. Which approach should the init container use?

A.Create a Service resource for the database

B.Use a readiness probe on the main container

C.Run a command that polls the database until it responds

D.Set a sleep timer for 60 seconds

Explanation: The init container should actively check (poll) the database service availability using a command like "nslookup db-service" or "nc -z db-service 5432" in a loop. This ensures the main container only starts when dependencies are ready. Creating a Service does not wait for the database to be ready. Readiness probes run on app containers, not init containers. A sleep timer is unreliable as the database might not be ready within the fixed time.

8Which Kubernetes object should you use to run a batch job that processes data and completes when finished?

A.Deployment

B.StatefulSet

C.Job

D.DaemonSet

Explanation: A Job creates one or more Pods and ensures that a specified number of them successfully terminate. Jobs are designed for batch processing tasks that run to completion. Deployments are for stateless, long-running services. StatefulSets are for stateful applications requiring stable identities. DaemonSets run one Pod per node for cluster-wide services.

9You need to schedule a backup job to run every day at 2:00 AM. Which Kubernetes resource and schedule expression should you use?

A.Job with schedule: "0 2 * * *"

B.CronJob with spec.schedule: "0 2 * * *"

C.ScheduledJob with cron: "0 2 * * *"

D.Deployment with restartPolicy: "0 2 * * *"

Explanation: CronJob is the correct resource for time-based scheduling. The schedule "0 2 * * *" in cron format means "at 2:00 AM every day" (minute 0, hour 2, every day of month, every month, every day of week). Job does not support scheduling. ScheduledJob was an older alpha resource replaced by CronJob. Deployment is not used for batch scheduling.

10A Job is configured with completions: 5 and parallelism: 2. How does Kubernetes execute this Job?

A.Creates 5 Pods sequentially, one at a time

B.Creates 2 Pods at a time until 5 successful completions

C.Creates exactly 2 Pods that each complete 5 times

D.Creates 5 Pods immediately and runs 2 at a time

Explanation: The completions field specifies that 5 Pods must complete successfully. The parallelism field of 2 means up to 2 Pods run concurrently. Kubernetes creates Pods in batches of 2 until 5 successful completions are achieved. The Job continues creating new Pods as running ones complete until the desired completions count is reached.

About the CKAD Exam

The Certified Kubernetes Application Developer (CKAD) validates skills in designing, building, configuring, and exposing cloud-native applications for Kubernetes. This performance-based exam focuses on practical application deployment skills including multi-container Pods, Deployments, Services, ConfigMaps, Secrets, and Observability.

Questions

15 scored questions

Time Limit

2 hours

Passing Score

66%

Exam Fee

$375 (Cloud Native Computing Foundation (CNCF))

CKAD Exam Content Outline

20%

Application Design & Build

Pod design patterns, multi-container Pods, Init containers, Jobs, CronJobs, Deployments

20%

Application Deployment

Rolling updates, rollbacks, scaling, blue/green deployments, canary deployments

15%

Observability & Maintenance

Liveness/readiness/startup probes, monitoring, logging, debugging, deprecation

25%

Environment, Configuration & Security

ConfigMaps, Secrets, security contexts, ServiceAccounts, quotas, NetworkPolicies

20%

Services & Networking

Services, Ingress, DNS, NetworkPolicies for traffic control

How to Pass the CKAD Exam

What You Need to Know

Passing score: 66%
Exam length: 15 questions
Time limit: 2 hours
Exam fee: $375

Keys to Passing

Complete 500+ practice questions
Score 80%+ consistently before scheduling
Focus on highest-weighted sections
Use our AI tutor for tough concepts

CKAD Study Tips from Top Performers

1Focus on Environment, Configuration & Security (25%) — it's the largest domain; master ConfigMaps, Secrets, and security contexts

2Master imperative kubectl commands — use --dry-run=client -o yaml to generate YAML quickly

3Practice multi-container Pod design — understand init containers and sidecar patterns

4Know your probes — liveness, readiness, and startup probes are frequently tested

5Understand deployment strategies — rolling updates, blue/green, and canary deployments

6Complete 200+ practice questions and score 80%+ consistently before scheduling

Frequently Asked Questions

What is the CKAD pass rate?

The CKAD exam has an estimated 60-70% first-attempt pass rate. CNCF does not publish official pass rates. The exam requires 66% to pass with 15-20 performance-based tasks in 2 hours. Candidates with Kubernetes fundamentals and hands-on application deployment experience typically pass on their first attempt.

How many questions are on the CKAD exam?

The CKAD exam has 15-20 performance-based tasks (not multiple choice). You have 2 hours to complete all tasks. Each task requires you to perform actions in a real Kubernetes cluster environment using the command line. Tasks vary in difficulty and point value.

What are the five domains of the CKAD exam?

The five exam domains are: Application Design & Build (20%): Pod patterns, multi-container Pods, Jobs, CronJobs; Application Deployment (20%): Rolling updates, scaling, deployment strategies; Observability & Maintenance (15%): Probes, monitoring, debugging; Environment, Configuration & Security (25%): ConfigMaps, Secrets, security contexts, quotas — the largest domain; Services & Networking (20%): Services, Ingress, NetworkPolicies.

How long should I study for the CKAD exam?

Most candidates study for 5-8 weeks, investing 80-120 hours total. CNCF recommends basic Kubernetes understanding. Key study areas: 1) Practice creating and managing all workload resources. 2) Master ConfigMaps and Secrets for configuration. 3) Understand Service and Ingress configuration. 4) Practice kubectl imperative commands for speed. 5) Complete 200+ practice questions simulating exam conditions.

What is the difference between CKAD and CKA?

CKAD (Certified Kubernetes Application Developer) focuses on application development — designing, building, and configuring applications to run on Kubernetes. CKA (Certified Kubernetes Administrator) focuses on cluster operations — installing, configuring, and managing Kubernetes clusters. CKAD is ideal for developers and DevOps engineers. CKA is ideal for platform engineers and SREs. Many professionals earn both certifications.

What is the CKAD exam environment?

The CKAD exam uses a remote desktop environment with multiple Linux terminals. You work with a real Kubernetes cluster. You can use kubectl, vim, and standard Linux tools. The exam is proctored remotely via PSI. You are allowed to access Kubernetes documentation (kubernetes.io/docs) during the exam. Time management is critical — practice completing tasks quickly.