Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

Kubernetes course: learn, administer and secure a cluster

  • 60 min

By updated

Improve this page

Logo Kubernetes

Kubernetes is the CNCF container orchestrator: you describe the desired state of your application, and it creates and maintains that state across a set of machines, even when one of them goes down. This free course takes you from your first Pods to the administration of a hardened cluster. It has 14 modules, 136 lessons, 123 verifiable labs, including 3 capstones and 3 mock exams, and a bank of 1,895 questions in French, about 170 hours of work. It is aimed at system administrators, SREs and developers who deploy on Kubernetes, and prepares you for the CNCF certifications from the KCNA to the CKS, with a first track towards the CKNE, the networking certification announced by the CNCF in November 2026.

What is Kubernetes and how does it work?

Kubernetes, abbreviated K8s, automates the deployment, scaling and repair of containerized applications spread across a group of machines called a cluster. Created by Google, it is now hosted by the CNCF (Cloud Native Computing Foundation).

Its operating principle comes down to one mechanism, the reconciliation loop. You declare a desired state, for example three copies of an application, and controllers constantly compare this declaration with the observed state of the cluster. As soon as a gap appears, a machine goes down or a container crashes, a controller acts to close it without being asked. This mechanism, not human supervision, is what makes applications resilient and lets you resize them by changing a single value.

Kubernetes cluster: the Control Plane (API Server, etcd, Scheduler, Controller Manager, Cloud Controller Manager) drives two Worker Nodes, each with a kubelet, kube-proxy and Pods; kubectl reaches the API Server over HTTPS.kubectlKubernetes clusterControl PlaneWorker Node 1Worker Node 2API ServeretcdSchedulerControllerManagerCloud ControllerManagerKubeletKube-proxycontainerdPodPodPodKubeletKube-proxyPodPodHTTPS
Source · SVG
Esc to close, + and − to zoom, scroll to move around. 100 %

The cluster is split into two roles. The Control Plane decides: the API Server receives all requests, etcd stores the declared state, the Scheduler chooses which machine each Pod goes on, and the Controller Manager runs the reconciliation loops. The Worker Nodes execute: the kubelet starts the containers there through a runtime such as containerd, and kube-proxy programs the network rules there.

Deployment flow: kubectl sends the YAML to the API Server, which stores it in etcd and hands it to the Scheduler; the Scheduler assigns a node, whose kubelet has containerd create the container until the Pod is Running.Worker NodeControl PlaneYAMLStoreScheduleAssign nodeCreateRunDevOpskubectlAPI ServeretcdSchedulerKubeletcontainerdPodRunning
Source · SVG
Esc to close, + and − to zoom, scroll to move around. 100 %

The path of a deployment always follows this order. Your manifest goes from kubectl apply to the API Server, which validates it and writes it to etcd. The Scheduler sees a Pod with no assigned machine appear and gives it one. The kubelet of that machine fetches the definition and asks containerd to download the image and start the container. Understanding this chain is what will let you, at the first incident, know where to look when a Pod does not start.

What does the Kubernetes course contain, and how long does it take?

The course has 14 teaching modules and 136 lessons, for about 170 hours of actual work, reading, hands-on steps, labs and knowledge checks included. It is free, accessible without sign-up, and its practice bank has 1,895 questions in French; the English quizzes cover the lessons already translated.

What you followVolume
Teaching modules14
Lessons136
Estimated duration170 h
Question bank1,895 (in French)
Verifiable labs123, including 3 capstones and 3 mock exams
Graded capstones3 (one per hands-on certification)
Certification exercises68 (22 CKA, 20 CKAD, 26 CKS)
Practice clusterkind, locally
Hands-on exerciseskubernetes-dsoxlab-training repository
Target certificationsKCNA, KCSA, CKAD, CKA, CKS; CKNE in part

These hours are not limited to reading: they also count reproducing the hands-on steps on a real cluster. Reading YAML is not enough to master Kubernetes, you have to observe what the cluster does with it.

The breakdown below helps you set your pace and spot the modules you can skip if you already have hands-on experience. The Level column gives the difficulty of a module and the durations are those of the course path. This column is not the same thing as the course's five validation levels, which group the modules and each end with a trial, presented in the section on validating what you have learned.

ModuleLevelLessonsDuration
FundamentalsBeginner97 h 55
Cluster architectureBeginner33 h 30
The core resourcesBeginner1415 h 30
Deploying your applicationsIntermediate1216 h 25
Networking and exposureIntermediate57 h 05
Persistent storageIntermediate23 h 40
Advanced workloadsIntermediate58 h 50
Scheduling and capacityIntermediate67 h 15
Workload securityAdvanced48 h 10
Installing a clusterAdvanced910 h 55
Administering the clusterAdvanced67 h 15
Day-to-day operationsAdvanced2022 h 55
Securing the clusterAdvanced2632 h 25
CertificationsAdvanced1518 h 00

Two modules are much longer than the others: Day-to-day operations has 20 lessons and Securing the cluster has 26. This imbalance is deliberate. Deploying successfully is only the beginning, and a large share of the time spent on a cluster then goes into hardening it, diagnosing an incident and upgrading it without downtime.

How do you track your progress in the course?

Each lesson has a checkbox, and your progress is saved in your browser, with no account or sign-up. No data leaves for a server.

The My path page shows the complete programme, module by module, with the completion percentage. At the top of each lesson, a banner reminds you where you are; at the bottom, a button marks the lesson as read and takes you to the next one. A course of about 170 hours is rarely followed in one go: this tracking lets you pick it up after three weeks without searching for where you were.

The course, module by module

Follow the course in order if you are starting out. If you already practise, go straight to the module you are missing: each lesson recalls its prerequisites.

Understand the cluster before deploying

The first three modules build the foundation. From the first module on, you install kubectl and create a local cluster; you then open the hood to see what happens inside.

These three modules make up level 1, which ends with the level 1 trial: deliver an application in three replicas, update it and repair a failing component, in about an hour.

Ship an application that holds up in production

Five modules separate an application that merely starts from one that is fit for production: declared health, reserved resources, the right type of workload, controlled exposure and Pod placement.

Three Service types: ClusterIP relays to Pods inside the cluster only, NodePort receives external traffic on a port 30000-32767 of each node, LoadBalancer receives it from a cloud provider load balancer.ClusterIPcluster-internal onlyNodePortport 30000-32767 on every nodeLoadBalancerexternal IP from the cloud providerServicePodPodExternalServicePodCloud LBServicePod
Source · SVG
Esc to close, + and − to zoom, scroll to move around. 100 %

The Networking and exposure module deserves a word, because beginners often get lost there. A Service gives a stable address to a group of Pods: ClusterIP makes it reachable inside the cluster only, NodePort opens a port on every node, LoadBalancer asks the provider for an external address. On a kind cluster, this last type gets no external address without an extra component. On top of Services, an Ingress or the Gateway API add HTTP routing by domain name and path, and Network Policies filter the traffic between Pods.

Install, operate, repair

Three modules cover the administrator's job, the one that starts once the cluster already exists or has to be built.

Pod lifecycle: Pending, then ContainerCreating, then Running, which ends in Succeeded on Exit(0) or Failed on Exit(1+); an image download failure leads to ImagePullBackOff, and a failing container that restarts in a loop gives CrashLoopBackOff.ScheduledStartedExit(0)Exit(1+)Pull failedCrashLoopBackOffPendingwaiting for schedulingContainerCreatingimage pull + creationRunningapplication upSucceededFailedImagePullBackOff
Source · SVG
Esc to close, + and − to zoom, scroll to move around. 100 %

Three incidents come up often, and each has its own lesson. A CrashLoopBackOff signals a container that starts and then dies in a loop, so an application or configuration problem. A Pending Pod most often has not found a machine able to host it, so a capacity or placement problem. An ImagePullBackOff (in French) blocks before the container even starts, at the image download. Knowing how to read this difference saves you from looking in the wrong place.

Harden the cluster and the workloads

Two modules, 30 lessons in total, make up the security part of the course and match the CKS syllabus. The cross-cutting hub Securing Kubernetes (in French) opens the second module.

Prepare for the CNCF certifications

The last module does not replace the previous ones: it trains you to mobilize, within the time limit of an exam, what they teach. It serves to decide which certification to aim for, then to prepare for it.

  • Certifications: the page choosing your certification compares the six exams. The two multiple-choice exams each have a preparation page, KCNA and KCSA. Each hands-on exam has its preparation guide, CKAD, CKA or CKS, then a command cheat sheet (CKAD, CKA, CKS) and timed exercises (CKAD, CKA, CKS). Each exercises page also carries a graded capstone and a hands-on mock exam, playable with dsoxlab. The CKNE has its own preparation page. The KAIA and the CKIE, announced for 2027, only have an information page for now.

Why do you need an orchestrator when you already know Docker?

Because Docker runs containers on one machine, whereas production requires spreading them across several, restarting them without intervention and updating them without downtime. The table below sets the manual action against its Kubernetes equivalent.

What you do by handWhat Kubernetes does for you
Start each container, machine by machineDeclare "3 replicas" and let the Scheduler place them
Monitor and restart after a failureControllers recreate the Pod without intervention
Add servers when traffic risesAutoscaling adjusts the replicas to the measured load
Cut the service to deploy a versionProgressive rolling update, with rollback possible
Note somewhere which container runs whereThe declared state lives in etcd and is read with kubectl get

The decisive point is the second row. With Docker alone, repair depends on someone triggering it. With Kubernetes, an automatic loop corrects the gap between the desired state and the actual state, at three in the morning as at noon. The lesson why orchestrate containers details what an engine alone does not do.

What are the prerequisites before starting Kubernetes?

Three skills are essential: administering Linux on the command line, knowing how to build and run a container, and reading YAML without getting the indentation wrong. The rest is learned here.

The Linux fundamentals come first: terminal, permissions, services, reading logs. Kubernetes does not replace this skill, it assumes it, and the first cluster incident will send you straight back to journalctl on a node.

The container foundation with Docker comes next. Kubernetes orchestrates containers: if the image, the layers, the environment variables and the volumes are not clear, the whole vocabulary of the cluster will stay blurry. YAML (in French) is the third pillar, since all the manifests depend on it.

Two skills are recommended without being blocking. Basic TCP/IP networking (in French) makes Services, internal DNS and Network Policies readable. Git (in French) becomes essential as soon as your manifests leave your workstation. Allow a few weeks to acquire these basics if you start from zero.

What I stand for

This course has opinions, and it is better to know them before committing to it.

You learn on a local cluster, not on a managed service. A kind cluster starts in a few dozen seconds, costs nothing and can be destroyed without consequences. A managed service hides exactly what you need to understand: the control plane, etcd, the certificates. Pay for a managed cluster once you know what it spares you.

Images are referenced by digest, never by latest. A tag is mutable: the same declaration can download two different contents two days apart, which makes a deployment non-reproducible and an incident hard to explain. The canonical form image:tag@sha256:… pins the exact content, and it is the one used in the manifests on the site.

Requests and limits are not optional. A Pod without requests skews the Scheduler's decisions, and a Pod without limits can consume all of a node's memory and take down its neighbours. The only remedy is to declare them from the first manifest.

RBAC is designed together with the application. Create a dedicated ServiceAccount and a Role limited to the namespace, and avoid the default account bound to a ClusterRoleBinding to cluster-admin, set "for the time being". This kind of shortcut is almost never removed, and it turns the compromise of one container into the compromise of the cluster.

Generating YAML with an AI is not mastering Kubernetes. An assistant produces a syntactically valid manifest in a few seconds. It does not diagnose a Pod stuck in CrashLoopBackOff, does not say whether a NetworkPolicy opens too many flows, and does not explain why an HPA refuses to scale up. The skill to build is understanding what happens in the cluster, and why.

What I advise against

Four mistakes come up often enough to deserve being named before you make them.

Starting with Helm. Packaging an application whose objects you cannot yet describe hides the very subject you need to learn. Write raw manifests first, understand what a Deployment generates, then abstract with the Helm course (in French). A chart you do not understand is much harder to debug than an explicit YAML file.

Putting a database in a Deployment. The replicas of a Deployment are interchangeable and have neither a stable identity nor a dedicated volume. A database needs both, and that is exactly what a StatefulSet provides. The mistake is not visible at the first deployment, it is visible at the first data loss.

Treating Kubernetes Secrets as a vault. A Secret object is base64-encoded, not encrypted. Without etcd encryption at rest or restrictive RBAC, anyone who reads the object reads the value. The lesson on Secrets explains what they actually protect, and what to add.

Aiming for the CKS before having administered a cluster. This is not only an enrolment rule, the CKA is a mandatory prerequisite of the CKS. It is also a matter of sense: hardening a component you do not know how to operate amounts to applying a recipe without understanding what it breaks.

Which cluster are the hands-on steps validated on?

Every published kubectl command is run on a local cluster before being written, with the real output taken into the guide. The reference cluster is built with kind (version 0.33) and runs Kubernetes 1.37: kind runs Kubernetes in containers on your workstation.

To follow the lessons, two processors and 4 GB of memory are enough: the kind cluster runs on your machine. The labs need more, because they run with dsoxlab in virtual machines, including those of the Fundamentals and Architecture modules; the lesson choosing a machine to train with dsoxlab gives the memory and processors required. The installation modules also build a multi-node cluster with kubeadm or a full distribution. No cloud account is needed.

Here is the minimal form of a manifest that follows the site's rules, with the image pinned by digest rather than by tag. Save it in a file named pod-nginx.yaml:

apiVersion: v1
kind: Pod
metadata:
name: mon-pod
spec:
containers:
- name: nginx
image: nginx:1.30.5@sha256:9bf97bd7714f5e24c1ccd545ecb9eb5435cb6d109c97cebb15e7e455e0239edb
ports:
- containerPort: 80

Applying and checking take two commands. The second one must show the Pod in the Running state:

Terminal window
kubectl apply -f pod-nginx.yaml
kubectl get pod mon-pod -o wide

The labs that extend these hands-on steps are in the companion repository presented right after.

Where to find the graded labs: the dsoxlab companion repository

The verifiable labs and the 3 capstones of this course live in the kubernetes-dsoxlab-training repository and are played with the dsoxlab CLI. The site carries the guides, the repository carries the exercises and their automatic grading. The lessons that have a guided lab present it in their "Put it into practice" section: there you repeat the gesture of the demonstration step by step. The challenges and the capstones give no steps to follow. In both cases, a test reads the actual state of the cluster to tell whether the skill has been acquired, which a commented exercise does not do.

The installation is done only once. The CLI is installed with uv or pipx, then you clone the catalogue and list what is playable:

Terminal window
uv tool install dsoxlab # or: pipx install dsoxlab
git clone https://github.com/stephrobert/kubernetes-dsoxlab-training.git
cd kubernetes-dsoxlab-training
dsoxlab list-labs

The KCNA labs, those of the Fundamentals and Architecture modules, run on a kind cluster installed in a virtual machine. The certification labs run on a kubeadm cluster on virtual machines, not on the kind cluster of the guides. This difference is deliberate: kind shares the host kernel, so an AppArmor profile, a broken kubelet, a static Pod or an etcd restore cannot be demonstrated there. The guides rely on kind, because a workstation is enough. The certification labs use virtual machines, because these cases cannot be reproduced on kind. The output of dsoxlab list-labs shows the identifiers you find in the cards of each lesson.

How do you validate what you have learned and prepare for the CNCF certifications?

Five mechanisms validate the skill: a knowledge check at the end of the fundamentals, a bank of questions, labs and 3 graded capstones on a real cluster, an end-of-level trial, and 68 timed exercises in the format of the hands-on exams.

The knowledge check closes the first module: 21 questions in 15 minutes, with a threshold of 80%. Below that, go back over the lessons of the module before continuing, otherwise the rest of the course will rest on uncertain foundations. A second review of 25 questions closes the core resources module.

The course is also divided into five levels: level 1 groups Fundamentals, Cluster architecture and The core resources; level 2, Deploying your applications, Networking and exposure, Persistent storage and Advanced workloads; level 3, Scheduling and capacity and Workload security; level 4, Installing a cluster, Administering the cluster and Day-to-day operations; level 5, Securing the cluster. The Certifications module stays outside the levels, since it guides without teaching. Each level ends with an end-of-level trial, with no step-by-step guide: level 1 (about 60 minutes), level 2 (90 minutes), level 3 (120 minutes), level 4 (180 minutes) and level 5 (150 minutes).

The practice bank has 1,895 questions in French, available from the exams page; the English quizzes cover the lessons already translated. It serves as a short revision between two chapters.

The CNCF offers six Kubernetes certifications, not three as is often read. Two are multiple-choice exams at associate level, four are fully hands-on exams where you solve tasks on a real cluster on the command line, with the official documentation available.

CertificationWho it is forFormatDurationPrerequisites
KCNADiscovering Kubernetes and cloud nativeMultiple choice90 minnone
KCSASecurity, associate levelMultiple choice90 minnone
CKADDevelopers who deploy to the clusterHands-on2 hnone
CKAAdministrators and SREsHands-on2 hnone
CKSAdvanced security of the cluster and workloadsHands-on2 hCKA required
CKNECluster networking: CNI, Services, Gateway API, policies, observabilityHands-on2 hnone, CKA level assumed

The difference between the CKA and the CKAD is not about difficulty but about point of view: the CKA looks at the cluster from the infrastructure side, the CKAD from the application running on it. Choose the one that matches your daily work, and revision will be much faster. The full comparison, with the recommended order, is in choosing your Kubernetes certification.

Each hands-on exam has its own preparation guide, its command cheat sheet and its timed exercises: 22 exercises for the CKA, 20 for the CKAD and 26 for the CKS. Each follows the exam format: short statement, observable goal, time constraint. Aim for 80% success before booking your session. The CKNE, more recent, has for now its preparation page, which says which objectives the course already covers.

FAQ: frequently asked questions about Kubernetes

Here are the answers to the questions most often asked by people starting with Kubernetes: what it does, what it costs, how it differs from Docker, the prerequisites, the learning time and how to choose the certification.