Aller au contenu
Encyclopédie informatique Édition 2026

Les conteneurs : Docker et Kubernetes

Partie 3 sur 3

Niveau de lecture :

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.
administrateur kubectl, CI/CD PLAN DE CONTRÔLE serveur d’API point d’entrée unique etcd base de l’état ordonnanceur place les pods contrôleurs corrigent les écarts NŒUD 1 kubelet kube-proxy pod pod pod moteur de conteneurs NŒUD 2 kubelet kube-proxy pod pod pod moteur de conteneurs NŒUD 3 kubelet kube-proxy pod pod moteur de conteneurs le kubelet de chaque nœud dialogue avec le serveur d’API pod : un ou plusieurs conteneurs déployés ensemble
Figure 3. L’architecture d’une grappe Kubernetes, simplifiée.

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.

Sécurité de l’information

Le coin cyber

Les conteneurs apportent des atouts de sécurité, images figées, environnements jetables, déploiements reproductibles, mais aussi des risques nouveaux, venus de leur isolation plus faible, de leurs images téléchargées et de la complexité des orchestrateurs. Les attaques sont décrites ici dans leur principe seulement.

C.1La chaîne d’approvisionnement des images

Une image s’appuie sur d’autres images, qui contiennent des centaines de bibliothèques écrites par d’autres. Une image de base vulnérable propage ses failles à toutes les applications construites dessus ; une image piégée publiée sur un registre public, sous un nom proche d’une image connue, peut contenir un logiciel de minage de cryptomonnaies ou une porte dérobée. En 2018, des chercheurs ont ainsi trouvé sur Docker Hub dix-sept images piégées téléchargées des millions de fois (voir les logiciels malveillants). Les parades : n’utiliser que des images de source sûre, les analyser automatiquement pour y détecter les failles connues, les signer, fixer leurs versions, et tenir l’inventaire de leurs composants, appelé SBOM (Software Bill of Materials, nomenclature logicielle).

C.2Sortir du conteneur

Comme tous les conteneurs d’un hôte partagent le noyau, une faille du noyau, ou du programme qui crée les conteneurs, peut permettre à un code malveillant de s’évader de son conteneur et de prendre le contrôle de l’hôte, donc de tous les autres conteneurs : une faille de ce type dans runc a ainsi été corrigée en 2019. Le risque est démultiplié par les mauvaises pratiques : conteneurs lancés en mode privilégié, qui lève presque toutes les protections ; conteneurs fonctionnant en administrateur ; montage dans le conteneur du dossier système de l’hôte ou de la prise de commande du moteur Docker, qui revient à lui donner les clés de la machine. Pour les charges les plus sensibles ou les codes non fiables, on ajoute une couche d’isolation, avec des micro-VM ou des noyaux intermédiaires (voir la virtualisation).

C.3Les orchestrateurs exposés

L’interface de commande à distance de Docker, le serveur d’API de Kubernetes, sa console Web ou la base etcd, exposés sur Internet sans authentification, sont recherchés en permanence par des robots, qui y lancent aussitôt des conteneurs de minage ou y volent des secrets (voir les anecdotes). Dans une grappe, des droits trop larges accordés à un compte de service, l’absence de règles de filtrage entre pods, ou des Secrets lisibles par tous permettent à un attaquant entré par une application vulnérable de se propager. Kubernetes doit donc être durci : authentification forte, droits minimaux, politiques réseau qui n’autorisent que les flux nécessaires, politiques de sécurité des pods qui interdisent les conteneurs privilégiés, journalisation (voir le Zero Trust).

C.4Idée reçue

« Un conteneur est aussi isolé qu’une machine virtuelle. » Faux. Une machine virtuelle a son propre noyau, et l’attaquant doit franchir l’hyperviseur pour en sortir ; un conteneur partage le noyau de l’hôte avec tous les autres, et ne repose que sur les mécanismes d’isolation de ce noyau. Bien configuré, un conteneur est une bonne barrière ; mal configuré, en mode privilégié ou en administrateur, il n’en est presque plus une.

C.5Bonnes pratiques

Particulier et développeur

  • Ne lancer que des images officielles ou de source connue, en version fixée, et les mettre à jour.
  • Ne jamais écrire de mot de passe dans un Dockerfile ni dans un fichier publié.
  • Ne pas exposer l’interface de commande de Docker sur le réseau, et éviter le mode privilégié.

Organisation

  • Analyser et signer les images dans la chaîne d’intégration, tenir leur nomenclature, n’autoriser que les images vérifiées.
  • Faire fonctionner les conteneurs sans privilège, avec des droits et des capacités minimaux, et des systèmes de fichiers en lecture seule.
  • Durcir Kubernetes : serveur d’API non exposé, droits minimaux, politiques réseau, chiffrement des Secrets, journaux surveillés, mises à jour régulières.

Référentiels : NIST (National Institute of Standards and Technology, l’institut américain de normalisation) SP 800-190, Application Container Security Guide (2017) · ANSSI (Agence nationale de la sécurité des systèmes d’information), Recommandations de sécurité relatives au déploiement de conteneurs Docker · NSA et CISA, Kubernetes Hardening Guide · guides de configuration du CIS (Center for Internet Security) pour Docker et Kubernetes.

Références

  1. D. Merkel, « Docker: Lightweight Linux Containers for Consistent Development and Deployment », Linux Journal, n° 239, 2014.
  2. B. Burns, B. Grant, D. Oppenheimer, E. Brewer, J. Wilkes, « Borg, Omega, and Kubernetes », ACM Queue, vol. 14, n° 1, 2016.
  3. A. Verma et al., « Large-scale cluster management at Google with Borg », EuroSys, 2015.
  4. M. Souppaya, J. Morello, K. Scarfone, Application Container Security Guide, NIST Special Publication 800-190, 2017.
  5. NSA, CISA, Kubernetes Hardening Guide, version 1.2, 2022.
  6. L. Rice, Container Security, O’Reilly, 2020.

Voir aussi

Citer cet article

« Les conteneurs : Docker et Kubernetes », Encyclopédie informatique, révision du 23 octobre 2026.