Un Dockerfile est un fichier texte contenant une série d'instructions utilisées pour créer une image Docker. Il sert de script pour automatiser la création d'images personnalisées.

Lorsque vous créez ce fichier, il se nomme Dockerfile sans aucune extension

Structure de base

• FROM : Spécifie l'image de base à partir de laquelle vous construisez.
• RUN : Exécute des commandes dans un nouveau calque au-dessus de l'image courante.
• CMD : Fournit des valeurs par défaut qui peuvent être exécutées lors du démarrage du conteneur.
• COPY/ ADD : Copie des fichiers ou des répertoires du système hôte vers l'image.

Exemple :

# Utiliser une image de base
FROM ubuntu:20.04

# Mettre à jour les paquets
RUN apt-get update && apt-get upgrade -y

# Copier le fichier source dans le conteneur
COPY . /app

# Définir le répertoire de travail
WORKDIR /app

# Exécuter l'application
CMD ["./mon-application"]

Cet exemple de Dockerfile décrit les étapes pour créer une image Docker basée sur Ubuntu 20.04, qui est destinée à exécuter une application spécifique. Voici ce que fait chaque instruction dans ce Dockerfile :

1. FROM ubuntu:20.04 :
   • Cette instruction indique à Docker d'utiliser l'image ubuntu:20.04 comme base pour la nouvelle image.
2. RUN apt-get update && apt-get upgrade -y :
   • Cette instruction actualise la liste des paquets et les paquets eux-mêmes dans l'image de base à leur dernière version disponible.
3. COPY . /app :
   • Cette instruction copie le contenu du répertoire courant sur la machine hôte dans un nouveau répertoire /app dans l'image Docker.
4. WORKDIR /app :
   • Cette instruction change le répertoire de travail dans le conteneur à /app. Toutes les instructions suivantes dans le Dockerfile seront exécutées dans ce répertoire.
5. CMD ["./mon-application"] :
   • Cette instruction définit la commande par défaut à exécuter lorsque le conteneur est démarré. Dans ce cas, il essaiera d'exécuter un fichier appelé mon-application dans le répertoire /app.

Lorsque vous construisez une image Docker à partir de ce Dockerfile et créez ensuite un conteneur depuis cette image, le conteneur exécutera le fichier mon-application situé dans le répertoire /app.

Notez que pour que cette instruction fonctionne comme prévu, un fichier exécutable nommé mon-application doit être présent dans le répertoire courant sur la machine hôte au moment de la construction de l'image.

Quelle est la différence entre les instructions CMD et ENTRYPOINT dans un Dockerfile ?

Les instructions CMD et ENTRYPOINT dans un Dockerfile sont utilisées pour spécifier une commande qui sera exécutée lorsqu'un conteneur sera démarré à partir de l'image. Cependant, elles fonctionnent de manière légèrement différente, ce qui peut affecter la manière dont les commandes sont exécutées dans vos conteneurs.

CMD (Command)

• L'instruction CMD est utilisée pour fournir des valeurs par défaut pour un conteneur Docker en cours d'exécution.
• Ces valeurs peuvent facilement être écrasées en passant des arguments supplémentaires à la commande docker run.
• Si CMD est utilisé sans ENTRYPOINT, la commande CMD sera exécutée comme un processus.
• Si ENTRYPOINT est également spécifié, les valeurs fournies par CMD seront passées comme arguments à ENTRYPOINT.

Exemple :

# Dockerfile avec CMD
FROM ubuntu
CMD ["echo", "Bonjour le monde!"]

Lorsque vous exécutez ce conteneur, il écrit : "Bonjour le monde!", mais si vous passez un argument à docker run, comme docker run <image_name> cat /etc/passwd, il écrasera la commande CMD et exécutera la commande cat /etc/passwd à la place.

ENTRYPOINT

• L'instruction ENTRYPOINT permet de configurer un conteneur qui s'exécutera comme un exécutable.
• ENTRYPOINT ne sera pas écrasé si des arguments supplémentaires sont passés à docker run.
• Les arguments passés à docker run seront ajoutés à la commande ENTRYPOINT.

Exemple :

# Dockerfile avec ENTRYPOINT
FROM ubuntu
ENTRYPOINT ["echo"]
CMD ["Bonjour le monde!"]

Dans cet exemple, si vous ne passez aucun argument à docker run, il écrit : "Bonjour le monde!" comme avant. Cependant, si vous passez un argument à docker run, comme docker run <image_name> Docker, il écrit : "Docker" au lieu de "Bonjour le monde!", car l'argument docker run est ajouté à la commande ENTRYPOINT, écrasant l'argument CMD.

En résumé, CMD est utilisé pour spécifier des arguments par défaut qui peuvent être écrasés, tandis qu'ENTRYPOINT est utilisé pour spécifier un exécutable fixe qui sera exécuté chaque fois que le conteneur est démarré, avec des arguments supplémentaires qui peuvent être ajoutés, mais pas écrasés.

Création d'Images Personnalisées

Construire une image

Utilisez la commande docker build pour construire une image à partir d'un Dockerfile.
Par exemple :

docker build -t mon-image-personnalisee .

L'option -t permet de nommer votre image et le . indique le contexte de construction (le répertoire courant dans ce cas).

Vérifier une image

Utilisez la commande docker images pour lister toutes les images disponibles et vérifier que votre image a été créée correctement.

docker images

Exécuter une image

Utilisez la commande docker run pour créer et lancer un conteneur à partir de votre image personnalisée.

docker run -d --name mon-conteneur mon-image-personnalisee

L'option -d dans la commande docker run signifie "détaché" (ou "detached" en anglais). Lorsque vous utilisez cette option, Docker exécutera le conteneur en arrière-plan, ce qui signifie que le conteneur s'exécutera de manière autonome sans bloquer votre terminal ou interface de ligne de commande. Vous obtiendrez le contrôle de votre terminal immédiatement après le démarrage du conteneur.

En exécutant un docker run dans le mode "détaché, il vous faudra quitter le mode interactif avec les touches Ctrl + P puis Ctrl + Q, sous Mac se sera Ctrl + C.

Essayez !

Lancez l'application Docker Desktop avant de commencer et lancez la commande suivante dans votre terminale :

docker run hello-world

Vous devriez obtenir ceci :

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/