Kubernetes : les fondamentaux

Ce cours ouvre la partie Kubernetes du chapitre Héberger. Il s'adresse aux personnes qui savent faire tourner un conteneur avec Docker et qui doivent maintenant en faire tourner beaucoup, sur plusieurs machines, sans les surveiller une à une : développeurs qui déploient sur un cluster, administrateurs qui en héritent, profils DevOps. Il suppose le cours Docker : les fondamentaux, l'aisance en ligne de commande, et les notions de réseau du cours Le modèle TCP/IP.

L'approche

Kubernetes a la réputation d'être compliqué, et il l'est : son API compte des dizaines de types d'objets. Mais presque tout repose sur une idée simple, déjà rencontrée dans le cours GitOps avec Argo CD : on déclare l'état voulu, et des contrôleurs travaillent sans relâche à en rapprocher la réalité. Le cours part de cette idée et n'introduit chaque objet qu'au moment où l'on en a besoin pour faire tourner Signalements, l'API Flask et PostgreSQL des cours précédents.

Les exercices se font sur un cluster local kind, comme dans le cours GitOps, ou sur un cluster Kapsule chez Scaleway pour qui en a un. Les manifestes des leçons sont écrits d'après la documentation et la référence de l'API de Kubernetes 1.36, et vérifiés par kubectl en mode client ; les leçons ne présentent pas de sortie de commande inventée, et décrivent ce que vous devez observer.

Le réseau en profondeur, le stockage, les workloads avancés et l'administration d'un cluster font chacun l'objet d'un cours de la partie ; Helm et Kapsule aussi.

Ce qu'il faut

• Docker, kubectl 1.36 et kind (installation décrite à la leçon 3), ou un cluster Kapsule et son kubeconfig.
• Environ 4 Go de mémoire libre pour le cluster local.
• L'image de Signalements, ghcr.io/lyneko-formation/signalements:1.2.0.

Les leçons

1. Pourquoi Kubernetes
2. L'architecture d'un cluster
3. kubectl et l'API
4. Les pods
5. Deployments et mises à jour progressives
6. Services et DNS
7. ConfigMaps et Secrets
8. Ressources, planification et qualité de service
9. Volumes et stockage persistant
10. Jobs, CronJobs, DaemonSets et StatefulSets
11. Déployer Signalements de bout en bout
12. Diagnostiquer les pannes courantes

Pour valider : le quiz (niveau 100) et le lab (niveau 200).

Plan du cours

1. Pourquoi Kubernetes 50 min 100 Comprendre
   Ce que Kubernetes résout quand une application conteneurisée doit tourner sur plusieurs machines : placement, redémarrage, mise à jour, découverte, mise à l'échelle. L'idée centrale de l'état voulu et des boucles de contrôle, l'histoire depuis Borg, ce que Kubernetes n'est pas, et quand ne pas l'utiliser.
2. L'architecture d'un cluster 55 min 100 Comprendre
   Les composants d'un cluster Kubernetes et leur rôle : serveur d'API, etcd, ordonnanceur, gestionnaire de contrôleurs, kubelet, runtime de conteneurs, kube-proxy, CoreDNS et CNI. Le chemin complet d'une commande kubectl apply jusqu'au conteneur, le mécanisme de surveillance qui relie tout, et ce que gère un Kubernetes managé.
3. kubectl et l'API 1 h 100 Comprendre
   Installer kind et créer le cluster du cours dans un kubeconfig dédié, comprendre le fichier kubeconfig (clusters, utilisateurs, contextes), la structure d'un objet et l'organisation de l'API en groupes, versions et ressources, puis les commandes kubectl qui servent tous les jours : get, describe, apply, diff, les formats de sortie, les étiquettes et les namespaces.
4. Les pods 1 h 15 200 Pratiquer
   Le Pod, plus petite unité que Kubernetes sait faire tourner : ce qu'il partage entre ses conteneurs, son cycle de vie et ses phases, les redémarrages et le CrashLoopBackOff, les conteneurs d'initialisation et les sidecars natifs, les trois sondes et le piège d'une sonde de vie qui teste la base, l'arrêt propre avec SIGTERM et preStop, et les commandes pour observer un pod.
5. Deployments et mises à jour progressives 1 h 15 200 Pratiquer
   Confier les pods à un contrôleur : ReplicaSet et Deployment, étiquettes et sélecteurs, mise à l'échelle, mise à jour progressive avec maxSurge et maxUnavailable, historique et retour arrière, ce qui déclenche un nouveau déploiement, déploiement sans coupure, PodDisruptionBudget, et pourquoi on ne fait pas kubectl set image en production.
6. Services et DNS 1 h 15 200 Pratiquer
   Donner une adresse stable à des pods qui changent : le Service ClusterIP et son adresse virtuelle, les EndpointSlices, ce que kube-proxy programme dans chaque nœud, le DNS des services et l'effet de ndots, NodePort et LoadBalancer (un Load Balancer Scaleway chez Kapsule), Services headless et ExternalName, affinité et répartition topologique, puis l'exposition de Signalements.
7. ConfigMaps et Secrets 1 h 15 200 Pratiquer
   Séparer la configuration de l'image : créer et consommer des ConfigMaps et des Secrets, comprendre ce qui est mis à jour à chaud et ce qui ne l'est pas, pourquoi base64 n'est pas du chiffrement, ce que protègent le chiffrement au repos et le contrôle d'accès, et comment fournir à Signalements l'adresse de sa base sans l'écrire dans Git.
8. Ressources, planification et qualité de service 1 h 20 200 Pratiquer
   Dimensionner les conteneurs avec les requests et les limits, comprendre ce que le planificateur et le noyau en font, lire les classes de qualité de service et l'ordre d'éviction, encadrer un namespace, répartir Signalements sur plusieurs nœuds et plusieurs zones, et poser un premier HorizontalPodAutoscaler.
9. Volumes et stockage persistant 1 h 20 200 Pratiquer
   Pourquoi les données d'un conteneur disparaissent, les volumes éphémères, puis le stockage persistant : PersistentVolume, PersistentVolumeClaim, StorageClass et provisionnement dynamique par CSI, modes d'accès, politique de récupération, agrandissement et instantanés, ce que fournissent kind et Scaleway, et une base PostgreSQL de formation qui survit à ses pods.
10. Jobs, CronJobs, DaemonSets et StatefulSets 1 h 200 Pratiquer
    Les contrôleurs qui complètent le Deployment : le Job pour une tâche qui doit se terminer (la migration de schéma de Signalements), le CronJob pour une tâche planifiée (la purge nocturne), le DaemonSet pour un pod par nœud, et le StatefulSet pour une identité et un stockage stables. Ce que chacun garantit, ce qu'il ne fait pas, et comment choisir.
11. Déployer Signalements de bout en bout 2 h 200 Pratiquer
    Assembler tout le cours : un namespace au profil de sécurité restricted, des Secrets, une base PostgreSQL de formation en StatefulSet, la migration en Job, l'API en Deployment durci et réparti, un Service, un PodDisruptionBudget, puis l'exposition par Gateway API avec Traefik, sur kind et sur Kapsule. Le tout rassemblé dans une kustomization.
12. Diagnostiquer les pannes courantes 1 h 30 200 Pratiquer
    Une méthode pour remonter d'un symptôme à sa cause dans un cluster Kubernetes : lire les états d'un pod (Pending, ImagePullBackOff, CrashLoopBackOff, CreateContainerConfigError, Running mais pas prêt), les événements, les journaux du conteneur précédent, un Service sans points de terminaison, le DNS, les objets bloqués en Terminating, puis déboguer avec un conteneur éphémère. Six pannes de Signalements corrigées.