Diwali Offer!Flat 20% OFF
Enroll Now
PrakalpanaLive online tech training
DevOps⏱️ 11 min readπŸ“… Nov 13

CKA Exam Guide 2026: How to Prepare and Pass the Certified Kubernetes Administrator

KS
Karthik Subramanianβ€’Site Reliability Engineer
πŸ“‘ Contents (27 sections)

πŸ“ŒWhat the CKA Is

The Certified Kubernetes Administrator (CKA) is the CNCF and Linux Foundation certification for people who run Kubernetes (K8s) clusters. Unlike multiple choice exams, it is performance based: you get a set of live clusters and a list of tasks, and you solve them in a terminal. That is exactly why employers trust it, and why it appears in so many DevOps and platform job posts in India.

Exam details such as the price, passing score, duration and the Kubernetes version it targets are updated by the Linux Foundation from time to time. Always check the official CKA page and candidate handbook before you book. This guide focuses on what stays the same: how to prepare and how to work fast.

πŸ“ŒHow the Exam Works

  • Hands-on: every question is a task on a real cluster, such as creating a Deployment, fixing a broken node or backing up etcd.
  • Remote proctored: you take it from home through a secure browser, with webcam monitoring. Your desk must be clear and your room private.
  • Multiple clusters: each task tells you which cluster context to use. Switching context is the first step of every question.
  • Official docs allowed: you can use the Kubernetes documentation in the exam browser. Knowing where things are in the docs saves real time.
  • Partial credit: tasks are scored individually, so a skipped hard question does not sink you.
  • A free retake has historically been included, and practice simulator sessions come with registration. Confirm the current terms when you book.
  • πŸ“ŒThe Exam Domains

    The curriculum is published on the CNCF GitHub and changes slightly over time, but it consistently covers these areas:

    Cluster architecture, installation and configuration

  • kubeadm based cluster setup and upgrades
  • RBAC: Roles, ClusterRoles, bindings and ServiceAccounts
  • etcd backup and restore
  • Managing highly available control planes at a conceptual level
  • Helm and Kustomize basics for installing components
  • Workloads and scheduling

  • Deployments, rolling updates and rollbacks
  • ConfigMaps and Secrets
  • Resource limits, node affinity, taints and tolerations
  • Static pods and manual scheduling
  • Services and networking

  • Services, DNS and endpoints
  • Ingress and the Gateway API
  • NetworkPolicies
  • CNI concepts
  • Storage

  • PersistentVolumes, PersistentVolumeClaims and StorageClasses
  • Access modes and reclaim policies
  • Mounting volumes into pods
  • Troubleshooting

  • Broken nodes, kubelet failures and certificate problems
  • Pods stuck in Pending, CrashLoopBackOff or ImagePullBackOff
  • Service and DNS issues
  • Reading logs from pods, kubelet and control plane components
  • Troubleshooting carries the largest weight. Practise it the most.

    πŸ“ŒSet Up Your Terminal for Speed

    The exam is a race against time. Small habits add up.

    alias k=kubectl
    export do="--dry-run=client -o yaml"
    export now="--force --grace-period 0"
    source <(kubectl completion bash)
    complete -o default -F __start_kubectl k

    In recent exam environments the k alias and completion are often preconfigured, but know how to set them yourself.

    Set your editor for YAML if needed:

    echo 'set expandtab tabstop=2 shiftwidth=2' >> ~/.vimrc

    πŸ“ŒUse Imperative Commands, Then Edit

    Never type YAML from scratch. Generate it.

    k create deployment web --image=nginx --replicas=3 $do > web.yaml
    k expose deployment web --port=80 --target-port=80 --type=ClusterIP
    k run tmp --image=busybox --restart=Never -it --rm -- wget -qO- web
    k create configmap app-cfg --from-literal=MODE=prod
    k create secret generic db --from-literal=PASSWORD=s3cret
    k create role reader --verb=get,list,watch --resource=pods -n dev
    k create rolebinding reader-bind --role=reader --user=jane -n dev
    k auth can-i list pods --as=jane -n dev
    k set image deployment/web nginx=nginx:1.27
    k rollout undo deployment/web
    k scale deployment web --replicas=5

    Use k explain pod.spec.containers --recursive when you forget a field name, it is faster than searching docs.

    πŸ“ŒPractise etcd Backup and Restore

    This task appears often and is easy marks if you have practised it.

    ETCDCTL_API=3 etcdctl snapshot save /opt/backup/etcd.db \
    --endpoints=https://127.0.0.1:2379 \
    --cacert=/etc/kubernetes/pki/etcd/ca.crt \
    --cert=/etc/kubernetes/pki/etcd/server.crt \
    --key=/etc/kubernetes/pki/etcd/server.key

    Find the certificate paths in the etcd static pod manifest at /etc/kubernetes/manifests/etcd.yaml. For a restore, restore the snapshot into a new data directory and point the etcd manifest's hostPath to it. Newer releases also provide etcdutl for snapshot restore, so practise with the version in your lab.

    πŸ“ŒA Troubleshooting Method That Works

    Work from the outside in, every time:

  • 1k get nodes: is any node NotReady?
  • 2k get pods -A: which pods are failing, and in which state?
  • 3k describe: read the Events section at the bottom first.
  • 4k logs (with --previous for crashed containers).
  • 5On a broken node, SSH in and check systemctl status kubelet and journalctl -u kubelet.
  • 6For control plane issues, inspect the static pod manifests in /etc/kubernetes/manifests.
  • 7For networking, test from inside a pod with a temporary busybox and check Service endpoints.
  • Our Kubernetes troubleshooting guide walks through the most common failures in detail.

    πŸ“ŒThree Sample Tasks, Solved

    These mirror the style of real CKA tasks.

    Task 1: Create a NetworkPolicy

    "In namespace prod, allow pods labelled app=api to receive traffic only from pods labelled app=web on port 8080."

    apiVersion: networking.k8s.io/v1
    kind: NetworkPolicy
    metadata:
    name: api-allow-web
    namespace: prod
    spec:
    podSelector:
    matchLabels:
    app: api
    policyTypes: [Ingress]
    ingress:
    - from:
    - podSelector:
    matchLabels:
    app: web
    ports:
    - port: 8080
    protocol: TCP

    Copy the skeleton from the NetworkPolicy docs page, then edit. Remember that a NetworkPolicy only has effect if the cluster's CNI supports it.

    Task 2: Fix a NotReady node

    SSH to the node, check systemctl status kubelet. If it is inactive, start and enable it. If it fails, read journalctl -u kubelet for the cause, often a wrong path in the kubelet config or an expired or missing certificate. Fix it, restart the kubelet and confirm the node shows Ready.

    Task 3: Upgrade a control plane node

    Drain the node, upgrade the kubeadm package, run kubeadm upgrade plan and kubeadm upgrade apply for the target version, upgrade kubelet and kubectl, restart the kubelet, then uncordon the node. The kubeadm upgrade page in the docs lists every command, so know where it is.

    πŸ“ŒCommon Mistakes That Cost Marks

  • Working in the wrong cluster context or namespace
  • Forgetting to save output files to the exact path asked
  • Writing YAML by hand and losing time to indentation errors
  • Not verifying resources after creating them
  • Spending too long on one troubleshooting task
  • Practising only on managed clusters and never touching kubeadm or static pods
  • πŸ“ŒExam Day Strategy

  • Read the context line first and switch cluster before doing anything.
  • Do easy tasks first. Flag long ones and return later.
  • Check your work: after each task, run a quick get or describe to verify.
  • Watch namespaces. Many lost marks come from creating resources in the default namespace.
  • Do not fight one question. Partial credit across many tasks beats perfection on one.
  • Keep the docs bookmarked in your head: know the pages for NetworkPolicy, PersistentVolume, Ingress and kubeadm upgrade.
  • πŸ“ŒA Focused Practice Plan

    PhaseWhat to do

    FoundationLearn architecture, workloads and Services with daily hands-on labs Admin skillskubeadm install and upgrade, RBAC, etcd backup, storage NetworkingServices, DNS, Ingress, Gateway API and NetworkPolicies TroubleshootingBreak clusters on purpose and fix them Exam simulationTimed mock exams, then review every mistake

    Build your own cluster with kubeadm at least twice. Nothing teaches the control plane faster.

    Where to practise

  • Your own lab: two or three small cloud VMs or local virtual machines running kubeadm
  • kind or minikube: fast for workloads, Services and RBAC drills
  • The official exam simulator included with registration, which is harder than the real exam on purpose
  • Kubernetes documentation: practise finding pages quickly, since you will use it during the exam
  • Keep a personal notes file of every command you got wrong, and redo those tasks until they are automatic.

    πŸ“ŒFAQ

    Is the CKA hard?

    It is challenging because of the time pressure, not because the tasks are obscure. With regular hands-on practice and timed mocks, most prepared candidates pass.

    Should I take CKAD or CKA first?

    CKA if you want DevOps, SRE or platform roles. CKAD if you are a developer deploying apps. Many people take both.

    Do I need Linux skills for the CKA?

    Yes. You will use systemctl, journalctl, file editing and basic networking tools on nodes.

    How long is the certification valid?

    Validity periods have changed over the years, so check the current policy on the Linux Foundation site.

    The Kubernetes roadmap and the Kubernetes interview questions.

    πŸ“ŒLearn It Live

    Prakalpana's Kubernetes course is taught live online with an optional 1-on-1 track, real kubeadm clusters, CKA style timed labs and mentor reviews. Explore the Kubernetes track, or WhatsApp or call +91 9180377502 for a free demo.

    KS

    Written by

    Karthik Subramanian

    Site Reliability Engineer

    πŸš€ Master DevOps

    Live online + 1-on-1 DevOps Engineering training Β· Join 5000+ developers

    Not sure what to do? Book career counselling (β‚Ή200 / 30 min)

    Not sure what to learn next?

    A 1-on-1 session with an industry mentor and a roadmap built for you. How it works

    1. 1Discuss your goals
    2. 2Get a personal plan
    3. 3Start learning
    Book for β‚Ή200/ 30 min