comment créer un Dockerfile

Un dockerfile est la recette qui va permettre de recréer l’image du code source et de ses dépendances. Exécutée dans un conteneur, cette image permettra de reproduire les résultats du code source.

Voici ce que pourrait être un dockerfile pour un script écrit en Python :

FROM python:3.13-slim 
COPY requirements.txt . 
RUN pip install -r requirements.txt 
COPY . /app 
CMD ["python", "/app/main.py"]

(nous reprenons ici l’exemple de 📓1)

La première ligne (FROM) sélectionne une image de base à partir de laquelle on va construire l’image. Ici il s’agit d’une version allégée (slim) de Python 3.13 ; L’idéal est de sélectionner l’image de base la plus pertinente et en même temps la plus légère possible pour compiler l’ensemble du code source et des dépendances. Par exemple, si on maîtrise bien ce que contient l’image lubuntu on l’utilisera de préférence à Ubuntu car elle est plus légère et s’il manque des paquets à lubuntu qui seront présents dans Ubuntu par défaut, il faudra les rajouter dans les lignes suivantes. Evidemment s’il en manque trop, on aura plutôt intérêt à passer à Ubuntu.

La seconde ligne (COPY) réalise une copie du fichier requirements.txt qui liste les dépendances utiles au code source (voir chapitres précédents) depuis le dossier de travail dans le conteneur (à la racine de celui-ci comme l’indique le point (.))

La troisième ligne (RUN) ouvre un terminal Python depuis Python 3.13 et installe les dépendances dans leurs versions indiquées dans le fichier requirements.txt

La quatrième ligne (COPY) procède de la même manière que pour le fichier requirements.txt mais cette fois avec tous les autres fichiers du dossier de travail dont le code source (main.py) et dans un nouveau dossier au sein du conteneur (app/). Cela permet de séparer le fichier requirements.txt qui est à la racine du conteneur des autres fichiers.

La dernière commande (CMD) ouvre un terminal (bash cette fois) et y envoie l’instruction suivante : exécuter avec Python le code source main.py.

Le résultat sera rendu disponible dans l’image.

Chaque ligne crée une nouvelle couche, et les couches doivent se succéder dans le même ordre.

créer le Dockerfile pour conteneuriser le script sur les cimetières militaires

FROM rocker/r-ver:4 # ici on part d'une image de base (rocker dans sa version 4 qui contient déjà R, ce qui fait qu'on n'aura pas à installer R)
RUN echo 'options(repos = c(CRAN = "https://cloud.r-project.org"))' >>"${R_HOME}/etc/Rprofile.site"
RUN apt-get update && apt-get install -y \
# mise à jour de la liste des dépendances disponibles d'APT (=gestionnaire de paquets pour GNU/Linux) et (&&) installation des paquets suivants ( -y permet de ne pas interrompre le processus en répondant automatiquement oui à toutes les questions)
software-properties-common \ # chargement d'un paquet qui permet de faciliter l'installation des dépendances provenant d'APT. On place celui-ci en premier, les autres suivront alphabétiquement (=plus simple pour la maintenance quand il y en a beaucoup) . De la même manère on recommande de les lister ligne par ligne et de les chaîner au moyen d'un \ pour plus de clarté
libudunits2-dev \ 
libgdal-dev \
libgeos-dev \
libproj-dev \
libsqlite3-dev \
pandoc \
# l'instruction précédente installe les dépendances systèmes dans l'image de base qui permettront de faire fonctionner correctement le package leaflet qui est listé dans le renv.lock (ces dépendances systèmes sont essentiellement gdal et geos et leurs dépendances respectives)
&& apt-get clean \ 
# supprime également tous les packages inutiles du cache de packages (seulement du cache, pas du système). Il efface les fichiers téléchargés pour l'installation de certains programmes sous Linux à l'aide d'APT. cette commande concourt à réduire le volume du conteneur
&& rm -rf /var/lib/apt/lists/*
# Docker crée automatiquement un cache, une copie cachée des paquets. Cela prend de la place ; cette commande comme la précédente vise à réduire le cache et donc le volume de l'image qui sera produite. Ces deux dernières instructions ne sont pas nécessaires mais elles permettent d'économiser du volume et de bâtir plus facilement l'image. 
RUN R -e "install.packages('renv', repos = c(CRAN = 'https://cloud.r-project.org'))"
# Cette commande ouvre dans le conteneur un terminal pour R et y entre la commande d'installation du package Renv
COPY . .
# copie tous les fichiers du répertoire courant à la base du conteneur
RUN R -e "renv::restore()" # dans les dossiers copiés, va chercher les dépendances mentionnées dans le renv.lock et va les installer
CMD ["R", "-e","rmarkdown::render('war_cemeteries.Rmd', output_file = 'html_document')"]
# lance la commande suivante : dans R exécute le fichier rmarkdown qui a pour nom war_cemeteries et envoie comme résultat un fichier html (celui qui contient la carte)

créer le dockerfile pour la constitution d’une image à partir du script pour Python

References

1.
Malka, J., Zacchiroli, S. & Zimmermann, T. Docker does not guarantee reproducibility. (2026) doi:10.48550/arXiv.2601.12811.