Exam Prep for the Certified Kubernetes Application Developer (CKAD)
Practise on a free kind cluster until you can design, build, deploy, configure, secure, observe and expose applications on Kubernetes quickly with kubectl, YAML, Helm and Kustomize. The course covers all 26 items of the CNCF CKAD curriculum (Kubernetes v1.37) in proportion to their weights.
Read lesson 1 free →Try 10 practice questions free →
Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed.

Expert · 39 levels · 4 free · Created Nov 2026 · Professionally curated by levelupwith.com
What's inside
- Level 1: The CKAD Exam and Your kind Practice ClusterFree
[Exam craft] Learn the exam facts and set up a free kind cluster for practice: CKAD is 15 to 20 command-line tasks in 2 hours on Kubernetes v1.37, the pass mark is 66%, one retake and two Killer.sh simulator sessions are included, and the certification is valid for two years. The course follows CNCF's CKAD curriculum (CC BY 4.0), is independent of and not endorsed by the Linux Foundation or CNCF, promises no pass, and its multiple-choice checks are original scenarios, not real exam questions, that do not replace hands-on practice.- State the CKAD format, duration, pass mark, retake, simulator and validity rules, and name the five curriculum domains with their weightings
- Create a kind cluster, then confirm it works with kubectl cluster-info and kubectl get nodes
- Explain why the course's multiple-choice checks support hands-on terminal practice but cannot replace it
- Level 2: Contexts, Namespaces and a Fast Shell SetupFree
[Exam craft] Learn to switch kubeconfig contexts and namespaces safely, because every CKAD task names the cluster and namespace it must be solved in, and set up the alias and shell completion that save time on every task.- Switch context with kubectl config use-context and set a default namespace with kubectl config set-context --current --namespace
- Set up the k alias, bash completion and an export for --dry-run=client -o yaml in under a minute
- Check the current context and namespace before each task so work never lands on the wrong cluster or namespace
- Level 3: Imperative Commands, Dry Runs and kubectl explainFree account
[Exam craft] Learn to generate correct manifests fast: create resources imperatively, print a YAML skeleton with --dry-run=client -o yaml, look up field paths with kubectl explain, and find YAML examples quickly in kubernetes.io/docs and helm.sh/docs, the documentation allowed in the exam.- Generate Pod, Deployment, Service, Job and ConfigMap YAML with kubectl run/create plus --dry-run=client -o yaml, then edit and apply it
- Find any nested field with kubectl explain <resource>.<field> --recursive
- Find a working YAML example in kubernetes.io/docs within 60 seconds and adapt it to a timed practice task
- Level 4: Define, Build and Modify Container ImagesFree account
[Application Design and Build] Learn to define, build and modify container images: write and change a Dockerfile, build and tag the image, export it as a tarball, load it into kind, and run it in a Pod.- Write or change a Dockerfile (base image, COPY, ENV, USER, CMD/ENTRYPOINT), then build and tag the image with docker or podman
- Save an image to a tar archive and load it into a kind cluster with kind load docker-image
- Run the new image in a Pod with the right imagePullPolicy, and fix ErrImagePull caused by a wrong tag
- Level 5: Choose the Workload: Deployment, DaemonSet, StatefulSet
[Application Design and Build] Learn to choose and use the right workload resource for a long-running application, comparing Deployment, DaemonSet and StatefulSet by how each schedules, names and replaces its Pods.- Choose Deployment, DaemonSet or StatefulSet for a given scenario and justify the choice
- Create a DaemonSet by converting a Deployment dry-run YAML (drop replicas and strategy, change kind)
- Confirm the Pod placement and naming each workload gives you with kubectl get pods -o wide
- Level 6: Jobs and CronJobs for Run-to-Completion Work
[Application Design and Build] Learn to use the run-to-completion workload resources, Job and CronJob, including how completions, parallelism, backoffLimit, activeDeadlineSeconds, schedule and history limits behave.- Create a Job and a CronJob imperatively, then add completions, parallelism, backoffLimit and activeDeadlineSeconds
- Trigger a CronJob by hand with kubectl create job --from=cronjob/<name>, then check the Job's status and logs
- Set successfulJobsHistoryLimit, failedJobsHistoryLimit and concurrencyPolicy to meet a stated requirement
- Level 7: Multi-Container Pods: Init, Sidecar and Others
[Application Design and Build] Learn the multi-container Pod design patterns: init containers, native sidecar containers (an init container with restartPolicy: Always), and the ambassador and adapter patterns, including the order containers start and stop in.- Add an init container that blocks app start-up until a dependency is reachable
- Declare a native sidecar with restartPolicy: Always under initContainers and explain how it differs from a regular extra container
- Name the right pattern (init, sidecar, ambassador, adapter) for a scenario and read each container's logs with kubectl logs -c
- Level 8: Ephemeral Volumes: emptyDir and Projected Data
[Application Design and Build] Learn to use ephemeral volumes, including emptyDir (on disk and memory-backed), configMap, secret and projected volumes, and generic ephemeral volumes, to share data between containers for the life of a Pod.- Share files between two containers in a Pod through an emptyDir volume, with mountPath and subPath set correctly
- Configure a memory-backed emptyDir with a sizeLimit and explain what happens to its data when the Pod is deleted
- Choose between emptyDir, projected and generic ephemeral volumes for a given requirement
- Level 9: Persistent Volumes, Claims and StorageClasses
[Application Design and Build] Learn to use persistent volumes: create PersistentVolumes and PersistentVolumeClaims, rely on a StorageClass for dynamic provisioning (kind's default class), and mount claims into Pods so data outlives them.- Write a PV and a matching PVC (capacity, accessModes, storageClassName) and check they show Bound
- Mount a PVC into a Deployment and show the data survives Pod deletion
- Find out why a PVC is stuck in Pending using kubectl describe pvc
- Level 10: Deployments and Rolling Updates
[Application Deployment] Learn how Deployments manage ReplicaSets and how to run rolling updates: change an image with kubectl set image, scale, and tune the RollingUpdate strategy with maxSurge and maxUnavailable, or switch to Recreate.- Update a Deployment's image with kubectl set image and follow it with kubectl rollout status
- Set maxSurge, maxUnavailable and minReadySeconds to meet a stated availability requirement
- Explain how the old and new ReplicaSets change during a rolling update and when Recreate is the right strategy
- Level 11: Rollout History, Rollback, Pause and Resume
[Application Deployment] Learn to control Deployment rollouts: read the revision history, record change causes, roll back to a chosen revision, and pause a rollout to batch several changes before resuming it.- List revisions with kubectl rollout history and inspect one with --revision
- Roll back a failed update with kubectl rollout undo --to-revision
- Pause a Deployment, make several changes, then resume it so they go out in a single rollout
- Level 12: Blue/Green Deployment with Labels and Services
[Application Deployment] Learn to use Kubernetes primitives for a blue/green deployment strategy: run two Deployments side by side and switch all traffic at once by changing the Service selector.- Run blue and green Deployments with different version labels behind one Service
- Switch traffic to green in one step with kubectl patch or kubectl edit on the Service selector, and confirm it with kubectl get endpointslices
- Switch back to blue instantly if a check on the new version fails
- Level 13: Canary Deployment with Replica Ratios
[Application Deployment] Learn to use Kubernetes primitives for a canary deployment strategy: put stable and canary Deployments behind one shared-label Service and control the traffic split with replica counts.- Build a canary that gets about 20% of traffic using a shared selector label and a 4:1 replica ratio
- Confirm the split by sending repeated requests from a temporary curl Pod
- Promote the canary or roll it back by scaling the two Deployments
- Level 14: Helm: Find and Install Existing Packages
[Application Deployment] Learn to use the Helm package manager to deploy existing packages: add and update chart repositories, search for charts, read a chart's default values, and install a release into a chosen namespace with custom values.- Run helm repo add, helm repo update and helm search repo to find a chart and its versions
- Read a chart's defaults with helm show values, then install it with --set or -f values.yaml, --namespace and --create-namespace
- Find releases across all namespaces with helm list -A and check what a release deployed with helm get values and helm status
- Level 15: Helm: Upgrade, Roll Back and Uninstall Releases
[Application Deployment] Learn to manage the lifecycle of existing Helm releases: upgrade with new values or chart versions, preview rendered manifests, read the release history, roll back, and uninstall.- Upgrade a release with helm upgrade --reuse-values --set, or move it to a specific --version
- Preview the output of a change with helm template or helm upgrade --dry-run before applying it
- Roll back with helm history and helm rollback, and remove a release with helm uninstall
- Level 16: Kustomize: Bases, Overlays and Patches
[Application Deployment] Learn Kustomize as kubectl uses it: write a kustomization.yaml, build per-environment overlays on a base with namespace, namePrefix, commonLabels, images and patches, and apply them with kubectl apply -k.- Write a base and a production overlay that changes the namespace, replica count and image tag
- Preview the result with kubectl kustomize, then apply it with kubectl apply -k
- Change a field with a strategic merge patch or a JSON 6902 patch referenced in kustomization.yaml
- Level 17: Discover and Use CRDs and Operators
[Application Environment, Configuration and Security] Learn to discover and use resources that extend Kubernetes: find CustomResourceDefinitions and their API groups, read their schema, create and manage custom resources, and understand how an Operator's controller acts on them.- List extension resources with kubectl get crd and kubectl api-resources --api-group
- Read a custom resource's fields with kubectl explain, then create, list and edit an instance of it
- Explain the relationship between a CRD, a custom resource and the Operator controller that reconciles it
- Level 18: Authentication and RBAC Authorization
[Application Environment, Configuration and Security] Learn how the API server authenticates users and ServiceAccounts through kubeconfig credentials and tokens, and how RBAC authorizes requests through Roles, ClusterRoles, RoleBindings and ClusterRoleBindings.- Create a Role and a RoleBinding imperatively that grant only the verbs a task asks for
- Test permissions with kubectl auth can-i, including --as=system:serviceaccount:<ns>:<name>
- Find the cause of a Forbidden error, telling an authentication failure apart from an authorization failure
- Level 19: Admission Control and Pod Security Admission
[Application Environment, Configuration and Security] Learn where admission control sits after authentication and authorization, how mutating and validating admission (including ValidatingAdmissionPolicy) changes or rejects requests, and how Pod Security Admission namespace labels enforce the Pod Security Standards.- Put a request's path in order: authentication, authorization, mutating admission, validating admission
- Label a namespace with pod-security.kubernetes.io/enforce=restricted, then fix a Pod the label rejects
- Read an admission denial message and decide whether the manifest or the policy needs changing
- Level 20: Define Resource Requirements: Requests and Limits
[Application Environment, Configuration and Security] Learn to define resource requirements: set CPU and memory requests and limits per container, understand how requests drive scheduling and limits drive throttling and OOMKilled, and identify the QoS class that results.- Set requests and limits on an existing Deployment with kubectl set resources or by editing the YAML
- Find the cause of a Pending Pod (Insufficient cpu) and an OOMKilled container from kubectl describe output
- Predict whether a Pod's QoS class will be Guaranteed, Burstable or BestEffort from its resources section
- Level 21: Quotas and LimitRanges per Namespace
[Application Environment, Configuration and Security] Serves 'Understand requests, limits, quotas': you build ResourceQuota and LimitRange objects in a namespace and fix workloads that the quota rejects or that need the LimitRange defaults.- Create a ResourceQuota with kubectl create quota and read how much is used with kubectl describe quota
- Write a LimitRange that sets default and maximum container requests and limits
- Fix a Deployment whose Pods are rejected for breaking a quota by reading its ReplicaSet events
- Level 22: ConfigMaps: Create and Consume
[Application Environment, Configuration and Security] Serves 'Understand ConfigMaps': you create ConfigMaps imperatively from literals, files and env files, then feed them to Pods as environment variables, envFrom and mounted volumes.- Create a ConfigMap with kubectl create configmap using --from-literal, --from-file and --from-env-file
- Feed a ConfigMap to a container through env valueFrom, envFrom and a configMap volume, mounting single keys where needed
- Explain why changes to a mounted ConfigMap reach the Pod but environment variables do not
- Level 23: Create and Consume Secrets
[Application Environment, Configuration and Security] Serves 'Create & consume Secrets': you create generic, docker-registry and TLS Secrets, decode them, and use them in Pods as environment variables, volumes and imagePullSecrets.- Create generic, docker-registry and tls Secrets imperatively and decode a value with base64 -d
- Feed a Secret to a container as environment variables and as a read-only volume with set file permissions
- Explain why base64 encoding is not encryption and what limits who can read a Secret
- Level 24: ServiceAccounts for Applications
[Application Environment, Configuration and Security] Serves 'Understand ServiceAccounts': you create ServiceAccounts, assign them to workloads, control token automounting, and give an application only the API access it needs with a Role and RoleBinding.- Create a ServiceAccount and set it on a Deployment with kubectl set serviceaccount or spec.serviceAccountName
- Turn off token automounting and get a short-lived token with kubectl create token
- Check what a ServiceAccount is allowed to do with kubectl auth can-i --as=system:serviceaccount:<ns>:<name>
- Level 25: SecurityContexts and Capabilities
[Application Environment, Configuration and Security] Serves 'Understand Application Security (SecurityContexts, Capabilities, etc.)': you harden Pods and containers with runAsUser, runAsNonRoot, fsGroup, readOnlyRootFilesystem, allowPrivilegeEscalation and Linux capabilities you add or drop.- Set runAsUser, runAsGroup, fsGroup and runAsNonRoot at Pod level and override them at container level
- Drop ALL capabilities and add back only the one needed, such as NET_BIND_SERVICE
- Make the root filesystem read-only, give the container a writable emptyDir, and check the result with kubectl exec id
- Level 26: Services: ClusterIP, NodePort and Selectors
[Services and Networking] Serves 'Provide and troubleshoot access to applications via services': you expose Deployments with kubectl expose and kubectl create service, choose between ClusterIP and NodePort, and map port to targetPort correctly.- Expose a Deployment with kubectl expose, setting --port, --target-port, --type and --name
- Explain how a Service's selector matches Pod labels and see the result with kubectl get endpointslices
- Reach a NodePort Service from the host on a kind cluster and a ClusterIP Service from a temporary busybox Pod
- Level 27: Service Discovery: DNS, Headless and Named Ports
[Services and Networking] Serves 'Provide and troubleshoot access to applications via services': you reach Services by DNS name inside and across namespaces, use named targetPorts, and see how headless Services return Pod addresses directly.- Resolve a Service by short name and by <svc>.<ns>.svc.cluster.local using nslookup from a test Pod
- Point a Service at a named container port so Pods can change port numbers without breaking it
- Create a headless Service (clusterIP: None) and explain when an application needs one
- Level 28: Troubleshooting Service Access
[Services and Networking] Serves 'Provide and troubleshoot access to applications via services': you work a fixed checklist (selector, labels, endpoints, ports, readiness, namespace) to find and repair broken Services against the clock.- Find a selector/label mismatch or a wrong targetPort from empty EndpointSlices and kubectl describe svc
- Test reachability step by step with kubectl run --rm -it and curl or wget, and with kubectl port-forward
- Repair a broken Service in place with kubectl edit, kubectl label or kubectl patch inside a timed task
- Level 29: Ingress Rules: Hosts and Paths
[Services and Networking] Serves 'Use Ingress rules to expose applications': you write networking.k8s.io/v1 Ingress resources with kubectl create ingress, routing by host and path (Prefix or Exact) to backend Services through an IngressClass on a kind cluster.- Generate an Ingress with kubectl create ingress --rule and --class, then refine it from --dry-run=client -o yaml
- Route two hosts or paths to different backend Services and pick the right pathType
- Install an actively maintained Ingress controller on kind with port mappings and test it with curl -H 'Host: ...'
- Level 30: Ingress TLS, Default Backends and Troubleshooting
[Services and Networking] Serves 'Use Ingress rules to expose applications': you add TLS from a tls Secret, set a default backend, and fix Ingresses that fail because of a wrong class, Service name, port or pathType.- Add a tls section that references a kubernetes.io/tls Secret for a given host
- Set defaultBackend and explain what traffic that matches no rule receives
- Fix a failing Ingress using kubectl describe ingress, the backend Service's endpoints and the controller's logs
- Level 31: NetworkPolicies: Default Deny and Allow Rules
[Services and Networking] Serves 'Demonstrate basic understanding of NetworkPolicies': you write default-deny ingress and egress policies, then allow chosen traffic with podSelector, namespaceSelector and port rules, on a kind cluster running a CNI that enforces policy.- Write default-deny ingress and egress NetworkPolicies for a namespace
- Allow traffic from Pods with a given label, or from a labelled namespace, to one port only
- Explain the difference between AND and OR when a from entry combines podSelector and namespaceSelector
- Level 32: NetworkPolicy Troubleshooting and DNS Egress
[Services and Networking] Serves 'Demonstrate basic understanding of NetworkPolicies': you reason about how several policies add together, allow DNS egress to kube-system, and find out why a connection is blocked or wrongly allowed in a timed networking task.- Allow UDP and TCP port 53 egress so that Pods under an egress default-deny can still resolve names
- Work out from kubectl get netpol -o yaml which policies select a Pod and what traffic they allow together
- Finish a timed task that combines a Service, an Ingress and a NetworkPolicy on one application
- Level 33: API Deprecations and Migrating Manifests
[Application Observability and Maintenance] Serves 'Understand API depreciations': you read the Kubernetes deprecation policy and migration guide, find the API versions a v1.37 cluster serves with kubectl api-resources and kubectl api-versions, and update outdated manifests.- List served groups and versions with kubectl api-versions and kubectl api-resources, and look up fields with kubectl explain --api-version
- Rewrite a manifest that uses a removed apiVersion (for example extensions/v1beta1 Ingress) to its current GA version
- Read deprecation warnings from kubectl and find the replacement in the Deprecated API Migration Guide on kubernetes.io/docs
- Level 34: Probes and Health Checks
[Application Observability and Maintenance] Serves 'Implement probes and health checks': you set liveness, readiness and startup probes using httpGet, tcpSocket, exec and grpc, and tune their timing so slow or broken applications behave correctly.- Add liveness, readiness and startup probes to a container with the right handler for the application
- Tune initialDelaySeconds, periodSeconds, failureThreshold and timeoutSeconds, and explain what each probe failing does
- Find failing probes in kubectl describe events and tell apart a readiness failure (removed from endpoints) and a liveness failure (restart)
- Level 35: Built-in CLI Monitoring: top, events, describe
[Application Observability and Maintenance] Serves 'Use built-in CLI tools to monitor Kubernetes applications': you monitor workloads with kubectl top (with metrics-server on kind), kubectl get events, kubectl describe, --watch and custom output with jsonpath and custom-columns.- Install metrics-server on kind and sort Pods by CPU or memory with kubectl top pod --sort-by
- List recent events in order with kubectl get events --sort-by=.metadata.creationTimestamp and filter them with --field-selector
- Pull status fields fast with -o jsonpath, -o custom-columns and kubectl rollout status
- Level 36: Utilize Container Logs
[Application Observability and Maintenance] Serves 'Utilize container logs': you read logs from single and multi-container Pods, previous crashed instances and whole Deployments, and filter them by time, tail and label selector.- Read logs with kubectl logs using -c, --previous, -f, --tail and --since
- Collect logs from every Pod matching a label with -l and --all-containers, adding --prefix
- Save the log lines a task asks for to a file on the exam host
- Level 37: Debugging in Kubernetes
[Application Observability and Maintenance] Serves 'Debugging in Kubernetes': you find out why workloads fail (CrashLoopBackOff, ImagePullBackOff, Pending, CreateContainerConfigError) using kubectl describe, kubectl exec, kubectl debug ephemeral containers and Pod copies.- Diagnose the common failure states in a Pod from status, events and exit codes, and apply the fix
- Attach an ephemeral debug container to a running Pod with kubectl debug -it --image=busybox --target
- Make a debuggable copy of a crashing Pod with kubectl debug --copy-to, changing its command or image
- Level 38: Exam-Day Strategy and Mixed Timed Practice
[Exam craft across all domains] Prepares you to apply the whole CNCF curriculum under exam conditions: you practise switching context per task, triaging by task weight, flagging and coming back, and checking work, on a mixed set of timed tasks from all five domains, without any promise that this ensures a pass.- Start every task by running the given kubectl config use-context command and setting the namespace, and check before moving on
- Plan two hours across 15 to 20 tasks, skipping and flagging low-value or stuck tasks
- Finish a mixed timed practice set and check each solution with kubectl get, describe and auth can-i
- Level 39: Timed Mock Exam (50 questions, 75 minutes) Timed mock
[Mock exam: all domains] A timed mock exam of 50 original scenario multiple-choice questions in 75 minutes (pass mark 66%), weighted like the CNCF CKAD curriculum, that tests whether you can pick the command or manifest that solves each task across all five domains, and say why.
Free 10 questions from the bank behind this course's timed mock are free to try, no account needed. Read all 10 with their answers →
Access
Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.
More like this
- Exam Prep for the Certified Kubernetes Security Specialist (CKS)
Harden Kubernetes clusters, nodes, workloads and the software supply chain, and catch threats at runtime, working at the command line against the CNCF CKS…
Exam prep · CKS · Cloud & Compute · Expert · 42 levels · 4 free · Professionally curated by levelupwith.com
- Exam Prep for the Certified Kubernetes Administrator (CKA)
Go from knowing Kubernetes objects to building, upgrading, securing, networking and repairing Kubernetes v1.37 clusters at the terminal, under exam time…
Exam prep · CKA · Cloud & Compute · Expert · 48 levels · 4 free · Professionally curated by levelupwith.com
- Exam Prep for the Kubernetes and Cloud Native Associate (KCNA)
Go from never having run a container to sitting the KCNA exam with confidence.
Exam prep · KCNA · Cloud & Compute · Expert · 41 levels · 4 free · Professionally curated by levelupwith.com
- HPC on GCP and Azure: Test, Benchmark, Decide
Take one open benchmark from your laptop through containers, Kubernetes, Terraform, Harness and Backstage to real tests on GKE, Cloud Batch, Slurm, AKS, Azure…
Course · Cloud · Cloud & Compute · Expert · 60 levels · 4 free · Professionally curated by levelupwith.com
- Google Cloud Professional Cloud Network Engineer Exam Prep
Design, build, secure and troubleshoot Google Cloud networks with gcloud and the console, covering VPCs, Shared VPC, Network Connectivity Center, Cloud Load…
Exam prep · Google · Cloud & Compute · Expert · 58 levels · 4 free · Professionally curated by levelupwith.com
- Google Cloud Professional Cloud DevOps Engineer Exam Prep
Prepare for the Professional Cloud DevOps Engineer exam by working through every item in Google's exam guide: bootstrapping an organisation, CI/CD and…
Exam prep · Google · Cloud & Compute · Expert · 52 levels · 4 free · Professionally curated by levelupwith.com