know.

CookbookStudy and examsNo. 11

Kubernetes certification notesdomain by domain, with typed-command drills

Recipe No. 11Study and exams

For
A platform engineer preparing for the Certified Kubernetes Administrator exam
You bring
The current CKA curriculum, a practice cluster you can break, the Kubernetes documentation, and the Markdown notes you keep while you work through labs
You get
A set of CKA notes with a document per exam domain, a finding per task with its kubectl commands, typed-answer drills that make you write each command exactly, and a lab plan
Time
An evening to set up, then fifteen minutes after each lab session for six to eight weeks
Works in
know.sh on the web · your AI assistant, through MCP · a coding assistant with the plugin
Keep it
Private. This one never goes on a public link.

The Certified Kubernetes Administrator exam is hands-on. You get a terminal, a set of clusters and a clock, and the only references you may open are the official documentation pages the candidate handbook lists. Knowing that etcdctl can take a snapshot is not enough; you need the flags, the certificate paths and the order of steps, typed correctly under time pressure. Reading someone else’s cheat sheet does not build that. Doing the labs and writing down what you did does.

This recipe keeps those notes without retyping them. Each domain in the CNCF curriculum is a document; each task is a numbered finding with the commands in a code block and a section on what went wrong the first time. A coding assistant with the know.sh plugin, such as Claude Code, reads the Markdown notes you keep during a lab and files them; you fix them up in the editor. Then your assistant writes typed-answer quizzes where the answer is the command, which must match exactly: the closest thing a notes app can give you to the exam’s terminal.

The practice cluster, the labs and the typing stay outside know.sh. Your notes do not go into the exam with you.

What you will use

Your AI assistant
Claude Code with the know.sh plugin reads your lab notes from disk and files each exercise as a finding; it, or any assistant you connect, writes the quizzes.
The editor
Where you check each filed command against your terminal history, settle on one form for each, and mark the hard tasks Key.
Research document
One document per curriculum domain, from Cluster architecture, installation and configuration to Troubleshooting.
Finding
One finding per task, with the commands in a code block and the documentation page as a source link; tasks you broke filed as Problem.
Quiz
Typed-answer quizzes, where you type the command and it must match exactly.
Campaigns
A lab plan made by Claude Code: a set per domain, a step per lab, and which labs must come first.
Look up
Look up with ⌘K during practice, to find the finding with the command you half remember.
Star and Focus
Put Troubleshooting in Focus for the last week before the exam.

Method

  1. 1

    Connect Claude Code and build the shelf

    Install the plugin with claude plugin marketplace add knowsh-curtis/know-cli and claude plugin install know-dev@know-sh, start claude, and run /mcp to sign in. Then ask it to read the current CKA curriculum on the CNCF’s GitHub and set up the library: a shelf called CKA with your exam date and the Kubernetes version the curriculum names, and a document per domain, titled as the curriculum titles them: Cluster architecture, installation and configuration, Workloads and scheduling, Services and networking, Storage, Troubleshooting.

    Ask for a sixth, Exam habits, for things that cut across domains: switching to the right context or host at the start of every task, kubectl explain when you forget a field, and generating YAML with --dry-run=client -o yaml instead of writing it from memory.

  2. 2

    Let it file each lab session

    Keep notes in a Markdown file while you work through a lab, as you probably do now. At the end of the session, point Claude Code at the file and the domain: “Read labs/etcd.md and add a finding per exercise to my Cluster architecture document in know.sh, with the commands exactly as I ran them.” Six weeks of labs become a hundred findings without a line retyped.

    Tell it the shape once: title each finding as a task you might be asked to do, “Back up etcd with a snapshot”; the commands in a code block; what each flag does; how you checked it worked; What went wrong on the first attempt; the documentation page as a source link. Ask it not to tidy the commands; a wrong flag you corrected is worth keeping.

  3. 3

    Fix the findings up in the editor

    Open the domain and press Edit. Check each filed command against your shell history, not against the assistant’s memory; a flag it “corrected” may be wrong for your cluster’s version. Choose one form for each command, -A or --all-namespaces, and write it that way everywhere, because the drills in the next step will hold you to it.

    Drag the findings into the order you would do the tasks, mark the ones that took you more than two attempts as Key, and change a finding’s type to Problem where the lab broke something you still do not understand. Every change the assistant made shows in Revisions, so you can see what it touched.

  4. 4

    Drill the commands with typed-answer quizzes

    Ask your assistant for typed answers only: “Using know.sh, make a quiz of eight typed-answer questions from Cluster architecture, installation and configuration on my CKA shelf. Each answer is one command, written exactly as it appears in the finding.” It writes the quiz with know.sh’s quiz tools, and you take it in know.sh or the iOS app: you read the task and type the command.

    The match is exact, character for character. kubectl get pods --all-namespaces is marked wrong when the answer is kubectl get pods -A, even though both work, which is why the previous step matters. A wrong answer cites the finding, so you can see which character you missed.

  5. 5

    Plan the labs as a campaign

    Claude Code can also plan. Ask it to make a campaign called CKA labs with an operation set per domain and an operation per lab, and to add dependencies: “Build a kubeadm cluster” blocks “Upgrade the cluster” and “Back up and restore etcd”. The graph view shows what is waiting on what.

    Mark each operation done as you finish it, and ask Claude Code to link the operation to the findings it filed from that lab. The plan is for you alone; there are no assignees, and campaigns need the planning permissions the Claude Code plugin asks for, which a chat connector does not get.

  6. 6

    Use Look up while you practise, and Focus at the end

    During practice labs, keep know.sh open beside the terminal. ⌘K and “drain” finds the finding with the exact command faster than scrolling. In the last two weeks, stop doing that: practise with only the Kubernetes documentation open, because that is close to what you will have.

    A week before the exam, put Troubleshooting in Focus, and take whatever quizzes Revisit brings back. A quiz you scored under 60 per cent returns in three days; one you scored 80 or more waits three weeks, which may be after the exam, so ask your assistant for a fresh mixed quiz in the final days.

Specimen

QuizzesCluster architecture, installation and configurationQuestion 5 of 8

Type the command that marks node worker-2 unschedulable and evicts its pods, ignoring pods managed by DaemonSets.

Your answerkubectl drain worker-2 --ignore-daemonsets

Right. drain cordons the node first, then evicts; without --ignore-daemonsets it refuses to go on while DaemonSet pods are on the node. Afterwards, kubectl uncordon worker-2 puts it back. See Cluster architecture, installation and configuration, 8.

A typed-answer drill: the answer is the command itself, and it must match the finding character for character.
  1. You

    Read labs/2026-09-21-etcd.md. Add a finding per exercise to my Cluster architecture document in know.sh: the task as the title, the commands in a code block exactly as I ran them, and a “What went wrong” section from my notes. Do not tidy the commands.

  2. Claude Code

    The file has three exercises: a snapshot, a restore and a check of the restored cluster. I will find the document first.

  3. searchFound Cluster architecture, installation and configuration, 11 findings
  4. finding_addAdded “Back up etcd with a snapshot” to Cluster architecture, installation and configuration, 12
  5. finding_addAdded “Restore etcd from a snapshot” to Cluster architecture, installation and configuration, 13
  6. finding_addAdded “Check the cluster after an etcd restore” to Cluster architecture, installation and configuration, 14
  7. Claude Code

    Added findings 12 to 14. Your notes restore to /var/lib/etcd-from-backup but do not say what you changed in the etcd static pod manifest afterwards, so finding 13 ends with that as an open question. Your notes also use etcdctl snapshot restore; newer etcd releases move restore to etcdutl, so check which your practice cluster has.

Claude Code filing a lab session’s notes as findings, and pointing out the step the notes left out.

Prompts to try

  1. Your assistant, connected to know.sh (Claude, ChatGPT or a local model)

    Using know.sh, make a quiz of eight typed-answer questions from the document “Troubleshooting” on my “CKA” shelf. Each answer is a single command, exactly as written in the finding it cites. Say in the question whether you want short or long flags, and do not ask for anything that needs more than one line.

  2. A coding assistant with the know.sh plugin, such as Claude Code

    Using know.sh, make a campaign called “CKA labs” with an operation set for each document on my CKA shelf and an operation for each lab listed in its overview. Add a blocks dependency from “Build a kubeadm cluster” to every lab that needs a cluster of my own. Set all operations to draft.

  3. A coding assistant with the know.sh plugin, such as Claude Code

    Read every finding in my Troubleshooting document on know.sh. For each, check that the commands in its code block are valid for the Kubernetes version in the shelf line, using the kubectl on this machine (`kubectl --help` and `kubectl explain`), and list any that are wrong or deprecated. Do not change the findings.

Variations

  • The same shelf works for the CKAD or CKS: new domains, the same finding shape. Keep the CKA documents; much of Workloads and scheduling carries over.
  • After the exam, move the findings you still use into your team’s incident runbooks and let the rest stand as a record of what you learned.
  • For a cloud certification with a multiple-choice exam, keep the commands but ask your assistant for multiple-choice and select-all quizzes on the service limits and trade-offs instead.

Where it falls short

  • Typed answers must match exactly. There is no fuzzy matching, so two correct ways to write a command will mark one of them wrong unless your findings pick one.
  • know.sh does not run commands. Every command in your notes needs a real cluster to prove it works, and a quiz answer can be word-perfect and still wrong for your cluster’s version.
  • Quizzes are one-line typed answers at most. There is no way to drill a multi-step task or a YAML manifest as a single question.
  • There is no file import into know.sh. Lab notes arrive through an assistant that can read them, such as Claude Code on your own machine; a chat assistant needs the file attached in its own window.

A note on exam content and your employer’s rules

Indexed under

KubernetesCommand drillsCKA examTyped-answer quizzesLab notesExam domains