KCNA course and practice exam: Kubernetes and Cloud Native Associate

This KCNA course has 27 video lessons and 65 graded labs, and its KCNA practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Kubernetes fundamentals, orchestration, delivery and architecture

Prepares you for KCNA: Kubernetes fundamentals, container orchestration, cloud native application delivery and cloud native architecture.

Beginner · 2 hours · 27 lessons · 65 labs

KCNA exam guide

The KCNA exam (Kubernetes and Cloud Native Associate, by CNCF / The Linux Foundation): 90 minutes; questions: 60 multiple-choice questions; pass mark: 75%; cost: USD 250 (includes two exam attempts and 12 months to schedule).

  • Format: Online, proctored, multiple-choice
  • Duration: 90 minutes
  • Questions: 60 multiple-choice questions
  • Pass mark: 75%
  • Cost: USD 250 (includes two exam attempts and 12 months to schedule)
  • Valid for: 2 years; passing CKA or CKAD automatically renews KCNA (CARE program)
  • Delivery: Online, proctored (PSI)
  • Prerequisites: None

Exam domains and weights

  • Kubernetes Fundamentals: 44%
  • Container Orchestration: 28%
  • Cloud Native Application Delivery: 16%
  • Cloud Native Architecture: 12%

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 KCNA sample questions with answers: free to read, no account needed.

Common questions

How long is the KCNA exam?

The KCNA exam lasts 90 minutes.

How many questions are on the KCNA exam?

60 multiple-choice questions.

What is the KCNA passing score?

The pass mark is 75%.

How much does the KCNA exam cost?

USD 250 (includes two exam attempts and 12 months to schedule).

Is there a free KCNA practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: KCNA exam page (Linux Foundation Education) (CNCF / The Linux Foundation), checked 2026-10-03.

Who it is for

Beginner level.

For anyone starting out with Kubernetes, or working alongside teams that use it, who wants a first certificate in it: new engineers, testers, support staff and managers.

What you don't need yet:

What helps:

No prerequisites. You can start here.

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

What this exam proves, and what it doesn't

KCNA is an online, proctored, multiple-choice exam: passing shows you know the cloud native and Kubernetes basics. It doesn't test hands-on skill or replace running clusters; our graded labs have you use kubectl on a simulated cluster.

Exam objectives this course teaches

Kubernetes and Cloud Native Associate (KCNA)

Labs

65 labs, 65 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Start Here

  1. One Command, Six Programs (2 labs): You can trace a Deployment from kubectl to running containers, name the component behind each event, and explain desired state and the control loop.
  2. Sixty Questions, Ninety Minutes (3 labs): You can plan KCNA pacing from the published facts, run three passes through the paper and cross out wrong options with four named moves.

Kubernetes Fundamentals

  1. Pin It, Lint It, Prove It: Images And Runtimes (2 labs): You can explain what a container and an OCI image are, lint a Dockerfile, read the container runtime off a node, and say how tags, digests and pull policy decide what runs.
  2. Who Owns The Symptom: Control Plane And Nodes (2 labs): You can name every control plane and node component, say how each is run, and match an on-call symptom to the component that owns it.
  3. Same Name, Wrong Namespace: Objects, Namespaces And Labels (2 labs): You can describe any object as API version, kind, metadata, spec and status, tell namespaced kinds from cluster-wide ones, generate and apply a manifest, and select objects by label.
  4. Five Jobs, Five Workloads (2 labs): You can describe the pod and pick Deployment, StatefulSet, DaemonSet, Job or CronJob from a description, run a DaemonSet and a StatefulSet and explain their pods and claims, and run a Job by hand from a CronJob.
  5. A Name That Outlives Its Pods: Services And DNS (2 labs): You can expose pods behind a Service, choose ClusterIP, NodePort, LoadBalancer, ExternalName or headless, resolve Service names across namespaces and fix a Service with no endpoints.
  6. Pending All Saturday: How The Scheduler Places Pods (2 labs): You can explain filtering, scoring and binding, size requests to fit a node, read a FailedScheduling event and reserve a node with a taint, a toleration and a selector.
  7. Wrong Cluster, Wrong Version: Contexts, Upgrades And Skew (2 labs): You can read a kubeconfig, switch context and default namespace safely, order a cluster upgrade and check component versions against the version skew policy.
  8. Not The Admin Certificate: RBAC And ServiceAccounts (2 labs): You can describe authentication, authorization and admission, grant a ServiceAccount exactly the access it needs with a Role and RoleBinding, prove it with auth can-i and explain how pod tokens work.
  9. Fundamentals Sprint: Four Tickets Before The Doors Open (4 labs): You can triage and fix one fault from each fundamentals objective in a single cluster and score yourself by objective on eight timed questions.

Container Orchestration

  1. Who May Call Payments: Pod Networking And Policy (2 labs): You can describe the Kubernetes network model and the CNI plugin that implements it, isolate pods with a default-deny NetworkPolicy, open one path by label and port, and say what a service mesh adds.
  2. Not As Root, Not In Plain Sight: Pod Security And Secrets (2 labs): You can name the three Pod Security Standards and enforce one on a namespace, write a security context that passes restricted, handle Secrets knowing they are only encoded, and match supply-chain controls to their risks.
  3. The Status Tells You Where To Look: Troubleshooting Pods (2 labs): You can map Pending, ImagePullBackOff, CreateContainerConfigError, CrashLoopBackOff and restart loops to the command that explains each, and fix a crash loop, a missing ConfigMap and a wrong liveness probe.
  4. Bookings That Survive The Pod: Volumes And Claims (2 labs): You can choose between ephemeral and persistent volumes, predict which PersistentVolume a claim binds, provision storage through a StorageClass and explain access modes, reclaim policies and CSI.
  5. Six Times The Traffic: Autoscaling Pods And Nodes (2 labs): You can choose between the horizontal, vertical and cluster autoscalers, predict the horizontal autoscaler from its formula, tolerance and scale-down window, and run autoscaling/v2 autoscalers on a cluster, including one whose target shows unknown.
  6. Orchestration Sprint: Four Fixes, No Walls Removed (4 labs): You can triage and fix one networking, security, troubleshooting and storage fault in one cluster without weakening a safeguard, and score yourself by objective on eight timed questions.

Cloud Native Application Delivery

  1. Two Versions Of The Truth: GitOps, Helm And Kustomize (2 labs): You can explain CI, push and pull delivery and the four GitOps principles, render environments from a Kustomize base and overlays, compare Helm and Kustomize, and find drift between git and the cluster.
  2. Always A Way Back: Rolling, Blue/Green And Canary (2 labs): You can choose between recreate, rolling update, blue/green and canary, predict a rollout from maxSurge and maxUnavailable, roll back with one command and size a canary by pod count.
  3. Running, Green And Still Broken: Debugging Applications (2 labs): You can debug an application that never crashed: find a failing readiness probe from events and endpoints, read sidecar logs, test configuration, DNS and connectivity from inside the pod, and add a debugging container with kubectl debug.
  4. Delivery Sprint: Friday At Five (4 labs): You can follow a release from a Kustomize overlay to a rollout, spot a readiness failure that stops it, roll back in seconds, explain why the real fix belongs in git, and score yourself by objective on eight timed questions.

Cloud Native Architecture

  1. The Image Nobody Tested: Cloud Native Principles (3 labs): You can define cloud native as the CNCF does, apply twelve-factor configuration to run one image in two environments, weigh microservices against a monolith, and name serverless, immutable infrastructure and declarative APIs in a scenario.
  2. Slow, Or Broken? Metrics, Logs And Traces (3 labs): You can match a question to metrics, logs, traces or events, make a file-only app's logs readable with a sidecar, compute a request rate, error ratio and percentile as Prometheus does, find the slow span in a trace, and name how observability serves cost management.
  3. Who Decides What Ships: The CNCF And Its Community (2 labs): You can describe how the CNCF is governed, place projects at sandbox, incubating or graduated, route a decision to the TOC, a SIG, a working group or a KEP, apply the deprecation policy to migrate a manifest off a removed beta API, and name the open standards and roles of the cloud native community.
  4. Architecture Sprint: The Refunds Review (3 labs): You can review a Deployment against cloud native principles, fix a moving tag, baked-in configuration, missing requests and a single replica on the cluster, name what the manifest cannot show about observability and API versions, and score yourself by objective on eight timed questions.

Mock And Review

  1. Forty Four Of Sixty: The Full Mock, And How To Read It (2 labs): You can sit a full mock under exam conditions, judge how much one score really says, review a result by domain, objective and time, label each miss by its cause, and turn the review into a replay plan.
  2. The Festival, End To End: Final Review (3 labs): You can tell apart the pairs KCNA candidates most often confuse, predict a cluster's endpoints, QoS class and permissions across domains, and prepare for exam day and the next certification.

Certification courses