kcna

Kubernetes and Cloud Native Associate

DevOps / Containers

The Kubernetes and Cloud Native Associate (KCNA) is a pre-professional, multiple-choice certification covering foundational Kubernetes and cloud native concepts. It validates conceptual understanding of the Kubernetes architecture, container orchestration patterns, application delivery practices, and the broader CNCF ecosystem. KCNA is designed as an on-ramp to performance-based certifications such as CKA, CKAD, and CKS.

exam: 60 questions · 90 min

Sign up free — practice 5 questions on this cert without a card.

Kubernetes fundamentalsCloud native ecosystemMultiple-choice90 min examNo prerequisites$250 USDIncludes one free retake

Difficulty

Easy

Avg study time

30-60h

3-6 weeks typical for candidates with no prior Kubernetes exposure; faster for experienced engineers

Pass rate

Not published

CNCF / Linux Foundation does not publish a pass rate. The exam package includes one free retake, suggesting a non-trivial fail rate but not punishingly so for a multiple-choice format.

Market demand

Low (stepping stone)

KCNA is rarely listed as a hiring requirement on its own. It is best understood as a credential of conceptual K8s literacy and the entry point of the Kubestronaut path - employers value the downstream CKA / CKAD / CKS far more than KCNA in isolation.

Exam Domain Breakdown

Kubernetes Fundamentals44%
Container Orchestration28%
Cloud Native Application Delivery16%
Cloud Native Architecture12%

Difficulty by Topic

Kubernetes core objects (Pod, Deployment, Service, ConfigMap, Secret)
Know the YAML shape, the relationships (Deployment -> ReplicaSet -> Pod, Service -> Pod selector), and what each object's purpose is. Multiple-choice means you need to recognize correct answers, not write YAML from scratch.
Control plane vs node components
API server, etcd, scheduler, controller-manager on the control plane; kubelet, kube-proxy, container runtime on nodes. Know which component does what when something fails.
Container fundamentals (images, layers, registries, runtimes)
Container vs image, OCI image spec, image layers and caching, registries (Docker Hub, Quay, ECR/GCR/ACR), runtimes (containerd, CRI-O, Docker).
Scheduling: nodeSelector, affinity, taints/tolerations, resource requests/limits
How the scheduler picks a node, how to influence placement, the difference between requests (scheduler input) and limits (kernel cgroup enforcement).
Networking: Service types, kube-proxy modes, CNI, NetworkPolicy basics
ClusterIP / NodePort / LoadBalancer / ExternalName, what kube-proxy does (iptables/IPVS), the role of CNI plugins (Calico, Cilium, Flannel), default-deny NetworkPolicy patterns.
Storage: volumes, PV, PVC, StorageClass, CSI
Static vs dynamic provisioning, access modes (ReadWriteOnce / ReadOnlyMany / ReadWriteMany), CSI as the standardized plugin interface.
Observability: the four golden signals, metrics/logs/traces, OpenTelemetry, Prometheus
Latency / traffic / errors / saturation. Know which CNCF project addresses which pillar - Prometheus (metrics), Fluentd / Fluent Bit (logs), Jaeger / OpenTelemetry (traces).
Application delivery: Helm, Kustomize, GitOps (Argo CD / Flux)
Helm charts vs raw manifests, Kustomize overlays, GitOps as a continuous-reconciliation pattern, the role of CI/CD vs the cluster's native reconciliation loop.
Cloud native principles (12-factor, microservices, immutable infrastructure)
12-factor app methodology, why microservices and how they trade complexity for autonomy, immutable infrastructure as a deployment pattern.
CNCF landscape and graduated projects
Know the graduated/incubating/sandbox tiers and which projects sit where (graduated examples: Kubernetes, Prometheus, Envoy, etcd, Linkerd, Helm, Jaeger, Fluentd; incubating examples: OpenTelemetry, Tekton; sandbox examples: K3s). Surprisingly, several questions test landscape recognition rather than deep technical knowledge.

Exam Tips

1

KCNA is conceptual, not hands-on. You will not run kubectl in this exam - the questions test that you understand what kubectl, the API server, the scheduler, and the various objects do. Studying for KCNA the way you would study for CKA (drilling kubectl on a live cluster) is overkill and misallocates time. Read the docs and the curriculum bullets thoroughly instead.

2

Kubernetes Fundamentals is 44% of the exam - by far the largest domain. If your background is non-Kubernetes (e.g. you came from VMs or PaaS), spend the bulk of your study time here: pods, deployments, services, configmaps, secrets, namespaces, the controller pattern, the role of etcd. Everything else builds on these primitives.

3

Cloud Native Architecture (12%) is the surprise domain. It tests recognition of the CNCF landscape - which projects are graduated, what each one is for, and the broader cloud-native principles (12-factor, immutable infra, GitOps). Most candidates underprepare here because it sounds vague. Skim the CNCF Landscape (landscape.cncf.io) and read the graduated-project list at least once.

4

Multiple-choice format means distractors matter. Many questions list four similar-sounding answer choices (e.g. four different Service types, four different probe types). The trap is moving fast and clicking the first plausible option. Read every choice before answering - the test writers are good at making the second-best answer look right.

5

Networking is consistently the hardest 28%-domain topic for first-timers. Memorize the four Service types and what each one creates: ClusterIP (cluster-internal virtual IP), NodePort (opens a port on every node), LoadBalancer (provisions a cloud LB), ExternalName (DNS CNAME, no proxying). Know that kube-proxy is what makes ClusterIP work, and that NetworkPolicy is enforced by the CNI plugin (not by the API server).

6

Storage questions hinge on two things: access modes and provisioning. Access modes - ReadWriteOnce / ReadOnlyMany / ReadWriteMany / ReadWriteOncePod - and which storage backends support which (block storage = RWO, file storage like NFS = RWX). Provisioning - static (admin pre-creates PV) vs dynamic (StorageClass triggers creation when a PVC binds).

7

Observability questions love the four golden signals (latency, traffic, errors, saturation) and the three pillars (metrics, logs, traces). Know which CNCF project owns which pillar: Prometheus (metrics), Fluentd / Fluent Bit (logs), Jaeger / OpenTelemetry (traces). OpenTelemetry is increasingly the unified API for all three - this is the modern shape of the answer.

8

GitOps comes up under Application Delivery. Argo CD and Flux are the two big graduated tools - know that GitOps means 'the desired cluster state lives in git and a controller continuously reconciles toward it', not just 'we use git to store YAML'. The reconciliation loop is the load-bearing concept.

9

Manage the clock loosely. 90 minutes for a multiple-choice exam (estimated 60 questions based on community reports) is roughly 90 seconds per question - generous. Don't agonize over single questions; flag and come back. If a question is asking about a CNCF project you've never heard of, the answer is usually the one that names a well-known project (Prometheus, Envoy, Linkerd, Helm) over a niche one.

10

The free retake is a real safety net - use it as one. If you fail by a small margin on attempt 1, treat the gap analysis as the study plan for attempt 2. CNCF deliberately offers the retake because KCNA is positioned as a learning credential, not a gatekeeping one.

Study Resources

Who It's Best Suited For

Engineers new to Kubernetes

Developers, sysadmins, and cloud engineers who have read about Kubernetes but have not yet operated a cluster. KCNA validates conceptual literacy without forcing you to commit to the steeper CKA / CKAD performance-based path immediately.

Career changers entering cloud native

Professionals transitioning into platform engineering, DevOps, or SRE roles from adjacent fields (system administration, traditional dev, ops). Multiple-choice format and no prerequisites make it a low-friction entry point.

Engineers pursuing the Kubestronaut path

KCNA is one of the five CNCF certifications required for Kubestronaut status (KCNA, KCSA, CKA, CKAD, CKS, all simultaneously active). It is the easiest of the five and the natural starting point for the path.

Non-engineering roles in cloud-native organizations

Product managers, technical program managers, technical writers, and pre-sales engineers at companies whose product runs on Kubernetes. KCNA establishes shared vocabulary without requiring hands-on operator skills.

Certification Path