Docker et Kubernetes (préparation CKA)
Quatre semaines pour passer des conteneurs Docker à l'administration d'un cluster Kubernetes : images, Compose, pods, déploiements, services, Ingress et Gateway API, stockage, RBAC, Helm, kubeadm, sauvegarde d'etcd et dépannage, avec un lab corrigé chaque jour, un terminal Kubernetes simulé et un examen pratique blanc chronométré.
🛡️ Garantie réussite : 3 mois offerts si l'examen officiel ne passe pas- Durée4 semaines (≈ 108 h)
- NiveauIntermédiaire : bases de Linux et du terminal recommandées
- Contenu108 h · 21 ateliers
- ValidationCertificat
Ce que vous saurez faire
- Comprendre ce qu'est un conteneur (espaces de noms, cgroups, images OCI) et le distinguer d'une machine virtuelle
- Lancer, inspecter et dépanner des conteneurs avec Docker, et publier des images dans un registre
- Écrire des Dockerfile propres, légers et sûrs (multi-étapes, cache, utilisateur non root, analyse de vulnérabilités)
- Assembler une application complète avec Docker Compose (réseaux, volumes, variables, contrôles de santé)
- Décrire l'architecture d'un cluster Kubernetes et le rôle de chaque composant (API server, etcd, scheduler, controller manager, kubelet, kube-proxy, runtime)
- Piloter un cluster avec kubectl en impératif et en déclaratif, à la vitesse exigée par l'examen
- Déployer des applications avec les Pods, Deployments, DaemonSets, StatefulSets, Jobs et CronJobs, et gérer les mises à jour et retours arrière
- Configurer les applications (ConfigMaps, Secrets, sondes, requêtes et limites, quotas) et contrôler l'ordonnancement (affinités, teintes et tolérances, autoscaling)
- Exposer les applications avec les Services, CoreDNS, l'Ingress et la Gateway API, et les isoler avec les NetworkPolicies
- [object Object]
- [object Object]
- Installer des applications avec Helm et Kustomize, et comprendre les CRD, les opérateurs et les interfaces CRI, CNI et CSI
- Installer un cluster avec kubeadm, le mettre à jour, sauvegarder et restaurer etcd
- Dépanner méthodiquement les applications, les nœuds, le plan de contrôle et le réseau, le domaine le plus lourd de l'examen (30 %)
- S'entraîner sur plus de 650 questions expliquées et un examen pratique blanc de 17 tâches en 2 heures
Docker a rendu les conteneurs accessibles à tous ; Kubernetes est devenu le système standard pour les faire tourner en production, dans le cloud comme dans les centres de données. Savoir les administrer est aujourd'hui demandé dans la plupart des offres d'emploi DevOps, SRE, administrateur systèmes et ingénieur cloud.
La certification CKA (Certified Kubernetes Administrator) de la Linux Foundation et de la CNCF est la référence pour le prouver. Elle a une particularité : ce n'est pas un QCM. Pendant deux heures, vous résolvez de vraies tâches en ligne de commande sur de vrais clusters. Ce parcours vous y prépare de la seule façon qui marche : en pratiquant tous les jours.
Ce parcours de quatre semaines part de Docker, que vous maîtriserez d'abord pour lui-même, puis couvre les cinq domaines de l'examen CKA dans sa version en vigueur : architecture, installation et configuration du cluster (25 %), charges de travail et ordonnancement (15 %), services et réseau (20 %), stockage (10 %) et dépannage (30 %).
Tout au long du parcours, vous rejoignez Kalypso Sports, une jeune entreprise fictive de Bordeaux qui édite ResaClub, une application de réservation de terrains pour les clubs de tennis, de padel et de foot à cinq. ResaClub tourne aujourd'hui sur deux serveurs installés à la main, et chaque lundi soir, quand les clubs ouvrent les réservations de la semaine, quelque chose casse. Aux côtés d'Inès Garnier, responsable de la plateforme et votre tutrice, vous conteneurisez ResaClub, puis vous construisez et exploitez le cluster Kubernetes qui la fera tourner.
Chaque journée suit la même logique : comprendre grâce à des cours structurés (schémas, manifestes YAML commentés, commandes prêtes à copier, exercices corrigés intégrés) et une vidéo, pratiquer avec un lab sur votre propre machine suivi de sa correction pas à pas et, certains jours, un terminal Kubernetes simulé dans le navigateur, puis vérifier avec une fiche mémo et un quiz expliqué.
- Semaine 1 · Docker (jours 1 à 5) : l'examen et le lab, images et conteneurs, Dockerfile, réseaux, volumes et Docker Compose, ce qui se passe sous le capot et la sécurité des conteneurs.
- Semaine 2 · Les bases de Kubernetes (jours 6 à 10) : l'architecture et le premier cluster, les Pods et kubectl, les Deployments et autres contrôleurs, la configuration des applications, l'ordonnancement et l'autoscaling.
- Semaine 3 · Réseau, stockage, sécurité et outils (jours 11 à 15) : Services et DNS, Ingress, Gateway API et NetworkPolicies, stockage persistant, authentification et RBAC, Helm, Kustomize, CRD et opérateurs.
- Semaine 4 · Administrer et dépanner (jours 16 à 20) : installer un cluster avec kubeadm, le mettre à jour et sauvegarder etcd, dépanner applications, nœuds et réseau, un projet final et un examen pratique blanc de 17 tâches en 2 heures, puis deux examens blancs théoriques et l'examen final.
Au total : environ 108 heures, une vidéo et un lab corrigé par jour, des labos interactifs, des fichiers à télécharger (code source de ResaClub, Dockerfile, fichiers Compose, manifestes Kubernetes, chart Helm, scripts d'installation kubeadm, de sauvegarde etcd et de pannes à réparer), une fiche mémo par journée et plus de 650 questions expliquées. Le rythme conseillé est d'environ 5 h 30 par jour pendant quatre semaines, ou de 2 h 45 par jour pendant deux mois.
Kubernetes® est une marque de la Linux Foundation ; CKA et Certified Kubernetes Administrator sont des marques de la Linux Foundation et de la Cloud Native Computing Foundation. Docker® est une marque de Docker, Inc. Égide Academy est un organisme indépendant, sans lien avec ces organisations : ce parcours prépare à l'examen mais ne délivre pas la certification. Toutes les tâches et questions sont originales et ne proviennent pas de l'examen officiel. Le programme, la version de Kubernetes de l'examen et son prix évoluent : vérifiez-les sur le site de la Linux Foundation avant de vous inscrire.
Programme jour par jour
Jour 1 L'examen CKA, les conteneurs et votre lab9 leçons · 4 h 17
Découvrir la certification CKA (format pratique, cinq domaines, règles), comprendre ce qu'est un conteneur et ce qui le distingue d'une machine virtuelle, rencontrer Kalypso Sports et ResaClub, puis installer le lab : une machine virtuelle Ubuntu Server avec Docker Engine.
- Bienvenue dans le parcours Docker et Kubernetes Cours 15 min Gratuit
- L'examen CKA : format, domaines et règles du jeu Cours 35 min Gratuit
- Conteneurs et machines virtuelles : ce qui change vraiment Cours 35 min 🔒
- Votre lab : Ubuntu Server et Docker Engine Cours 40 min 🔒
- Vidéo : des conteneurs à Kubernetes en 7 minutes Vidéo 7 min 🔒
- Lab 1 : installer Docker et lancer vos premiers conteneurs Atelier 60 min 🔒
- Correction du lab 1 : Docker installé, premiers conteneurs Correction 30 min 🔒
- Fiche mémo du jour 1 Cours 10 min 🔒
- Quiz du jour 1 Quiz 25 min 🔒
Jour 2 Images et conteneurs : cycle de vie, inspection et registres8 leçons · 4 h 11
Maîtriser docker run et ses options, le cycle de vie et les codes de sortie d'un conteneur, l'inspection et le débogage (logs, exec, inspect, stats), puis les images, leurs noms, étiquettes et empreintes, et les registres publics et privés.
- Le cycle de vie d'un conteneur et les options de docker run Cours 40 min 🔒
- Inspecter et déboguer un conteneur Cours 35 min 🔒
- Images, étiquettes, empreintes et registres Cours 40 min 🔒
- Vidéo : la vie d'un conteneur en 6 minutes Vidéo 6 min 🔒
- Lab 2 : les briques de ResaClub en conteneurs Atelier 60 min 🔒
- Correction du lab 2 : Redis, PostgreSQL, pannes et registre Correction 35 min 🔒
- Fiche mémo du jour 2 Cours 10 min 🔒
- Quiz du jour 2 Quiz 25 min 🔒
Jour 3 Construire ses images avec un Dockerfile8 leçons · 4 h 22
Écrire un Dockerfile instruction par instruction, comprendre CMD et ENTRYPOINT, la forme exec et le PID 1, exploiter le cache des couches et le .dockerignore, puis produire des images légères et sûres : constructions multi-étapes, choix de l'image de base, utilisateur non root, secrets de construction et analyse de vulnérabilités.
- Les instructions du Dockerfile Cours 40 min 🔒
- Le cache des couches et le .dockerignore Cours 30 min 🔒
- Des images légères et sûres Cours 40 min 🔒
- Vidéo : le Dockerfile parfait en 7 minutes Vidéo 7 min 🔒
- Lab 3 : conteneuriser l'API de ResaClub Atelier 75 min 🔒
- Correction du lab 3 : l'image de production de l'API Correction 35 min 🔒
- Fiche mémo du jour 3 Cours 10 min 🔒
- Quiz du jour 3 Quiz 25 min 🔒
Jour 4 Réseaux, volumes et Docker Compose8 leçons · 4 h 27
Comprendre les réseaux Docker (pont par défaut, réseaux définis par l'utilisateur et leur DNS, host, none), garder les données avec les volumes et les montages, puis décrire et lancer toute l'application ResaClub avec Docker Compose : services, dépendances, contrôles de santé, variables et mise à l'échelle.
- Les réseaux Docker Cours 35 min 🔒
- Garder les données : volumes et montages Cours 35 min 🔒
- Docker Compose : toute l'application dans un fichier Cours 45 min 🔒
- Vidéo : ResaClub en une commande avec Compose Vidéo 7 min 🔒
- Lab 4 : toute l'application ResaClub avec Docker Compose Atelier 75 min 🔒
- Correction du lab 4 : ResaClub sous Docker Compose Correction 35 min 🔒
- Fiche mémo du jour 4 Cours 10 min 🔒
- Quiz du jour 4 Quiz 25 min 🔒
Jour 5 Sous le capot des conteneurs et leur sécurité9 leçons · 4 h 52
Voir ce qu'est vraiment un conteneur (espaces de noms, cgroups), comprendre la chaîne containerd, runc, CRI et les outils crictl et ctr, puis durcir les conteneurs de ResaClub : capacités, système de fichiers en lecture seule, no-new-privileges, seccomp, AppArmor, mode rootless, signature et inventaire des images. Bilan de la semaine 1.
- Espaces de noms et cgroups : ce qu'est vraiment un conteneur Cours 40 min 🔒
- containerd, runc, CRI : la chaîne d'exécution Cours 30 min 🔒
- Durcir les conteneurs Cours 40 min 🔒
- Vidéo : un conteneur, c'est un processus Linux Vidéo 7 min 🔒
- Lab 5 : observer et durcir les conteneurs de ResaClub Atelier 70 min 🔒
- Correction du lab 5 : espaces de noms, cgroups et durcissement Correction 35 min 🔒
- Fiche mémo du jour 5 Cours 10 min 🔒
- Quiz du jour 5 Quiz 20 min 🔒
- Bilan de la semaine 1 : Docker (30 questions) Quiz 40 min 🔒
Jour 6 L'architecture de Kubernetes et votre premier cluster9 leçons · 5 h 08
Comprendre les composants d'un cluster Kubernetes (serveur d'API, etcd, ordonnanceur, gestionnaire de contrôleurs, kubelet, kube-proxy, runtime, modules complémentaires) et le chemin d'une demande, le modèle déclaratif et la structure des objets, maîtriser kubectl et le fichier kubeconfig (contextes, formats de sortie, jsonpath), puis créer un cluster de trois nœuds avec kind.
- Les composants d'un cluster Kubernetes Cours 45 min 🔒
- L'API, les objets et le modèle déclaratif Cours 35 min 🔒
- kubectl, le fichier kubeconfig et les formats de sortie Cours 45 min 🔒
- Créer un cluster de trois nœuds avec kind Cours 30 min 🔒
- Vidéo : Kubernetes de l'intérieur en 8 minutes Vidéo 8 min 🔒
- Lab 6 : votre premier cluster Kubernetes Atelier 75 min 🔒
- Correction du lab 6 : un cluster exploré de fond en comble Correction 35 min 🔒
- Fiche mémo du jour 6 Cours 10 min 🔒
- Quiz du jour 6 Quiz 25 min 🔒
Jour 7 Les Pods, les étiquettes et kubectl à la vitesse de l'examen9 leçons · 4 h 52
Écrire et comprendre un Pod (conteneurs, ports, variables, commandes, politique de redémarrage), ses phases et les états de ses conteneurs, les Pods multi-conteneurs, les conteneurs d'initialisation et les sidecars natifs, les étiquettes et sélecteurs, puis manier kubectl run, exec, logs, port-forward, edit et replace à la vitesse exigée par l'examen.
- Le Pod, la plus petite unité de Kubernetes Cours 45 min 🔒
- Étiquettes, sélecteurs et annotations Cours 25 min 🔒
- kubectl à la vitesse de l'examen Cours 45 min 🔒
- Labo : vos premiers Pods dans un terminal Kubernetes simulé Cours 25 min 🔒
- Vidéo : le Pod et le trio du dépannage Vidéo 7 min 🔒
- Lab 7 : les Pods de ResaClub et quatre pannes Atelier 75 min 🔒
- Correction du lab 7 : Pods, réseau partagé et pannes Correction 35 min 🔒
- Fiche mémo du jour 7 Cours 10 min 🔒
- Quiz du jour 7 Quiz 25 min 🔒
Jour 8 Deployments, mises à jour et autres contrôleurs9 leçons · 5 h 02
Faire tourner une application avec un Deployment et son ReplicaSet, régler la stratégie de mise à jour progressive (maxSurge, maxUnavailable), mettre à jour, suivre et annuler un déploiement, puis choisir le bon contrôleur : DaemonSet, StatefulSet, Job et CronJob.
- Deployments et ReplicaSets Cours 40 min 🔒
- Mettre à jour, suivre et annuler un déploiement Cours 35 min 🔒
- DaemonSets, StatefulSets, Jobs et CronJobs Cours 45 min 🔒
- Labo : déployer, mettre à jour et revenir en arrière Cours 25 min 🔒
- Vidéo : mettre à jour sans coupure Vidéo 7 min 🔒
- Lab 8 : ResaClub en Deployments, une mise à jour ratée et un retour arrière Atelier 80 min 🔒
- Correction du lab 8 : Deployments, rollout et contrôleurs Correction 35 min 🔒
- Fiche mémo du jour 8 Cours 10 min 🔒
- Quiz du jour 8 Quiz 25 min 🔒
Jour 9 Configurer les applications : ConfigMaps, Secrets, sondes et ressources9 leçons · 5 h 07
Séparer la configuration de l'image avec les ConfigMaps et les Secrets (variables et fichiers), surveiller la santé des conteneurs avec les sondes de démarrage, de vivacité et de disponibilité, réserver et plafonner les ressources (requests, limits, classes de QoS), et poser des garde-fous par namespace avec les ResourceQuotas et les LimitRanges.
- ConfigMaps et Secrets Cours 45 min 🔒
- Les sondes : démarrage, vivacité et disponibilité Cours 40 min 🔒
- Requêtes, limites, QoS, quotas et LimitRanges Cours 40 min 🔒
- Labo : configurer l'API de ResaClub Cours 25 min 🔒
- Vidéo : configurer et protéger une application Vidéo 7 min 🔒
- Lab 9 : une configuration propre pour ResaClub Atelier 80 min 🔒
- Correction du lab 9 : ConfigMaps, Secrets, sondes et quotas Correction 35 min 🔒
- Fiche mémo du jour 9 Cours 10 min 🔒
- Quiz du jour 9 Quiz 25 min 🔒
Jour 10 Placer les Pods : ordonnancement, affinités, teintes et mise à l'échelle11 leçons · 6 h 22
Comprendre comment l'ordonnanceur choisit un nœud, guider ce choix avec nodeSelector, les affinités et anti-affinités, les contraintes de répartition, les teintes et tolérances, gérer les priorités, reconnaître les Pods statiques, puis faire varier automatiquement le nombre de copies avec metrics-server et l'HorizontalPodAutoscaler. Bilan de la semaine 2.
- Comment l'ordonnanceur choisit un nœud Cours 40 min 🔒
- Affinités, anti-affinités et répartition Cours 45 min 🔒
- Teintes, tolérances, priorités et Pods statiques Cours 45 min 🔒
- metrics-server et mise à l'échelle automatique Cours 40 min 🔒
- Labo : placer les Pods de ResaClub Cours 25 min 🔒
- Vidéo : guider l'ordonnanceur Vidéo 7 min 🔒
- Lab 10 : placer et dimensionner ResaClub Atelier 80 min 🔒
- Correction du lab 10 : ordonnancement et autoscaling Correction 35 min 🔒
- Fiche mémo du jour 10 Cours 10 min 🔒
- Quiz du jour 10 Quiz 25 min 🔒
- Bilan de la semaine 2 Quiz 30 min 🔒
Jour 11 Le réseau des Pods : Services, EndpointSlices, CoreDNS et kube-proxy10 leçons · 5 h 37
Comprendre le modèle réseau de Kubernetes (une adresse par Pod, pas de NAT), exposer une application avec les Services ClusterIP, NodePort, LoadBalancer, ExternalName et headless, suivre les EndpointSlices, résoudre les noms avec CoreDNS, voir comment kube-proxy programme les règles sur chaque nœud, et diagnostiquer un Service qui ne répond pas.
- Le modèle réseau de Kubernetes Cours 35 min 🔒
- Les Services : ClusterIP, NodePort, LoadBalancer et les autres Cours 50 min 🔒
- Le DNS du cluster : CoreDNS Cours 40 min 🔒
- kube-proxy : comment l'adresse d'un Service mène à un Pod Cours 30 min 🔒
- Labo : le Service qui ne répondait pas Cours 25 min 🔒
- Vidéo : Services et DNS Vidéo 7 min 🔒
- Lab 11 : exposer ResaClub et réparer le réseau Atelier 80 min 🔒
- Correction du lab 11 : Services et DNS Correction 35 min 🔒
- Fiche mémo du jour 11 Cours 10 min 🔒
- Quiz du jour 11 Quiz 25 min 🔒
Jour 12 Exposer et cloisonner : Ingress, Gateway API et NetworkPolicies9 leçons · 5 h 32
Publier plusieurs applications HTTP derrière une seule entrée avec un Ingress, puis avec la Gateway API qui lui succède (GatewayClass, Gateway, HTTPRoute), terminer le TLS, et cloisonner le trafic entre Pods et entre namespaces avec les NetworkPolicies. Comprendre le rôle du plugin CNI et ce qui change quand il n'applique pas les politiques.
- L'Ingress : une entrée HTTP pour plusieurs Services Cours 45 min 🔒
- La Gateway API, la nouvelle génération Cours 40 min 🔒
- Les NetworkPolicies : cloisonner le trafic Cours 50 min 🔒
- Le plugin réseau (CNI) sous la loupe Cours 25 min 🔒
- Vidéo : entrer et circuler dans le cluster Vidéo 7 min 🔒
- Lab 12 : publier ResaClub et cloisonner son réseau Atelier 90 min 🔒
- Correction du lab 12 : Ingress, Gateway API et NetworkPolicies Correction 40 min 🔒
- Fiche mémo du jour 12 Cours 10 min 🔒
- Quiz du jour 12 Quiz 25 min 🔒
Jour 13 Garder les données : volumes, PersistentVolumes, StorageClasses et StatefulSets9 leçons · 5 h 17
Choisir le bon type de volume, comprendre le couple PersistentVolume et PersistentVolumeClaim (modes d'accès, politique de récupération, liaison), provisionner dynamiquement avec une StorageClass, agrandir un volume, puis faire de la base de ResaClub un StatefulSet dont les données survivent à tout.
- Les volumes d'un Pod Cours 35 min 🔒
- PersistentVolumes et PersistentVolumeClaims Cours 45 min 🔒
- StorageClasses et provisionnement dynamique Cours 35 min 🔒
- Les StatefulSets : des Pods avec une identité Cours 40 min 🔒
- Vidéo : des données qui survivent Vidéo 7 min 🔒
- Lab 13 : la base de ResaClub ne perd plus rien Atelier 85 min 🔒
- Correction du lab 13 : PV, PVC et StatefulSet Correction 35 min 🔒
- Fiche mémo du jour 13 Cours 10 min 🔒
- Quiz du jour 13 Quiz 25 min 🔒
Jour 14 Sécuriser le cluster : authentification, RBAC, comptes de service et sécurité des Pods11 leçons · 6 h 27
Suivre une requête de kubectl à travers l'authentification, l'autorisation et l'admission, créer un utilisateur avec un certificat signé par le cluster, lui donner exactement les droits nécessaires avec le RBAC, gérer les comptes de service des applications, puis durcir les Pods avec le securityContext et les Pod Security Standards.
- Le chemin d'une requête vers l'API Cours 40 min 🔒
- Créer un utilisateur avec un certificat Cours 30 min 🔒
- Le RBAC : des droits au plus juste Cours 50 min 🔒
- Les comptes de service Cours 30 min 🔒
- Durcir les Pods : securityContext et Pod Security Standards Cours 40 min 🔒
- Labo : les droits de l'équipe de Bastien Cours 25 min 🔒
- Vidéo : qui a le droit de faire quoi Vidéo 7 min 🔒
- Lab 14 : des accès propres pour Kalypso Sports Atelier 90 min 🔒
- Correction du lab 14 : certificats, RBAC et sécurité des Pods Correction 40 min 🔒
- Fiche mémo du jour 14 Cours 10 min 🔒
- Quiz du jour 14 Quiz 25 min 🔒
Jour 15 Industrialiser : Helm, Kustomize, CRD et opérateurs10 leçons · 5 h 42
Installer et mettre à jour des applications avec Helm, construire un chart pour ResaClub, gérer les différences entre développement et production avec Kustomize, comprendre comment les CustomResourceDefinitions et les opérateurs étendent Kubernetes, et situer les interfaces CRI, CNI et CSI. Bilan de la semaine 3.
- Helm : le gestionnaire de paquets de Kubernetes Cours 45 min 🔒
- Écrire un chart pour ResaClub Cours 35 min 🔒
- Kustomize : des variantes sans modèles Cours 35 min 🔒
- Étendre Kubernetes : CRD, opérateurs et interfaces Cours 35 min 🔒
- Vidéo : installer et décliner des applications Vidéo 7 min 🔒
- Lab 15 : ResaClub en chart et en overlays Atelier 85 min 🔒
- Correction du lab 15 : Helm, Kustomize et CRD Correction 35 min 🔒
- Fiche mémo du jour 15 Cours 10 min 🔒
- Quiz du jour 15 Quiz 25 min 🔒
- Bilan de la semaine 3 Quiz 30 min 🔒
Jour 16 Construire un vrai cluster avec kubeadm9 leçons · 5 h 57
Préparer trois machines (noyau, swap, containerd avec le pilote systemd, paquets kubeadm, kubelet et kubectl), initialiser le plan de contrôle, installer le plugin réseau Calico, joindre les nœuds de travail, puis comprendre ce que kubeadm a créé et comment on construit un plan de contrôle hautement disponible.
- Préparer les nœuds Cours 45 min 🔒
- Initialiser le plan de contrôle et joindre les nœuds Cours 45 min 🔒
- Anatomie d'un nœud kubeadm Cours 35 min 🔒
- Un plan de contrôle hautement disponible Cours 30 min 🔒
- Vidéo : un cluster de A à Z Vidéo 7 min 🔒
- Lab 16 : le cluster de recette de Kalypso Sports Atelier 120 min 🔒
- Correction du lab 16 : un cluster kubeadm Correction 40 min 🔒
- Fiche mémo du jour 16 Cours 10 min 🔒
- Quiz du jour 16 Quiz 25 min 🔒
Jour 17 Maintenir le cluster : nœuds, mises à jour et sauvegarde d'etcd8 leçons · 5 h 27
Vider et isoler un nœud pour une maintenance (cordon, drain, PodDisruptionBudget), mettre à jour un cluster kubeadm d'une version mineure en respectant l'ordre et les écarts de versions autorisés, puis sauvegarder et restaurer etcd, la mémoire du cluster.
- Mettre un nœud en maintenance Cours 35 min 🔒
- Mettre à jour un cluster kubeadm Cours 50 min 🔒
- Sauvegarder et restaurer etcd Cours 50 min 🔒
- Vidéo : entretenir un cluster Vidéo 7 min 🔒
- Lab 17 : la nuit de maintenance de Kalypso Sports Atelier 110 min 🔒
- Correction du lab 17 : maintenance, mise à jour et etcd Correction 40 min 🔒
- Fiche mémo du jour 17 Cours 10 min 🔒
- Quiz du jour 17 Quiz 25 min 🔒
Jour 18 Dépanner : applications, plan de contrôle, nœuds et réseau10 leçons · 6 h 48
Adopter une méthode de diagnostic systématique, puis l'appliquer aux quatre familles de pannes du domaine le plus lourd de l'examen (30 %) : les applications, le plan de contrôle, les nœuds et le réseau. Journaux, événements, métriques, kubectl debug, crictl et journalctl.
- Une méthode pour ne jamais rester bloqué Cours 35 min 🔒
- Dépanner les applications Cours 40 min 🔒
- Dépanner le plan de contrôle et les nœuds Cours 50 min 🔒
- Dépanner le réseau et surveiller les ressources Cours 35 min 🔒
- Labo : la nuit des pannes Cours 30 min 🔒
- Vidéo : la méthode du dépanneur Vidéo 8 min 🔒
- Lab 18 : douze pannes sur le cluster de recette Atelier 130 min 🔒
- Correction du lab 18 : douze pannes Correction 45 min 🔒
- Fiche mémo du jour 18 Cours 10 min 🔒
- Quiz du jour 18 Quiz 25 min 🔒
Jour 19 Le projet final et l'examen pratique blanc7 leçons · 6 h 51
Préparer le jour de l'examen (environnement, gestion du temps, réflexes), mettre ResaClub en production sur le cluster kubeadm en réunissant tout le parcours, puis passer un examen pratique blanc de 17 tâches en 2 heures, dans les conditions du CKA, avec sa correction détaillée et son barème.
- Le jour de l'examen : stratégie et réflexes Cours 35 min 🔒
- Vidéo : deux heures pour réussir Vidéo 6 min 🔒
- Projet final : ResaClub en production Atelier 150 min 🔒
- Correction du projet final Correction 40 min 🔒
- Examen pratique blanc : 17 tâches en 2 heures Atelier 120 min 🔒
- Correction de l'examen pratique blanc Correction 50 min 🔒
- Fiche mémo du jour 19 : la check-list du jour J Cours 10 min 🔒
Jour 20 Examens blancs, révisions et examen final9 leçons · 5 h 30
Deux examens blancs de 60 questions pondérés comme les cinq domaines du CKA, un atelier d'analyse de vos résultats, un guide de remédiation, le lexique français-anglais de Kubernetes, les conseils pour la suite, puis l'examen final du parcours qui donne accès au certificat Égide Academy.
- Consignes des examens blancs Cours 10 min 🔒
- Examen blanc n°1 (60 questions, 75 minutes) Quiz 75 min 🔒
- Atelier 20 : analyser ses résultats Atelier 30 min 🔒
- Guide de remédiation : les confusions qui coûtent des points Correction 25 min 🔒
- Lexique français-anglais de Kubernetes Cours 15 min 🔒
- Examen blanc n°2 (60 questions, 75 minutes) Quiz 75 min 🔒
- Et après : s'inscrire, réussir, continuer Cours 15 min 🔒
- Fiche mémo du jour 20 : les chiffres et les chemins Cours 10 min 🔒
- Examen final Docker et Kubernetes (50 questions) Examen 75 min 🔒