Accueil › Docker & conteneurs › Construction multi-étapes
Construction multi-étapes — entretien Docker & conteneurs
14 questions posées en entretien sur 9 sujets, avec la bonne réponse et son explication.
Principe
Qu'est-ce qu'un build multi-étapes ?
- Un Dockerfile contenant plusieurs `FROM`, dont une seule étape devient l'image publiée ✓
- Plusieurs Dockerfile construits l'un après l'autre par un script
- Une construction découpée en plusieurs couches successives
- Une construction répartie sur plusieurs machines
Pourquoi : Chaque `FROM` ouvre une étape indépendante, avec sa propre image de base et son propre système de fichiers. Une seule est publiée : la dernière, ou celle demandée en cible. Une bonne réponse enchaîne tout de suite sur le motif d'usage — on construit avec un outillage complet et on exécute avec le strict nécessaire.
Niveau junior
Quel est le but principal d'une construction multi-étapes ?
- Garder les outils de construction hors de l'image publiée ✓
- Accélérer le téléchargement de l'image de base
- Permettre de construire plusieurs images à la fois
- Remplacer le fichier d'exclusion du contexte
Pourquoi : Compilateur, gestionnaire de paquets et dépendances de développement servent à fabriquer, pas à exécuter. Les étapes intermédiaires ne sont pas publiées, donc leurs couches n'entrent jamais dans l'image. Une bonne réponse ajoute la conséquence de sécurité : moins de programmes présents, moins de moyens offerts en cas d'exécution de code non prévue.
Niveau junior
Étape finale
Dans un Dockerfile à trois étapes construit sans option particulière, quelle étape devient l'image produite ?
- La dernière écrite dans le fichier ✓
- La première étape nommée
- Celle qui contient l'instruction de démarrage
- Les trois, publiées sous trois étiquettes
Pourquoi : C'est une règle de position, pas de contenu : la dernière étape du fichier l'emporte, nommée ou non, qu'elle contienne ou non une commande de démarrage. La conséquence pratique mérite d'être citée — ajouter une étape de débogage en fin de fichier change silencieusement l'image livrée par la chaîne d'intégration.
Niveau junior
Un `WORKDIR /app` déclaré dans l'étape de construction s'applique-t-il à l'étape finale ?
- Non : chaque étape repart de son propre `FROM`, rien n'est hérité ✓
- Oui, comme toutes les métadonnées du Dockerfile
- Oui, si les deux étapes partagent la même image de base
- Oui, sauf si l'étape finale déclare un autre répertoire
Pourquoi : Répertoire de travail, variables d'environnement, utilisateur et paquets installés sont remis à zéro à chaque `FROM`. C'est précisément ce qui garantit que rien de l'étape de construction ne fuit. L'oubli le plus coûteux porte sur `USER` — l'image paraît non privilégiée à la lecture et tourne pourtant en racine.
Niveau confirme
Une image Node multi-étapes démarre sur une erreur de module introuvable. Quelle est la cause la plus probable ?
- Seul le répertoire compilé a été copié, sans les dépendances de production ✓
- L'étape de construction a été supprimée du fichier
- Le gestionnaire de paquets manque dans l'image finale
- La compilation a échoué sans faire échouer la construction
Pourquoi : Compiler ne supprime pas le besoin des dépendances de production : il faut soit les installer dans l'étape finale, soit les copier depuis l'étape de construction. L'absence du gestionnaire de paquets n'est pas en cause au démarrage — il ne sert qu'à l'installation. C'est le piège classique d'une première migration vers le multi-étapes.
Niveau confirme
Copie entre étapes
À quoi sert `COPY --from=build` ?
- À copier des fichiers depuis l'étape `build` au lieu du contexte de construction ✓
- À reprendre toutes les couches de l'étape `build`
- À relancer l'étape `build` avant la copie
- À copier des fichiers depuis la machine hôte vers l'étape `build`
Pourquoi : C'est le seul lien entre deux étapes : une copie explicite de chemins. Il n'y a pas d'héritage de couches, de variables ni de répertoire de travail. Préciser qu'on copie l'artefact nommé et non un répertoire entier montre qu'on a compris où se joue réellement le gain.
Niveau junior
Depuis quel répertoire est résolu le chemin source d'une copie entre étapes ?
- Depuis la racine de l'étape source, son `WORKDIR` n'intervenant pas ✓
- Depuis le `WORKDIR` déclaré dans l'étape source
- Depuis le `WORKDIR` de l'étape courante
- Depuis le contexte de construction envoyé au constructeur
Pourquoi : Les deux côtés de l'instruction ne suivent pas la même règle : la source part de la racine de l'étape désignée, la destination suit le `WORKDIR` courant. D'où la consigne constante d'écrire la source en chemin absolu. L'erreur se solde par un chemin introuvable, ou par une copie incomplète qui ne se voit qu'au démarrage.
Niveau confirme
Étapes nommées
Comment nomme-t-on une étape dans un Dockerfile ?
- `FROM node:22 AS build` ✓
- `STAGE build`
- `FROM node:22 NAME build`
- `LABEL stage=build`
Pourquoi : Le nom se déclare sur la ligne qui ouvre l'étape. Il sert ensuite dans une copie, comme base d'une autre étape, et comme cible de construction. L'étiquette existe bien en Dockerfile, mais elle écrit une métadonnée dans l'image : elle ne désigne pas une étape.
Niveau junior
Étape cible
À quoi sert l'option `--target` d'une construction ?
- À publier l'image d'une étape intermédiaire choisie explicitement ✓
- À choisir l'architecture de processeur visée
- À limiter le nombre de couches de l'image produite
- À désigner le registre de destination de l'image
Pourquoi : Le constructeur s'arrête à l'étape demandée et publie son résultat. C'est ainsi qu'un seul Dockerfile produit une image de développement, une image de test et une image de production, avec une base commune et un cache commun. Avec `docker compose`, la même cible se déclare dans la section de construction du service.
Niveau confirme
Quelles étapes BuildKit exécute-t-il avec cette recette et `--target test` ?
FROM node:22 AS deps
COPY package*.json ./
RUN npm ci
FROM deps AS build
COPY . .
RUN npm run build
FROM deps AS test
COPY . .
RUN npm test
- `deps` puis `test` : `build` ne fait pas partie des dépendances de la cible ✓
- `deps`, `build` et `test`, dans l'ordre du fichier
- `test` seule : ses dépendances sont déjà construites
- Toutes les étapes, la cible ne choisissant que l'image publiée
Pourquoi : BuildKit déduit un graphe des `FROM` et des `COPY --from`, puis n'exécute que les étapes dont la cible descend. L'ordre d'écriture n'impose rien, et deux branches indépendantes peuvent même avancer en parallèle. L'idée fausse — un parcours de haut en bas jusqu'à la cible — décrit l'ancien constructeur, pas celui utilisé par défaut.
Niveau senior
Taille de l'image
Deux étapes suffisent-elles à réduire la taille d'une image ?
- Non : il faut aussi une image d'exécution minimale et une copie restreinte à l'artefact ✓
- Oui : la séparation retire mécaniquement les outils de construction
- Oui, à condition que l'étape de construction soit nommée
- Non : la réduction vient uniquement du fichier d'exclusion du contexte
Pourquoi : Une étape finale qui repart de la même image généraliste et copie tout le répertoire de construction pèse exactement autant que la version mono-étape. Le gain vient de ce qu'on choisit comme base d'exécution et de la précision de la copie. Savoir le dire évite de vendre un gain qui n'existe pas.
Niveau confirme
Cache entre étapes
Que partage `RUN --mount=type=cache,target=/root/.npm` entre deux étapes qui l'utilisent ?
- Un répertoire persistant hors des couches, réutilisé par toute étape visant le même chemin ✓
- Les couches déjà construites de l'autre étape
- Le contexte de construction, transféré une seule fois
- Les variables d'environnement déclarées en amont
Pourquoi : Le répertoire survit d'une construction à l'autre et d'une étape à l'autre, sans qu'aucun fichier n'entre dans une couche. Deux limites méritent d'être citées : il dépend de la machine de construction, donc il est vide sur un agent neuf, et il ne garantit rien — une recette doit rester correcte avec un cache vide.
Niveau senior
Surface d'attaque
Quelles conséquences a le choix d'une image finale sans interpréteur de commandes ?
- La forme en tableau devient obligatoire au démarrage, et le diagnostic passe par les journaux ✓
- Le conteneur ne peut plus accéder au réseau
- Les variables d'environnement ne sont plus lues
- L'image ne peut plus être construite en multi-étapes
Pourquoi : La forme texte des instructions de démarrage suppose un interpréteur : sans lui, elle échoue. Ouvrir un interpréteur dans le conteneur devient également impossible, ce qui change les habitudes de diagnostic. Le bénéfice attendu est une réduction de surface — pas une protection contre le défaut applicatif lui-même, et il faut savoir le nuancer.
Niveau senior
Image minimale
Une application qui appelle une interface distante en HTTPS échoue depuis une image `scratch`. Quelle cause examiner en premier ?
- L'absence des certificats d'autorité, que l'image vide ne contient pas ✓
- L'absence de l'instruction qui déclare le port d'écoute
- L'absence de l'instruction de démarrage en forme tableau
- L'absence de réseau, une image vide ne pouvant pas en recevoir
Pourquoi : Une image vide ne contient ni certificats, ni fuseaux horaires, ni configuration de résolution : tout ce qui manque doit être copié explicitement, généralement depuis une image externe avec `COPY --from`. Le réseau, lui, ne dépend pas de l'image mais du lancement. Citer les trois manques d'un coup est ce qui distingue une réponse pratiquée d'une réponse apprise.
Niveau senior