CKA Study Guide

Why CKA Matters

Kubernetes is the undisputed standard for container orchestration. Every major cloud provider builds around it, every serious platform engineering team runs it, and the ecosystem shows no signs of slowing down. The Certified Kubernetes Administrator (CKA) credential, issued by the Cloud Native Computing Foundation (CNCF), validates that you can design, install, configure, and manage production-grade Kubernetes clusters.

What sets CKA apart from most IT certifications is its format. There are no multiple-choice questions. The entire exam is performance-based — you are dropped into a live command-line environment and given real tasks to complete against actual clusters. You either know how to do the work or you don’t. This makes CKA one of the most respected and practical certifications in the cloud-native space. Employers trust it because passing it means you have genuinely demonstrated the ability to operate Kubernetes under pressure, not just memorize theory.

If you are serious about a career in DevOps, platform engineering, or cloud infrastructure, CKA is the credential that opens doors.

Who This Guide Is For

• System administrators and DevOps engineers looking to formalize their Kubernetes skills with a recognized credential.
• Cloud engineers already working with AWS, Azure, or GCP who want to deepen their container orchestration expertise.
• Software developers transitioning into infrastructure or platform engineering roles.
• IT professionals targeting senior or lead roles where Kubernetes competency is a hard requirement.

2026 Market Snapshot

Kubernetes adoption continues to accelerate across industries. According to CNCF survey data, over 80% of organizations now run Kubernetes in production, and demand for certified administrators consistently outpaces supply. CKA holders are among the highest-paid infrastructure professionals in the market.

The certification sits at the intersection of several high-growth areas: cloud migration, microservices architecture, and platform engineering. Companies that have moved past the experimentation phase now need operators who can manage clusters at scale, handle upgrades safely, implement RBAC policies, and troubleshoot production incidents quickly. That is exactly what CKA validates.

CKA pairs powerfully with cloud provider certifications. If you already hold the AWS Solutions Architect or Azure Administrator AZ-104, adding CKA signals that you can manage workloads across any environment — not just a single vendor’s managed Kubernetes service. This combination is particularly valuable for organizations running hybrid or multi-cloud strategies.

On the compensation side, CKA holders in 2026 command median salaries above $135,000 in the US market, with senior roles pushing well beyond $160,000. The certification also serves as a gateway to more specialized credentials like CKAD and CKS, further increasing earning potential.

Check the latest job market data for CKA on the CKA certification page to see current demand trends and employer interest.

Exam Structure

The CKA exam is a proctored, online, performance-based test. Here is what you need to know:

• Format: 15-20 performance-based tasks in a live Linux command-line environment
• Duration: 2 hours
• Passing Score: 66%
• Retake Policy: One free retake included with your exam purchase
• Proctoring: Online via PSI, with webcam and screen sharing required
• Resources Allowed: Access to the official Kubernetes documentation (kubernetes.io/docs) during the exam

Domain Weight Breakdown

Troubleshooting carries the most weight at 30%. This is deliberate — the CNCF wants to certify administrators who can diagnose and fix real problems, not just deploy resources in ideal conditions.

Key Knowledge Areas by Domain

Cluster Architecture, Installation & Configuration (25%)

You must be able to set up a cluster from scratch using kubeadm and understand every component.

• kubeadm init, kubeadm join, kubeadm upgrade — know these cold
• etcd backup and restore: etcdctl snapshot save, etcdctl snapshot restore
• RBAC configuration: kubectl create role, kubectl create clusterrole, kubectl create rolebinding
• Manage kubeconfig files and contexts: kubectl config use-context, kubectl config set-context
• Understand the control plane: API server, scheduler, controller manager, etcd
• Perform cluster version upgrades safely with zero downtime strategies

Workloads & Scheduling (15%)

• Create and manage Deployments, ReplicaSets, DaemonSets, StatefulSets, and Jobs
• kubectl create deployment, kubectl scale, kubectl rollout
• Configure resource requests and limits in pod specs
• Use nodeSelector, taints, tolerations, and node affinity for scheduling control
• kubectl taint nodes, kubectl label nodes
• Understand pod lifecycle, init containers, and multi-container pod patterns

Services & Networking (20%)

• Create and expose Services: ClusterIP, NodePort, LoadBalancer
• kubectl expose deployment, kubectl get endpoints
• Configure and troubleshoot Ingress resources and Ingress controllers
• Understand DNS resolution within the cluster (CoreDNS)
• Implement NetworkPolicies to control pod-to-pod communication
• kubectl get networkpolicy, understand ingress/egress rules in policy specs

Storage (10%)

• Create and manage PersistentVolumes (PV) and PersistentVolumeClaims (PVC)
• Understand StorageClasses and dynamic provisioning
• Configure volume mounts in pod specs: emptyDir, hostPath, configMap, secret
• kubectl get pv, kubectl get pvc, kubectl get storageclass

Troubleshooting (30%)

This is where the exam is won or lost. Practice these relentlessly:

• kubectl describe pod, kubectl logs, kubectl logs --previous
• kubectl exec -it <pod> -- /bin/sh for interactive debugging
• kubectl get events --sort-by=.metadata.creationTimestamp
• Diagnose node failures: kubectl get nodes, kubectl describe node, check kubelet status with systemctl status kubelet
• Fix broken cluster components: static pod manifests in /etc/kubernetes/manifests/
• Debug networking issues: verify service endpoints, DNS resolution, network policies
• crictl ps, crictl logs for container runtime troubleshooting

8-Week Study Plan (10-12 Hours/Week)

This exam is 100% hands-on. Flashcards will not save you. You must practice in a real cluster — use minikube, kind, or a cloud-based lab environment from day one.

Week 1: Foundations & Cluster Setup

• Topics: Kubernetes architecture, control plane components, etcd
• Labs: Install a cluster using kubeadm on two or more nodes (use VMs or cloud instances). Break it. Fix it. Repeat.
• Tip: Set up your terminal environment early. Get comfortable with kubectl aliases (alias k=kubectl) and bash completion.

Week 2: Cluster Configuration & RBAC

• Topics: kubeconfig, namespaces, RBAC (Roles, ClusterRoles, Bindings), ServiceAccounts
• Labs: Create restricted ServiceAccounts, test permissions with kubectl auth can-i
• Tip: RBAC questions are common and easy points if you practice. Know the difference between Role and ClusterRole.

Week 3: Workloads & Scheduling

• Topics: Deployments, ReplicaSets, DaemonSets, StatefulSets, Jobs, CronJobs
• Labs: Deploy applications, perform rolling updates, rollbacks. Configure resource limits.
• Tip: Practice creating resources imperatively with kubectl create and kubectl run. Speed matters on exam day.

Week 4: Scheduling & Pod Design

• Topics: Taints, tolerations, node affinity, pod affinity, nodeSelector, static pods
• Labs: Taint nodes, schedule pods to specific nodes, create static pods in /etc/kubernetes/manifests/
• Tip: Memorize the YAML structure for tolerations and affinity rules — the docs are helpful but slow to navigate.

Week 5: Services & Networking

• Topics: Services (ClusterIP, NodePort, LoadBalancer), Ingress, CoreDNS, NetworkPolicies
• Labs: Expose deployments, create Ingress resources, write NetworkPolicies that allow/deny specific traffic
• Tip: NetworkPolicy questions trip up many candidates. Practice writing policies from scratch without copying from docs.

Week 6: Storage & Security

• Topics: PVs, PVCs, StorageClasses, ConfigMaps, Secrets, SecurityContexts
• Labs: Create PVs and PVCs, mount them in pods. Create ConfigMaps and Secrets, consume them as environment variables and volume mounts.
• Tip: Know the difference between static and dynamic provisioning. Practice the full PV-PVC-Pod lifecycle.

Week 7: Troubleshooting Deep Dive

• Topics: Node troubleshooting, pod failures, networking issues, cluster component failures
• Labs: Intentionally break cluster components (stop kubelet, corrupt manifests, misconfigure services) and fix them under time pressure.
• Tip: This domain is 30% of the exam. Spend extra time here. Build a mental checklist for diagnosing issues: events, logs, describe, exec.

Week 8: Full Practice Exams & Review

• Topics: End-to-end exam simulation, weak area review, time management practice
• Labs: Complete at least two full practice exams under timed conditions. Review every mistake.
• Tip: On exam day, tackle high-point questions first. Flag difficult tasks and return to them. Do not burn 20 minutes on a 4-point question.

Practice Exam Strategy

killer.sh Simulator

Your CKA exam purchase includes two sessions on killer.sh, the official exam simulator. These are your most valuable preparation resources — do not waste them.

• Session 1: Take it after Week 6 to identify gaps. Expect to struggle. The killer.sh environment is intentionally harder than the real exam.
• Session 2: Take it in Week 8 as your final readiness check. Aim for 80%+ to have a comfortable margin on exam day.

Each session remains active for 36 hours after activation. Use every minute to review solutions and understand where you went wrong.

Additional Practice Environments

• minikube or kind: Free, local clusters for daily practice
• KodeKloud CKA Labs: Structured lab exercises aligned to the exam curriculum
• Kubernetes the Hard Way (Kelsey Hightower): Not exam-specific, but builds deep understanding of what kubeadm automates
• Play with Kubernetes (labs.play-with-k8s.com): Browser-based clusters for quick practice sessions

Career Impact

CKA is a career accelerator. Here is what the certification unlocks:

• Salary: CKA holders in the US earn a median of $135,000+, with experienced professionals in major markets exceeding $165,000
• Role Access: Senior DevOps Engineer, Platform Engineer, Site Reliability Engineer, Cloud Infrastructure Lead — these roles increasingly list CKA as preferred or required
• Credibility: CKA tells hiring managers you can operate Kubernetes in production, not just talk about it

The CKA Certification Pathway

The natural progression after CKA is:

1. CKA — Cluster administration and operations
2. CKAD (Certified Kubernetes Application Developer) — Application design and deployment on Kubernetes
3. CKS (Certified Kubernetes Security Specialist) — Cluster hardening, runtime security, supply chain security

Holding all three positions you as a complete Kubernetes professional. Many engineers also combine CKA with cloud provider certifications like the AWS Solutions Architect, Azure Administrator AZ-104, or Google Cloud Associate to demonstrate cross-platform expertise.

Common Mistakes

• Not practicing in a real cluster. Reading documentation and watching videos is not enough. You need muscle memory with kubectl commands, YAML manifests, and the Linux command line. If you have not built, broken, and fixed clusters repeatedly, you are not ready.
• Poor time management on exam day. Some tasks are worth 4 points, others 8 or more. Candidates who spend too long on low-value tasks run out of time before reaching high-value ones. Scan all questions first, prioritize by points.
• Ignoring the documentation during the exam. You are allowed to access kubernetes.io/docs. Practice navigating the docs quickly so you can look up YAML specs and command syntax without losing minutes. Bookmark key pages before the exam starts.
• Underestimating the troubleshooting domain. At 30%, troubleshooting is the single largest scoring area. Many candidates over-index on deployment and scheduling while neglecting systematic debugging skills. Practice diagnosing failures you did not create.

Frequently Asked Questions

How hard is the CKA exam?

CKA is an advanced certification with a historically challenging pass rate. The performance-based format means you cannot guess your way through. However, with 8-10 weeks of consistent hands-on practice, most candidates with foundational Linux and container knowledge can pass on the first attempt.

CKA vs CKAD — which should I take first?

CKA focuses on cluster administration: installation, upgrades, networking, storage, RBAC, and troubleshooting. CKAD focuses on application development: designing, building, and deploying applications on Kubernetes. If you manage infrastructure, start with CKA. If you are a developer deploying to Kubernetes, start with CKAD. There is significant overlap, so passing one makes the other substantially easier.

Do I need Linux experience before attempting CKA?

Yes. The exam runs in a Linux terminal. You need to be comfortable with bash, systemd, file editing (vi/vim or nano), SSH, and basic system administration. If you are not, spend 2-3 weeks on Linux fundamentals before starting your CKA study plan.

How long is the CKA certification valid?

CKA is valid for two years from the date you pass. You can recertify by passing the current version of the exam before your certification expires.

Can I use bookmarks during the exam?

Yes. You can access kubernetes.io/docs, kubernetes.io/blog, and github.com/kubernetes during the exam. You are allowed to have one additional browser tab open for documentation. Setting up bookmarks to frequently referenced pages (like the kubectl cheat sheet and API reference) saves valuable time.

The Bottom Line

CKA is not a checkbox certification — it is a practical validation that you can operate Kubernetes in production. The performance-based format makes it harder to pass but far more valuable to hold. Employers know that a CKA holder has actually done the work, not just studied slides.

Commit to the 8-week study plan, practice in real clusters every single day, and use your killer.sh sessions strategically. Focus heavily on troubleshooting since it accounts for nearly a third of your score. If you put in the hours with hands-on practice, you will pass.

Start building your cluster today. The command line is waiting.