Dockerfile : comprendre son rôle et son usage

Auteur : Rédaction Domeny.ForSale Publié le 06.10.2026

En bref : un Dockerfile est un fichier texte contenant les instructions que Docker suit pour construire une image d’application : un paquet regroupant son code, les outils nécessaires et ses paramètres. Cette image permet de lancer des conteneurs, c’est-à-dire des processus isolés disposant d’un environnement préparé. Le Dockerfile décrit donc comment préparer l’application à son exécution, mais n’est pas lui-même un conteneur en cours d’exécution.

Dockerfile, image et conteneur : trois choses différentes

On peut comparer un Dockerfile à une recette, l’image à un ensemble préparé selon cette recette, et le conteneur à une instance de cet ensemble en cours d’exécution. Une seule image peut servir à créer plusieurs conteneurs, par exemple plusieurs instances de la même application.

Dans le Dockerfile, vous définissez notamment l’environnement de base, les fichiers à copier, les dépendances à installer et la commande de démarrage par défaut. Il n’est donc plus nécessaire de préparer manuellement chaque serveur en suivant des instructions distinctes. Après une modification du code ou des dépendances, vous construisez généralement une nouvelle image.

Un conteneur n’est pas une machine virtuelle complète : il utilise le noyau du système de l’environnement dans lequel fonctionne le moteur de conteneurs. L’image aide à uniformiser l’environnement de l’application, mais n’élimine pas toutes les différences entre les ordinateurs. L’architecture du processeur, la configuration réseau et l’accès aux fichiers restent notamment importants.

Quelles instructions contient un Dockerfile ?

Le fichier s’appelle généralement Dockerfile, sans extension. Chaque instruction décrit une étape précise de la construction ou un paramètre de l’image. Les plus courantes sont :

FROM — choisit l’image de base, par exemple un environnement Python ou Node.js.
WORKDIR — définit le répertoire de travail pour les instructions suivantes et pour l’application à exécuter.
COPY — copie des fichiers du contexte de construction dans l’image.
RUN — exécute une commande pendant la construction, par exemple pour installer des bibliothèques.
ENV — définit des variables d’environnement.
EXPOSE — déclare le port utilisé par l’application ; ne le rend pas automatiquement accessible depuis l’extérieur du conteneur.
CMD — définit la commande exécutée par défaut au démarrage du conteneur.

Il est essentiel de distinguer RUN de CMD. La commande RUN s’exécute pendant la création de l’image, tandis que CMD ne s’exécute qu’au démarrage du conteneur. L’installation des dépendances relève généralement de RUN, et le démarrage du serveur de CMD.

Il existe aussi ENTRYPOINT, qui définit le programme principal du conteneur. Vous pouvez l’associer à CMD pour transmettre des arguments par défaut à ce programme. Pour un premier exemple simple, CMD suffit.

Exemple simple : une page HTML dans un conteneur

Supposons que vous souhaitiez lancer une page simple en local sans installer Python sur votre ordinateur. Il vous faut une installation fonctionnelle de Docker et un répertoire contenant deux fichiers : index.html et Dockerfile.

Dans le fichier index.html, placez :

<!doctype html>
<html lang="fr">
<meta charset="utf-8">
<title>Exemple Docker</title>
<h1>La page fonctionne dans un conteneur</h1>
</html>

Le fichier Dockerfile peut se présenter ainsi :

FROM python:3.13-slim
WORKDIR /app
COPY index.html .
EXPOSE 8000
CMD ["python", "-m", "http.server", "8000", "--bind", "0.0.0.0"]

Docker utilisera une image contenant Python, définira le répertoire /app et y copiera la page. Au démarrage du conteneur, il lancera un serveur HTTP simple. L’adresse 0.0.0.0 indique que le serveur écoute sur toutes les interfaces réseau du conteneur, ce qui permet de l’atteindre par le port publié.

Dans un terminal, depuis le répertoire contenant ces fichiers, exécutez :

docker build -t ma-page .
docker run --rm -p 127.0.0.1:8080:8000 ma-page

La première commande construit l’image et lui attribue le nom ma-page. Le point désigne le répertoire courant comme contexte de construction, c’est-à-dire l’ensemble des fichiers accessibles au processus de construction. La deuxième commande lance un conteneur et relie le port local 8080 au port 8000 du conteneur.

Ouvrez http://localhost:8080 dans votre navigateur. L’association du port à 127.0.0.1 limite l’accès à l’ordinateur local. Pour arrêter le serveur, utilisez le raccourci Ctrl+C ; l’option --rm supprimera le conteneur une fois arrêté. Il s’agit d’un exemple pédagogique, et non d’une configuration de serveur de production.

Qu’est-ce qui influe sur la rapidité et la sécurité de la construction ?

Docker peut réutiliser les résultats des étapes précédentes grâce à sa mémoire cache. La modification des fichiers utilisés par une instruction peut imposer de réexécuter cette étape et les étapes suivantes qui en dépendent. C’est pourquoi, dans une application utilisant des bibliothèques, on copie souvent d’abord le fichier des dépendances et on installe les paquets, avant de copier le code qui change plus fréquemment.

Le fichier .dockerignore exclut les fichiers inutiles du contexte de construction. Il s’agit généralement du répertoire .git, des environnements locaux, des journaux et des fichiers contenant des secrets. Cela réduit le volume de données transférées ainsi que le risque d’inclure accidentellement des éléments confidentiels.

N’enregistrez pas de mots de passe ni de jetons dans le Dockerfile et ne les copiez pas dans l’image. Supprimer un secret lors d’une étape ultérieure ne garantit pas sa suppression des couches précédentes de l’image. Transmettez les secrets nécessaires pendant la construction à l’aide des mécanismes de gestion des secrets de BuildKit. Pour les données nécessaires à l’application en cours d’exécution, utilisez une configuration adaptée de l’environnement d’exécution.

En production, envisagez d’exécuter l’application avec un utilisateur dépourvu de droits d’administrateur. Contrôlez également la version de l’image de base : un tag peut, avec le temps, désigner une image modifiée, tandis qu’un digest identifie un contenu précis. Consultez la documentation officielle de l’image choisie pour connaître les versions disponibles et la procédure de mise à jour.

Quand faut-il un Dockerfile, et quand utiliser Compose ?

Le Dockerfile répond à la question : « Comment construire l’image ? ». Docker Compose sert à décrire et à lancer un ensemble de services, par exemple une application, une base de données et un cache, avec leurs réseaux, leurs ports et leurs volumes. Un volume est un mécanisme qui permet de conserver des données indépendamment de la durée de vie d’un conteneur.

Ces outils peuvent fonctionner ensemble : Compose peut construire une image à partir d’un Dockerfile, puis la lancer aux côtés d’une image de base de données prête à l’emploi. Si vous utilisez uniquement des images prêtes à l’emploi, vous n’avez pas toujours besoin de votre propre Dockerfile.

Commencez par construire et lancer une image simple. Remplacez ensuite la page d’exemple par votre application, définissez explicitement ses dépendances et vérifiez quels fichiers doivent réellement être inclus dans l’image.

Voir aussi : Qu’est-ce qu’une API ?