CKA — Final Checklist

5 minute read

CKA Exam Domain

All Domains — This checklist covers everything you need before exam day.

Pre-Exam Day Checklist

Complete everything on this list before your exam day:

Knowledge & Skills

  • Completed all CKA tutorial chapters (Chapters 1–13)
  • Practiced with Killer.sh (2 free sessions included with exam purchase)
  • Scored 66%+ on both Mock Exam Part 1 and Part 2
  • Comfortable with vi/vim editor — can edit YAML files without struggling
  • Can type kubectl commands quickly with aliases (k, $do, $now)
  • Know how to use kubernetes.io/docs efficiently
  • Can create Pods, Deployments, Services using imperative commands
  • Can set up RBAC (Role, RoleBinding, ClusterRole, ClusterRoleBinding)
  • Can back up and restore etcd from snapshot
  • Can upgrade a cluster node using kubeadm
  • Can troubleshoot NotReady nodes, broken Pods, and DNS issues
  • Understand NetworkPolicies and can create them from scratch
  • Know PersistentVolumes, PersistentVolumeClaims, and StorageClasses

Technical Setup

  • Government-issued photo ID ready (must match registration name exactly)
  • Webcam working and tested
  • Microphone working and tested
  • Stable internet connection (wired recommended)
  • Browser ready: Google Chrome or Chromium with PSI Secure Browser extension installed
  • Tested the PSI system check at https://syscheck.bridge.psiexams.com
  • Second monitor disconnected (only one monitor allowed)

Environment

  • Clean desk — remove all papers, books, notes, extra devices
  • Clear room — no other people allowed during the exam
  • Door closed
  • Water in a clear glass or clear bottle (labels removed) — only drink allowed
  • Phone placed out of reach (proctor may ask you to show this)

Exam Day Checklist

Follow this sequence on exam day:

Before the Exam (15 minutes early)

  • Close all unnecessary applications on your computer
  • Join the exam session 15 minutes early
  • Complete the check-in process (ID verification, room scan)
  • Read and accept the exam agreement

First 2 Minutes of the Exam

  • Set up your terminal environment immediately:
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
  • Test the alias: k get nodes
  • Open the kubernetes.io/docs tab

During the Exam

  • Read each question completely before typing anything
  • Switch context before every question — kubectl config use-context <cluster>
  • Check which namespace the question requires — don’t assume default
  • Use the 3-Pass Strategy:
    • Pass 1 (0–60 min): Quick wins, easy questions
    • Pass 2 (60–100 min): Medium difficulty
    • Pass 3 (100–120 min): Hard questions
  • Verify after every answer (kubectl get, kubectl describe, kubectl auth can-i)
  • Flag difficult questions — come back later
  • Don’t spend more than 8 minutes on any single question in Pass 1

Last 10 Minutes

  • Revisit all flagged questions
  • Double-check context switches on your completed answers
  • Don’t start a new complex question — use time to verify existing answers

Domain Confidence Checklist

Be honest with yourself. Rate your confidence in each domain:

Domain Weight Key Skills Confident?
Cluster Architecture, Installation & Configuration 25% kubeadm upgrade, etcd backup/restore, RBAC, certificates, static Pods ☐
Workloads & Scheduling 15% Deployments, ReplicaSets, DaemonSets, resource limits, taints, tolerations, nodeSelector, affinity ☐
Services & Networking 20% Services (ClusterIP, NodePort, LoadBalancer), DNS, NetworkPolicies, Ingress ☐
Storage 10% PersistentVolumes, PersistentVolumeClaims, StorageClasses, volume mounts ☐
Troubleshooting 30% Node troubleshooting, Pod debugging, journalctl, crictl, kubelet logs, control plane issues, DNS troubleshooting ☐

If any domain is unchecked, go back to that chapter and review before taking the exam.

Troubleshooting is 30% of the exam — if you’re weak here, you cannot pass. Practice it more than anything else.

Must-Know Commands Quick Reference

These are the top 30 commands you MUST have in muscle memory on exam day:

Cluster & Context

k config use-context <cluster>          # Switch context (DO THIS FIRST)
k config current-context                # Verify current context
k get nodes                             # Check node status
k get nodes -o wide                     # Nodes with IPs and versions
k cluster-info                         # Cluster endpoint info

Pods & Workloads

k run nginx --image=nginx $do           # Generate Pod YAML
k create deployment web --image=nginx --replicas=3   # Create Deployment
k scale deployment web --replicas=5     # Scale
k get pods -A                          # All Pods, all namespaces
k get pods -o wide                     # Pods with node placement
k describe pod <name>                  # Pod details and events
k logs <pod> --tail=100                # Pod logs
k exec -it <pod> -- /bin/sh            # Shell into Pod
k delete pod <name> $now               # Force delete immediately

Services & Networking

k expose deployment web --port=80 --type=ClusterIP   # Create Service
k get svc                              # List Services
k get endpoints <svc>                  # Check Service endpoints
k get networkpolicy -n <ns>            # List NetworkPolicies

RBAC

k create role <name> --verb=get,list --resource=pods -n <ns>
k create rolebinding <name> --role=<role> --user=<user> -n <ns>
k create clusterrole <name> --verb=get,list --resource=nodes
k create clusterrolebinding <name> --clusterrole=<cr> --user=<user>
k auth can-i get pods --as <user> -n <ns>   # Test permissions

Storage

k get pv                               # List PersistentVolumes
k get pvc -n <ns>                      # List PersistentVolumeClaims
k get sc                               # List StorageClasses

Troubleshooting

k get events --sort-by=.metadata.creationTimestamp   # Recent events
k top nodes                            # Node resource usage
k top pods -n <ns>                     # Pod resource usage
systemctl status kubelet               # Kubelet status (on node)
journalctl -u kubelet --no-pager -l    # Kubelet logs (on node)
crictl ps                              # Container runtime status
crictl logs <container-id>             # Container logs

etcd

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

ETCDCTL_API=3 etcdctl snapshot restore /opt/backup.db \
  --data-dir=/var/lib/etcd-restored

What’s Next After CKA?

Congratulations on completing this tutorial series! Here’s where to go next:

More Kubernetes Certifications

Complementary Skills

  • Terraform — Infrastructure as Code for provisioning Kubernetes clusters on any cloud
  • AWS / Azure / GCP — Cloud-specific Kubernetes services (EKS, AKS, GKE)
  • Prometheus & Grafana — Monitoring and observability for Kubernetes clusters
  • GitOps (ArgoCD / Flux) — Continuous deployment for Kubernetes
  • Service Mesh (Istio / Linkerd) — Advanced networking, observability, and security

Keep Practicing

  • Killer.sh — Best CKA practice environment (2 free sessions with exam purchase)
  • KodeKloud — Interactive Kubernetes labs
  • Build your own cluster — Set up a multi-node cluster with kubeadm on VMs

You’ve Got This

You’ve put in the work. You’ve gone through every chapter — from cluster architecture to RBAC, from etcd to troubleshooting. You’ve practiced with 16 mock exam questions and learned from the most common mistakes.

Trust your preparation.

On exam day:

  1. Set up your aliases
  2. Use the 3-Pass Strategy
  3. Switch context before every question
  4. Verify everything
  5. Don’t panic if you get stuck — flag it and move on

Take a deep breath and go pass that exam. You’re ready.

Good luck! 🎯

← Back to Exam Tips Hub

Updated:

You may also enjoy