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:
- No previous Kubernetes or container experience
- No cluster of your own: labs use a simulated one in your browser
- No cloud account needed
- No Python needed: labs use kubectl commands
What helps:
- Typing short commands: each lab gives you a script to run and extend
No prerequisites. You can start here.
Take next:
- Certified Kubernetes Administrator (CKA) Exam Prep — Intermediate
- Certified Kubernetes Application Developer (CKAD) Exam Prep — Intermediate
- Kubernetes: Production-Grade Container Orchestration — Advanced
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)
- Kubernetes Fundamentals (44% of the exam): Kubernetes Core Concepts; Administration; Scheduling; Containerization
- Container Orchestration (28% of the exam): Networking; Security; Troubleshooting; Storage
- Cloud Native Application Delivery (16% of the exam): Application Delivery; Debugging
- Cloud Native Architecture (12% of the exam): Observability; Cloud Native Ecosystem and Principles; Cloud Native Community and Collaboration
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.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.