Decouverte
du Dockerfile

Cette decouverte suppose qu'on a deja lance des conteneurs avec docker run. Si ce n'est pas le cas, faire d'abord la Decouverte de Docker avant celle-ci.

Ici, on ne va plus utiliser des images faites par d'autres - on va en fabriquer une. Le fichier qui decrit comment fabriquer une image s'appelle un Dockerfile.

Un Dockerfile est un fichier texte qui contient la recette pour fabriquer une image. Une instruction par ligne, lues de haut en bas.

Trois mots-cles suffisent pour 80 % des cas :

Une image se construit a partir d'un dossier. Tout ce qui est dans ce dossier est envoye a Docker pendant la construction. On commence par un dossier vide, dedie au projet.

Dans ce dossier, on va creer un fichier nomme exactement Dockerfile - sans extension, avec un D majuscule. Avec n'importe quel editeur de texte.

Deux lignes. C'est tout. On part d'Alpine - une mini distribution Linux d'environ 5 Mo - et on lui dit ce qu'il faut afficher au demarrage.

FROM alpine
CMD ["echo", "Bonjour le monde !"]

FROM alpine

partir de l'image officielle alpine - notre image hereditera de tout ce qu'elle contient

CMD [...]

au demarrage du conteneur, executer echo Bonjour le monde !

Sauvegarder et fermer (dans nano : Ctrl+O, Entree, Ctrl+X).

Maintenant, on demande a Docker de lire notre Dockerfile et d'en faire une image. La commande docker build fait le travail.

build

construire une image

-t bonjour

nommer (tag) l'image bonjour pour pouvoir la lancer plus tard

.

le dossier courant - c'est la qu'on cherche le Dockerfile

L'image existe maintenant sur la machine. On la lance comme n'importe quelle image.

Pour confirmer qu'elle existe sur la machine :

Chaque ligne du Dockerfile cree une couche. Les couches s'empilent et forment l'image finale. Chaque couche est mise en cache - si on ne touche pas a une ligne, sa couche est reutilisee telle quelle.

C'est pour cela qu'on met les choses qui changent peu en haut du Dockerfile, et les choses qui changent souvent en bas - le cache reste utile plus longtemps.

On modifie le Dockerfile pour qu'il fabrique un fichier pendant la construction, puis l'affiche au demarrage.

FROM alpine
RUN echo "Salut depuis l'interieur de l'image" > /message.txt
CMD ["cat", "/message.txt"]

RUN

execute pendant la construction - le fichier est ecrit une fois, puis fait partie de l'image

CMD

execute au demarrage du conteneur - lit le fichier deja present

On reconstruit, puis on relance.

Si on relance docker build une troisieme fois sans rien modifier, la construction est quasi instantanee. Docker reutilise les couches en cache.

Avec ENV, on peut declarer une variable d'environnement utilisable au demarrage. Ca donne une image personnalisable sans rebuild.

FROM alpine
ENV NOM=monde
CMD echo "Bonjour $NOM !"

Reconstruire puis lancer normalement :

Et avec une valeur differente, sans toucher au Dockerfile :

Avec ces trois instructions plus docker build et docker run, on peut fabriquer la majorite des images simples qu'on rencontre dans un cours, un projet personnel ou un prototype.

Le devoir final demande des Dockerfiles plus riches. Les briques suivantes y seront utiles.