Aller au contenu
Encyclopédie informatique Édition 2026

Les conteneurs : Docker et Kubernetes

Partie 2 sur 3

Niveau de lecture :

3Comment le noyau isole un conteneur

Un conteneur Linux repose sur deux mécanismes du noyau, complétés par des restrictions de sécurité (voir Linux).

3.1Les espaces de noms : ce que le conteneur voit

Les espaces de noms (en anglais namespaces) donnent à un groupe de processus sa propre vue d’une ressource du système. Il en existe plusieurs sortes :

  • PID (identifiants de processus) : le conteneur ne voit que ses propres processus, et le premier d’entre eux porte le numéro 1, comme s’il était le premier programme lancé au démarrage ;
  • réseau : le conteneur a ses propres cartes réseau virtuelles, ses adresses IP et ses règles ;
  • montage : il a sa propre arborescence de fichiers, construite à partir de son image ;
  • UTS : il a son propre nom de machine ;
  • IPC : ses propres moyens de communication entre processus ;
  • utilisateurs : l’utilisateur administrateur à l’intérieur du conteneur peut correspondre à un utilisateur ordinaire, sans privilège, à l’extérieur (voir les utilisateurs et les droits) ;
  • cgroup et temps, plus récents.

3.2Les groupes de contrôle : ce que le conteneur consomme

Les groupes de contrôle (en anglais control groups, abrégé cgroups) limitent et mesurent les ressources qu’un groupe de processus peut utiliser : temps de processeur, mémoire, accès aux disques, nombre de processus. Un conteneur limité à 512 Mo de mémoire est arrêté par le noyau s’il dépasse cette limite, au lieu de mettre en difficulté tout le serveur. Ce sont aussi les groupes de contrôle qui permettent de facturer ou de répartir équitablement les ressources entre conteneurs.

3.3Les restrictions de sécurité

Enfin, plusieurs mécanismes réduisent ce qu’un conteneur a le droit de faire : les capacités découpent les pouvoirs de l’administrateur en une quarantaine de droits séparés, dont un conteneur ne reçoit qu’une petite partie ; un filtre des appels système, seccomp, interdit au conteneur d’appeler les fonctions du noyau dont il n’a pas besoin ; et des modules de sécurité comme AppArmor ou SELinux confinent ses accès aux fichiers. Bien réglés, ces mécanismes rendent un conteneur nettement plus difficile à compromettre et, surtout, à quitter.

4Images, Dockerfile et registres

4.1L’image, modèle du conteneur

Un conteneur est démarré à partir d’une image : un modèle en lecture seule qui contient le système de fichiers de l’application, bibliothèques comprises, et quelques métadonnées, comme la commande à lancer au démarrage. Une image est formée de couches empilées, chacune ajoutant ou modifiant des fichiers par rapport à la précédente (figure 2). Quand on démarre un conteneur, le moteur ajoute au-dessus une couche d’écriture, propre à ce conteneur, où vont toutes ses modifications ; elle disparaît quand le conteneur est supprimé. Les couches communes sont partagées : dix conteneurs lancés à partir de la même image n’occupent qu’une fois l’espace de l’image.

4.2La recette : le Dockerfile

On construit une image à partir d’une recette, un fichier texte appelé Dockerfile, dont chaque instruction produit une couche. Voici celle d’une petite application Web écrite en Python :

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
USER 1000
EXPOSE 8000
CMD ["python", "app.py"]

La première ligne part d’une image existante, un système Debian réduit avec Python déjà installé. On se place ensuite dans le dossier /app, on copie la liste des dépendances, on les installe, puis on copie le code de l’application. La ligne USER 1000 fait fonctionner l’application sous un utilisateur sans privilège plutôt qu’en administrateur, une bonne pratique de sécurité. EXPOSE indique le port sur lequel l’application écoute, et CMD la commande à lancer. L’ordre des instructions compte : chaque couche est gardée en cache, et n’est reconstruite que si elle ou une couche précédente a changé ; en copiant les dépendances avant le code, on évite de les réinstaller à chaque modification du code (exercice 1).

DOCKERFILE (RECETTE) FROM python:3.12-slim RUN pip install -r requirements.txt COPY . /app CMD ["python", "app.py"] IMAGE : COUCHES EN LECTURE SEULE système de base (Debian réduit) + Python dépendances installées code de l’application métadonnées : commande de démarrage couche d’écriture 1 conteneur 1 couche d’écriture 2 conteneur 2 Chaque instruction crée une couche. Les couches sont partagées entre images et entre conteneurs, et gardées en cache. Chaque conteneur ajoute sa propre couche d’écriture, perdue quand il est supprimé.
Figure 2. Une image est une pile de couches en lecture seule ; chaque conteneur y ajoute sa couche d’écriture. Le Dockerfile est simplifié.

4.3Construire, partager, lancer

Trois commandes résument le cycle de vie d’une image avec Docker :

docker build -t registre.example.org/equipe/monapp:1.0 .
docker push registre.example.org/equipe/monapp:1.0
docker run -d -p 8080:8000 registre.example.org/equipe/monapp:1.0

La première construit l’image à partir du Dockerfile du dossier courant, et lui donne un nom et une étiquette de version, ici 1.0. La deuxième l’envoie dans un registre, un serveur qui stocke et distribue les images : le registre public Docker Hub, ceux des fournisseurs de cloud, ou un registre privé de l’entreprise. La troisième, exécutée sur n’importe quelle machine, télécharge l’image si nécessaire et démarre un conteneur en arrière-plan, en reliant le port 8080 de la machine au port 8000 du conteneur (voir les ports). On peut ensuite le lister, consulter ses journaux, l’arrêter ou le supprimer.

Les données qui doivent survivre au conteneur, comme celles d’une base de données, ne doivent pas rester dans sa couche d’écriture : on les place dans des volumes, des espaces de stockage gérés à part et montés dans le conteneur. Un conteneur bien conçu est jetable : on doit pouvoir le détruire et le recréer à tout moment sans rien perdre.

4.4Des images petites et sûres

Une image contient souvent bien plus que nécessaire : compilateurs, outils de diagnostic, documentation, qui alourdissent le téléchargement et offrent autant de failles potentielles. Plusieurs techniques permettent de l’amaigrir :

  • partir d’une image de base réduite, comme les variantes « slim » de Debian ou la distribution Alpine Linux, qui ne pèse que quelques mégaoctets ;
  • utiliser une construction en plusieurs étapes : une première étape, qui contient les outils de compilation, fabrique l’application ; la seconde part d’une image minimale et n’y copie que le résultat. Pour un programme compilé en un seul fichier, l’image finale peut même partir de rien, l’image vide scratch ;
  • utiliser des images dites « sans distribution », qui ne contiennent que l’environnement d’exécution, sans interpréteur de commandes ni gestionnaire de paquets : un attaquant qui y entre ne trouve presque aucun outil ;
  • exclure de la construction, par un fichier .dockerignore, les fichiers inutiles ou sensibles du dossier : historique Git, fichiers de configuration locaux, clés.

Une image plus petite se télécharge et démarre plus vite, et contient moins de composants à surveiller et à mettre à jour.

4.5Au-delà de Docker

Grâce aux normes de l’OCI, Docker n’est plus le seul outil. Le moteur qu’il utilise, containerd, et le programme qui crée réellement les conteneurs, runc, sont des projets indépendants, utilisés aussi par Kubernetes. Podman, développé par Red Hat, fonctionne sans service permanent et sans privilège d’administrateur. D’autres outils construisent des images sans Dockerfile. Toutes ces images sont compatibles entre elles. Docker reste néanmoins l’outil le plus utilisé par les développeurs sur leur poste ; son application Docker Desktop est payante pour les grandes entreprises depuis 2021.

Pour s’exercer

Exercice 1 : l’ordre des instructions

Un développeur écrit son Dockerfile ainsi : FROM python:3.12-slim, COPY . /app, RUN pip install -r /app/requirements.txt. L’installation des dépendances prend 3 minutes. Il modifie une ligne de son code et reconstruit l’image. Combien de temps attend-il ? Comment améliorer le Dockerfile ?

Voir la réponse

La couche COPY . /app a changé, puisque le code a changé ; toutes les couches suivantes doivent être reconstruites, y compris l’installation des dépendances : 3 minutes à chaque modification. En copiant d’abord le seul fichier requirements.txt, puis en installant les dépendances, puis en copiant le reste du code, comme dans la section 4.2, la couche des dépendances reste en cache tant que la liste des dépendances ne change pas : la reconstruction prend quelques secondes.