Travaux pratiques Avancé Gratuit
TP Kubernetes
Cinq ateliers : fondations, configuration, Traefik, Helm et Argo CD sur un cluster local.
- 5 ateliers
- 59 étapes
Fondations Kubernetes
Créer un cluster, déployer les cinq services et comprendre leur communication.
3h30 Fondations 12 étapes
Cinq Deployments et Services disponibles ; une page HTML affiche le message de l’API ; les outils MariaDB et Mailpit sont consultables.
Prérequis
- Docker Engine et k3d fonctionnels
- kubectl installé
- Application Docker du TP précédent
Préparer le cluster et les images
-
Étape 1 : Vérifier les outils
Vérifier que Docker, k3d et kubectl répondent ; expliquer le rôle de chacun.
docker version && k3d version && kubectl version --clientLes trois commandes s’exécutent sans erreur.
-
Étape 2 : Démarrer le cluster
Exécuter le script fourni ; identifier le nœud de contrôle et le nœud worker.
bash scripts/01-setup-cluster.sh && kubectl get nodesLes nœuds sont Ready.
-
Étape 3 : Construire les images
Reprendre les Dockerfiles PHP et Node/SCSS du projet précédent ; construire et charger les images dans k3d.
bash scripts/02-build-images.shLes images tp-lab-api:1.0 et tp-lab-app:1.0 sont disponibles sur les nœuds.
-
Étape 4 : Créer le Namespace
Lire le manifeste Namespace puis créer le périmètre tp-devops.
kubectl apply -f niveau-01/00-namespace.yamlLe Namespace tp-devops apparaît dans kubectl get ns.
Déployer les objets Kubernetes
-
Étape 5 : Repérer les objets YAML
Lire apiVersion, kind, metadata et spec ; expliquer le lien labels/selectors.
cat niveau-01/10-app.yamlChaque ressource a un rôle identifié.
-
Étape 6 : Reconstituer les Deployments manquants
À partir des Services fournis, créer api, app, phpmyadmin et mailpit et affecter les images, ports et variables.
kubectl apply -f etudiants/niveau-01/10-app.yamlTous les Deployments existent sans InvalidImageName ni selector incohérent.
-
Étape 7 : Démarrer les cinq services
Appliquer le manifeste complété. Utiliser les commandes get et describe pour analyser les erreurs éventuelles.
kubectl get deploy,pods,svc -n tp-devopsLes cinq Services sont présents et les Pods deviennent Ready.
-
Étape 8 : Comprendre la résolution DNS
Expliquer pourquoi l’API contacte la base via mariadb:3306, et non localhost.
kubectl get svc -n tp-devopsLes adresses DNS internes correspondent aux noms des Services.
Tester et observer
-
Étape 9 : Ouvrir le frontend
Établir un tunnel de port vers Service/app et visiter le navigateur.
kubectl port-forward -n tp-devops service/app 8080:80La page HTML répond sur http://localhost:8080.
-
Étape 10 : Tester l’API et MariaDB
Afficher Hello World et le compteur de messages. Si 503, patienter pendant l’initialisation de MariaDB.
curl http://localhost:8080/api/helloUne réponse JSON contient database_connected et messages_count.
-
Étape 11 : Inspecter phpMyAdmin et Mailpit
Établir deux tunnels dans des terminaux séparés, puis tester l’envoi d’un message.
kubectl port-forward -n tp-devops svc/phpmyadmin 8081:80Le message apparaît dans la base et l’email dans Mailpit (port 8025).
-
Étape 12 : Diagnostiquer les conteneurs
Lire les logs et décrire l’état d’un Pod ; identifier les phases du cycle de vie.
kubectl logs -n tp-devops deployment/api --tail=40Les étudiants expliquent une erreur probable et sa méthode de diagnostic.
Ressources
- Pods — documentation Kubernetes — Comprendre ce qui exécute réellement les conteneurs
- Deployment — documentation — Contrôleur de déploiement et réplicas
- Service — documentation — Accès réseau stable aux Pods
- k3d — guide de démarrage — Cluster Kubernetes local
- kubectl port-forward — Exposer temporairement un service
Configuration et exploitation
Séparer la configuration, maintenir les données et observer la santé des services.
3h30 Exploitation 12 étapes
Base persistante après recréation du Pod, configuration externalisée, réplicas opérationnels et sondes de santé observables.
Prérequis
- Niveau 1 acquis
- Namespace tp-devops actif
- Manifestes corrigés N2 disponibles
Externaliser la configuration
-
Étape 1 : Observer les limites du niveau 1
Identifier les informations codées en dur et distinguer la configuration applicative des mots de passe.
Lister au moins trois paramètres à externaliser.
-
Étape 2 : Créer un ConfigMap
Déployer les valeurs DB_HOST, DB_NAME, SMTP_HOST et autres paramètres non secrets.
kubectl apply -f niveau-02/10-config.yamlkubectl get cm tp-config -n tp-devops affiche le ConfigMap.
-
Étape 3 : Créer un Secret pédagogique
Lire secretKeyRef ; expliquer que le Secret Kubernetes n’est pas un coffre-fort et que les valeurs du TP sont factices.
kubectl get secret tp-db-auth -n tp-devopsLe secret contient les deux clés attendues sans révéler de vraies données.
-
Étape 4 : Référencer la configuration
Relier l’API à envFrom ConfigMap et à secretKeyRef pour DB_PASSWORD.
kubectl describe deployment api -n tp-devopsLe Pod lit les bonnes variables d’environnement.
Stockage et état
-
Étape 5 : Supprimer le Deployment MariaDB du N1
Éviter deux contrôleurs concurrents avant de créer le StatefulSet.
kubectl delete deployment mariadb -n tp-devops --ignore-not-foundUn seul contrôleur gère les Pods MariaDB.
-
Étape 6 : Écrire le StatefulSet
Reconstituer le manifeste avec volumeClaimTemplates, serviceName et montage /var/lib/mysql.
Le YAML passe la validation et spécifie 1Gi de stockage.
-
Étape 7 : Créer le PVC
Appliquer les manifests et examiner StatefulSet, Pod et PersistentVolumeClaim.
kubectl get sts,pod,pvc -n tp-devopsLe PVC est Bound et mariadb-0 est Ready.
-
Étape 8 : Tester la persistance
Créer un message, supprimer le Pod mariadb-0 et vérifier le compteur après redémarrage.
kubectl delete pod mariadb-0 -n tp-devopsLes données sont conservées ; le PVC reste présent.
Observabilité et maintenance
-
Étape 9 : Identifier les sondes
Différencier readiness, liveness et startup. Examiner les sondes ajoutées au corrigé.
kubectl describe pod -l app=api -n tp-devopsLa readiness est visible et agit sur la disponibilité du Pod.
-
Étape 10 : Évaluer les ressources
Lire requests/limits et expliquer une situation de manque de mémoire.
kubectl describe deployment api -n tp-devopsLe rôle de chaque valeur est correctement formulé.
-
Étape 11 : Modifier les réplicas
Passer temporairement le frontend à trois Pods puis revenir à deux.
kubectl scale deployment app --replicas=3 -n tp-devopsLe Service distribue vers plusieurs Pods.
-
Étape 12 : Analyser les mises à jour
Observer rollout status/history puis une modification d’image simulée si disponible.
kubectl rollout status deployment/app -n tp-devopsL’étudiant distingue mise à jour progressive et redémarrage de Pod.
Ressources
- ConfigMaps — Variables non sensibles
- Secrets — Gestion des données sensibles
- StatefulSet — Identité et persistance
- PVC et volumes — Stockage durable
- Probes — Santé et disponibilité
- Resource management — Requests et limits
Traefik et exposition réseau
Acheminer les requêtes HTTP vers les bons services et introduire l’isolation réseau.
3h30 Réseau 11 étapes
Une entrée HTTP sur le port 8088 distribue correctement le frontend, /api, phpMyAdmin et Mailpit.
Prérequis
- Niveau 2 terminé
- Traefik K3s disponible
- Port 8088 libre
Comprendre le chemin des requêtes
-
Étape 1 : Identifier Traefik intégré
Contrôler le contrôleur installé avec K3s ; ne pas lancer un deuxième Traefik.
kubectl get pods -n kube-systemUn contrôleur Traefik K3s fonctionne.
-
Étape 2 : Vérifier le port publié
Comprendre la publication hôte 8088 → load balancer K3d → port 80 Traefik.
curl -I http://127.0.0.1:8088Le port répond, même si le code HTTP n’est pas encore 200.
-
Étape 3 : Comparer port-forward et Ingress
Distinguer accès temporaire pour diagnostic et entrée HTTP partagée.
Expliquer l’usage de chaque mécanisme.
Configurer les routes
-
Étape 4 : Reconstituer l’Ingress principal
Définir Host tp.localhost, chemin /api vers Service api:8000, chemin / vers Service app:80.
Le manifeste répond au schéma networking.k8s.io/v1.
-
Étape 5 : Déployer les trois Ingress
Ajouter aussi db.tp.localhost et mail.tp.localhost.
kubectl apply -f niveau-03/30-ingress-policy.yamlLes trois objets Ingress apparaissent dans kubectl.
-
Étape 6 : Tester le frontend et l’API
Ouvrir le navigateur et analyser les réponses HTTP avec un header Host explicite.
curl -H "Host: tp.localhost" http://127.0.0.1:8088/api/helloLe front et le JSON API passent via Traefik.
-
Étape 7 : Tester les outils
Vérifier les deux autres domaines ; expliquer la différence entre host et path.
Les deux tableaux de bord répondent sur le port 8088.
Isoler et sécuriser
-
Étape 8 : Étudier NetworkPolicy
Examiner la règle qui limite l’entrée TCP 3306 vers MariaDB aux Pods API et phpMyAdmin.
kubectl describe networkpolicy mariadb-access -n tp-devopsLes sources autorisées sont identifiées.
-
Étape 9 : Comprendre les limites de NetworkPolicy
Identifier le besoin d’un CNI qui applique les politiques et les limites d’isolation du laboratoire.
Les étudiants ne confondent pas NetworkPolicy et pare-feu Internet.
-
Étape 10 : Expliquer le TLS
Relever qu’un nom .localhost n’obtient pas automatiquement un certificat public reconnu.
Un plan de certification réel est formulé sans activer un faux HTTPS.
-
Étape 11 : Résoudre un scénario de routage
Tester une mauvaise route volontairement puis identifier Host, path, Service et port dans le diagnostic.
kubectl describe ingress tp-web -n tp-devopsUn 404 ou 502 est analysé méthodiquement.
Ressources
- Ingress Kubernetes — Règles de routage
- Traefik et Kubernetes Ingress — Contrôleur HTTP
- Networking K3s — Traefik fourni par défaut
- NetworkPolicies — Filtrage réseau entre Pods
- TLS et Ingress — Conditions de chiffrement HTTPS
Helm — Packaging et réutilisation
Transformer les manifestes en Chart paramétrable et gérer le cycle de vie d’une release.
3h30 Industrialisation 12 étapes
Un Chart Helm validé peut installer, mettre à jour et restaurer la stack, avec des values distinctes.
Prérequis
- Manifestes Kubernetes des niveaux 1 à 3 maîtrisés
- Helm installé
- Cluster prêt pour une installation propre
Comprendre un Chart
-
Étape 1 : Préparer le cluster sans conflit
Ne pas réappliquer les manifests manuels sur les mêmes ressources. Repartir si nécessaire d’un cluster propre.
Aucun contrôleur concurrent ne gère les mêmes ressources.
-
Étape 2 : Créer le Secret de démonstration
Le Chart référence un Secret externe tp-db-auth ; il ne stocke aucun mot de passe dans values.yaml.
kubectl create secret generic tp-db-auth -n tp-devops --from-literal=DB_PASSWORD=tp_demo_password --from-literal=MARIADB_ROOT_PASSWORD=tp_root_demoLe Secret existe et reste hors Chart GitOps.
-
Étape 3 : Explorer Chart.yaml et values.yaml
Identifier la version du Chart, la version applicative, les images et les réplicas.
Différencier appVersion et version du Chart.
-
Étape 4 : Lire les templates
Comprendre .Values, .Release.Namespace, pipelines quote et directives if.
L’étudiant peut expliquer une expression Helm.
Construire et valider
-
Étape 5 : Reconstituer le template Ingress
Utiliser les variables d’hôte et l’option ingress.enabled pour activer ou désactiver les routes.
Le template rend trois Ingress valides.
-
Étape 6 : Valider le Chart
Exécuter helm lint et afficher les manifestes générés avec helm template.
helm lint niveau-04/charts/tp-stackPas d’erreur de Chart.
-
Étape 7 : Installer la release
Installer le Chart avec values-dev.yaml dans le namespace tp-devops.
helm upgrade --install tp niveau-04/charts/tp-stack -n tp-devops -f niveau-04/charts/tp-stack/values-dev.yamlLa release existe et les services répondent.
-
Étape 8 : Distinguer template et objet appliqué
Comparer un template Helm généré et les ressources effectivement créées.
helm template tp niveau-04/charts/tp-stack -n tp-devopsLe lien entre values et manifeste final est établi.
Faire évoluer et restaurer
-
Étape 9 : Simuler un environnement plus chargé
Utiliser values-prod-simule.yaml pour augmenter les réplicas du frontend.
helm upgrade tp niveau-04/charts/tp-stack -n tp-devops -f niveau-04/charts/tp-stack/values-prod-simule.yamlLe nombre de Pods app varie.
-
Étape 10 : Observer l’historique
Lister les révisions Helm et expliquer la notion de release.
helm history tp -n tp-devopsAu moins deux révisions visibles.
-
Étape 11 : Effectuer un rollback
Revenir à la révision antérieure et comparer le nombre de réplicas.
helm rollback tp 1 -n tp-devopsLe nombre de Pods retrouve sa valeur précédente.
-
Étape 12 : Vérifier la réutilisabilité
Modifier une valeur sans réécrire les templates et expliquer l’intérêt pour dev / production simulée.
Chart paramétrable et hypothèses de sécurité explicitées.
Ressources
- Charts Helm — Structure Chart.yaml / values.yaml / templates
- Guide templates Helm — Fonctions et expressions Go
- Commandes Helm — install, upgrade, history et rollback
- Helm values — Priorités et fichiers de valeurs
Argo CD — GitOps et réconciliation
Mettre Git au centre du déploiement et observer la convergence automatique de Kubernetes.
3h30 GitOps 12 étapes
Le Chart est déployé depuis un dépôt Git accessible, ses changements sont synchronisés et une dérive manuelle est corrigée.
Prérequis
- Chart Helm opérationnel
- Un dépôt Git réellement accessible à Argo CD
- Cluster avec images disponibles
- Aucune release Helm concurrente
Installer et préparer Git
-
Étape 1 : Réserver Git comme source de vérité
Copier le Chart dans un dépôt Git accessible ; ne pas committer de vrais mots de passe.
git status && git remote -vUn dépôt distant authentique est identifié.
-
Étape 2 : Éliminer les outils concurrents
Supprimer la release Helm CLI avant de remettre les ressources à Argo CD ; conserver ou recréer le Secret pédagogique.
helm list -n tp-devopsLa même application n’est pas contrôlée par deux outils.
-
Étape 3 : Installer Argo CD
Installer les manifestes officiels, vérifier les Pods et noter la disponibilité.
kubectl apply -n argocd --server-side --force-conflicts -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yamlTous les contrôleurs requis démarrent.
-
Étape 4 : Ouvrir Argo CD localement
Utiliser le port-forward HTTPS de l’interface ; ne pas publier l’interface avec des identifiants initiaux.
kubectl port-forward svc/argocd-server -n argocd 8443:443L’interface Argo CD est disponible via https://localhost:8443.
Déclarer l’application
-
Étape 5 : Construire le manifeste Application
Ajouter repoURL réel, targetRevision, path, valeurs Helm et destination Kubernetes.
Le YAML ne contient plus de placeholders Git.
-
Étape 6 : Déployer l’Application
Appliquer la ressource dans le namespace argocd et vérifier ses conditions.
kubectl apply -f niveau-05/gitops/argocd/application.yamlL’objet Application apparaît.
-
Étape 7 : Observer la synchronisation
Contrôler l’état Synced / Healthy et comprendre les conditions qui peuvent retarder Healthy.
kubectl get applications -n argocdL’application converge vers l’état souhaité.
-
Étape 8 : Vérifier le parcours utilisateur
Accéder au front, envoyer un message, vérifier la base et Mailpit.
curl -H "Host: tp.localhost" http://127.0.0.1:8088/api/helloLa stack reste fonctionnelle après migration GitOps.
Tester la réconciliation et conclure
-
Étape 9 : Modifier les réplicas dans Git
Changer app.replicas dans values-dev.yaml, pousser le commit et attendre Argo CD.
git add . && git commit -m "tp: augmenter replicas" && git pushLe Deployment app adopte la valeur de Git.
-
Étape 10 : Créer volontairement une dérive
Modifier manuellement les réplicas via kubectl pendant que selfHeal est activé.
kubectl scale deploy app --replicas=4 -n tp-devopsArgo CD détecte et corrige la dérive.
-
Étape 11 : Restaurer depuis Git
Revenir à un commit antérieur, pousser et vérifier la synchronisation.
git revert <identifiant-du-commit> && git pushL’état désiré antérieur est rétabli.
-
Étape 12 : Soutenance technique
Présenter les rôles respectifs de Docker, Kubernetes, Helm et Argo CD ; citer risques et limites du TP.
Une démonstration de 5 minutes valide l’autonomie.
Ressources
- Démarrage Argo CD — Installer et accéder à Argo CD
- Argo CD + Helm — Rendu Helm et gestion du cycle de vie
- Sync automatisée — Prune, self-heal, sync
- Application declarative — Ressource Application et état désiré
- Concepts GitOps — Principes de base GitOps
Dans la même série Étape 2 sur 2
- 1 Cours Kubernetes — Le cours
-
2 TP TP Kubernetes Vous êtes ici
Dans la même catégorie
Infra · Intermédiaire
Docker & Docker Compose — Le cours
Images, conteneurs, volumes, réseaux et Compose : le lexique, les commandes essentielles et les bonnes pratiques.
Infra · Intermédiaire
Kubernetes — Le cours
Pods, déploiements, services, configuration et stockage : orchestrer des conteneurs, de la théorie à kubectl.
Infra · Intermédiaire
Terraform & Ansible — Le cours
Décrire l'infrastructure avec Terraform et la configurer avec Ansible : providers, playbooks, rôles et idempotence.