Skip to content

Kubernetes and Cloud Native Associate (KCNA)

Exam Overview

The Kubernetes and Cloud Native Associate (KCNA) is an entry-level certification that demonstrates a candidate's foundational knowledge of Kubernetes and the broader cloud native ecosystem. This certification is ideal for anyone beginning their cloud native journey, including students, developers, operations staff, and managers who want to understand the cloud native landscape.

Exam Details: - Exam Code: KCNA - Duration: 90 minutes - Number of Questions: 60 multiple choice questions - Passing Score: 75% - Cost: $250 USD (includes one free retake) - Delivery: Online proctored via PSI - Validity: 3 years - Prerequisites: None - Format: Multiple choice only - no hands-on component

Important: This is a knowledge-based exam. Unlike CKA/CKS, there are no hands-on tasks. Focus on understanding concepts, terminology, and the relationships between cloud native technologies.

Exam Domains

Domain 1: Kubernetes Fundamentals (46%)

This is the largest domain by far. Nearly half the exam tests your understanding of core Kubernetes concepts.

  • Kubernetes architecture and components
  • The Kubernetes API and API resources
  • Containers and container orchestration
  • Kubernetes objects (Pods, Deployments, Services, etc.)
  • Kubernetes networking basics
  • Kubernetes storage concepts
  • Scheduling and workload management
  • Configuration and secrets management

Key Concepts: - Control plane components: API server, etcd, scheduler, controller manager - Worker node components: kubelet, kube-proxy, container runtime - Pod lifecycle and states - Deployment strategies (rolling update, recreate) - Service types (ClusterIP, NodePort, LoadBalancer, ExternalName) - Namespaces and resource scoping - Labels, selectors, and annotations - ConfigMaps and Secrets - Persistent Volumes (PV) and Persistent Volume Claims (PVC)

Domain 2: Container Orchestration (22%)

  • Container runtime fundamentals (Docker, containerd, CRI-O)
  • Container image building and management
  • Container networking and storage
  • Orchestration benefits and patterns
  • Kubernetes as an orchestration platform
  • Comparing orchestration platforms

Key Concepts: - OCI (Open Container Initiative) standards - Container images and registries - Container lifecycle management - Why orchestration is needed (scaling, healing, discovery) - Kubernetes vs other orchestrators (Docker Swarm, Nomad) - Declarative vs imperative management

Domain 3: Cloud Native Architecture (16%)

  • Cloud native application design principles
  • Microservices architecture
  • Serverless computing concepts
  • 12-factor application methodology
  • Cloud native patterns and anti-patterns
  • Autoscaling concepts

Key Concepts: - 12-factor app methodology - Microservices vs monolithic architecture - Loosely coupled systems - Stateless application design - Service discovery patterns - API gateway patterns - Sidecar and ambassador patterns - Circuit breaker pattern - Horizontal vs vertical scaling

Domain 4: Cloud Native Observability (8%)

  • Observability pillars (metrics, logs, traces)
  • Prometheus and Grafana
  • Monitoring Kubernetes clusters
  • Logging architectures
  • Distributed tracing concepts
  • OpenTelemetry

Key Concepts: - Three pillars: metrics, logs, traces - Prometheus metrics collection and PromQL basics - Grafana for visualization - Jaeger and Zipkin for distributed tracing - Fluentd/Fluent Bit for log aggregation - OpenTelemetry as a unified observability framework - Kubernetes-native monitoring (metrics-server, kube-state-metrics)

Domain 5: Cloud Native Application Delivery (8%)

  • GitOps principles and practices
  • CI/CD pipeline concepts
  • Infrastructure as Code (IaC)
  • Helm package management
  • Kubernetes deployment strategies
  • Argo CD and Flux

Key Concepts: - GitOps workflow (Git as single source of truth) - CI/CD pipeline stages (build, test, deploy) - Helm charts, repositories, and releases - Kustomize for configuration management - Blue-green deployments - Canary deployments - Rolling updates - Argo CD for GitOps delivery - Flux for GitOps delivery

CNCF Landscape Overview

What is the CNCF?

The Cloud Native Computing Foundation (CNCF) is a vendor-neutral organization that hosts and promotes cloud native open-source projects. Understanding the CNCF ecosystem is important for the KCNA exam.

CNCF Project Maturity Levels

  • Graduated - Mature, widely adopted projects (Kubernetes, Prometheus, Envoy, CoreDNS, containerd, Fluentd, Helm, etc.)
  • Incubating - Growing projects with increasing adoption (Argo, Falco, gRPC, Jaeger, Linkerd, OpenTelemetry, etc.)
  • Sandbox - Early-stage projects in experimental phase

Key CNCF Projects to Know

Category Projects
Orchestration Kubernetes
Service Mesh Istio, Linkerd, Envoy
Monitoring Prometheus, Grafana, Thanos
Logging Fluentd, Fluent Bit
Tracing Jaeger, OpenTelemetry
CI/CD Argo, Flux, Tekton
Package Management Helm
Container Runtime containerd, CRI-O
Networking CoreDNS, Cilium, Calico
Security Falco, OPA, cert-manager
Storage Rook, Longhorn

Core Kubernetes Architecture

Control Plane Components

  • kube-apiserver - Central management entity, all communication goes through it
  • etcd - Distributed key-value store for all cluster data
  • kube-scheduler - Assigns pods to nodes based on resource requirements and constraints
  • kube-controller-manager - Runs controller loops (Deployment, ReplicaSet, Node, etc.)
  • cloud-controller-manager - Integrates with cloud provider APIs

Worker Node Components

  • kubelet - Agent on each node, ensures containers are running in pods
  • kube-proxy - Network proxy on each node, implements Service networking
  • Container runtime - Software that runs containers (containerd, CRI-O)

Add-ons

  • CoreDNS - Cluster DNS for service discovery
  • Dashboard - Web-based UI for Kubernetes
  • Metrics Server - Resource metrics collection
  • CNI plugins - Network implementation (Calico, Cilium, Flannel)

Kubernetes Objects Quick Reference

Workload Resources

  • Pod - Smallest deployable unit, one or more containers
  • Deployment - Manages ReplicaSets, declarative updates for Pods
  • ReplicaSet - Ensures a specified number of pod replicas are running
  • StatefulSet - For stateful applications with persistent storage and stable identities
  • DaemonSet - Ensures a pod runs on all (or selected) nodes
  • Job - Runs a task to completion
  • CronJob - Runs Jobs on a schedule

Networking Resources

  • Service - Stable network endpoint for a set of pods
  • Ingress - HTTP/HTTPS routing to services
  • NetworkPolicy - Pod-level network access control

Configuration Resources

  • ConfigMap - Non-sensitive configuration data
  • Secret - Sensitive data (passwords, tokens, keys)

Storage Resources

  • PersistentVolume (PV) - Cluster-level storage resource
  • PersistentVolumeClaim (PVC) - Request for storage by a pod
  • StorageClass - Defines provisioner and parameters for dynamic provisioning

Study Strategy

Week 1: Kubernetes Fundamentals - Study control plane and worker node architecture - Learn core Kubernetes objects (Pods, Deployments, Services) - Understand namespaces, labels, and selectors - Watch introductory Kubernetes videos

Week 2: Container Orchestration and Cloud Native Architecture - Study container fundamentals (images, registries, runtimes) - Learn cloud native design principles and 12-factor apps - Understand microservices patterns - Study the CNCF landscape

Week 3: Observability and Application Delivery - Study observability pillars (metrics, logs, traces) - Learn Prometheus, Grafana, and OpenTelemetry basics - Understand GitOps, CI/CD, and Helm - Study deployment strategies

Week 4: Review and Practice - Take practice exams and identify weak areas - Review all domains with focus on weak spots - Re-read key documentation pages - Final practice exam under timed conditions

Study Tips for MCQ Format

  1. Focus on understanding why rather than memorizing how
  2. Know the purpose of each Kubernetes component
  3. Understand when to use each resource type
  4. Learn the CNCF project categories and key projects
  5. Read the official Kubernetes documentation concepts section
  6. Take multiple practice exams to get comfortable with the question style

Common Exam Topics

Frequently Tested Areas

  • Kubernetes architecture and component responsibilities
  • Service types and when to use each
  • Deployment vs StatefulSet vs DaemonSet use cases
  • Container runtime interface (CRI) and OCI standards
  • 12-factor app principles
  • Observability pillars and tools
  • GitOps principles
  • CNCF project purposes and categories
  • Helm concepts (charts, releases, repositories)

Exam Tips

  1. Read carefully - Some questions test subtle differences between concepts
  2. Eliminate wrong answers - Usually 2 answers are clearly incorrect
  3. Think conceptually - This exam tests understanding, not implementation details
  4. Time management - 90 minutes for 60 questions = 90 seconds per question
  5. CNCF focus - Know which projects solve which problems
  6. No hands-on - You do not need to memorize kubectl commands

Study Resources

Official Resources

  1. Linux Foundation - KCNA Course - Official preparation course
  2. KodeKloud KCNA Course - Beginner-friendly with visual explanations
  3. A Cloud Guru KCNA Path - Good conceptual coverage
  4. FreeCodeCamp Kubernetes Course (YouTube) - Free comprehensive intro

Practice Exams

  1. Linux Foundation Practice Exam - Official practice test
  2. KodeKloud Practice Tests - Good question bank
  3. Whizlabs KCNA - Affordable practice exams

Free Learning Resources

Good luck with your KCNA certification!

Remember: The KCNA is a foundational exam that tests breadth of knowledge across the cloud native ecosystem. You do not need deep hands-on experience, but you do need to understand the concepts, terminology, and how different technologies relate to each other. Focus on the Kubernetes Fundamentals domain (46%) as it carries the most weight, but do not neglect the smaller domains - they are easier to master and provide quick points.