Aperçu du Dockerfile

Table des matières

Dockerfile

Tout commence avec un Dockerfile.

Docker construit des images en lisant les instructions d'un Dockerfile. Un Dockerfile est un fichier texte contenant des instructions pour construire votre code source. La syntaxe des instructions Dockerfile est définie par la référence de spécification dans la référence Dockerfile.

Voici les types d'instructions les plus courants :

Instruction	Description
`FROM <image>`	Définit une base pour votre image.
`RUN <command>`	Exécute toute commande dans une nouvelle couche au-dessus de l'image actuelle et valide le résultat. `RUN` a aussi une forme shell pour exécuter des commandes.
`WORKDIR <directory>`	Définit le répertoire de travail pour toute instruction `RUN`, `CMD`, `ENTRYPOINT`, `COPY`, et `ADD` qui la suit dans le Dockerfile.
`COPY <src> <dest>`	Copie de nouveaux fichiers ou répertoires depuis `<src>` et les ajoute au système de fichiers du conteneur au chemin `<dest>`.
`CMD <command>`	Vous permet de définir le programme par défaut qui s'exécute une fois que vous démarrez le conteneur basé sur cette image. Chaque Dockerfile n'a qu'un seul `CMD`, et seule la dernière instance `CMD` est respectée quand plusieurs existent.

Les Dockerfiles sont des entrées cruciales pour les constructions d'images et peuvent faciliter des constructions d'images automatisées multi-couches basées sur vos configurations uniques. Les Dockerfiles peuvent commencer simplement et croître avec vos besoins pour supporter des scénarios plus complexes.

Nom de fichier

Le nom de fichier par défaut à utiliser pour un Dockerfile est Dockerfile, sans extension de fichier. Utiliser le nom par défaut vous permet d'exécuter la commande docker build sans avoir à spécifier des flags de commande supplémentaires.

Certains projets peuvent avoir besoin de Dockerfiles distincts pour des besoins spécifiques. Une convention commune est de les nommer <quelquechose>.Dockerfile. Vous pouvez spécifier le nom de fichier Dockerfile en utilisant le flag --file pour la commande docker build. Référez-vous à la référence CLI docker build pour apprendre le flag --file.

Note

Nous recommandons d'utiliser le défaut (Dockerfile) pour le Dockerfile principal de votre projet.

Images Docker

Les images Docker consistent en couches. Chaque couche est le résultat d'une instruction de construction dans le Dockerfile. Les couches sont empilées séquentiellement, et chacune est un delta représentant les changements appliqués à la couche précédente.

Exemple

Voici à quoi ressemble un flux de travail typique pour construire des applications avec Docker.

L'exemple de code suivant montre une petite application "Hello World" écrite en Python, utilisant le framework Flask.

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

Pour expédier et déployer cette application sans Docker Build, vous devriez vous assurer que :

Les dépendances d'exécution requises sont installées sur le serveur
Le code Python est téléchargé sur le système de fichiers du serveur
Le serveur démarre votre application, en utilisant les paramètres nécessaires

Le Dockerfile suivant crée une image de conteneur, qui a toutes les dépendances installées et qui démarre automatiquement votre application.

# syntax=docker/dockerfile:1
FROM ubuntu:22.04

# installer les dépendances de l'app
RUN apt-get update && apt-get install -y python3 python3-pip
RUN pip install flask==3.0.*

# installer l'app
COPY hello.py /

# configuration finale
ENV FLASK_APP=hello
EXPOSE 8000
CMD ["flask", "run", "--host", "0.0.0.0", "--port", "8000"]

Voici une ventilation de ce que fait ce Dockerfile :

Syntaxe Dockerfile
Image de base
Configuration de l'environnement
Commentaires
Installation des dépendances
Copie de fichiers
Définition des variables d'environnement
Ports exposés
Démarrage de l'application

Syntaxe Dockerfile

La première ligne à ajouter à un Dockerfile est une directive de parseur # syntax. Bien qu'optionnelle, cette directive instruit le constructeur Docker quelle syntaxe utiliser lors de l'analyse du Dockerfile, et permet aux versions Docker plus anciennes avec BuildKit activé d'utiliser un frontend Dockerfile spécifique avant de commencer la construction. Les directives de parseur doivent apparaître avant tout autre commentaire, espace, ou instruction Dockerfile dans votre Dockerfile, et devraient être la première ligne dans les Dockerfiles.

# syntax=docker/dockerfile:1

Tip

Nous recommandons d'utiliser docker/dockerfile:1, qui pointe toujours vers la dernière version de la syntaxe version 1. BuildKit vérifie automatiquement les mises à jour de la syntaxe avant de construire, s'assurant que vous utilisez la version la plus actuelle.

Image de base

La ligne suivant la directive de syntaxe définit quelle image de base utiliser :

FROM ubuntu:22.04

L' instruction FROM définit votre image de base à la version 22.04 d'Ubuntu. Toutes les instructions qui suivent sont exécutées dans cette image de base : un environnement Ubuntu. La notation ubuntu:22.04, suit le standard nom:tag pour nommer les images Docker. Quand vous construisez des images, vous utilisez cette notation pour nommer vos images. Il y a beaucoup d'images publiques que vous pouvez exploiter dans vos projets, en les important dans vos étapes de construction en utilisant l'instruction FROM du Dockerfile.

Docker Hub contient un grand ensemble d'images officielles que vous pouvez utiliser à cet effet.

Configuration de l'environnement

La ligne suivante exécute une commande de construction à l'intérieur de l'image de base.

# installer les dépendances de l'app
RUN apt-get update && apt-get install -y python3 python3-pip

Cette instruction RUN exécute un shell dans Ubuntu qui met à jour l'index des paquets APT et installe les outils Python dans le conteneur.

Commentaires

Notez la ligne # installer les dépendances de l'app. C'est un commentaire. Les commentaires dans les Dockerfiles commencent par le symbole #. Alors que votre Dockerfile évolue, les commentaires peuvent être instrumentaux pour documenter comment votre Dockerfile fonctionne pour tout futur lecteur et éditeur du fichier, y compris votre futur vous !

Note

Vous avez peut-être remarqué que les commentaires sont notés en utilisant le même symbole que la directive de syntaxe sur la première ligne du fichier. Le symbole n'est interprété comme directive que si le motif correspond à une directive et apparaît au début du Dockerfile. Sinon, il est traité comme un commentaire.

Installation des dépendances

La deuxième instruction RUN installe la dépendance flask requise par l'application Python.

RUN pip install flask==3.0.*

Un prérequis pour cette instruction est que pip soit installé dans le conteneur de construction. La première commande RUN installe pip, ce qui assure que nous pouvons utiliser la commande pour installer le framework web flask.

Copie de fichiers

L'instruction suivante utilise l' instruction COPY pour copier le fichier hello.py depuis le contexte de construction local dans le répertoire racine de notre image.

COPY hello.py /

Un contexte de construction est l'ensemble des fichiers auxquels vous pouvez accéder dans les instructions Dockerfile telles que COPY et ADD.

Après l'instruction COPY, le fichier hello.py est ajouté au système de fichiers du conteneur de construction.

Définition des variables d'environnement

Si votre application utilise des variables d'environnement, vous pouvez définir des variables d'environnement dans votre construction Docker en utilisant l' instruction ENV.

ENV FLASK_APP=hello

Ceci définit une variable d'environnement Linux dont nous aurons besoin plus tard. Flask, le framework utilisé dans cet exemple, utilise cette variable pour démarrer l'application. Sans ceci, flask ne saurait pas où trouver notre application pour pouvoir l'exécuter.

Ports exposés

L' instruction EXPOSE marque que notre image finale a un service écoutant sur le port 8000.

EXPOSE 8000

Cette instruction n'est pas requise, mais c'est une bonne pratique et aide les outils et les membres de l'équipe à comprendre ce que fait cette application.

Démarrage de l'application

Finalement, l' instruction CMD définit la commande qui s'exécute quand l'utilisateur démarre un conteneur basé sur cette image.

CMD ["flask", "run", "--host", "0.0.0.0", "--port", "8000"]

Cette commande démarre le serveur de développement flask écoutant sur toutes les adresses sur le port 8000. L'exemple ici utilise la version "forme exec" de CMD. Il est aussi possible d'utiliser la "forme shell" :

CMD flask run --host 0.0.0.0 --port 8000

Il y a des différences subtiles entre ces deux versions, par exemple dans la façon dont elles traitent les signaux comme SIGTERM et SIGKILL. Pour plus d'informations sur ces différences, voir Forme shell et exec

Construction

Pour construire une image de conteneur en utilisant l'exemple Dockerfile de la section précédente, vous utilisez la commande docker build :

$ docker build -t test:latest .

L'option -t test:latest spécifie le nom et le tag de l'image.

Le point unique (.) à la fin de la commande définit le contexte de construction au répertoire courant. Cela signifie que la construction s'attend à trouver le Dockerfile et le fichier hello.py dans le répertoire où la commande est invoquée. Si ces fichiers ne sont pas là, la construction échoue.

Après que l'image ait été construite, vous pouvez exécuter l'application comme conteneur avec docker run, en spécifiant le nom de l'image :

$ docker run -p 127.0.0.1:8000:8000 test:latest

Ceci publie le port 8000 du conteneur vers http://localhost:8000 sur l'hôte Docker.

Tip

Vous voulez une meilleure expérience d'édition pour les Dockerfiles dans VS Code ? Consultez l'Extension Docker VS Code (Beta) pour le linting, la navigation de code, et l'analyse de vulnérabilités.