Les fichiers Dockerifle définissent comment construire une image Docker. Chaque instruction dans un Dockerfile est une étape dans le processus de construction de l'image. Voici une explication détaillée des instructions les plus courantes :

FROM

L'instruction FROM initialise une nouvelle étape de construction et définit l'image sur laquelle elle sera basée. Elle doit être la première instruction dans un Dockerfile. Si vous souhaitez créer une image à partir de zéro (sans base), utilisez FROM scratch.

FROM <image>
FROM <image>:<tag>
FROM <image>:<digest></digest></image></tag></image></image>

Les options <tag> et <digest> sont facultatives. Si elles ne sont pas spécifiées, la valeur par défaut latest est utilisée.

RUN

L'instruction RUN exécute des commandes dans une nouvelle couche par-dessus l'image actuelle et valide le résultat. Ces commandes sont typiquement utilisées pour installer des paquets ou d'autres tâches durant la construction de l'image.

Il existe deux formats pour RUN :

1. RUN <command> : Exécute la commande dans le shell (par défaut /bin/sh -c sous Linux et cmd /S /C sous Windows).
2. RUN ["executable", "param1", "param2"] : Format d'appel de fonction, où executable est le programme à exécuter et les paramètres suivants sont ses arguments.

Exemples comparatifs :

# Format shell
RUN /bin/bash -c 'source $HOME/.bashrc; echo $HOME'

# Format exécutable
RUN ["/bin/bash", "-c", "echo hello"]

Important : Évitez d'utiliser plusieurs instructions RUN pour des commandes multiples. Chaque instruction RUN crée une nouvelle couche dans l'image, ce qui peut entraîner des images volumineuses et inutilement complexes. Il est préférable de combiner les commandes en une seule instruction RUN en utilisant des sauts de ligne avec le caractère \.

CMD

L'instruction CMD spécifie la commande par défaut à exécuter lorsqu'un conteneur est lancé à partir de l'image. Elle ne s'exécute pas pendant la construction de l'image.

Il existe trois syntaxes pour CMD :

1. CMD ["executable", "param1", "param2"] : Format exécutable (recommandé). Les chaînes doivent être entre guillemets doubles.
2. CMD ["param1", "param2"] : Utile lorsque l'instruction ENTRYPOINT est utilisée. Les paramètres sont alors transmis à l'ENTRYPOINT.
3. CMD command param1 param2 : Format shell.

Exemples :

# Format exécutable
CMD ["sh", "-c", "echo $HOME"]

# Format exécutable (pour ENTRYPOINT)
CMD ["echo", "$HOME"]

Note : Dans le format exécutable (JSON array), utiliesz impérativement des guillemets doubles pour les chaînes de caractères.

LABEL

L'instruction LABEL ajoute des métadonnées à une image. Ces métadonnées peuvent inclure des informations sur le créateur, la version, etc.

LABEL <key>=<value> <key>=<value> ...</value></key></value></key>

Vous pouvez spécifier plusieurs labels dans une seule instruction LABEL en les séparant par des espaces, ou utiliser plusieurs instructions LABEL.

LABEL "com.example.vendor"="ACME Incorporated" \
      com.example.label-with-value="foo" \
      version="1.0" \
      description="Ceci est une description sur plusieurs lignes.\nElle illustre que les valeurs de label peuvent s'étendre sur plusieurs lignes."

Les labels sont hérités de l'image de base. Si une clé de label existe déjà, sa valeur sera écrasée.

MAINTAINER

L'instruction MAINTAINER spécifie l'auteur de l'image. Cette instruction est obsolète et LABEL est préférée.

MAINTAINER <name></name>

EXPOSE

L'instruction EXPOSE informe Docker que le conteneur écoutera sur les ports réseau spécifiés au moment de l'exécution. Cependant, cela ne publie pas automatiquement les ports sur l'hôte. Pour cela, utilisez l'option -p lors du lancement du conteneur.

EXPOSE <port>[<port>/<protocol>]...

ENV

L'instruction ENV définit les variables d'environnement qui seront disponibles à la fois pendant la construction de l'image et lors de l'exécution du conteneur.

Deux syntaxes sont possibles :

1. ENV <key> <value> : Définit une variable d'environnement à la fois.
2. ENV <key>=<value> ... : Définit plusieurs variables d'environnement en une seule instruction.

ENV MY_PORT=8080
ENV MY_APP_VERSION=1.0 MY_APP_URL=http://example.com

ADD

L'instruction ADD copie des fichiers ou des répertoires du contexte de build vers le système de fichiers du conteneur. Elle peut également extraire automatiquement les archives compressées locales (tar, gzip, bzip2, xz) et télécharger des fichiers depuis une URL.

ADD <src>... <dest>
ADD ["<src>",... "<dest>"]

<dest> peut être un chemin absolu ou relatif au répertoire de travail. <src> peut être un fichier local, une archive locale, ou une URL.

ADD test.tar.gz /app/
ADD http://example.com/file.tar.gz /app/

Utilisez ADD avec prudence lorsque <src> est un répertoire, car il copie le contenu du répertoire, y compris les métadonnées du système de fichiers.

COPY

L'instruction COPY est similaire à ADD mais plus simple. Elle copie uniquement des fichiers et des répertoires locaux du contexte de build vers le système de fichiers du conteneur. Elle n'extrait pas les archives et ne télécharge pas depuis les URLs.

COPY <src>... <dest>
COPY ["<src>",... "<dest>"]

COPY est généralement préférée à ADD pour copier des fichiers locaux car son comportement est plus prévisible.

COPY local_file.txt /app/data/
COPY ./config /etc/my_app/config

ENTRYPOINT

L'instruction ENTRYPOINT configure un conteneur pour qu'il s'exécute comme un exécutable. Les instructions CMD peuvent être utilisées pour fournir des arguments par défaut à l'ENTRYPOINT.

Deux syntaxes sont possibles :

1. ENTRYPOINT ["executable", "param1", "param2"] : Format exécutable (recommandé).
2. ENTRYPOINT command param1 param2 : Format shell.

Différence avec CMD :

• ENTRYPOINT n'est pas écrasé par une instruction CMD avec un format shell.
• Si ENTRYPOINT et CMD sont tous deux définis et que CMD utilise le format exécutable, le CMD est passé comme argument à l'ENTRYPOINT.
• Si ENTRYPOINT est défini avec le format shell et CMD avec le format exécutable, c'est le CMD qui sera exécuté.

Exemple de combinaison ENTRYPOINT et CMD :

FROM ubuntu
ENTRYPOINT ["top", "-b"]
CMD ["-c"]

Dans cet exemple, le conteneur exécutera top -b -c.

VOLUME

L'instruction VOLUME crée un point de montage avec le nom spécifié et marque le répertoire comme persistant. Les données dans le volume survivent aux cycles de vie des conteneurs. Elle est utile pour la persistance des données, car le système de fichiers AUFS (utilisé par défaut par Docker) ne garantit pas la persistance des données après l'arrêt du conteneur.

VOLUME ["/data"]
VOLUME /var/log /var/db

USER

L'instruction USER définit l'utilisateur et le groupe à utiliser pour exécuter les instructions RUN, CMD et ENTRYPOINT suivantes. Elle peut être spécifiée par nom d'utilisateur ou UID.

USER daemon
USER 1000:1000

WORKDIR

L'instruction WORKDIR définit le répertoire de travail pour toutes les instructions RUN, CMD, ENTRYPOINT, COPY et ADD qui suivent. Si le répertoire n'existe pas, il sera créé. Il peut également être utilisé pour résoudre les variables d'environnement.

WORKDIR /app
RUN pwd # Affiche /app
WORKDIR /app/logs
RUN pwd # Affiche /app/logs

ENV DIRPATH=/path
WORKDIR $DIRPATH/$DIRNAME
RUN pwd # Affiche /path/$DIRNAME

ARG

L'instruction ARG déclare une variable qui peut être passée à docker build via l'option --build-arg. Les variables ARG définies dans le Dockerfile peuvent être utilisées pour construire l'image. Si une varible ARG est définie sans valeur par défaut, elle doit être fournie lors du build.

ARG user1
ARG buildno=1

# Utilisation lors du build
docker build --build-arg user1=test --build-arg buildno=2 .

ONBUILD

L'instruction ONBUILD ajoute des instructions au Dockerfile de l'image parente qui s'exécuteront uniquement lorsqu'une image est construite à partir de celle-ci. C'est utile pour automatiser certaines étapes de construction pour les images dérivées.

ONBUILD RUN echo "Construction démarrée"

L'instruction RUN echo "Construction démarrée" sera exécutée lorsque vous construirez une image basée sur cette image contenant l'instruction ONBUILD.

STOPSIGNAL

L'instruction STOPSIGNAL définit le signal système envoyé au conteneur lors de son arrêt.

STOPSIGNAL SIGKILL

HEALTHCHECK

L'instruction HEALTHCHECK configure une commande à exécuter périodiquement dans les conteneurs pour vérifier leur état de santé. Elle ne s'exécute pas pendant la construction de l'image, mais seulement lorsque le conteneur est en cours d'exécution.

HEALTHCHECK [OPTIONS] CMD command
HEALTHCHECK NONE

Les options incluent --interval, --timeout et --retries. La commande spécifiée dans CMD doit retourner 0 pour indiquer la réussite, 1 pour l'échec, et 2 pour une valeur réservée.

HEALTHCHECK --interval=5m --timeout=3s \
  CMD curl -f http://localhost/ || exit 1

Une seule instruction HEALTHCHECK est autorisée par Dockerfile ; la dernière est celle qui sera retenue.