LevelUpWith

Explore / Cloud & Compute

Exam Prep for the Certified Kubernetes Administrator (CKA)

Go from knowing Kubernetes objects to building, upgrading, securing, networking and repairing Kubernetes v1.37 clusters at the terminal, under exam time pressure. Practise every item in the CNCF CKA curriculum with kind, kubeadm VMs, Helm, Kustomize, Gateway API and timed tasks.

Read lesson 1 free →Try 10 practice questions free →

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed.

Photographic 3D course artwork for Exam Prep for the Certified Kubernetes Administrator (CKA)

Expert · 48 levels · 4 free · Created Nov 2026 · Professionally curated by levelupwith.com

What's inside

  1. Level 1: The CKA Exam: Format, Rules and This CourseFree
    [Exam craft] Learners get the CKA facts that shape their preparation: 2 hours of hands-on terminal tasks, a 66% pass mark, one retake, two exam simulator sessions and a certificate valid for two years. The level also covers the CNCF curriculum (v1.37, CC BY 4.0) and its five weighted sections, and makes clear that this course is independent of and not endorsed by the Linux Foundation or CNCF, that the knowledge checks are original scenarios, not real exam questions, that they do not replace hands-on practice, and that no pass is guaranteed.
    • State the exam duration, pass mark, retake allowance, simulator sessions and certification validity
    • Map the five curriculum sections and their weightings (Troubleshooting 30%, Cluster Architecture, Installation and Configuration 25%, Services and Networking 20%, Workloads and Scheduling 15%, Storage 10%) to a personal study plan
    • Explain why practising tasks in a terminal, not recalling facts, is how the exam is passed
  2. Level 2: Speed Habits: kind Labs, Contexts and Imperative YAMLFree
    [Exam craft] Learners build a multi-node kind practice cluster and the habits that save time in every task: switching contexts and namespaces, imperative kubectl commands, generating YAML with --dry-run=client -o yaml, finding fields with kubectl explain, and searching the allowed docs at kubernetes.io/docs, helm.sh/docs and gateway-api.sigs.k8s.io.
    • Create a multi-node kind cluster and switch between contexts and namespaces with kubectl config use-context and set-context --current --namespace
    • Generate Pod, Deployment and Service manifests with kubectl create/run --dry-run=client -o yaml, then edit and apply them
    • Use kubectl explain --recursive and the allowed documentation to find a field you don't know in under a minute
  3. Level 3: RBAC I: Roles, RoleBindings and kubectl auth can-i
    [Cluster Architecture, Installation and Configuration — Manage role based access control (RBAC)] Learners grant namespaced permissions with Role and RoleBinding objects and test them with kubectl auth can-i and impersonation.
    • Create a Role and RoleBinding imperatively with kubectl create role/rolebinding, using the right verbs, resources and apiGroups
    • Check a user's or group's permissions with kubectl auth can-i --as and --list
    • Fix a RoleBinding that points to the wrong subject or namespace
  4. Level 4: RBAC II: ClusterRoles, ServiceAccounts and Scope
    [Cluster Architecture, Installation and Configuration — Manage role based access control (RBAC)] Learners extend RBAC to cluster scope with ClusterRole and ClusterRoleBinding, bind permissions to ServiceAccounts used by Pods, and know when to bind a ClusterRole with a namespaced RoleBinding.
    • Create a ServiceAccount, bind a ClusterRole to it, and run a Pod that uses it
    • Choose between a RoleBinding to a ClusterRole and a ClusterRoleBinding for a given scope requirement
    • Check ServiceAccount permissions with kubectl auth can-i --as=system:serviceaccount:<ns>:<name>
  5. Level 5: Prepare Underlying Infrastructure for a Cluster
    [Cluster Architecture, Installation and Configuration — Prepare underlying infrastructure for installing a Kubernetes cluster] On two or three VMs, learners prepare each node for kubeadm: they install and configure containerd with the systemd cgroup driver, load the required kernel modules and sysctls, handle swap, open the required ports, and install matching kubeadm, kubelet and kubectl packages from pkgs.k8s.io.
    • Configure containerd, kernel modules (overlay, br_netfilter) and net.ipv4.ip_forward so that the kubeadm preflight checks pass
    • Install and pin kubeadm, kubelet and kubectl at a chosen minor version from the Kubernetes package repository
    • List the control plane and worker node ports that must be reachable
  6. Level 6: Create a Cluster with kubeadm init and join
    [Cluster Architecture, Installation and Configuration — Create and manage Kubernetes clusters using kubeadm] Learners bootstrap a control plane with kubeadm init (pod network CIDR, advertise address), set up kubeconfig, install a CNI plugin, and join worker nodes with a bootstrap token.
    • Run kubeadm init with the right flags and copy admin.conf into a user kubeconfig
    • Install a CNI plugin and confirm that nodes become Ready
    • Create a new join command with kubeadm token create --print-join-command and join a worker node
  7. Level 7: Manage kubeadm Clusters: Static Pods, Certs, Config
    [Cluster Architecture, Installation and Configuration — Create and manage Kubernetes clusters using kubeadm] Learners manage a running kubeadm cluster: they edit the static Pod manifests in /etc/kubernetes/manifests, inspect the kubeadm-config and kubelet configuration, and check and renew control plane certificates.
    • Change a kube-apiserver or kube-controller-manager flag safely through its static Pod manifest and confirm that it restarts
    • Check and renew certificates with kubeadm certs check-expiration and kubeadm certs renew
    • Find where a kubeadm cluster stores its kubeconfig files, PKI and kubelet configuration
  8. Level 8: Lifecycle I: Upgrade the Control Plane with kubeadm
    [Cluster Architecture, Installation and Configuration — Manage the lifecycle of Kubernetes clusters] Learners upgrade a kubeadm control plane node by one minor version: they change the package repository version, upgrade kubeadm, run kubeadm upgrade plan and apply, then upgrade kubelet and kubectl.
    • Follow the supported upgrade order and the version skew rules between components
    • Run kubeadm upgrade plan and kubeadm upgrade apply v1.x.y on the first control plane node
    • Drain the node, upgrade and restart the kubelet, and uncordon it
  9. Level 9: Lifecycle II: Upgrade Workers and Node Maintenance
    [Cluster Architecture, Installation and Configuration — Manage the lifecycle of Kubernetes clusters] Learners upgrade worker nodes with kubeadm upgrade node, and use cordon, drain and uncordon for any maintenance, including drains blocked by DaemonSets, emptyDir data or PodDisruptionBudgets.
    • Upgrade a worker node end to end with kubeadm upgrade node and a kubelet upgrade
    • Drain a node with --ignore-daemonsets and --delete-emptydir-data and explain what each flag allows
    • Diagnose a drain that a PodDisruptionBudget blocks and resolve it
  10. Level 10: Lifecycle III: Back Up and Restore etcd
    [Cluster Architecture, Installation and Configuration — Manage the lifecycle of Kubernetes clusters] Learners take an etcd snapshot with etcdctl and the correct endpoint and TLS certificate flags, check it, and restore it into a new data directory that the etcd static Pod then uses.
    • Find the etcd endpoint, CA, cert and key paths in the etcd static Pod manifest
    • Save and check a snapshot with etcdctl snapshot save and etcdutl snapshot status
    • Restore a snapshot to a new --data-dir and point the etcd manifest's hostPath at it
  11. Level 11: Implement a Highly-Available Control Plane
    [Cluster Architecture, Installation and Configuration — Implement and configure a highly-available control plane] Learners compare stacked and external etcd topologies, put a load balancer endpoint in front of the API servers, and add extra control plane nodes with kubeadm init --control-plane-endpoint and --upload-certs.
    • Choose between stacked and external etcd and explain etcd quorum for 3 versus 5 members
    • Bootstrap a control plane behind a load balancer endpoint and join a second control plane node with --control-plane --certificate-key
    • Check control plane health across nodes with kubectl get nodes and etcdctl member list
  12. Level 12: Use Helm and Kustomize to Install Cluster Components
    [Cluster Architecture, Installation and Configuration — Use Helm and Kustomize to install cluster components] Learners install and configure cluster components with Helm (repo add, search, show values, install and upgrade with --set or -f, list, rollback, uninstall) and Kustomize (kustomization.yaml, resources, patches, namePrefix, kubectl apply -k).
    • Install a chart into a chosen namespace with overridden values and upgrade or roll back the release
    • Build a Kustomize overlay that patches a base and apply it with kubectl apply -k
    • Preview the rendered output with helm template and kubectl kustomize before applying it
  13. Level 13: Extension Interfaces: CNI, CSI and CRI
    [Cluster Architecture, Installation and Configuration — Understand extension interfaces (CNI, CSI, CRI, etc.)] Learners learn what each extension interface plugs into: CNI config in /etc/cni/net.d, CSI drivers and CSIDriver objects, and the CRI between the kubelet and containerd, which they inspect directly with crictl.
    • Find a node's CNI configuration and plugin binaries and say which component calls them
    • List the CSI drivers in a cluster and relate them to the provisioner field of a StorageClass
    • Use crictl ps, pods, images and logs to inspect containers through the CRI endpoint
  14. Level 14: Understand CRDs, Install and Configure Operators
    [Cluster Architecture, Installation and Configuration — Understand CRDs, install and configure operators] Learners read and apply a CustomResourceDefinition, create and query custom resources, and install an operator (with Helm or manifests) that reconciles them, then configure it by changing its custom resources.
    • Inspect a CRD's group, versions, scope and schema with kubectl get crd and kubectl explain
    • Create, list and edit custom resources by their kind and short names
    • Install an operator, confirm that its controller is running, and configure a managed component through a custom resource
  15. Level 15: Deployments, Rolling Updates and Rollbacks
    [Workloads and Scheduling — Understand application deployments and how to perform rolling update and rollbacks] Learners create and scale Deployments, tune the RollingUpdate strategy with maxSurge and maxUnavailable, change images, and manage revisions with kubectl rollout status, history, undo, pause and resume.
    • Update a Deployment's image with kubectl set image and watch the rollout with kubectl rollout status
    • Roll back to a specific revision with kubectl rollout undo --to-revision
    • Choose between the RollingUpdate and Recreate strategies and set maxSurge/maxUnavailable for a given availability requirement
  16. Level 16: Use ConfigMaps and Secrets to Configure Applications
    [Workloads and Scheduling — Use ConfigMaps and Secrets to configure applications] Learners create ConfigMaps and Secrets imperatively from literals and files, and use them in Pods as environment variables (env, envFrom) and as mounted volumes, including how updates reach a running Pod.
    • Create ConfigMaps and generic or TLS Secrets with kubectl create --from-literal and --from-file
    • Inject values with valueFrom/envFrom and mount them as files with items and subPath
    • Decode a Secret's value with base64 and explain why mounted values update while environment variables do not
  17. Level 17: Configure Workload Autoscaling
    [Workloads and Scheduling — Configure workload autoscaling] Learners install metrics-server, set CPU and memory requests, and set up a HorizontalPodAutoscaler with kubectl autoscale and autoscaling/v2 manifests, including scaling behaviour, then watch it react to load.
    • Create an HPA with kubectl autoscale and write the matching autoscaling/v2 manifest
    • Explain why an HPA shows <unknown> targets and fix it with metrics-server and resource requests
    • Tune min/max replicas and scale-down behaviour, and check what the HPA does with kubectl describe hpa
  18. Level 18: Self-Healing Primitives for Robust Deployments
    [Workloads and Scheduling — Understand the primitives used to create robust, self-healing, application deployments] Learners combine the primitives that keep applications running: ReplicaSets, DaemonSets and StatefulSets, restartPolicy, liveness, readiness and startup probes, and PodDisruptionBudgets.
    • Add liveness, readiness and startup probes to a container and predict how Kubernetes reacts when each one fails
    • Choose a Deployment, DaemonSet or StatefulSet for a given workload requirement
    • Create a PodDisruptionBudget that keeps a minimum number of replicas available during voluntary disruptions
  19. Level 19: Pod Admission: Requests, Limits, LimitRange, Quota
    [Workloads and Scheduling — Configure Pod admission and scheduling (limits, node affinity, etc.)] Learners set container resource requests and limits, and control Pod admission per namespace with LimitRange defaults and ResourceQuota caps, including how QoS classes and admission rejections follow from them.
    • Set requests and limits imperatively and in YAML, and identify the resulting QoS class (Guaranteed, Burstable or BestEffort)
    • Create a LimitRange that applies default requests and limits, and a ResourceQuota that caps a namespace
    • Diagnose a Pod rejected at admission because of a quota or limit and fix the manifest
  20. Level 20: Scheduling: Node Affinity, Taints and Tolerations
    [Workloads and Scheduling — Configure Pod admission and scheduling (limits, node affinity, etc.)] Learners control where Pods land with nodeSelector, required and preferred node affinity, Pod affinity and anti-affinity, and taints with matching tolerations, and debug Pods left Pending by scheduling constraints.
    • Label nodes and write requiredDuringSchedulingIgnoredDuringExecution and preferred node affinity rules
    • Taint a node with NoSchedule or NoExecute and add a toleration so that only chosen Pods run there
    • Read FailedScheduling events in kubectl describe pod to explain and fix a Pending Pod
  21. Level 21: Understand Connectivity Between Pods
    [Services and Networking] Serves 'Understand connectivity between Pods': you learn the Kubernetes network model (every Pod gets its own IP and Pods reach each other across nodes without NAT), see the CNI plugin set it up, and prove it with commands from a throwaway Pod.
    • Find Pod IPs, node Pod CIDRs and the installed CNI plugin with kubectl get pods -o wide, kubectl get nodes -o jsonpath and /etc/cni/net.d on a node
    • Test Pod-to-Pod connectivity on the same node and across nodes with a temporary debugging Pod (kubectl run --rm -it) using wget, curl and nslookup
    • Tell whether a connectivity problem lies in the Pod, the node or the CNI layer
  22. Level 22: Network Policies: Default Deny and Ingress Rules
    [Services and Networking] Serves 'Define and enforce Network Policies': you write NetworkPolicy objects that isolate Pods with default-deny and then allow chosen ingress by podSelector, and you check that a CNI which enforces policy is installed.
    • Install a CNI that enforces NetworkPolicy in kind (the default kindnet CNI is replaced for this lab) and confirm that policies take effect
    • Write a default-deny ingress policy for a namespace, then allow traffic from specific Pods by label on specific ports
    • Check a policy's effect with kubectl describe networkpolicy and connection tests from allowed and blocked Pods
  23. Level 23: Network Policies: Namespaces, Egress and DNS
    [Services and Networking] Serves 'Define and enforce Network Policies' in harder cases: namespaceSelector, the AND and OR logic of combined selectors, ipBlock, egress rules and the DNS exception, practised as a timed multi-policy task.
    • Tell apart a single from entry with namespaceSelector and podSelector together (AND) from two separate from entries (OR), and choose the right YAML for a scenario
    • Write default-deny egress policies that still allow DNS to CoreDNS on UDP and TCP port 53 and allow named destinations
    • Use the kubernetes.io/metadata.name namespace label and ipBlock with except to allow or block traffic
  24. Level 24: ClusterIP Services, Endpoints and EndpointSlices
    [Services and Networking] Serves 'Use ClusterIP, NodePort, LoadBalancer service types and endpoints' (ClusterIP and endpoints): you expose workloads with kubectl expose, check that selectors match through EndpointSlices, and use headless Services and Services that have no selector.
    • Create ClusterIP Services imperatively with kubectl expose and kubectl create service, setting port, targetPort and named ports correctly
    • Check Service backends with kubectl get endpointslices -l kubernetes.io/service-name=<svc> and fix a selector or port that does not match
    • Build a headless Service (clusterIP: None) and a Service without a selector with manually defined EndpointSlices, and explain how DNS answers for each
  25. Level 25: NodePort and LoadBalancer Service Types
    [Services and Networking] Serves 'Use ClusterIP, NodePort, LoadBalancer service types and endpoints' (external types): you publish applications on a NodePort and through a LoadBalancer in kind, and learn how kube-proxy and externalTrafficPolicy affect reachability.
    • Expose a Deployment as a NodePort Service with a fixed nodePort in the 30000-32767 range and reach it via a node IP
    • Provision a LoadBalancer Service in kind with a local load-balancer implementation and explain why EXTERNAL-IP stays <pending> without one
    • Compare externalTrafficPolicy Cluster and Local and predict how source IP preservation and node reachability change
  26. Level 26: Gateway API: GatewayClass, Gateway and HTTPRoute
    [Services and Networking] Serves 'Use the Gateway API to manage Ingress traffic': you install the Gateway API CRDs and a conformant implementation, then route traffic through a GatewayClass, a Gateway and an HTTPRoute, using gateway-api.sigs.k8s.io as reference.
    • Install the Gateway API standard-channel CRDs and a Gateway controller, then check the GatewayClass is Accepted
    • Create a Gateway with an HTTP listener and an HTTPRoute that attaches by parentRefs and sends a hostname to a backend Service
    • Read Gateway and HTTPRoute status conditions (Accepted, Programmed, ResolvedRefs) to fix a route that does not attach
  27. Level 27: Gateway API: Matching, Splitting and TLS
    [Services and Networking] Serves 'Use the Gateway API to manage Ingress traffic' in more depth: path and header matching, weighted traffic splitting for canaries, request redirects, HTTPS listeners with TLS Secrets, and allowedRoutes across namespaces.
    • Write HTTPRoute rules with PathPrefix, Exact and header matches and weighted backendRefs for a canary split
    • Terminate TLS on a Gateway listener using a kubernetes.io/tls Secret, and add an HTTP-to-HTTPS RequestRedirect filter
    • Use listener allowedRoutes and a ReferenceGrant so routes and backends can work across namespaces
  28. Level 28: Ingress Controllers and Ingress Resources
    [Services and Networking] Serves 'Know how to use Ingress controllers and Ingress resources': you deploy an Ingress controller, write Ingress resources with ingressClassName, pathType, host rules and TLS, and learn that the community Ingress NGINX project was retired in March 2026 with no further releases or security fixes.
    • Create Ingress resources imperatively with kubectl create ingress --rule and --class, then refine pathType (Prefix, Exact) and the default backend in YAML
    • Explain the IngressClass and ingressClassName link and why an Ingress with no matching controller is never served
    • Add TLS to an Ingress from a Secret, and say when to choose an Ingress over a Gateway API route for a given scenario
  29. Level 29: Understand and Use CoreDNS
    [Services and Networking] Serves 'Understand and use CoreDNS': you resolve Service and Pod DNS names, read and edit the CoreDNS Corefile in its ConfigMap, and change Pod DNS behaviour with dnsPolicy and dnsConfig.
    • Resolve <svc>.<ns>.svc.cluster.local, short names and headless-Service Pod records from a test Pod, and explain the search domains in /etc/resolv.conf
    • Edit the coredns ConfigMap in kube-system (for example, add a stub domain with forward) and roll the CoreDNS Deployment so the change applies
    • Set dnsPolicy and dnsConfig on a Pod and check the effect with nslookup
  30. Level 30: Volume Types for Pods
    [Storage] Serves 'Configure volume types, access modes and reclaim policies' (volume types): you mount emptyDir, hostPath, configMap, secret and projected volumes, and learn which volume types last beyond the life of a Pod and which do not.
    • Share data between containers in a Pod with an emptyDir volume, including medium: Memory and sizeLimit
    • Mount hostPath, configMap, secret and projected volumes with the correct volumeMounts, subPath and readOnly settings
    • Explain how each volume's data behaves when a container restarts, the Pod is deleted or the Pod moves to another node
  31. Level 31: PersistentVolumes, Access Modes and Reclaim Policies
    [Storage] Serves 'Configure volume types, access modes and reclaim policies': you create PersistentVolumes by hand and choose ReadWriteOnce, ReadOnlyMany, ReadWriteMany or ReadWriteOncePod, along with the Retain or Delete persistentVolumeReclaimPolicy.
    • Write a static PersistentVolume manifest with capacity, accessModes, persistentVolumeReclaimPolicy, storageClassName and volumeMode, using the kubernetes.io/docs storage pages
    • Choose the correct access mode for a scenario and explain how ReadWriteOncePod differs from ReadWriteOnce
    • Predict a PV's phase (Available, Bound, Released, Failed) after its claim is deleted under each reclaim policy
  32. Level 32: Manage PersistentVolumeClaims and Binding
    [Storage] Serves 'Manage persistent volumes and persistent volume claims': you write PVCs that bind to the PV you mean them to, mount them in Pods and Deployments, and fix claims stuck in Pending.
    • Create a PVC whose storageClassName, accessModes, size and optional selector or volumeName bind it to a chosen static PV
    • Mount a PVC in a Pod and show that data is still there after the Pod is deleted and recreated
    • Find why a PVC is Pending (size, access mode, class mismatch or no PV) from kubectl describe pvc events, and fix it
  33. Level 33: StorageClasses and Dynamic Volume Provisioning
    [Storage] Serves 'Implement storage classes and dynamic volume provisioning': you create StorageClasses for a CSI or local provisioner, set the default class, and use volumeBindingMode WaitForFirstConsumer so PVs are created on demand.
    • Inspect kind's default StorageClass and create a new StorageClass with provisioner, parameters, reclaimPolicy and volumeBindingMode
    • Change the cluster default StorageClass with the storageclass.kubernetes.io/is-default-class annotation, and predict what a PVC with no class receives
    • Explain why a WaitForFirstConsumer PVC stays Pending until a Pod uses it, and check the dynamically provisioned PV it gets
  34. Level 34: PV and PVC Lifecycle: Expand, Retain, Reuse
    [Storage] Serves 'Manage persistent volumes and persistent volume claims' on day 2: you expand claims with allowVolumeExpansion, change the reclaim policy of a live PV, and bring a Released PV back into use, all in a timed storage task.
    • Expand a PVC by editing spec.resources.requests.storage on a StorageClass that allows expansion, and check the new capacity
    • Patch a dynamically provisioned PV from Delete to Retain with kubectl patch so its data survives the claim being deleted
    • Make a Released PV Available again by clearing its claimRef, and bind a new PVC to it
  35. Level 35: Read Pod Status, Events and Container Logs
    [Troubleshooting] Serves 'Manage and evaluate container output streams': you read a failing Pod through its status, events and stdout and stderr with kubectl logs, and diagnose CrashLoopBackOff, ImagePullBackOff, Error and OOMKilled.
    • Use kubectl logs with -c, --previous, --all-containers, -f, --since, --tail and -l selectors to find the failing output quickly
    • Read lastState, exit codes and restart counts with kubectl describe and jsonpath to tell an application crash from an OOMKilled container
    • Save log output and event lists to files exactly as a task asks, with kubectl get events --sort-by and output redirection
  36. Level 36: Container Output Streams on the Node and Sidecars
    [Troubleshooting] Serves 'Manage and evaluate container output streams' at node level: you find container logs under /var/log/pods with crictl when kubectl cannot help, and stream file-based logs through a sidecar container.
    • Use crictl ps -a, crictl logs and crictl inspect on a node to read the output of containers that have exited or are static
    • Find and read Pod log files under /var/log/pods and /var/log/containers, and explain how the kubelet rotates them
    • Add a native sidecar (an init container with restartPolicy: Always) that streams an application's log file to stdout for kubectl logs
  37. Level 37: Monitor Cluster and Application Resource Usage
    [Troubleshooting] Serves 'Monitor cluster and application resource usage': you install metrics-server (the metrics.k8s.io API is Stable in Kubernetes v1.37) and use kubectl top to find the nodes, Pods and containers using the most CPU and memory.
    • Install metrics-server in kind (including the kubelet TLS flag that lab clusters need) and check that kubectl top nodes returns data
    • Use kubectl top pods with -A, --containers, -l and --sort-by=cpu|memory, and write the top consumer's name to a file as a task asks
    • Compare live usage with requests and limits and with node allocatable to explain evictions and scheduling failures
  38. Level 38: Troubleshoot NotReady Nodes and the kubelet
    [Troubleshooting] Serves 'Troubleshoot clusters and nodes': you bring a NotReady worker node back by checking the kubelet and container runtime with systemctl and journalctl and fixing a broken kubelet configuration, on kubeadm VMs.
    • Read node conditions and kubelet status with kubectl describe node, systemctl status kubelet and journalctl -u kubelet
    • Fix common kubelet faults (service stopped or disabled, wrong config.yaml path or flags, containerd down, wrong CRI socket), then restart and check the node is Ready
    • Tell a node-level fault from a cluster-level fault in a few commands
  39. Level 39: Node Pressure, Cordon, Drain and Node Recovery
    [Troubleshooting] Serves 'Troubleshoot clusters and nodes' for degraded nodes: you diagnose MemoryPressure, DiskPressure and PIDPressure, evictions and node taints, and safely cordon, drain and uncordon a node, in a timed node-repair task.
    • Find node pressure conditions and the node.kubernetes.io taints they add automatically, and free the resource causing the pressure
    • Cordon, drain (--ignore-daemonsets, --delete-emptydir-data) and uncordon a node, and fix a drain blocked by a PodDisruptionBudget
    • Explain how evicted Pods are recorded and clean them up after the node recovers
  40. Level 40: Troubleshoot etcd, Certificates and Kubeconfig Faults
    [Troubleshooting – Troubleshoot cluster components] Learners diagnose and repair control plane failures caused by a broken etcd static Pod, expired or mismatched kubeadm certificates, and wrong kubeconfig files, working from crictl, journalctl and kubeadm certs check-expiration output, and finish with a timed fix-the-cluster task and its solution.
    • Find why etcd or kube-apiserver will not start by reading crictl ps -a, crictl logs and the static Pod manifests in /etc/kubernetes/manifests
    • Check and renew control plane certificates with kubeadm certs check-expiration and kubeadm certs renew, then restart the affected components
    • Repair a broken admin.conf, kubelet.conf or controller-manager kubeconfig (wrong server, wrong CA, wrong context) and confirm with kubectl get nodes
  41. Level 41: Diagnose OOMKilled, Evictions and Node Pressure
    [Troubleshooting – Monitor cluster and application resource usage] Learners trace application failures caused by resource exhaustion (OOMKilled containers, CPU throttling, kubelet evictions under MemoryPressure or DiskPressure, Pending Pods with Insufficient cpu or memory) and fix them by right-sizing requests and limits under time pressure.
    • Read lastState.terminated.reason, exit code 137 and restart counts in kubectl describe pod and kubectl get pod -o jsonpath to confirm an OOMKill
    • Find node pressure conditions and eviction events with kubectl describe node and kubectl get events --field-selector reason=Evicted
    • Fix a Pending or crash-looping workload by changing requests and limits with kubectl set resources and check it reaches Running
  42. Level 42: Manage Container Output Streams with kubectl logs
    [Troubleshooting – Manage and evaluate container output streams] Learners pull and filter stdout and stderr from running, restarted, multi-container and sidecar Pods with kubectl logs, and finish with a timed task that extracts specific log lines into a file.
    • Use kubectl logs with -c, --previous, -f, --tail, --since, --timestamps and --all-containers to get the right stream from the right container
    • Read logs across many Pods with label selectors (-l, --prefix, --max-log-requests) and from Deployments and Jobs by resource name
    • Filter log output with grep and redirect it to a required file path exactly as a task specifies
  43. Level 43: Node-Level Logs: crictl, journalctl and /var/log/pods
    [Troubleshooting – Manage and evaluate container output streams] Learners go below the API server to read container output and component logs on the node itself, for when kubectl cannot reach the API server or the container has already gone, and they use kubectl debug to look inside running workloads.
    • Find containers and read their logs on a node with crictl ps -a, crictl logs and the files under /var/log/pods and /var/log/containers
    • Read kubelet and container runtime logs with journalctl -u kubelet and journalctl -u containerd, using --since and -f
    • Attach an ephemeral debug container with kubectl debug to look inside a distroless or crashing Pod and a node
  44. Level 44: Troubleshoot Services, Selectors and Endpoints
    [Troubleshooting – Troubleshoot services and networking] Learners debug Services that do not route traffic (selector and label mismatches, wrong port or targetPort, unready Pods kept out of endpoints, a missing NodePort) and test each fix from a temporary client Pod in a timed task.
    • Check whether a Service has backends using kubectl get endpointslices -l kubernetes.io/service-name and kubectl describe svc
    • Fix selector, port, targetPort and named-port mistakes with kubectl edit or kubectl patch, and check readiness probes that keep Pods out of endpoints
    • Test connectivity from a throwaway Pod with kubectl run --rm -it and curl or wget against the ClusterIP, the DNS name and the NodePort
  45. Level 45: Troubleshoot DNS Resolution and CoreDNS
    [Troubleshooting – Troubleshoot services and networking] Learners find why Pods cannot resolve Service names (CoreDNS Pods down or scaled to zero, a broken Corefile in the coredns ConfigMap, a wrong kube-dns Service, a bad Pod dnsPolicy or resolv.conf) and restore name resolution against the clock.
    • Test resolution with nslookup or dig from a debug Pod and read the Pod's /etc/resolv.conf to check search domains and nameserver
    • Check CoreDNS health through its Deployment, its logs, the kube-dns Service and its endpoints, then repair a broken Corefile and restart CoreDNS
    • Tell a DNS fault apart from a Service or Network Policy fault by testing the ClusterIP directly and then the DNS name
  46. Level 46: Troubleshoot Pod Networking: CNI, kube-proxy, Policies
    [Troubleshooting – Troubleshoot services and networking] Learners fix cross-node and cross-namespace connectivity failures caused by a missing or broken CNI plugin, a failing kube-proxy, or a Network Policy that blocks too much, including one that denies DNS egress, using a step-by-step isolation method.
    • Find nodes that are NotReady because of a missing CNI and repair the CNI DaemonSet, its Pods and /etc/cni/net.d config
    • Check kube-proxy's DaemonSet, ConfigMap and logs and confirm Service rules are programmed on the node
    • List the Network Policies that select a Pod and add the missing ingress or egress rule (including UDP/TCP 53 to kube-system) so traffic flows again
  47. Level 47: Timed Break-and-Fix Drill: Mixed Troubleshooting
    [Troubleshooting – all five competencies] Learners work through a timed sequence of multi-fault scenarios across nodes, cluster components, resource usage, output streams and services and networking on kind and kubeadm VMs, practising triage order, switching context on every task, and checking each fix before moving on.
    • Use a repeatable triage order (context, nodes, control plane Pods, events, describe, logs, node logs) to find a root cause within a time budget
    • Fix several separate faults in one session, using kubectl config use-context for each task and checking each result
    • Decide when to skip a stuck task, flag it and come back to it, so the whole time budget gets used
  48. Level 48: Timed Mock Exam Timed mock
    [All sections] A 50-question, 75-minute timed mock exam of original multiple-choice scenarios drawn from all five curriculum sections and weighted like the CNCF CKA curriculum (Troubleshooting 30%, Cluster Architecture, Installation and Configuration 25%, Services and Networking 20%, Workloads and Scheduling 15%, Storage 10%), with a 66% pass mark; it does not use real exam questions, does not replace hands-on practice and does not guarantee a pass.
    Free 10 questions from the bank behind this course's timed mock are free to try, no account needed. Read all 10 with their answers →

Access

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Read lesson 1 free →Try 10 practice questions free →

More like this