LevelUpWith

Explore / Cloud & Compute

Exam Prep for the Kubernetes and Cloud Native Associate (KCNA)

Go from never having run a container to sitting the KCNA exam with confidence. Every idea is explained plainly and then shown with short kubectl commands and YAML that run on a free kind cluster, across all four domains and 13 competencies of CNCF's November 2025 curriculum, weighted as the exam is.

Read lesson 1 free →Try 10 practice questions free →

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed.

Photographic 3D cloud-native infrastructure sculpture with a green container and connected servers for KCNA Exam Prep

Expert · 41 levels · 4 free · Created Nov 2026 · Professionally curated by levelupwith.com

What's inside

  1. Level 1: The KCNA Exam and Your First kind ClusterFree
    [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.
    • 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
  2. Level 2: Cluster Architecture and the Control PlaneFree
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Explains in plain terms what container orchestration is and why it is needed, then goes through the control plane components named on kubernetes.io: kube-apiserver, etcd, kube-scheduler, kube-controller-manager and cloud-controller-manager.
    • Describe a cluster as a control plane plus worker nodes and say what problem orchestration solves
    • State the job of each control plane component and identify it among the Pods shown by `kubectl get pods -n kube-system` on kind
    • Explain why etcd is the cluster's single source of truth and why only kube-apiserver talks to it directly
  3. Level 3: Node Components and the Reconciliation Loop
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Covers the components that run on every node (kubelet, kube-proxy and a container runtime) and follows one request from kubectl, through the API server, the scheduler and the controllers, to a running container, so the learner sees desired state and reconciliation at work.
    • State the role of kubelet, kube-proxy and the container runtime on a node
    • Trace the path of a `kubectl create` request through the control plane to a kubelet
    • Explain the difference between desired state and current state, and how controllers reconcile them
  4. Level 4: The Kubernetes API: Objects, Groups and Versions
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Shows that the Kubernetes API underlies everything in a cluster. Topics are object structure (apiVersion, kind, metadata, spec, status), API groups and versions from alpha through beta to stable, and finding your way around with `kubectl api-resources` and `kubectl explain`.
    • Identify the apiVersion, kind, metadata, spec and status fields of any object
    • Tell the core group (v1) apart from named groups such as apps/v1, and explain what alpha, beta and stable (GA) mean
    • Use `kubectl api-resources` and `kubectl explain pod.spec` to find fields without the internet
  5. Level 5: Pods: The Smallest Deployable Unit
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Covers what a Pod is, why it may hold more than one container that shares network and storage, the init and sidecar container patterns, and the Pod lifecycle phases. Learners create and inspect a Pod on kind.
    • Write and apply a minimal Pod manifest, then check it with `kubectl get pod -o wide`
    • Explain why the containers in one Pod share an IP address and can reach each other on localhost
    • Name the Pod phases (Pending, Running, Succeeded, Failed, Unknown) and say when init containers run
  6. Level 6: Namespaces, Labels and Selectors
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Covers dividing a cluster with Namespaces, labelling objects with labels (and annotations, for comparison), and selecting objects with equality-based and set-based selectors, which every controller and Service later depends on.
    • Create a Namespace, set it on a resource, and list resources across namespaces with `-A`
    • Add labels and filter objects with `kubectl get pods -l app=web,tier!=db`
    • Tell labels apart from annotations, and namespaced resources apart from cluster-scoped ones
  7. Level 7: ReplicaSets and Deployments
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Shows how a ReplicaSet uses a label selector to keep a set number of Pods running, and how a Deployment manages ReplicaSets so applications can be scaled, updated and rolled back declaratively.
    • Create a Deployment, scale it with `kubectl scale`, and watch a deleted Pod get replaced
    • Update an image and follow it with `kubectl rollout status`, `rollout history` and `rollout undo`
    • Explain how a Deployment, its ReplicaSets and their Pods are related, and why Deployments are used instead of bare ReplicaSets
  8. Level 8: Services: Stable Access to Changing Pods
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Covers why Pod IP addresses are not stable and how a Service uses selectors and EndpointSlices to give Pods a stable virtual IP address. Compares the ClusterIP, NodePort, LoadBalancer and ExternalName types.
    • Expose a Deployment with `kubectl expose` and reach it from a test Pod and with `kubectl port-forward`
    • Choose the right Service type for an exam scenario and explain why the others do not fit
    • Check which Pods back a Service with `kubectl get endpointslices`
  9. Level 9: ConfigMaps and Secrets
    [Kubernetes Fundamentals – Kubernetes Core Concepts] Covers separating configuration from container images with ConfigMaps and Secrets, injected as environment variables or mounted files. Makes clear that Secret values are only base64-encoded by default, not encrypted, unless encryption at rest is configured.
    • Create a ConfigMap and a Secret with `kubectl create` and use both in a Pod as environment variables and as volumes
    • Decode a Secret value to show that base64 encoding is not encryption
    • Decide whether a ConfigMap or a Secret suits a given piece of configuration
  10. Level 10: kubectl Essentials and kubeconfig
    [Kubernetes Fundamentals – Administration] Covers using kubectl efficiently: command structure, the get, describe, explain, logs and exec commands, output formats (-o yaml, json, wide), and how kubeconfig clusters, users and contexts decide which cluster you are talking to.
    • Use `kubectl config get-contexts` and `use-context`, and say which file kubeconfig lives in by default
    • Get structured output with `-o yaml`, `-o wide` and `--dry-run=client -o yaml`
    • Choose the right kubectl verb for a task described in an exam scenario
  11. Level 11: Declarative Configuration with Manifests
    [Kubernetes Fundamentals – Administration] Compares imperative commands with declarative configuration, where YAML manifests under version control are applied with `kubectl apply`. Covers previewing changes with `kubectl diff`, multi-document files and how apply merges changes.
    • Tell imperative commands, imperative object configuration and declarative `kubectl apply` apart
    • Edit a manifest, preview the change with `kubectl diff -f`, then apply it
    • Explain why declarative configuration is the foundation for the GitOps practices covered later
  12. Level 12: Access Control Basics and Cluster Lifecycle
    [Kubernetes Fundamentals – Administration] Covers the path every API request takes (authentication, then authorization, then admission control), RBAC basics with a Role and RoleBinding, and an outline of the cluster lifecycle: building with kubeadm, upgrading the control plane before the nodes, and the release cadence and support window.
    • Put authentication, authorization and admission in order, and check permissions with `kubectl auth can-i`
    • Create a Role and RoleBinding that grant read-only access to Pods in a single namespace
    • Outline how kubeadm builds and upgrades a cluster, and why the control plane is upgraded before the nodes
  13. Level 13: How the Scheduler Places Pods
    [Kubernetes Fundamentals – Scheduling] Explains how kube-scheduler picks a node for each unscheduled Pod by filtering out unsuitable nodes and scoring the rest, and how nodeSelector and nodeName influence or bypass that choice. Learners use a multi-node kind cluster.
    • Explain the scheduler's filtering and scoring phases and what happens when no node fits
    • Create a multi-node kind cluster and pin a Pod to a labelled node with nodeSelector
    • Read a FailedScheduling event in `kubectl describe pod` and say why the Pod stayed Pending
  14. Level 14: Resource Requests, Limits and QoS
    [Kubernetes Fundamentals – Scheduling] Covers how CPU and memory requests drive scheduling decisions while limits are enforced at runtime, which QoS class follows from each combination (Guaranteed, Burstable, BestEffort), and what OOMKilled and CPU throttling mean.
    • Set requests and limits in millicores (m) and Mi, and predict whether a Pod will schedule
    • Work out a Pod's QoS class from its spec and confirm it with `kubectl get pod -o yaml`
    • Explain what happens when a container goes over its memory limit and what happens when it goes over its CPU limit
  15. Level 15: Taints, Tolerations and Affinity
    [Kubernetes Fundamentals – Scheduling] Contrasts taints and tolerations, which let a node repel Pods, with node affinity, Pod affinity and Pod anti-affinity, which attract Pods to nodes or to each other, including the difference between required and preferred rules.
    • Taint a kind node with NoSchedule and add a toleration that lets a Pod run there
    • Write a node affinity rule using requiredDuringSchedulingIgnoredDuringExecution
    • Choose taints, nodeSelector, affinity or anti-affinity for a given placement scenario
  16. Level 16: Container Images and How They Are Built
    [Kubernetes Fundamentals – Containerization] Explains what a container is compared with a virtual machine, how images are built from a Dockerfile as stacked read-only layers, and why referencing an image by digest is safer than using a mutable tag such as latest.
    • Contrast containers with virtual machines in terms of the kernel, isolation and start-up time
    • Read a simple Dockerfile and say which instructions create layers
    • Explain the difference between an image tag and a digest, and why pinning by digest helps reproducibility
  17. Level 17: Registries and Pulling Images
    [Kubernetes Fundamentals – Containerization] Covers how Kubernetes gets images from public and private container registries: the parts of an image reference, imagePullPolicy, imagePullSecrets, and loading local images into kind with `kind load docker-image`.
    • Break an image reference into registry, repository, tag and digest
    • Predict pull behaviour under the Always, IfNotPresent and Never values of imagePullPolicy
    • Diagnose ErrImagePull and ImagePullBackOff, and fix them with a correct name or an imagePullSecret
  18. Level 18: Container Runtimes, containerd, CRI and OCI
    [Kubernetes Fundamentals – Containerization] Explains how the kubelet talks to a container runtime such as containerd or CRI-O through the Container Runtime Interface (CRI), how low-level runtimes such as runc implement the OCI specifications (runtime, image and distribution), and why the removal of dockershim did not break Docker-built images.
    • Arrange the kubelet, CRI, containerd and runc in order and say what each does
    • Name the three OCI specifications and what each one standardises
    • Run `crictl ps` inside a kind node with `docker exec` to see containers through the CRI
  19. Level 19: The Kubernetes Network Model and CNI
    [Container Orchestration – Networking] Covers the Kubernetes network model, in which every Pod gets its own IP address and Pods reach each other without NAT, and how Container Network Interface (CNI) plugins such as kind's default kindnet, Calico or Cilium put that model into practice.
    • State the main rules of the Kubernetes network model
    • Explain what a CNI plugin does when a Pod is created, and find the CNI plugin running on kind
    • Show Pod-to-Pod connectivity across nodes using Pod IP addresses
  20. Level 20: Service Networking, kube-proxy and DNS
    [Container Orchestration – Networking] Explains how a Service's virtual IP address actually works: kube-proxy programs iptables or IPVS rules, CoreDNS gives Services and Pods DNS names, and headless Services return Pod IP addresses directly. This builds on the Service types covered in Core Concepts.
    • Resolve `my-svc.my-namespace.svc.cluster.local` from a test Pod with nslookup
    • Explain how kube-proxy turns traffic to a ClusterIP into traffic to a backing Pod
    • Explain when a headless Service (clusterIP: None) is the right choice
  21. Level 21: Ingress and the Gateway API
    [Container Orchestration – Networking] Our reading of this heading's scope: you learn how traffic from outside the cluster reaches Services, first through an Ingress resource handled by an Ingress controller, then through the role-based Gateway API resources (GatewayClass, Gateway, HTTPRoute), and why Kubernetes SIG Network now points users to the Gateway API since Ingress NGINX was retired in March 2026.
    • Write an Ingress with host and path rules, then describe how an Ingress controller puts it into effect
    • Map the same routing onto a GatewayClass, a Gateway and an HTTPRoute, and say which role (infrastructure provider, cluster operator or application developer) owns each one
    • Answer scenario questions that ask whether a Service of type LoadBalancer, an Ingress or the Gateway API is the best way to expose an app
  22. Level 22: Network Policies and Service Mesh
    [Container Orchestration – Networking] Our reading of this heading's scope: you learn how NetworkPolicy objects control Pod-to-Pod traffic through label selectors when the CNI plugin enforces them, and what a service mesh such as Istio or Linkerd adds on top: sidecar or sidecarless data planes, mutual TLS, retries and traffic splitting.
    • Apply a default-deny NetworkPolicy and an allow rule on a kind cluster, then test them with a curl Pod
    • Explain that a NetworkPolicy only works if the CNI plugin enforces it, and spot that trap in exam questions
    • Tell apart the control plane and data plane of a service mesh, and name mTLS, observability and traffic management as its main benefits
  23. Level 23: The 4Cs of Cloud Native Security and Image Security
    [Container Orchestration – Security] Our reading of this heading's scope: you learn the 4Cs layered model from kubernetes.io (Cloud, Cluster, Container, Code) and apply it to container images: minimal or distroless base images, vulnerability scanning, signing, pinning images by digest and using trusted registries.
    • Name the 4Cs from the outer layer to the inner one, and place a given control (firewall, RBAC, image scanning, TLS in the app) in the right layer
    • Pin an image by its digest in a Pod spec, and explain why the latest tag is risky
    • Choose the best image-hardening step in an exam-style scenario: scanning, signing, a smaller base image or a private registry
  24. Level 24: RBAC in Depth and Service Accounts
    [Container Orchestration – Security] Our reading of this heading's scope: this builds on the RBAC basics from Administration. You learn Role vs ClusterRole and RoleBinding vs ClusterRoleBinding, the principle of least privilege, and how ServiceAccounts give Pods an identity with short-lived projected tokens.
    • Create a ServiceAccount, Role and RoleBinding, then check them with kubectl auth can-i --as=system:serviceaccount:<ns>:<name>
    • Explain when a ClusterRole should be bound with a RoleBinding rather than a ClusterRoleBinding
    • Explain why automountServiceAccountToken: false and least-privilege Roles shrink the blast radius when a Pod is compromised
  25. Level 25: Pod Security Standards and Admission
    [Container Orchestration – Security] Our reading of this heading's scope: you learn the three Pod Security Standards (Privileged, Baseline, Restricted), how the built-in Pod Security Admission controller applies them with namespace labels in enforce, audit and warn modes, and which securityContext settings make a Pod compliant.
    • Label a namespace with pod-security.kubernetes.io/enforce=restricted and watch a non-compliant Pod get rejected
    • Fix the Pod with runAsNonRoot, allowPrivilegeEscalation: false, dropped capabilities and a seccompProfile
    • Tell apart the enforce, audit and warn modes, and pick the right Standard for a given workload
  26. Level 26: Troubleshooting with Logs, Events and Describe
    [Container Orchestration – Troubleshooting] Our reading of this heading's scope: you learn a repeatable workflow for reading cluster state: kubectl get with -o wide and -o yaml, kubectl describe, kubectl get events sorted by time, and kubectl logs including --previous and -c for multi-container Pods.
    • Read the Status, Conditions and Events sections of kubectl describe pod and say what each one tells you
    • Fetch logs from a crashed container's previous instance and from a named container in a multi-container Pod
    • Choose the right first command for a given symptom in exam-style questions
  27. Level 27: Fixing Failing Pods on kind
    [Container Orchestration – Troubleshooting] Our reading of this heading's scope: you deliberately break Pods on a kind cluster and fix them, working through Pending (unschedulable, insufficient resources), ImagePullBackOff and ErrImagePull, CrashLoopBackOff, OOMKilled and failing readiness or liveness probes.
    • Find the cause behind Pending, ImagePullBackOff, CrashLoopBackOff and OOMKilled from describe output and events
    • Fix each fault by correcting the image name, the resource requests or limits, the command or the probe
    • Explain how a failing readiness probe drops a Pod from Service endpoints while a failing liveness probe restarts the container
  28. Level 28: Volumes and Ephemeral Storage
    [Container Orchestration – Storage] Our reading of this heading's scope: you learn why a container's filesystem is lost when it restarts, and how Pod volumes solve that: emptyDir for scratch space shared between containers, hostPath and its risks, and configMap, secret and projected volumes.
    • Share data between two containers in one Pod through an emptyDir volume, and show that it lasts across container restarts but not across Pod deletion
    • Mount a ConfigMap as files and explain how this differs from injecting it as environment variables
    • Explain why hostPath is discouraged, and spot it as a security and portability problem in exam scenarios
  29. Level 29: PersistentVolumes, PVCs, StorageClasses and CSI
    [Container Orchestration – Storage] Our reading of this heading's scope: you learn persistent storage in Kubernetes: PersistentVolumes and PersistentVolumeClaims, binding, access modes (ReadWriteOnce, ReadOnlyMany, ReadWriteMany, ReadWriteOncePod), reclaim policies, dynamic provisioning with StorageClasses, and the Container Storage Interface (CSI) as the open standard for storage drivers.
    • Create a PVC against kind's default StorageClass, mount it in a Pod and watch the PV get provisioned and bound
    • Choose the right access mode and reclaim policy (Retain or Delete) for a given scenario
    • Explain what CSI standardises, and how it compares with CNI and CRI
  30. Level 30: CI/CD and Rollout Strategies
    [Cloud Native Application Delivery – Application Delivery] Our reading of this heading's scope: you learn how continuous integration and continuous delivery pipelines build, test and ship container images, and how Deployments roll out changes: RollingUpdate with maxSurge and maxUnavailable, Recreate, and the blue/green and canary patterns built with labels, Services or traffic splitting.
    • Trace a commit through a CI/CD pipeline from build and test to image push and deploy, naming the artefact at each stage
    • Run a rolling update with kubectl set image and kubectl rollout status, and tune maxSurge and maxUnavailable
    • Pick rolling, recreate, blue/green or canary for a scenario, and justify the choice by its risk, cost and rollback speed
  31. Level 31: Packaging Applications with Helm
    [Cloud Native Application Delivery – Application Delivery] Our reading of this heading's scope: you learn Helm, the CNCF package manager for Kubernetes: charts, templates, values files, repositories, releases and revisions, and the commands for installing, upgrading and rolling back an application.
    • Install a public chart on kind with helm install, override values with --set and -f, then list the release
    • Upgrade a release, inspect its revisions with helm history and roll back with helm rollback
    • Describe how a chart is laid out (Chart.yaml, values.yaml, templates/) and what problem templating solves
  32. Level 32: Configuration Management with Kustomize
    [Cloud Native Application Delivery – Application Delivery] Our reading of this heading's scope: you learn Kustomize, the template-free way to customise YAML that is built into kubectl: bases and overlays, patches, common labels, and generators for ConfigMaps and Secrets, all applied with kubectl apply -k.
    • Build a base and two overlays (dev and prod) that change the replica count and image tag, then render them with kubectl kustomize
    • Apply an overlay with kubectl apply -k and check the result
    • Tell Kustomize's overlay approach apart from Helm's templating approach, and pick the better tool for a scenario
  33. Level 33: GitOps with Argo CD and Flux
    [Cloud Native Application Delivery – Application Delivery] Our reading of this heading's scope: you learn GitOps (Git as the single source of truth, declarative desired state, pull-based reconciliation, drift detection) and how the CNCF projects Argo CD and Flux put it into practice, compared with push-based CI/CD.
    • Explain the core GitOps principles and why a pull-based agent inside the cluster differs from a pipeline pushing with kubectl
    • Set up an Argo CD Application or a Flux GitRepository plus Kustomization that syncs a Git path to a kind cluster, then watch it correct a manual change
    • Answer recognition questions that tell Argo CD and Flux apart from CI tools, Helm and Kustomize
  34. Level 34: Debugging a Failed Release
    [Cloud Native Application Delivery – Debugging] Our reading of this heading's scope: you learn to find out why a release did not land, working from the delivery workflow down: pipeline output, GitOps sync and health status, Helm release status, a stalled Deployment rollout (ProgressDeadlineExceeded), and the ReplicaSet and Pod events beneath it.
    • Diagnose a stuck rollout with kubectl rollout status, rollout history and describe deployment, then recover with kubectl rollout undo
    • Read an out-of-sync or degraded GitOps application and a failed Helm upgrade, and trace each to its root cause in the manifests
    • Follow a top-down path from workflow to Deployment, ReplicaSet and Pod to find the failing layer in exam scenarios
  35. Level 35: Interactive Debugging of Running Apps
    [Cloud Native Application Delivery – Debugging] Our reading of this heading's scope: you learn hands-on tools for inspecting a running app that looks deployed but misbehaves: kubectl exec, kubectl port-forward, kubectl debug with ephemeral containers for distroless images, checking Service selectors against EndpointSlices, and testing DNS from inside the cluster.
    • Attach an ephemeral debug container to a distroless Pod with kubectl debug -it --target
    • Use kubectl port-forward and an in-cluster curl Pod to tell whether a fault lies in the app, the Service or DNS
    • Find a Service with no endpoints caused by a label-selector mismatch, and fix it
  36. Level 36: Observability Pillars and Prometheus
    [Cloud Native Architecture – Observability] Our reading of this heading's scope: you learn the difference between monitoring and observability, the three signals (metrics, logs, traces), and Prometheus, the CNCF graduated project: its pull-based scraping, time-series data model, exporters, PromQL, Alertmanager and Grafana dashboards.
    • Explain what metrics, logs and traces each answer, and pick the right signal for a scenario
    • Describe Prometheus's pull model, its /metrics endpoint and the role of exporters and Alertmanager
    • Read a simple PromQL query such as rate(http_requests_total[5m]) and say what it measures
  37. Level 37: OpenTelemetry, Tracing, Logging and Cost
    [Cloud Native Architecture – Observability] Our reading of this heading's scope: you learn OpenTelemetry as the vendor-neutral standard for instrumenting and collecting telemetry (APIs, SDKs, the Collector, OTLP), distributed tracing with spans and backends such as Jaeger, cluster log collection with Fluentd and Fluent Bit, and cost management through right-sizing requests and tools such as OpenCost.
    • Describe how a trace is made of spans, and where the OpenTelemetry Collector sits between apps and backends
    • Explain node-level log collection with a DaemonSet agent such as Fluent Bit, and why apps should log to stdout and stderr
    • Link resource requests to cluster cost, and suggest right-sizing or autoscaling steps that cut waste
  38. Level 38: Microservices, Autoscaling and Serverless
    [Cloud Native Architecture – Cloud Native Ecosystem and Principles] Our reading of this heading's scope: you learn the cloud native principles behind microservices (loose coupling, immutable infrastructure, declarative APIs, resilience), the autoscalers (Horizontal Pod Autoscaler, Vertical Pod Autoscaler, Cluster Autoscaler and event-driven KEDA), and serverless and functions-as-a-service with Knative and CloudEvents.
    • Compare a monolith with microservices, and give the trade-offs in an exam-style scenario
    • Create a HorizontalPodAutoscaler with kubectl autoscale on kind (with metrics-server installed), and say how the HPA, VPA and Cluster Autoscaler differ
    • Explain scale-to-zero and event-driven scaling, and pick Knative or KEDA for a described workload
  39. Level 39: CNCF Projects, Maturity Levels and Open Standards
    [Cloud Native Architecture – Cloud Native Ecosystem and Principles] Our reading of this heading's scope: you learn how the CNCF landscape is organised, the Sandbox, Incubating and Graduated maturity levels and what it takes to move up, which project solves which problem (including those the curriculum names: Kubernetes, Fluentd, Linkerd, Prometheus, OpenTracing and gRPC), and the open standards that make components interchangeable: OCI, CRI, CNI and CSI.
    • Put the three CNCF maturity levels in order, and explain what graduation signals about a project
    • Match common CNCF projects to their category (orchestration, runtime, observability, service mesh, GitOps, packaging)
    • Explain how OCI, CRI, CNI and CSI avoid vendor lock-in, and pick the right standard for a scenario
  40. Level 40: CNCF Governance, SIGs, KEPs and Contributing
    [Cloud Native Architecture – Cloud Native Community and Collaboration] Our reading of this heading's scope: you learn how the CNCF is governed under the Linux Foundation (Governing Board, Technical Oversight Committee and its technical groups), how the Kubernetes project runs through its Steering Committee, Special Interest Groups (SIGs) and Working Groups, how features move through Kubernetes Enhancement Proposals (KEPs) from alpha to beta to stable, and how newcomers can contribute.
    • Name who does what among the CNCF Governing Board, the TOC and Kubernetes SIGs, checking cncf.io and kubernetes.dev for the current structure
    • Trace a feature from KEP to alpha, beta and GA, and explain feature gates and the release cycle
    • List practical ways to contribute (docs, issues, SIG meetings, code reviews, the Contributor Guide), and say why open governance matters
  41. Level 41: Timed Mock Exam: KCNA Practice Paper Timed mock
    [All four domains] A timed mock exam of 60 original exam-style multiple-choice questions in 90 minutes, weighted like the curriculum (Kubernetes Fundamentals 44%, Container Orchestration 28%, Cloud Native Application Delivery 16%, Cloud Native Architecture 12%), testing all 13 competencies with every wrong option explained and a 75% pass mark; these are practice questions written for this course, not real exam questions, and passing them does not guarantee a pass on the real exam.
    Free 10 questions from the bank behind this course's timed mock are free to try, no account needed. Read all 10 with their answers →

Access

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Read lesson 1 free →Try 10 practice questions free →

More like this