Les conteneurs : Docker et Kubernetes
Partie 3 sur 3
5Kubernetes, l’orchestrateur
5.1Pourquoi orchestrer ?
Lancer un conteneur sur une machine est simple. En faire fonctionner des centaines, répartis sur des dizaines de machines, qui doivent communiquer entre eux, survivre aux pannes, être mis à jour sans interruption et s’adapter à la charge, ne l’est pas. C’est le rôle d’un orchestrateur. Kubernetes, du grec « timonier » (souvent abrégé en K8s, les huit lettres entre le K et le s étant remplacées par leur nombre), s’est imposé face à ses concurrents à partir de 2017. Tous les grands fournisseurs de cloud en proposent une version gérée (voir IaaS, PaaS, SaaS).
5.2L’architecture
Une grappe Kubernetes comprend deux parties (figure 3) :
- le plan de contrôle, le cerveau de la grappe. Le serveur d’API est le point d’entrée unique : toutes les demandes, celles des administrateurs comme celles des composants internes, passent par lui. L’état complet de la grappe est stocké dans etcd, une base de données répartie et très fiable. L’ordonnanceur choisit sur quelle machine placer chaque nouveau groupe de conteneurs, en fonction des ressources disponibles et des contraintes. Les contrôleurs comparent en permanence l’état réel à l’état souhaité, et agissent pour les faire coïncider ;
- les nœuds, les machines, physiques ou virtuelles, qui font fonctionner les conteneurs. Sur chacune, un agent, le kubelet, reçoit ses instructions du serveur d’API et les applique en pilotant le moteur de conteneurs ; un autre composant, kube-proxy, gère les règles réseau qui acheminent le trafic vers les bons conteneurs.
5.3Décrire l’état souhaité
Avec Kubernetes, on ne dit pas « lance ce conteneur ici », on décrit l’état souhaité, dans des fichiers au format YAML, un format texte lisible, et Kubernetes se charge d’y parvenir et de l’y maintenir. Les principaux objets sont :
- le pod, la plus petite unité : un ou plusieurs conteneurs qui fonctionnent ensemble sur le même nœud et partagent la même adresse réseau ;
- le déploiement (en anglais Deployment), qui indique quelle image utiliser et combien de copies, ou réplicas, faire fonctionner : si un pod disparaît, un autre est recréé ;
- le service, qui donne une adresse et un nom stables à un ensemble de pods, et répartit le trafic entre eux, même si les pods changent ;
- l’Ingress ou la passerelle, qui expose des services au monde extérieur, en HTTPS (la version chiffrée du protocole du Web) ;
- les ConfigMaps et les Secrets, qui fournissent aux conteneurs leur configuration et leurs mots de passe, séparément des images ;
- les espaces de noms Kubernetes, qui découpent une grappe en zones logiques, par équipe ou par application, avec leurs propres droits.
Voici la description d’un déploiement de trois réplicas de l’application de la section 4 :
apiVersion: apps/v1
kind: Deployment
metadata:
name: monapp
spec:
replicas: 3
selector:
matchLabels:
app: monapp
template:
metadata:
labels:
app: monapp
spec:
containers:
- name: web
image: registre.example.org/equipe/monapp:1.0
ports:
- containerPort: 8000
resources:
requests: { cpu: "250m", memory: "256Mi" }
limits: { cpu: "500m", memory: "512Mi" }
La section resources indique ce que chaque conteneur demande, en millièmes de processeur (250m signifie un quart de cœur) et en mémoire, et ce qu’il ne doit pas dépasser : l’ordonnanceur s’en sert pour placer les pods là où il y a de la place (exercice 3).
5.4Ce que Kubernetes fait pour vous
- L’auto-réparation : un conteneur qui plante est redémarré ; un nœud qui tombe voit ses pods recréés ailleurs ; un conteneur qui ne répond plus à ses tests de santé est remplacé.
- La mise à l’échelle : le nombre de réplicas peut être ajusté automatiquement selon la charge, et, chez les fournisseurs de cloud, le nombre de nœuds aussi.
- Les mises à jour progressives : pour passer à une nouvelle version, Kubernetes remplace les pods un par un, en vérifiant que les nouveaux fonctionnent avant de supprimer les anciens, et peut revenir en arrière en cas de problème (exercice 4).
- La découverte des services : chaque service reçoit un nom, résolu par un DNS interne, l’annuaire qui traduit les noms en adresses (voir le DNS).
5.5Et les données ?
Les conteneurs sont jetables, mais les données ne le sont pas. Kubernetes fournit donc des volumes persistants, des espaces de stockage, disques du fournisseur de cloud ou partages réseau, qui existent indépendamment des pods et sont rattachés à celui qui en a besoin, même s’il change de nœud (voir le stockage en réseau). Pour les applications qui gardent un état, comme les bases de données, un objet particulier, le StatefulSet, donne à chaque réplica une identité et un stockage stables. Des programmes spécialisés, appelés opérateurs, automatisent ensuite les tâches d’un administrateur de base de données : création des répliques, sauvegardes, bascule en cas de panne, mises à jour. Beaucoup d’organisations préfèrent néanmoins confier leurs bases de données à un service géré, et ne garder dans Kubernetes que des applications sans état.
Pour installer une application complète, faite de nombreux objets, on utilise souvent Helm, un gestionnaire de paquets pour Kubernetes, qui regroupe toutes les descriptions dans un modèle paramétrable, appelé chart. Et pour savoir ce qui se passe dans des centaines de conteneurs éphémères, il faut une observabilité centralisée : collecte des journaux, des mesures et des traces de chaque requête à travers les services, car un conteneur détruit emporte ses journaux avec lui s’ils n’ont pas été envoyés ailleurs.
Cette puissance a un prix : Kubernetes est complexe à installer, à sécuriser et à exploiter. Pour une petite application, une plateforme à la demande ou un simple serveur avec quelques conteneurs suffit souvent.
Pour s’exercer
Exercice 2 : machines virtuelles ou conteneurs ?
Un serveur de 64 Go de mémoire doit héberger des instances d’une petite application qui utilise 200 Mo. En machine virtuelle, chaque instance demande en plus 1 Go pour son système invité ; en conteneur, le surcoût est d’environ 20 Mo. En gardant 4 Go pour l’hôte, combien d’instances peut-on loger dans chaque cas ?
Voir la réponse
Mémoire disponible : 60 Go, soit 61 440 Mo. En machines virtuelles : 61 440 ÷ 1 224 ≈ 50 instances. En conteneurs : 61 440 ÷ 220 ≈ 279 instances, plus de cinq fois plus. C’est cette densité, avec la rapidité de démarrage, qui explique le succès des conteneurs ; il faut toutefois mettre en regard leur isolation plus faible.
Exercice 3 : placer des pods
Un nœud dispose de 4 cœurs et de 16 Gio de mémoire, dont Kubernetes réserve 0,5 cœur et 1 Gio pour le système. Combien de pods du déploiement de la section 5.3, qui demandent chacun 250m de processeur et 256 Mio de mémoire, l’ordonnanceur peut-il y placer ?
Voir la réponse
Processeur disponible : 3,5 cœurs, soit 3 500m, donc 3 500 ÷ 250 = 14 pods. Mémoire disponible : 15 Gio, soit 15 360 Mio, donc 15 360 ÷ 256 = 60 pods. C’est le processeur qui limite : 14 pods au plus. L’ordonnanceur raisonne sur les demandes, et non sur la consommation réelle : des demandes surestimées gaspillent de la place, des demandes sous-estimées surchargent les nœuds.
Exercice 4 : une mise à jour progressive
Un déploiement de 10 réplicas passe à une nouvelle version. Kubernetes est réglé pour ne jamais avoir plus d’un pod indisponible, ni plus d’un pod en surplus. Chaque nouveau pod met 30 secondes à être prêt. Combien de pods fonctionnent au minimum pendant la mise à jour, et combien de temps dure-t-elle environ ?
Voir la réponse
Au minimum 9 pods sur 10 sont disponibles à tout moment, et au plus 11 existent. Au départ, Kubernetes arrête un ancien pod (il en reste 9) et crée deux nouveaux pods (on atteint 11 pods au total). Une fois ceux-ci prêts, 30 secondes plus tard, il recommence : chaque étape de 30 secondes remplace donc deux pods, et la mise à jour prend de l’ordre de 5 étapes, soit environ 2 minutes et demie, auxquelles s’ajoute le temps d’arrêt propre des anciens pods. Si les nouveaux pods échouent à leurs tests de santé, la mise à jour s’arrête d’elle-même, avec 9 anciens pods toujours en service, et l’on peut revenir à la version précédente.
Exercice 5 : un secret bien gardé ?
Dans un fichier de description Kubernetes publié par erreur sur un dépôt public, on trouve un Secret contenant la valeur bW90ZGVwYXNzZTIwMjY=. Est-ce grave ?
Voir la réponse
Oui. Les Secrets Kubernetes sont seulement codés en base64, une représentation du binaire en caractères imprimables, pas chiffrés : n’importe qui peut décoder cette valeur, qui donne motdepasse2026. Il faut considérer ce mot de passe comme compromis, le changer immédiatement, et à l’avenir garder les secrets hors des dépôts, dans un coffre-fort de secrets, avec le chiffrement des Secrets activé dans etcd.
Exercice 6 : relire un Dockerfile
Repérez les problèmes de ce Dockerfile : FROM inconnu/ubuntu-tout-en-un:latest, ENV DB_PASSWORD=Secret123, RUN apt-get install -y ssh, CMD ["/start.sh"], sans instruction USER.
Voir la réponse
1) L’image de base vient d’un auteur inconnu : elle peut contenir des failles ou des logiciels malveillants ; on préfère des images officielles ou vérifiées. 2) L’étiquette latest change dans le temps : on ne sait pas ce qu’on construit ; on fixe une version précise, voire l’empreinte de l’image. 3) Le mot de passe est écrit dans l’image : quiconque y a accès le lit ; il doit être fourni au démarrage par un mécanisme de secrets. 4) Installer un serveur SSH dans un conteneur est inutile et augmente la surface d’attaque. 5) Sans USER, l’application fonctionne en administrateur du conteneur, ce qui aggrave toute compromission.
6Ce que les conteneurs ont changé
6.1Les microservices
Les conteneurs ont accompagné l’essor des microservices : au lieu d’un seul gros programme, une application est découpée en petits services indépendants, chacun dans ses conteneurs, qui communiquent par le réseau, souvent par des API (Application Programming Interfaces, interfaces de programmation ; voir les API). Chaque service peut être développé, mis à jour et dimensionné séparément, par une petite équipe. En contrepartie, l’ensemble devient un système réparti, plus difficile à surveiller, à déboguer et à sécuriser ; beaucoup d’équipes reviennent à des applications plus grosses lorsque le découpage n’apporte pas de bénéfice réel.
6.2L’intégration et le déploiement continus
L’image de conteneur est devenue l’unité de livraison des logiciels. Dans une chaîne d’intégration et de déploiement continus (CI/CD, Continuous Integration / Continuous Delivery), chaque modification du code, enregistrée dans Git (voir Git), déclenche automatiquement la construction d’une image, ses tests, son analyse de sécurité, puis son déploiement en test et en production. La même image, identique au bit près, passe d’un environnement à l’autre : ce qui a été testé est exactement ce qui est livré. Cette démarche, dite DevOps, rapproche le développement et l’exploitation (voir les méthodes agiles).
6.3Pour le développeur
Même sans Kubernetes, les conteneurs ont simplifié la vie des développeurs : lancer une base de données, un serveur de messages ou un outil pour tester son code prend une seule commande, sans rien installer sur son poste. Un fichier de description, avec l’outil Docker Compose, permet de démarrer d’un coup tous les services d’une application, et chaque membre de l’équipe dispose du même environnement.
6.4Les limites
Les conteneurs ne conviennent pas à tout. Les applications de bureau à interface graphique, les logiciels qui ont besoin d’un accès très direct au matériel, ou les systèmes anciens conçus pour un serveur unique s’y prêtent mal. Les conteneurs ne dispensent pas non plus de mettre à jour : une image figée en 2022 contient les failles découvertes depuis, et il faut la reconstruire régulièrement à partir d’images de base corrigées. Enfin, la multiplication des conteneurs, des images, des versions et des outils crée une complexité qui a un coût en compétences et en surveillance : pour une petite équipe, une plateforme à la demande ou quelques machines virtuelles bien gérées restent souvent le choix le plus raisonnable. Les conteneurs sont un outil remarquable de livraison et d’exploitation, pas une fin en soi.