CKA course and practice exam: Certified Kubernetes Administrator
This CKA course has 32 video lessons and 59 graded labs, and its CKA practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
Install, operate and troubleshoot Kubernetes clusters
Prepares you for the hands-on CKA exam: cluster architecture, workloads, networking, storage and troubleshooting, practised as timed tasks.
Intermediate · 3 hours · 32 lessons · 69 labs
CKA exam guide
The CKA exam (Certified Kubernetes Administrator, by CNCF / The Linux Foundation): 2 hours; questions: 15–20 performance-based tasks; pass mark: 66%; cost: USD 445 (includes one free retake).
How do I prepare for the CKA exam?
Study the open source CNCF curriculum domain by domain on a cluster you can break and rebuild, starting with troubleshooting, the heaviest domain. Registration includes two attempts at an exam simulator provided by Killer.sh (not with CKA-SINGLE); keep them for a timing check near the end. Linux Foundation, CKA, CKAD and CKS FAQ
Is the CKA exam difficult?
It is demanding because it is hands-on and timed: 15 to 20 performance-based tasks in 2 hours, solved at a command line, with a pass mark of 66%. Speed at the terminal matters as much as knowing the concepts. Linux Foundation, important tips for the CKA and CKAD
How to prepare for the CKA and CKAD exams, with labs
- Format: Performance-based: tasks solved in a live Kubernetes environment from the command line
- Duration: 2 hours
- Questions: 15–20 performance-based tasks
- Pass mark: 66%
- Cost: USD 445 (includes one free retake)
- Valid for: 2 years
- Delivery: Online, proctored (PSI)
- Prerequisites: None
Exam domains and weights
- Storage: 10%
- Workloads & Scheduling: 15%
- Services & Networking: 20%
- Troubleshooting: 30%
- Cluster Architecture, Installation & Configuration: 25%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 CKA sample questions with answers: free to read, no account needed.
Common questions
How long is the CKA exam?
The CKA exam lasts 2 hours.
How many questions are on the CKA exam?
15–20 performance-based tasks.
What is the CKA passing score?
The pass mark is 66%.
How much does the CKA exam cost?
USD 445 (includes one free retake).
Is there a free CKA practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: CKA exam page (Linux Foundation Training) (CNCF / The Linux Foundation), checked 2026-09-25.
Related guides
- How to prepare for the CKA and CKAD exams, with labs
- CKA vs CKAD: which Kubernetes exam should you take first?
Who it is for
Intermediate level.
For administrators and platform engineers preparing for the hands-on CKA exam, who keep Kubernetes clusters running and fix them when they break.
What you don't need yet:
- No cluster of your own: most labs run on a simulated one
- No cloud account needed
- No experience installing Kubernetes: kubeadm is taught
- No Python: labs use kubectl, YAML and the node's own tools
What helps:
- Comfort at a Linux command line and with pods and Deployments
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
- Kubernetes and Cloud Native Associate (KCNA) Exam Prep — Beginner
- Linux Fundamentals & Systems Administration — Beginner
Take next:
- Certified Kubernetes Application Developer (CKAD) Exam Prep — Intermediate
- Certified Kubernetes Security Specialist (CKS) Exam Prep — Advanced
- Certified Argo Project Associate (CAPA) Exam Prep — Intermediate
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
The CKA is a performance-based exam: you solve tasks from the command line on a live Kubernetes cluster, so passing shows you can do the work under time. It doesn't replace running production clusters; our graded labs use a simulated cluster, not a real one.
Exam objectives this course teaches
Certified Kubernetes Administrator (CKA)
- Storage (10% of the exam): Implement storage classes and dynamic volume provisioning; Configure volume types, access modes and reclaim policies; Manage persistent volumes and persistent volume claims
- Workloads & Scheduling (15% of the exam): Understand application deployments and how to perform rolling update and rollbacks; Use ConfigMaps and Secrets to configure applications; Configure workload autoscaling; Understand the primitives used to create robust, self-healing, application deployments; Configure Pod admission and scheduling (limits, node affinity, etc.)
- Services & Networking (20% of the exam): Understand connectivity between Pods; Define and enforce Network Policies; Use ClusterIP, NodePort, LoadBalancer service types and endpoints; Use the Gateway API to manage Ingress traffic; Know how to use Ingress controllers and Ingress resources; Understand and use CoreDNS
- Troubleshooting (30% of the exam): Troubleshoot clusters and nodes; Troubleshoot cluster components; Monitor cluster and application resource usage; Manage and evaluate container output streams; Troubleshoot services and networking
- Cluster Architecture, Installation & Configuration (25% of the exam): Manage role based access control (RBAC); Prepare underlying infrastructure for installing a Kubernetes cluster; Create and manage Kubernetes clusters using kubeadm; Manage the lifecycle of Kubernetes clusters; Implement and configure a highly-available control plane; Use Helm and Kustomize to install cluster components; Understand extension interfaces (CNI, CSI, CRI, etc.); Understand CRDs, install and configure operators
Labs
69 labs, 59 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- A Node Goes NotReady Forty Minutes In (2 labs): You can read a NotReady node the way the exam expects: what the node controller did, which taints it added, and why you drain the node before you repair its kubelet.
- Spend Two Hours Like A Points Table (3 labs): You can budget each task from its weight, run the exam in two passes, switch host and namespace per task, and verify every answer before you leave it.
Speed Kit
- Generators Write The YAML, You Decide (2 labs): You can create namespaces, deployments, services, config maps, service accounts, roles and bindings in one command each, and turn a client dry run into a manifest you edit and apply.
- Contexts, Namespaces And One-Line Answers (1 lab): You can read a kubeconfig's contexts, pin a namespace, and pull exact answers out of the cluster with JSONPath, custom columns and sort by, then store them where a grader can read them.
Troubleshooting
- Node NotReady: Kubelet, Runtime And Certificates (3 labs): You can go from a NotReady node to the line in the kubelet's journal that explains it, name the file that holds the fault, and fix it so the node stays Ready after a reboot.
- When A Control Plane Pod Breaks (2 labs): You can name the broken control plane component from what the cluster does, read its container log with crictl when kubectl cannot help, and fix its static pod manifest.
- Usage, Requests And The Pod That Will Not Fit (2 labs): You can find the heaviest pod or container with kubectl top, tell usage from requests and limits, read an OOMKilled exit, and resize requests so a Pending workload fits.
- What A Container Said Before It Died (3 labs): You can read the logs of the right container, including the one that already crashed, follow where kubelet stores them, and turn a log file into a stream with a native sidecar.
- A Service With Nobody Behind It (2 labs): You can trace a request from a Service to its pods, find the broken link among selector, readiness and target port, and fix the Service without touching a correct deployment.
- The Name That Will Not Resolve (3 labs): You can read a pod's resolv.conf, predict which names its resolver will try, tell a wrong name from a broken CoreDNS, and fix a cross-namespace lookup.
- Blocked On Purpose: Opening One Path Through Default Deny (1 lab): You can read which NetworkPolicies select a pod, explain why a connection is dropped, and open exactly the paths a task names in both directions, DNS included.
- Four Faults, Twelve Minutes (1 lab): You can triage a namespace from one pod listing, map each status to its likely cause, and clear four unrelated faults inside the time the exam would give them.
Cluster Architecture And Installation
- RBAC: From Everything To Exactly Enough (1 lab): You can read who may do what with auth can-i, spot an over-broad role, and replace it with namespaced roles and bindings that grant exactly the verbs a task lists.
- Preparing A Node Before kubeadm Will Touch It (3 labs): You can prepare a Linux machine for kubeadm in an order that works: packet forwarding, swap, containerd on systemd cgroups, pinned and held packages, and read kubeadm's preflight errors to see what is still wrong.
- kubeadm init And join: What Lands Where (2 labs): You can say what kubeadm init creates and in what order, find any certificate, kubeconfig or static pod manifest on a control plane node without searching, check certificate expiry, and produce a fresh join command for a worker or a second control plane node.
- Upgrades In The Only Order That Works (2 labs): You can upgrade a kubeadm cluster one minor version at a time in the right order, keep every component inside the version skew policy while you do it, and renew certificates with kubeadm when a task asks.
- etcd: Snapshot, Restore, And The Cache That Lies (2 labs): You can save an etcd snapshot with the right endpoint and certificates, verify it, restore it into a new data directory, point the etcd static pod at it, and prove the restore worked rather than trusting a stale API server.
- HA Control Planes: Quorum, Stacked Or External (2 labs): You can compute how many etcd members a cluster can lose, choose between stacked and external etcd for a stated failure, and write the kubeadm configuration that puts a load balancer in front of several API servers.
- Helm And Kustomize For Cluster Components (3 labs): You can install, upgrade, inspect and roll back a Helm release of a cluster component, say which values a release is really running with, and build a Kustomize overlay that changes namespace, image, replicas and labels without editing the base.
- CNI, CSI, CRI And CRDs: The Plug-In Points (3 labs): You can name which plug-in interface a symptom belongs to, find the network, runtime and storage plug-ins a node actually uses, and read what a set of custom resource definitions added to the API, and what an operator adds on top.
Services And Networking
- Which IP Answers: Pods, Services And NodePorts (1 lab): You can trace a request from a client pod through a Service's virtual IP to a pod IP and port, fix a Service whose targetPort misses the container, and expose the same pods on a fixed NodePort.
- NetworkPolicy Truth Tables: One Dash Decides (2 labs): You can predict, source by source, what a NetworkPolicy lets in, tell an AND peer from an OR peer by its dashes, and write a policy that admits exactly the pods and namespaces a task names.
- Ingress: Hosts, Paths And The Class That Serves Them (1 lab): You can write an Ingress in one command with hosts, Prefix and Exact paths, a class and TLS, read which backend a URL will reach, and tell a routing mistake from a missing controller.
- Gateway API: A Route Asks, A Gateway Allows (2 labs): You can name the job of GatewayClass, Gateway and HTTPRoute, attach a route to a listener across namespaces, and read the Accepted, ResolvedRefs and Programmed conditions to find which side of the handshake is wrong.
- CoreDNS: The Corefile Every Name Depends On (2 labs): You can find CoreDNS's configuration, read a Corefile plugin by plugin, add a stub domain or a new upstream safely, and recognise a broken edit from the pods' status and logs before it takes DNS down.
Workloads And Scheduling
- Rolling Updates And Rollbacks (2 labs): You can predict the pods during a rolling update from maxSurge and maxUnavailable, choose budgets for a stated requirement, read rollout history and roll back a broken release to a chosen revision.
- ConfigMaps And Secrets (2 labs): You can create ConfigMaps and Secrets with generators, consume them as single variables, all variables or files, explain why base64 is not protection, and fix a pod stuck in CreateContainerConfigError.
- Self-Healing And Autoscaling: Who Restarts, Who Replaces, Who Adds (4 labs): You can say which controller restarts a container, replaces a pod or adds replicas, fix a probe that kills a healthy app, create an autoscaler in one command or as autoscaling/v2 YAML, and predict its replica count from the formula.
- Placing Pods: Selectors, Affinity, Taints And Requests (2 labs): You can read a FailedScheduling message filter by filter, pull a pod onto a node with a selector or required affinity, keep pods off a node with a taint or NotIn, and say which of those attracts and which only permits.
Storage
- StorageClasses: Why A Claim Waits For Its Pod (3 labs): You can trace a claim through its StorageClass and provisioner to a bound volume, predict when WaitForFirstConsumer leaves a claim Pending, and write a class with the binding mode, reclaim policy and expansion a task asks for.
- Volumes By Hand: Access Modes, Binding And Reclaim (2 labs): You can predict which pre-created volume a claim binds to, explain what each access mode and reclaim policy promises, and make a Released volume usable again without losing its data.
Mock And Review
- Mock Exam: Seventeen Tasks Against The Clock (3 labs): You can work a full CKA-style paper under time: eight graded tasks in the simulated cluster, four self-graded tasks on a real one, and a review that turns every miss into a lesson to revisit before the exam.