Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.

AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by CNCF
Exam Format
Registration
Validity
Skills this practice test covers
- Install and upgrade a cluster with kubeadm, and back up and restore etcd.
- Grant least-privilege access with Roles, ClusterRoles and their bindings.
- Expose workloads with Services and limit their traffic with Network Policies.
- Provision storage with storage classes and bind persistent volumes to claims.
- Find the cause of a broken node, pod or Service from logs, events and metrics.
- Schedule pods with requests, affinity and taints, and scale them automatically.
Explore related topics
CKA exam content
5 domains · 30 topics · 199 questions
Storage10%20 questions
This domain covers how workloads keep their data. Candidates create storage classes for dynamic provisioning, pick access modes and reclaim policies, and bind persistent volumes to claims.
Skills tested
- Create a storage class and use it to provision volumes on demand.
- Choose access modes and a reclaim policy that protect the data.
- Fix a persistent volume claim that stays unbound.
Questions by topic
- Manage persistent volumes and persistent volume claims8
- Implement storage classes and dynamic volume provisioning5
- Configure volume types, access modes and reclaim policies7
Workloads & Scheduling15%30 questions
This domain covers running applications. Candidates roll deployments forward and back, configure them with ConfigMaps and Secrets, set up autoscaling, and control pod placement with requests, limits, affinity and taints.
Skills tested
- Perform a rolling update, check its status and roll it back.
- Pass configuration to pods with ConfigMaps and Secrets.
- Configure a Horizontal Pod Autoscaler for a deployment.
- Place pods with resource requests, node affinity, taints and tolerations.
- Add health probes so that failed containers restart on their own.
Questions by topic
- Use ConfigMaps and Secrets to configure applications7
- Configure Pod admission and scheduling (limits, node affinity, etc.)8
- Understand the primitives used to create robust, self-healing, application deployments6
- Configure workload autoscaling4
- Understand application deployments and how to perform rolling update and rollbacks5
Services & Networking20%38 questions
This domain covers how pods reach each other and the outside world. Candidates choose Service types, write Network Policies, route traffic with the Gateway API or Ingress, and work with CoreDNS.
Skills tested
- Expose a deployment with a ClusterIP, NodePort or LoadBalancer Service.
- Write a Network Policy that allows only the traffic a workload needs.
- Route HTTP traffic with a Gateway and an HTTPRoute, or with an Ingress resource.
- Check how Service and pod names resolve through CoreDNS.
Questions by topic
- Use ClusterIP, NodePort, LoadBalancer service types and endpoints15
- Use the Gateway API to manage Ingress traffic7
- Understand and use CoreDNS4
- Define and enforce Network Policies6
- Troubleshoot services and networking3
- Understand connectivity between Pods3
Troubleshooting30%58 questions
The largest domain asks candidates to find and fix faults on a live cluster. A fault can sit in a node, a control plane component, an application or the network, and the clues come from logs, events and resource metrics.
Skills tested
- Find why a node is NotReady by checking the kubelet and its logs.
- Diagnose a failed control plane component, such as the API server or etcd.
- Read container logs and events to explain a crashing pod.
- Check resource use to find a pod or node under pressure.
- Trace a broken Service through its endpoints and DNS.
Questions by topic
- Troubleshoot services and networking7
- Manage and evaluate container output streams11
- Monitor cluster and application resource usage6
- Troubleshoot clusters and nodes21
- Troubleshoot cluster components10
- Understand connectivity between Pods1
- Configure Pod admission and scheduling (limits, node affinity, etc.)2
Cluster Architecture, Installation & Configuration25%53 questions
This domain covers building and running the cluster itself. Candidates install and upgrade clusters with kubeadm, manage RBAC, set up a highly available control plane, install components with Helm and Kustomize, and work with CRDs, operators and extension interfaces.
Skills tested
- Install a cluster with kubeadm and join worker nodes to it.
- Upgrade the control plane and the nodes by one minor version.
- Back up etcd and restore it from a snapshot.
- Create Roles, ClusterRoles and bindings for users and service accounts.
- Install a component with Helm or Kustomize and check the CRDs it adds.
Questions by topic
- Implement and configure a highly-available control plane7
- Manage the lifecycle of Kubernetes clusters12
- Manage role based access control (RBAC)8
- Prepare underlying infrastructure for installing a Kubernetes cluster5
- Use Helm and Kustomize to install cluster components8
- Understand extension interfaces (CNI, CSI, CRI, etc.)4
- Understand CRDs, install and configure operators5
- Create and manage Kubernetes clusters using kubeadm3
- Understand the primitives used to create robust, self-healing, application deployments1
Requirements
- No formal prerequisites: anyone can book the exam.
- Recommended: regular hands-on Kubernetes work for six months or more.
- Recommended: Linux command line skills, YAML, container basics and basic networking.
About the CKA exam
CKA shows that an engineer can install, configure and repair Kubernetes clusters by hand. The Cloud Native Computing Foundation offers it as a performance-based exam: candidates solve tasks at the command line on live clusters instead of picking answers. Troubleshooting is the largest domain, followed by cluster architecture, installation and configuration. The exam environment follows a recent Kubernetes release, and the certification is valid for two years.
Because the exam is hands-on, the PlanetCert practice test is best used to learn what each task needs before typing it in a lab. Troubleshooting has the most questions in the practice test, just as it carries the most weight on the exam. Study Mode suits the longer scenarios, and Flashcard Mode suits kubectl commands and resource names. Brainy AI Assistant can explain an unfamiliar manifest, or turn a missed question into a small task to repeat on a practice cluster.
How to earn the certification
- Earns
- Certified Kubernetes Administrator (CKA)Professional
The CKA certification is valid for two years.
How to prepare for CKA
- 1
Build a kubeadm practice cluster
Set up one control plane node and one or two workers on virtual machines with kubeadm. Rebuild it several times until init, join and the network plugin install feel routine.
- 2
Break the cluster on purpose
Troubleshooting carries the most weight. Stop the kubelet, damage a static Pod manifest or remove a Service's selector, then fix each fault from logs and events alone.
- 3
Generate manifests from the command line
Create objects with imperative commands such as kubectl create and kubectl expose, and add --dry-run=client -o yaml to get a manifest to edit. Speed at the command line matters on a hands-on exam.
- 4
Rehearse an upgrade and an etcd restore
Upgrade the practice cluster by one minor version with kubeadm upgrade plan and kubeadm upgrade apply, draining each node in turn. Take an etcd snapshot first and practise restoring it.
- 5
Check knowledge, then use the simulator
Work through the CKA practice test in Study Mode to find weak domains, and ask Brainy AI Assistant about each missed concept. Then use the Killer.sh simulator sessions that come with the exam for timed, hands-on practice.
Start a timed CKArun
The Linux Foundation offers Kubernetes Fundamentals (LFS258) as the course for this exam. Each exam registration includes sessions in the Killer.sh exam simulator.
Who CKA is for
- System administrators who now run Kubernetes clusters as well as servers.
- Platform and DevOps engineers who run the clusters their teams deploy to.
- Site reliability engineers who are on call for production clusters.
- Cloud architects who want hands-on proof of cluster skills.
Typical job titles: Kubernetes administrator · Platform engineer · DevOps engineer · Site reliability engineer · Cloud engineer · Systems administrator
CKA glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- ClusterRoles
- RBAC roles that apply across the whole cluster, unlike Roles, which apply inside one namespace.
- CNI plugins
- Container Network Interface plugins that connect pods to the cluster network and give them IP addresses.
- CoreDNS
- The DNS server inside a Kubernetes cluster that turns Service and pod names into IP addresses.
- Custom Resource Definitions
- Extensions that add new object types to the Kubernetes API; operators use them to manage applications.
- DaemonSets
- Workloads that run one copy of a pod on every node, or on each selected node, such as a log collector.
- etcd
- The key-value store that holds the state of a Kubernetes cluster; a snapshot of it is the cluster's backup.
- Gateway API
- A Kubernetes API for routing traffic into the cluster, built from Gateway resources and route resources such as HTTPRoute.
- Horizontal Pod Autoscaler
- A controller that adds or removes pod replicas based on measured load, such as CPU use.
- kubeadm
- The official Kubernetes tool that creates a cluster's control plane, joins nodes to it and upgrades the cluster.
- kubectl cordon
- The command that marks a node as unschedulable, so that no new pods land on it before maintenance.
- Kustomize
- A tool built into kubectl that adjusts Kubernetes manifests through overlays, without editing the original files.
- Network Policies
- Rules that allow or block traffic to and from pods by label, namespace or IP range; the network plugin must support them.
- Node affinity
- Pod rules that attract a pod to nodes with certain labels, either as a firm requirement or as a preference.
- Persistent volume claims
- Requests for storage made by workloads; Kubernetes binds each claim to a persistent volume that matches its size and access mode.
- Reclaim policies
- Settings that decide what happens to a persistent volume after its claim is deleted, such as Retain or Delete.
- Role-based access control (RBAC)
- The Kubernetes system that grants permissions through Roles and ClusterRoles, attached to users or service accounts by bindings.
- Storage classes
- Definitions of storage types, each with a provisioner, that let Kubernetes create persistent volumes on demand.
- Taints and tolerations
- A pair of settings: a taint keeps pods off a node, and a matching toleration lets a chosen pod run there anyway.