This exam measures whether you can, on your own, ship and bring back to a healthy state the application of a music festival: make it reachable, repair a failing component, isolate it, place it, cap its workspace, scale it and harden it. It is meant for people who are finishing level 3, "Place, secure and deliver an application", and it also covers the exposure taught at level 2. It runs in a virtual machine of the lab catalogue, k8s-kind.lab, on a kind cluster named capacite with Kubernetes 1.37 and four nodes, so plan about 120 minutes. You pass it by meeting the six critical criteria and reaching at least 70 points out of 100. It gives no hints and teaches nothing new: it checks what the lessons have taught.
What you will learn
- Say what the exam expects and which state of the cluster it grades.
- Spot the lessons to review before you start.
- Tell the six critical criteria, which decide the verdict whatever the total, from the others.
- Read your result to decide whether to move on to the next level or to consolidate.
What should you be able to do before you start?
No step-by-step guide goes with the exam, and choosing the right resources is part of what it measures. The specification names no Kubernetes object: it describes results, and it is up to you to decide which resource produces them. Everything it asks is taught in the Scheduling and capacity and Workload security modules, which make up level 3, and in the Networking and exposure module, seen at level 2. It also assumes the basic resources of level 1. If a step feels unclear, reread those modules before you start.
You must also be able to diagnose: several applications in the festival namespace are shipped broken, and finding what is wrong is part of the work. The section "What should you do after the exam?" lists the lessons tied to each criterion.
What does the specification ask for?
The scenario describes a festival whose previous team left in a hurry. It says what must be true at the end, never how to get there. The lab scenario gives the names that the grader looks for: it is authoritative, so read it in full when you start.
The cluster has one control plane and three workers. Three namespaces are involved.
- The
festivalnamespace holds the ticketing frontendbillets(two replicas), theprogrammeapplication, theregistredatabase and a poster generator,affiches. Several of them do not run, or do not run as they should. - The
paiementnamespace holds thecaissecomponent, which no longer answers athttp://caisse.paiementeven though its replicas are running. - The
partenairesnamespace holdspartenaire, a partner's client.
The capacite-worker3 node is reserved for the database: the platform team closed it to other workloads and labelled it reserve=registre. The HTTP entry point of the cluster, Traefik, answers on port 30080 of every node and serves the cluster's standard HTTP routes.
The specification comes down to eleven requirements, each graded by one criterion.
- For the host
festival.local, the path/billetsreaches the ticketing frontend and the path/programmereaches the programme, from outside the cluster. An undeclared path, or another host, reaches neither. - Before any repair, you write to
~/epreuve/cause-caisse.txtwhycaissedoes not answer: what prevents it, and how. You then repair it, without touching the file again, since its date is compared with the date of the repair.caisseanswers again athttp://caisse.paiementfrom any Pod in the cluster. - From
partenaire, the full nameprogramme.festival.svc.cluster.localresolves, and the programme answers over HTTP on port 80. - On the database's port 5432, only the ticketing frontend gets in. The programme is refused, like any client from another namespace.
- The database can still resolve names, and any other outgoing traffic is refused.
- The database runs on the reserved node, and nothing else from
festivalruns there. The two replicas of the ticketing frontend never share a node, and their description guarantees it. - The
festivalnamespace never reserves more than 2 CPUs and 2 GiB of memory, never exceeds 4 CPUs and 4 GiB in limits, and holds no more than 15 Pods. A workload that would exceed this ceiling is refused at creation. - A container in
festivalthat declares nothing gets a request of 100m CPU and 128Mi of memory, and a limit of 250m CPU and 256Mi. Theaffichesworkload runs. - The programme follows its CPU load between 2 and 6 replicas, aiming at 60% of the CPU that each replica requests, and its autoscaling really reads a value.
- The programme runs under an identity of its own, that no other workload uses, and no credential for the API is handed to its containers. This identity can read the ConfigMaps of
festival, and nothing else, anywhere. - The programme's container runs as non-root, under a numeric user, with a read-only root filesystem and no capability at all, and the programme still answers.
How do you start the exam and get graded?
The lab prepares the cluster and the full statement, then reads the state of the cluster again when you ask for your grade. You start it with dsoxlab run k8s-epreuve-livrer-une-application. Two commands are then used, and they do not do the same thing: dsoxlab check k8s-epreuve-livrer-une-application tells you where you stand, criterion by criterion, as many times as you like; dsoxlab submit k8s-epreuve-livrer-une-application returns the verdict. The grade never looks at the commands you typed: it reads what is true in the cluster, and the ~/epreuve/cause-caisse.txt file for the caisse component.
Each check acts on the cluster. It runs commands in partenaire and in replicas of your applications, and it submits test workloads to festival as server-side dry runs, which create nothing.
Put it into practice
This lab is the exam itself. It puts you in front of the scenario described above and it is validated on the final state: the grader queries the cluster and reads the cause file, as a colleague taking over your work would.
How is the exam graded?
Eleven criteria make up the grade, at equal weight: each is worth about 9.1 points out of 100. The pass mark is 70 points, that is, at least eight criteria. Six criteria are critical: they must all pass, and failing a single one fails the exam, whatever the total. The six critical criteria are worth about 54.5 points: you must therefore pass all of them, then at least two of the other five to reach 70. No hints are offered.
| Criterion | Critical | |
|---|---|---|
| C1 | the two web applications are reachable from outside by the requested host, each on its own path | yes |
| C2 | the inherited component answers again, and the cause of its failure was recorded before the repair | yes |
| C3 | a client from another namespace resolves the programme's full name and reaches it | no |
| C4 | only the frontend reaches the database, the programme and a client from another namespace are refused | yes |
| C5 | the database can still resolve names, and any other outgoing traffic is refused | no |
| C6 | the database runs on the reserved node, alone in its namespace, and the frontend replicas are on different nodes | no |
| C7 | the namespace carries the requested ceiling and refuses a workload that exceeds it | yes |
| C8 | a workload with no declared resources gets the requested defaults, and the posters workload runs | no |
| C9 | the programme's autoscaling carries the requested bounds and reads a metric value | no |
| C10 | the programme runs under a dedicated identity, with no token, and only the requested right | yes |
| C11 | the programme's container runs as non-root, with a read-only root filesystem and no capabilities, and still answers | yes |
What should you do after the exam?
If the six critical criteria pass and the total reaches 70, the level is validated and you can move on to the next one. Otherwise, reread the lesson that teaches the failed criterion, then retake the exam:
- C1: the lesson on Ingress with Traefik, or the one on the Gateway API if that is the route you chose;
- C2: the lessons on Services and on Pod networking;
- C3: the lesson on CoreDNS;
- C4: the lesson on NetworkPolicies, which also serves for C5 together with the lesson on CoreDNS;
- C6: the lesson on Pod placement;
- C7 and C8: the lesson on quotas and limits per namespace;
- C9: the lesson on horizontal autoscaling;
- C10: the lessons on ServiceAccounts and on RBAC;
- C11: the lesson on the security context.
Key points
- The exam is a measurement: it explains nothing again, gives no hints and grades the final state of the cluster, not your commands.
- The specification names no Kubernetes object: it is up to you to choose the resources and to find what is broken.
- The six critical criteria decide the verdict: failing one fails the exam, and the total must also reach 70 points.
- The cause of the
caissefailure is written before the repair, and the file is not touched again afterwards. dsoxlab checktells you where you stand as often as you like; onlydsoxlab submitreturns the verdict.