LevelUpWith

Explore / Exam Prep for the Certified Kubernetes Application Developer (CKAD) / Lesson 1

Lesson 1: The CKAD Exam and Your kind Practice Cluster

[Exam craft] Learn the exam facts and set up a free kind cluster for practice: CKAD is 15 to 20 command-line tasks in 2 hours on Kubernetes v1.37, the pass mark is 66%, one retake and two Killer.sh simulator sessions are included, and the certification is valid for two years. The course follows CNCF's CKAD curriculum (CC BY 4.0), is independent of and not endorsed by the Linux Foundation or CNCF, promises no pass, and its multiple-choice checks are original scenarios, not real exam questions, that do not replace hands-on practice.

Free to read, no account needed. Part of Exam Prep for the Certified Kubernetes Application Developer (CKAD).

By the end of this level you'll be able to

  • State the CKAD format, duration, pass mark, retake, simulator and validity rules, and name the five curriculum domains with their weightings
  • Create a kind cluster, then confirm it works with kubectl cluster-info and kubectl get nodes
  • Explain why the course's multiple-choice checks support hands-on terminal practice but cannot replace it

Welcome to CKAD Prep

The Certified Kubernetes Application Developer (CKAD) exam checks whether you can do the work in a terminal. It does not test whether you can recall facts. You already know containers, Linux and basic Kubernetes. This course builds the missing skill, which is building, running and fixing applications on a cluster while the clock is running.

In this level you will:

  1. Learn the exam rules and the curriculum weightings.
  2. Build a free practice cluster with kind.
  3. Learn how to use this course's quizzes.

Task 1: Know the Exam Facts

The Linux Foundation lists these facts for CKAD. Commit them to memory before you plan your study time.

  • Format: online, proctored and performance-based. You get 15 to 20 command-line tasks on live clusters. There is no multiple choice.
  • Duration: 2 hours.
  • Kubernetes version: v1.37. The exam moves to each new minor release within roughly 4 to 8 weeks of its release.
  • Pass mark: 66%.
  • Retake: one retake is included. You have 12 months to schedule and take the exam.
  • Simulator: two Killer.sh simulator sessions are included. Each gives 36 hours of access once you activate it.
  • Validity: the certification lasts 2 years.

DO: Work out your time budget now. 120 minutes across about 17 tasks gives you roughly 7 minutes per task. Some tasks are worth more points than others, so don't let one hard task use up time that would earn points elsewhere.

Task 2: Learn the Five Curriculum Domains

This course follows CNCF's CKAD curriculum for Kubernetes v1.37, which is published under CC BY 4.0. The five domains and their weightings are:

Domain Weight
Application Design and Build 20%
Application Deployment 20%
Application Observability and Maintenance 15%
Application Environment, Configuration and Security 25%
Services and Networking 20%

The curriculum describes "the Knowledge, Skills and Abilities that a Certified Kubernetes Application Developer (CKAD) can be expected to demonstrate." The largest domain is Application Environment, Configuration and Security at 25%. It covers ConfigMaps, Secrets, ServiceAccounts, requests, limits and quotas, SecurityContexts, and resources that extend Kubernetes (CRDs and Operators). The smallest domain is Observability and Maintenance at 15%.

DO: Spend study time in proportion to these weights. Even so, don't skip any domain. Every task you can't attempt costs points.

Task 3: Create Your kind Practice Cluster

kind ("Kubernetes in Docker") runs Kubernetes nodes as containers on your own machine. It is free, quick to create and quick to delete. That makes it well suited to repeated practice.

Prerequisites: a container runtime such as Docker, plus kubectl.

  1. Install kind. The current release is v0.33.0. Use brew install kind (macOS) or choco install kind (Windows), or download a binary from the kind releases page.

  2. Create the cluster. kind v0.33.0 uses Kubernetes 1.37.0 as its default node image. The kind release notes say to pin the image by its @sha256 digest to guarantee an image built for that release:

    kind create cluster --name ckad \
      --image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5
    

    A plain kind create cluster also works. It creates a cluster named kind with the context kind-kind. Contexts are always named kind-<cluster-name>, so the command above gives you kind-ckad.

  3. Confirm that the control plane is reachable:

    kubectl cluster-info --context kind-ckad
    

    Expected output (your port will differ):

    Kubernetes control plane is running at https://127.0.0.1:41235
    CoreDNS is running at https://127.0.0.1:41235/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
    
  4. Confirm that the node is Ready:

    kubectl get nodes
    
    NAME                 STATUS   ROLES           AGE   VERSION
    ckad-control-plane   Ready    control-plane   60s   v1.37.0
    

    If STATUS shows NotReady, wait 30 seconds and run the command again. Check that the VERSION column reads v1.37.0 so that you practise on the exam's version.

  5. Reset whenever you need to:

    kind delete cluster --name ckad
    

    This command does not fail if the cluster is already gone, so you can run it safely at any time. Build a fresh cluster whenever an experiment leaves things in a mess.

Task 4: Use the Quizzes the Right Way

Each level ends with multiple-choice checks. Keep these points in mind:

  • They are original scenarios written for this course. They are not real exam questions.
  • They check whether you understand which command or manifest solves a problem, and why.
  • They cannot replace hands-on practice. The real exam scores the cluster state you produce. Picking the right answer from four options is a different skill from typing a correct manifest from memory under time pressure, with typos, indentation mistakes and the wrong namespace as real risks.

DO: After every quiz, carry out the level's timed practice task on your kind cluster. Then use your two Killer.sh sessions close to exam day.

One more point: this course is independent of the Linux Foundation and CNCF and is not endorsed by either. No course can promise you a pass. Your terminal practice is what gets you there.

Timed Practice Task (5 minutes)

Create a kind cluster named practice on Kubernetes v1.37. Confirm that its control plane responds and that its node is Ready. Then delete it.

Solution:

kind create cluster --name practice --image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5
kubectl cluster-info --context kind-practice
kubectl get nodes          # practice-control-plane  Ready  v1.37.0
kind delete cluster --name practice

What the Exam Asks About This

The exam itself won't ask about kind or exam rules. These facts decide how you prepare:

  • The 66% pass mark and 2-hour limit mean you need speed and must choose which tasks to do first.
  • The weightings tell you where most of the points are.
  • A working local cluster is where you build the habits the exam rewards.

Key Takeaways

  • CKAD: 15 to 20 terminal tasks, 2 hours, Kubernetes v1.37, 66% to pass, one retake, two Killer.sh sessions, valid for 2 years.
  • Domains: Design and Build 20%, Deployment 20%, Observability and Maintenance 15%, Environment, Configuration and Security 25%, Services and Networking 20%.
  • kind create cluster --name X creates the context kind-X. Verify the cluster with kubectl cluster-info and kubectl get nodes.
  • The quizzes are original scenarios that support hands-on practice. They do not replace it.

A 6-question knowledge check follows this lesson in the app, free and without an account.

More like this