Infra

Travaux pratiques Avancé Gratuit

TP Kubernetes

Cinq ateliers : fondations, configuration, Traefik, Helm et Argo CD sur un cluster local.

  • 5 ateliers
  • 59 étapes
Commencer le TP

Fondations Kubernetes

Créer un cluster, déployer les cinq services et comprendre leur communication.

3h30 Fondations 12 étapes

Résultat attendu

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

Étapes du TP

Préparer le cluster et les images

  1. É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 --client

    Les trois commandes s’exécutent sans erreur.

  2. É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 nodes

    Les nœuds sont Ready.

  3. É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.sh

    Les images tp-lab-api:1.0 et tp-lab-app:1.0 sont disponibles sur les nœuds.

  4. É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.yaml

    Le Namespace tp-devops apparaît dans kubectl get ns.

Déployer les objets Kubernetes

  1. Étape 5 : Repérer les objets YAML

    Lire apiVersion, kind, metadata et spec ; expliquer le lien labels/selectors.

    cat niveau-01/10-app.yaml

    Chaque ressource a un rôle identifié.

  2. É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.yaml

    Tous les Deployments existent sans InvalidImageName ni selector incohérent.

  3. É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-devops

    Les cinq Services sont présents et les Pods deviennent Ready.

  4. É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-devops

    Les adresses DNS internes correspondent aux noms des Services.

Tester et observer

  1. É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:80

    La page HTML répond sur http://localhost:8080.

  2. É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/hello

    Une réponse JSON contient database_connected et messages_count.

  3. É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:80

    Le message apparaît dans la base et l’email dans Mailpit (port 8025).

  4. É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=40

    Les étudiants expliquent une erreur probable et sa méthode de diagnostic.

Ressources

Configuration et exploitation

Séparer la configuration, maintenir les données et observer la santé des services.

3h30 Exploitation 12 étapes

Résultat attendu

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

Étapes du TP

Externaliser la configuration

  1. É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.

  2. É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.yaml

    kubectl get cm tp-config -n tp-devops affiche le ConfigMap.

  3. É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-devops

    Le secret contient les deux clés attendues sans révéler de vraies données.

  4. Étape 4 : Référencer la configuration

    Relier l’API à envFrom ConfigMap et à secretKeyRef pour DB_PASSWORD.

    kubectl describe deployment api -n tp-devops

    Le Pod lit les bonnes variables d’environnement.

Stockage et état

  1. É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-found

    Un seul contrôleur gère les Pods MariaDB.

  2. É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.

  3. Étape 7 : Créer le PVC

    Appliquer les manifests et examiner StatefulSet, Pod et PersistentVolumeClaim.

    kubectl get sts,pod,pvc -n tp-devops

    Le PVC est Bound et mariadb-0 est Ready.

  4. É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-devops

    Les données sont conservées ; le PVC reste présent.

Observabilité et maintenance

  1. É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-devops

    La readiness est visible et agit sur la disponibilité du Pod.

  2. Étape 10 : Évaluer les ressources

    Lire requests/limits et expliquer une situation de manque de mémoire.

    kubectl describe deployment api -n tp-devops

    Le rôle de chaque valeur est correctement formulé.

  3. Étape 11 : Modifier les réplicas

    Passer temporairement le frontend à trois Pods puis revenir à deux.

    kubectl scale deployment app --replicas=3 -n tp-devops

    Le Service distribue vers plusieurs Pods.

  4. É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-devops

    L’étudiant distingue mise à jour progressive et redémarrage de Pod.

Ressources

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

Résultat attendu

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

Étapes du TP

Comprendre le chemin des requêtes

  1. É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-system

    Un contrôleur Traefik K3s fonctionne.

  2. É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:8088

    Le port répond, même si le code HTTP n’est pas encore 200.

  3. É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

  1. É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.

  2. Étape 5 : Déployer les trois Ingress

    Ajouter aussi db.tp.localhost et mail.tp.localhost.

    kubectl apply -f niveau-03/30-ingress-policy.yaml

    Les trois objets Ingress apparaissent dans kubectl.

  3. É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/hello

    Le front et le JSON API passent via Traefik.

  4. É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

  1. É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-devops

    Les sources autorisées sont identifiées.

  2. É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.

  3. É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.

  4. É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-devops

    Un 404 ou 502 est analysé méthodiquement.

Ressources

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

Résultat attendu

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

Étapes du TP

Comprendre un Chart

  1. É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.

  2. É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_demo

    Le Secret existe et reste hors Chart GitOps.

  3. É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.

  4. Étape 4 : Lire les templates

    Comprendre .Values, .Release.Namespace, pipelines quote et directives if.

    L’étudiant peut expliquer une expression Helm.

Construire et valider

  1. É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.

  2. É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-stack

    Pas d’erreur de Chart.

  3. É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.yaml

    La release existe et les services répondent.

  4. É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-devops

    Le lien entre values et manifeste final est établi.

Faire évoluer et restaurer

  1. É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.yaml

    Le nombre de Pods app varie.

  2. Étape 10 : Observer l’historique

    Lister les révisions Helm et expliquer la notion de release.

    helm history tp -n tp-devops

    Au moins deux révisions visibles.

  3. Étape 11 : Effectuer un rollback

    Revenir à la révision antérieure et comparer le nombre de réplicas.

    helm rollback tp 1 -n tp-devops

    Le nombre de Pods retrouve sa valeur précédente.

  4. É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

Argo CD — GitOps et réconciliation

Mettre Git au centre du déploiement et observer la convergence automatique de Kubernetes.

3h30 GitOps 12 étapes

Résultat attendu

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

Étapes du TP

Installer et préparer Git

  1. É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 -v

    Un dépôt distant authentique est identifié.

  2. É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-devops

    La même application n’est pas contrôlée par deux outils.

  3. É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.yaml

    Tous les contrôleurs requis démarrent.

  4. É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:443

    L’interface Argo CD est disponible via https://localhost:8443.

Déclarer l’application

  1. É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.

  2. É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.yaml

    L’objet Application apparaît.

  3. Étape 7 : Observer la synchronisation

    Contrôler l’état Synced / Healthy et comprendre les conditions qui peuvent retarder Healthy.

    kubectl get applications -n argocd

    L’application converge vers l’état souhaité.

  4. É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/hello

    La stack reste fonctionnelle après migration GitOps.

Tester la réconciliation et conclure

  1. É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 push

    Le Deployment app adopte la valeur de Git.

  2. É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-devops

    Argo CD détecte et corrige la dérive.

  3. Étape 11 : Restaurer depuis Git

    Revenir à un commit antérieur, pousser et vérifier la synchronisation.

    git revert <identifiant-du-commit> && git push

    L’état désiré antérieur est rétabli.

  4. É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

Dans la même série Étape 2 sur 2

  1. 1 Cours Kubernetes — Le cours
  2. 2 TP TP Kubernetes Vous êtes ici

Partager cet article

Dans la même catégorie

Cours

Infra · Intermédiaire

Docker & Docker Compose — Le cours

Images, conteneurs, volumes, réseaux et Compose : le lexique, les commandes essentielles et les bonnes pratiques.

3 guides · 132 notions Dans la même série

Cours

Infra · Intermédiaire

Kubernetes — Le cours

Pods, déploiements, services, configuration et stockage : orchestrer des conteneurs, de la théorie à kubectl.

3 guides · 159 notions Dans la même série

Cours

Infra · Intermédiaire

Terraform & Ansible — Le cours

Décrire l'infrastructure avec Terraform et la configurer avec Ansible : providers, playbooks, rôles et idempotence.

3 guides · 146 notions Dans la même série