CKA
Certified Kubernetes Administrator (CKA) Program
Certified Kubernetes Administrator (CKA) Exam Guide: Skills, Planning, and Practical Preparation
The Certified Kubernetes Administrator (CKA) validates whether you can perform Kubernetes administrator responsibilities by solving practical, command-line tasks rather than answering multiple-choice questions. It suits people who administer, troubleshoot, configure, or support Kubernetes clusters and want a vendor-neutral credential from the Cloud Native Computing Foundation and The Linux Foundation. This guide helps you decide whether your current experience is sufficient, which domains deserve the most practice, how to use the official exam allowance, and when your workstation and study routine are ready for scheduling.
What the CKA actually validates
The CKA is designed to demonstrate the skills, knowledge, and competency required for Kubernetes administrator responsibilities. The exam is an online, proctored, performance-based test in which candidates solve Kubernetes problems from a Linux command line, so preparation must develop operational judgment and execution speed together.
The credential was created by the Cloud Native Computing Foundation in collaboration with The Linux Foundation to help develop the Kubernetes ecosystem. Its vendor-neutral scope is useful when your work spans different cloud providers, platforms, or distributions, because the assessment focuses on Kubernetes administration rather than one provider’s managed service.
A candidate should therefore judge readiness by asking, “Can I diagnose and change a cluster safely under time pressure?” Memorizing resource definitions is not enough. You need to recognize symptoms, identify the relevant control-plane or workload object, use documentation efficiently, and verify that your change produced the requested result.
This format also changes how you should interpret practice results. A correct command copied from a tutorial may show familiarity, but it does not prove that you can select the right command when the task is worded differently. Record why a solution works, what evidence confirmed it, and what you would inspect if the first fix failed.
Who benefits most from the certification
The CKA is most directly relevant to Kubernetes administrators and to engineers whose responsibilities include cluster configuration, workload operations, networking, storage, maintenance, or troubleshooting. It can also serve as a structured target for people moving from Linux, platform engineering, DevOps, or site reliability work into Kubernetes administration.
The certification does not remove the need for practical experience. If you have only deployed applications through a higher-level tool, begin with Kubernetes objects, cluster components, and command-line workflows before booking the exam. If you already maintain clusters, use the domains to expose neglected areas rather than assuming daily specialization covers the complete blueprint.
How the exam is organized
The CKA consists of 15-20 performance-based tasks, and candidates have 2 hours to complete them. The pass requirement is a score of 66% or above. Those facts make prioritization part of the skill: a preparation plan should include timed task sets, deliberate skipping of blocked work, and verification before moving on.
The current general domains and their weights are: Cluster Architecture, Installation & Configuration 25%; Workloads & Scheduling 15%; Services & Networking 20%; Storage 10%; and Troubleshooting 30%. Each percentage belongs to the named domain; do not use the figures as unlabeled measures of difficulty or as a prediction of the exact number of tasks.
The Linux Foundation states that the domains remained unchanged when the competency language was updated. Exams taken on or after February 18, 2025 reflect the updated competencies, and the date the candidate sits the exam—not the purchase date or whether the sitting is a first attempt or retake—determines which competencies apply. Check the current official page before relying on older notes.
The official CKA page currently states that the exam is based on Kubernetes v1.35. Kubernetes versions and exam environments can change, so treat the official certification page as the authority for the version that applies to your planned sitting. Do not build a study plan around an unofficial question list or an old course snapshot.
Where to place study time
Troubleshooting deserves the largest planned block because Troubleshooting carries 30% of the exam. That does not mean ignoring the other domains; it means your schedule should repeatedly require you to inspect a broken state, form a hypothesis, make a targeted correction, and validate the outcome.
Cluster Architecture, Installation & Configuration carries 25%, so study should include how core components fit together and how administrative changes affect the cluster. Services & Networking carries 20%, making connectivity diagnosis and service behavior important practice targets. Workloads & Scheduling carries 15%, while Storage carries 10%; give both hands-on coverage even though their blueprint weights are smaller.
A useful allocation method is to divide your available practice sessions by domain weight, then reserve additional sessions for weaknesses revealed by timed labs. This is a recommendation, not an official scheduling formula. A candidate with little storage experience should not abandon that domain merely because Storage carries 10%.
What changed and what to verify
The official program-change notice says that competencies were added, removed, or reworded while the major domain categories remained unchanged. Before studying, compare your notes, course version, and simulator scope with the current competency information. A familiar domain label can hide a changed task expectation.
Do not assume a retake automatically uses the blueprint you studied for the first sitting. The official notice says the exam date controls the applicable competency set. If your retake occurs after an update, reread the current domains and competencies and adjust your practice accordingly.
What each domain should mean in practice
Use the domain names as operational problem areas, not as vocabulary categories. For every topic, practice a complete loop: inspect the current state, choose a controlled change, apply it with the command line, and confirm the requested behavior. That approach is closer to the CKA’s performance-based design than passive reading.
The official CKA materials describe administrator work involving installation, configuration, cluster management, networking, storage, security, maintenance, logging, and monitoring concepts. The domain weights then show where the assessment places emphasis. Build breadth first, then deepen the failure modes most likely to consume time.
Cluster Architecture, Installation & Configuration
This 25% domain should become your map of the cluster: understand what the major components do, where configuration belongs, and how an administrative change can affect cluster operation. Practice reading the state of a cluster before editing anything, and keep a short record of the evidence that justified each change.
Study sequencing matters here. Start with architecture and normal operation, then work through configuration tasks, and finish with recovery-oriented exercises. When a lab gives you a broken component, avoid changing several files or objects at once. Isolate the suspected cause, make one defensible change, and verify the effect.
Workloads & Scheduling
This 15% domain calls for reliable control of workload behavior and placement. Practice interpreting workload requirements, checking why a workload is pending or unhealthy, and confirming that the scheduler and associated objects are producing the requested result. Treat declarative configuration as an operational tool, not as a document-format exercise.
A common preparation mistake is creating a workload successfully and stopping there. Add verification steps to every exercise: inspect status, events, related objects, and the actual behavior requested by the task. When a workload does not schedule, distinguish resource, constraint, taint, affinity, and configuration symptoms instead of repeatedly recreating it.
Services & Networking
This 20% domain requires you to connect Kubernetes objects to observable network behavior. Practice tracing a request from the client-facing object through selectors, endpoints or equivalent backing information, and the target workload. Also practice checking names, ports, policies, and node-level or cluster-level symptoms without guessing.
Networking tasks often fail because candidates edit the first object that looks relevant. Begin by defining the expected path and then test each link in that path. If the service exists but traffic does not reach a workload, inspect selection and readiness before changing unrelated configuration. Keep a repeatable diagnostic checklist rather than relying on memory.
Storage
Storage carries 10% and should be prepared through repeatable lifecycle exercises. Practice following a claim or volume from request to binding, mounting, and workload use, then inspect the state when a workload cannot mount or write. The goal is to understand relationships and failure evidence, not to memorize isolated resource snippets.
Do not postpone Storage until the last week because its percentage is smaller. A short, focused lab cycle can expose whether you understand binding, access expectations, mount configuration, and persistence behavior. After each exercise, remove and recreate the relevant objects so that you can diagnose both a clean setup and a partially completed one.
Troubleshooting
Troubleshooting carries 30%, the largest named domain, and should be practiced as a method rather than a list of fixes. Start with the symptom, gather the narrowest useful evidence, identify the failing layer, apply the smallest appropriate correction, and verify recovery. This sequence prevents random edits that create new problems.
Build failure drills across cluster components, workloads, networking, and storage. Use a timer only after you can explain your diagnostic process without one. During timed work, write down the symptom and first evidence quickly, then move to a different task if the investigation becomes circular. Return later with a fresh hypothesis.
How to build a study environment
A useful CKA study environment must let you repeat administrative actions from a Linux command line and observe the consequences. The exact infrastructure choice is a practical recommendation, not an official requirement: select a setup that gives you disposable clusters or nodes, access to the Kubernetes version relevant to your sitting, and enough control to create both healthy and faulty states.
Do not measure a lab by how attractive its dashboard looks. Measure whether you can work from the command line, locate authoritative documentation, inspect resources and events, and recover from an incorrect change. If a tool hides the underlying objects or automatically repairs them, add a second practice path that exposes the Kubernetes mechanics directly.
Keep a personal lab notebook with four fields: task objective, evidence collected, change made, and verification result. Add the failed approaches that taught you something. This converts practice into a troubleshooting reference without turning it into a collection of copied answers. It also helps identify whether a weakness is conceptual, command-line related, or caused by poor time management.
Use only legitimate study material and your own practice. The CKA is confidential and proctored, and memorizing leaked or purported exam questions does not demonstrate administrator competence or provide a reliable preparation method. Build transferable procedures instead: inspect, reason, change, verify.
Practice documentation use deliberately
Documentation access is part of the candidate’s working method, so rehearse finding the relevant official Kubernetes information without losing the task objective. Search by the resource or behavior you need, read the smallest relevant section, adapt the example to the stated context, and validate the result in the cluster.
A poor documentation habit is opening many pages before identifying the failing object. First capture names, namespaces, status, and events; then search using those concrete terms. Practice copying only what you understand and checking every namespace, selector, port, path, and field that could change the result.
Use simulation attempts as diagnostics
The CKA purchase listed by The Linux Foundation includes access to two exam simulation attempts, and each simulation attempt has 36 hours of access from activation. Treat these as assessment checkpoints rather than entertainment. Use the first to expose gaps and the second after targeted remediation to test whether your method improved.
Each CKA simulator session has 17 questions, with a different set of 17 questions in each attempt. That makes review more valuable than chasing a score. For every missed or slow item, classify the cause: did you misunderstand the requirement, fail to locate evidence, use the wrong command, make an inaccurate change, or run out of time?
A practical preparation roadmap
A staged roadmap works better than trying to cover every Kubernetes topic at once. Establish command-line and object fundamentals, move through the five official domains, then use timed mixed practice and simulations to close gaps. The sequence below is a recommendation for organizing work; adjust the pace to your experience and available lab time.
Keep the exam purchase window in mind while planning. The listed CKA purchase gives 12 months to schedule and take the exam, two exam attempts, and two simulation attempts. That allowance supports a deliberate plan, but it can also encourage postponement. Set a target sitting only after your lab evidence shows repeatable performance.
Stage one: establish the operating baseline
Begin by ensuring that you can move confidently around a Linux terminal and understand the Kubernetes objects used in ordinary administrative work. Practice identifying namespaces, reading object status, inspecting events, and checking relationships between workloads and supporting resources. Do not begin with timed performance; first make the diagnostic sequence automatic.
At the end of this stage, choose a small set of intentionally broken exercises and solve them without a tutorial walkthrough. Your next action is to document the commands and evidence that were genuinely necessary, then remove unnecessary steps. Efficiency comes from reducing noise, not from typing faster without understanding.
Stage two: cover the blueprint in domain order
Study Cluster Architecture, Installation & Configuration first, then Workloads & Scheduling, Services & Networking, Storage, and Troubleshooting. This order builds an operational map before asking you to diagnose failures across it. The official weights should influence time allocation, while your own error log should determine the final emphasis.
For each domain, alternate a learning session with a rebuild session. In the learning session, read and perform guided tasks. In the rebuild session, start from a clean or altered state and solve a stated objective with minimal reference to notes. Finish by explaining what evidence would distinguish your solution from two plausible but incorrect solutions.
Stage three: add time and uncertainty
Once you can complete isolated tasks, combine domains into mixed sets and impose a time limit. The exam gives candidates 2 hours for 15-20 performance-based tasks, so practice should include reading carefully, estimating effort, recording partial progress, and moving on when a task is consuming disproportionate time.
Use a simple triage rule: secure straightforward points first, isolate tasks that require deeper diagnosis, and revisit them after completing work you can verify. This is a preparation recommendation rather than an official scoring rule. The important habit is to avoid turning one ambiguous problem into the loss of time across the whole session.
Stage four: use the simulations and remediate
Activate the first simulation when you can work across all five domains but still need an honest baseline. Review every item, including correct answers that took too long. Then spend the next study block on the underlying method, not on reproducing the simulation’s wording. Reserve the second attempt for a later readiness check after you have repeated the weak workflows.
A simulation score alone should not decide whether you schedule. Look for repeatability: can you solve a similar problem with different names, namespaces, and symptoms? Can you verify the result without a provided hint? Can you recover from a wrong first command? Those indicators are more useful than familiarity with one practice set.
Stage five: make the scheduling decision
Schedule when you can complete mixed practical work with enough margin to investigate failures, use documentation efficiently, and verify changes. If you still require step-by-step guidance for a whole domain, delay the appointment and target that domain. If only isolated commands are slow, schedule may be reasonable while continuing focused practice.
Before committing, review the current exam version and competencies, confirm that your equipment passes the official system check, and read the current candidate instructions. The exam environment is aligned with the most recent Kubernetes minor version within approximately 4 to 8 weeks of that Kubernetes release date, so version awareness matters when planning near an update.
Common preparation mistakes and better replacements
The most damaging mistakes are usually process failures: studying only familiar tools, ignoring the highest-weight domain, practicing without verification, and treating a simulator as a question bank. Replace each with an observable behavior that resembles administration: diagnose from evidence, make controlled changes, and confirm the requested state.
Avoid building your plan around claims that the exam tests memory or that a particular collection of questions guarantees success. The official format is performance-based. A candidate who knows where to find relevant documentation but cannot interpret the cluster state still needs more lab work; a candidate who can solve only one fixed scenario is not yet demonstrating broad competence.
Mistake: learning by copying commands
Copying a command can be useful when learning syntax, but it becomes a weakness when you cannot explain its fields or adapt it. After using an example, change the namespace, object name, selector, port, or failure condition and solve the altered task. Verify that the result matches the requirement rather than merely producing a successful command exit.
Mistake: over-specializing in daily work
Production roles often divide responsibility, so daily experience may leave gaps in storage, cluster configuration, or low-level troubleshooting. Compare your real duties with all five domains and deliberately practice the areas your job abstracts away. Familiarity with a managed platform does not automatically prove that you can reason about the underlying Kubernetes behavior.
Mistake: treating troubleshooting as repair recipes
A repair recipe fails when the symptom changes. Instead, group incidents by layer: object specification, scheduling, control-plane or node health, network path, storage path, and workload behavior. For each layer, identify the evidence that would confirm or reject a hypothesis. This creates a portable diagnostic method without relying on exam-specific content.
Mistake: leaving logistics until exam day
Remote proctoring introduces requirements that are separate from Kubernetes knowledge. Complete the PSI system check, test the secure-browser workflow, confirm microphone and camera access, and arrange a private permitted location before the appointment. The Linux Foundation states that public spaces such as coffee shops, stores, and open office environments are not allowed.
Mistake: changing a reservation too late
An exam reservation may be cancelled or rescheduled up to 24 hours before its start time; changes are unavailable when 24 hours or less remain. A no-show forfeits the registration fees and does not qualify for a retake. Put the appointment in your calendar and make any necessary change before the cutoff rather than relying on last-minute flexibility.
Scheduling, delivery, and workstation requirements
The CKA is delivered online and remotely proctored through streaming audio, video, and screen-sharing feeds. Candidates provide their own computer and should confirm the technical requirements through PSI and the Linux Foundation before scheduling. These are official delivery conditions; the preparation suggestions below are practical ways to reduce preventable interruptions.
After registration, candidates generally have 12 months from the registration date to schedule and take the exam, or until a corporate subscription expires, whichever happens first. The My Portal expiration date is the last date on which the exam can be taken. The purchase page lists an exam-only price of $445, but verify the current catalog before buying because pricing can change.
The listed purchase includes two exam attempts and two exam simulation attempts. The terms provide one retake when a passing score is not achieved and the candidate remains eligible; unless otherwise indicated, the retake must be taken within 12 months of the original purchase or before corporate-subscription expiration, whichever comes first. A no-show is not eligible for a retake.
Plan the appointment through PSI
Selecting Schedule in the exam preparation checklist redirects the candidate to the PSI Dashboard. PSI presents the country and time-zone selection and available dates and times, with timeslots shown up to 90 days out. Exams require 24-hour lead time for virtual-machine preparation, so the earliest possible reservation date is the following day.
You may upload a photo ID before scheduling or skip that step and complete it later or during check-in using a mobile device. Read the identification requirements in the current official handbook and make sure the identity information used for registration is consistent with the document you plan to present.
Prepare the computer and room
The official instructions require a supported operating system, reliable internet access, a microphone, and one active monitor; dual monitors are not supported. The Linux Foundation recommends a screen size of 15” or higher and a 1080p screen resolution for the ExamUI. Run the PSI system check rather than assuming that a machine used for ordinary video calls will pass.
Reduce avoidable network contention by stopping file synchronization and other bandwidth-intensive services and by ensuring that others on the same connection are not streaming, gaming, or holding conference calls. A wired connection is often more stable than wireless. Confirm that HTTPS connectivity to the required AWS S3 endpoints is not blocked by firewall or proxy rules.
Use a private, controlled location. Public spaces are not allowed, and proctors can view the candidate’s desktop, including all monitors. Read the current rules before exam day because the proctoring session is monitored and recordings may be stored for a limited period if later review is needed.
Know what happens after submission
Results are emailed within 24 hours from the time the exam is completed, barring exceptions or technical difficulties. Use that information to plan work and study commitments, but do not treat the result window as a reason to rush the final verification of your tasks. A checked result is more valuable than a fast but unverified command.
If the result is unsuccessful and you remain eligible, review the terms for the one-retake policy and its deadline. Diagnose the outcome by domain and process: determine whether lost performance came from knowledge gaps, slow navigation, poor task triage, or logistics. Then revise the plan before using the retake rather than repeating the same practice routine.
Choosing training and study resources
Choose resources by the gap they solve. A structured course can provide sequence and explanations; a hands-on lab can build execution; official documentation can train reference use; and a simulator can test timing and breadth. No single resource replaces repeated, independent problem solving. Compare every course or lab against the current official domains and competencies before relying on it.
The Linux Foundation page lists an exam-only purchase at $445, an exam plus THRIVE-ONE annual subscription at $625, and an exam plus Kubernetes Fundamentals (LFS258) course at $645. These are catalog facts supplied for this guide, not a recommendation to buy a particular package. Check the live page for current availability and terms.
If you are new to Kubernetes, start with fundamentals before intensive exam drills. If you already operate clusters, a broad assessment and targeted labs may be more efficient than repeating introductory explanations. The decision should depend on whether you can independently perform and troubleshoot the tasks represented by the current blueprint.
A resource selection checklist
Before committing time or money, ask whether the resource uses the current competency set, provides a command-line practice environment, includes failure scenarios, encourages verification, and explains why a solution works. Be cautious with material that promises exam success through memorization or presents purported live questions. Confidential exam content is not a legitimate substitute for competence.
Use official Linux Foundation and CNCF pages as the final reference for the exam purpose, domains, delivery conditions, version information, pricing, and policies. Use third-party material only as a learning aid, and reconcile conflicting details against those official sources before changing your schedule.
What to do in the final week
The final week should consolidate execution rather than introduce an entirely new curriculum. Complete mixed practical sessions, revisit the error log, verify your documentation workflow, and rehearse the technical check-in conditions. Stop expanding your notes when they become a substitute for lab work; prioritize the procedures you can apply under pressure.
Review all five domains with emphasis on Troubleshooting 30%, Cluster Architecture, Installation & Configuration 25%, and Services & Networking 20%, while still performing targeted Workloads & Scheduling 15% and Storage 10% exercises. Keep each percentage attached to its named official domain; these weights guide attention but do not predict the exact task sequence.
Confirm the exam version and competencies, test the computer and browser, prepare the permitted room, and check the appointment time zone. Add the appointment to your calendar. If your environment is unreliable or your readiness evidence is weak, reschedule before the 24-hour cutoff rather than accepting a preventable no-show or technical failure.
A final readiness test
You are closer to ready when you can read a task once, identify the target state, locate the relevant objects, make a narrowly scoped change, and verify the result without a walkthrough. You should also be able to abandon a blocked line of investigation, preserve useful notes, and return later with a better hypothesis.
Run one final mixed session under the official 2-hour limit. Review not only whether each task was correct, but whether your process was safe and repeatable. Any task solved by luck, unexplained copying, or a last-second unverified change belongs in the remediation list rather than the success column.
After the exam: certification status and next steps
A successful CKA result is not the end of administrator development. Use the score report and your preparation log to identify operational areas that need deeper work, whether or not you passed on the first attempt. The credential confirms a certification requirement; continued competence comes from maintaining and expanding the skills behind it.
Linux Foundation certifications become non-current 24 months from the date the candidate successfully passes the certification exam unless revoked earlier or renewed under the applicable requirements. Candidates may keep the certification current by retaking and passing the same exam before expiration, and the certification becomes current for 2 years from the date that exam is retaken and passed.
Check the certification FAQ for all available renewal paths because options vary by certification. Keep your certificate ID and verification information accessible, and record the expiration date as soon as the credential is issued. This turns renewal into a planned professional task rather than an unexpected deadline.
Turn preparation into operational capability
Keep practicing after the result with the same loop used for the exam: observe, hypothesize, change, verify, and document. Apply it to non-exam work such as incident reviews, maintenance plans, cluster upgrades, access controls, workload reliability, and storage or networking investigations, provided those activities are appropriate to your role and environment.
If you did not pass, treat the result as a diagnostic signal rather than a verdict on your career. Map weaknesses to the official domains, rebuild the relevant workflows in a lab, and address the process issue that caused lost time. The retake is most useful when it follows new evidence of improvement, not simply a second attempt at the same preparation.
Conclusion
The CKA is a practical administrator assessment: 15-20 command-line tasks, 2 hours, remote proctoring, and a passing threshold of 66% or above. Make your decision from evidence rather than confidence alone. Study all five named domains, give deliberate attention to Troubleshooting 30% and Cluster Architecture, Installation & Configuration 25%, use simulations to expose process weaknesses, and verify the current competencies and exam environment before scheduling. Your next step is to compare the blueprint with your lab results, choose the weakest domain, and complete a focused troubleshooting cycle there.