LevelUpWith

Explore / Exam Prep for the Kubernetes and Cloud Native Associate (KCNA) / Lesson 1

Lesson 1: The KCNA Exam and Your First kind Cluster

[Exam craft – all four domains] Covers how the KCNA works: an online, proctored, multiple-choice exam of 90 minutes, with two attempts (one free retake) within 12 months of purchase and a certification valid for two years. The level also covers how CNCF's curriculum (published under CC BY 4.0) weights its four domains at 44/28/16/12, makes clear that this course is independent of the Linux Foundation and CNCF, is not endorsed by them and cannot promise a pass, and finishes with a free kind cluster up and running.

Free to read, no account needed. Part of Exam Prep for the Kubernetes and Cloud Native Associate (KCNA).

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

  • Name the four KCNA domains with their weights and the 13 competency headings under them, and state the exam format, duration, attempts and validity
  • Install kind and kubectl, create a cluster with `kind create cluster`, and confirm it with `kubectl cluster-info` and `kubectl get nodes`
  • Explain how exam-style multiple-choice questions work (recognition, contrast and scenario 'best answer') and how to rule out distractors

Welcome: what this course is (and is not)

This course prepares you for the Kubernetes and Cloud Native Associate (KCNA) exam from the Linux Foundation and the Cloud Native Computing Foundation (CNCF). Before any technical content, note three points:

  • Independence: This course is independent of the Linux Foundation and CNCF. Neither organisation has endorsed it.
  • No guarantee: No course can promise you a pass. Your result depends on your own practice.
  • Practice questions: Every quiz question here is original and written in exam style. None of them are real exam questions.

The exam outline comes from CNCF's published KCNA Curriculum, which is released under the CC BY 4.0 licence. CNCF describes cloud native computing as using "an open source software stack to deploy applications as microservices, packaging each part into its own container, and dynamically orchestrating those containers to optimize resource utilization." Kubernetes is the orchestrator at the centre of that stack.

Step 1: Learn the exam format

Write these facts down. They are the logistics you need to plan around:

  1. Delivery: online and proctored. You sit it remotely while a proctor watches.
  2. Question type: multiple choice only. There are no hands-on tasks.
  3. Duration: 90 minutes.
  4. Attempts: two attempts (one free retake). You must schedule and take both within 12 months of purchase.
  5. Validity: the certification is valid for two years.
  6. Prerequisites: none. It is a beginner-level exam.

Step 2: Map the four domains and 13 competencies

The current curriculum applies to exams taken from late November 2025 onward. In that version, Observability moved into Cloud Native Architecture. Study time should follow the weights:

Domain Weight Competencies
Kubernetes Fundamentals 44% Kubernetes Core Concepts, Administration, Scheduling, Containerization
Container Orchestration 28% Networking, Security, Troubleshooting, Storage
Cloud Native Application Delivery 16% Application Delivery, Debugging
Cloud Native Architecture 12% Observability, Cloud Native Ecosystem and Principles, Cloud Native Community and Collaboration

That makes 4 + 4 + 2 + 3 = 13 competencies.

The curriculum gives only these headings. It does not list the topics under each one. When this course decides that, for example, "Networking" includes the Gateway API, that is our reading of the heading, and we will say so when it comes up.

Do this now: note that Kubernetes Fundamentals alone makes up almost half the exam. The first block of levels covers it.

Step 3: Install the tools

You need three things: a container engine, kind (Kubernetes IN Docker) and kubectl (the Kubernetes command-line client). kind runs each Kubernetes "node" as a container on your machine. That gives you a real cluster for free.

  1. Install a container engine. kind works with Docker, Podman or nerdctl. Docker Desktop (Windows/macOS) or Docker Engine (Linux) is the simplest choice. Podman and nerdctl run rootless by default and need extra setup.
  2. Install kind. Use one of these:
    • Windows: winget install Kubernetes.kind or choco install kind
    • macOS: brew install kind
    • Any OS: download a release binary from the kind GitHub releases page
  3. Install kubectl. Follow the guide for your OS on kubernetes.io (Install Tools page). For example:
    • Windows: winget install -e --id Kubernetes.kubectl
    • macOS: brew install kubectl
  4. Verify both tools:
kind version
kubectl version --client

Keep kubectl within one minor version of your cluster. For example, a v1.28 cluster supports kubectl v1.27, v1.28 or v1.29.

Step 4: Create and confirm your first cluster

  1. Create the cluster:
kind create cluster

This pulls a pre-built node image and starts a single-node cluster named kind. It also writes connection details to ~/.kube/config under the context name kind-kind.

  1. Confirm the control plane is reachable:
kubectl cluster-info --context kind-kind

Expected output (your port will differ):

Kubernetes control plane is running at https://127.0.0.1:52341
CoreDNS is running at https://127.0.0.1:52341/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
  1. List the nodes:
kubectl get nodes
NAME                 STATUS   ROLES           AGE   VERSION
kind-control-plane   Ready    control-plane   60s   v1.xx.x

STATUS Ready means the cluster works. What each part of the control plane does comes in later levels.

  1. Useful housekeeping: kind get clusters lists your clusters. kind delete cluster removes the default one. You can recreate it at any time, so experiment freely.

Step 5: Learn how exam-style questions work

KCNA-style multiple-choice questions usually come in three shapes:

  • Recognition: "Which component/project does X?" You need to recall a name exactly.
  • Contrast: "What is the difference between A and B?" or "Which is NOT…?" You need to know where the boundaries between concepts lie.
  • Scenario, best answer: a short situation followed by several options that are partly true. You pick the most correct one.

To rule out distractors, follow these steps:

  1. Read the final sentence first, so you know exactly what is being asked.
  2. Underline qualifiers such as NOT, best, first and most secure.
  3. Eliminate options that are false in general.
  4. Eliminate options that are true but do not answer the question asked.
  5. Between the two that remain, choose the more specific and complete one. Watch for near-miss names, such as a wrong domain name or the wrong tool.

The exam uses official terminology word for word. Learn names exactly as written on kubernetes.io and cncf.io.

What the exam asks about this

The exam does not test logistics such as the 90 minutes or the retake policy. Those facts matter for planning. What this level gives you for the exam is the domain map: knowing which competency a topic belongs to tells you how much weight it carries. The kind cluster is your lab for every concept that follows.

Key takeaways

  • KCNA: online, proctored, multiple choice, 90 minutes, two attempts within 12 months, valid two years.
  • Domains: Kubernetes Fundamentals 44%, Container Orchestration 28%, Cloud Native Application Delivery 16%, Cloud Native Architecture 12%. Together they hold 13 competencies.
  • The curriculum is CNCF's (CC BY 4.0). This course is independent, not endorsed, and promises no pass.
  • kind create cluster → context kind-kind. Verify with kubectl cluster-info and kubectl get nodes.
  • Answer questions by reading the ask first, spotting qualifiers, and eliminating options that are "true but irrelevant".

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

More like this