Docker Dockerfile

Qu'est-ce qu'un Dockerfile ?

Un Dockerfile est un fichier texte qui contient toutes les instructions pour construire une image Docker.

Un Dockerfile est un fichier texte utilisé pour construire une image. Son contenu texte contient les instructions et les explications nécessaires à la construction de l'image.

En définissant une série de commandes et de paramètres, le Dockerfile guide Docker dans la construction d'une image personnalisée.

Utiliser Dockerfile pour personnaliser des images

Ici, nous expliquons seulement comment exécuter un fichier Dockerfile pour personnaliser une image. L'explication détaillée des instructions à l'intérieur du Dockerfile sera introduite dans la section suivante. Ici, vous avez seulement besoin de comprendre le processus de construction.

1. Ci-dessous, nous allons personnaliser une image nginx (l'image construite contiendra un fichier /usr/share/nginx/html/index.html)

Dans un répertoire vide, créez un nouveau fichier nommé Dockerfile et ajoutez le contenu suivant au fichier :

FROM nginx
RUN echo '这是一个本地构建的nginx镜像' > /usr/share/nginx/html/index.html

2. Le rôle des instructions FROM et RUN

FROM: Les images personnalisées sont toutes basées sur l'image FROM. Ici, nginx est l'image de base nécessaire à la personnalisation. Toutes les opérations suivantes sont basées sur nginx.

RUN: Utilisé pour exécuter la commande en ligne de commande qui suit. Il possède les deux formats suivants :

format shell :

RUN <命令行命令>
# <命令行命令> 等同于，在终端操作的 shell 命令。

format exec :

RUN ["可执行文件", "参数1", "参数2"]
# 例如：
# RUN ["./test.php", "dev", "offline"] 等价于 RUN ./test.php dev offline

Remarque: Chaque fois qu'une instruction du Dockerfile est exécutée, une nouvelle couche est créée sur Docker. Par conséquent, trop de couches inutiles rendront l'image trop volumineuse. Par exemple :

L'exécution ci-dessus créera une image à 3 couches. Elle peut être simplifiée au format suivant :

Comme ci-dessus, utilisez&&Utilisez "&&" pour connecter les commandes, ainsi après l'exécution, une seule couche d'image sera créée.

Commencer la construction de l'image

Dans le répertoire où se trouve le fichier Dockerfile, exécutez l'action de construction.

L'exemple suivant construit une nginx:v3 (nom d'image : tag d'image) via le Dockerfile dans le répertoire.

Remarque: le dernier.Représente le chemin de contexte pour cette exécution, qui sera présenté dans la section suivante.

L'affichage ci-dessus indique que la construction a réussi.

chemin du contexte

Dans la section précédente, il a été mentionné que la dernière partie de la commande.est le chemin du contexte. Alors, qu'est-ce que le chemin du contexte ?

Le chemin du contexte signifie que, lorsque Docker construit une image, il souhaite parfois utiliser des fichiers de la machine locale (par exemple, une copie). Une fois que la commande docker build connaît ce chemin, elle empaquette tout le contenu situé sous ce chemin.

Analyse：Parce que le mode de fonctionnement de Docker est C/S. Notre machine locale est C, et le moteur Docker est S. Le processus de construction réel est effectué dans le moteur Docker, donc les fichiers de notre machine locale ne peuvent pas être utilisés à ce moment-là. Cela nécessite d'empaqueter les fichiers dans le répertoire spécifié sur notre machine locale et de les fournir au moteur Docker pour utilisation.

Si le dernier paramètre n'est pas spécifié, le chemin du contexte par défaut est l'emplacement où se trouve le Dockerfile.

Remarque: Ne placez pas de fichiers inutiles dans le chemin du contexte, car ils seront empaquetés et envoyés en même temps au moteur Docker. S'il y a trop de fichiers, le processus sera lent.

Détails des instructions

COPY

Instruction Copy, copie des fichiers ou des répertoires du répertoire de contexte vers le chemin spécifié dans le conteneur.

Format :

COPY [--chown=<user>:<group>] <源路径1>...  <目标路径>
COPY [--chown=<user>:<group>] ["<源路径1>",...  "<目标路径>"]

[--chown=<user>:<group>]: Paramètre facultatif, modifie le propriétaire et le groupe des fichiers copiés dans le conteneur.

<source path>: Fichier source ou répertoire source, qui peut être ici une expression avec caractères génériques. Ses règles de caractères génériques doivent satisfaire les règles filepath.Match de Go. Par exemple :

COPY hom* /mydir/
COPY hom?.txt /mydir/

<target path>: Le chemin spécifié à l'intérieur du conteneur. Ce chemin n'a pas besoin d'être créé au préalable ; s'il n'existe pas, il sera créé automatiquement.

ADD

Le format d'utilisation de l'instruction ADD est similaire à celui de COPY (dans les mêmes conditions, la recommandation officielle est d'utiliser COPY). Les fonctions sont également similaires, avec les différences suivantes :

• Avantages d'ADD : lorsque le <source file> est un fichier compressé tar, et que le format de compression est gzip, bzip2 ou xz, il le copiera et le décompressera automatiquement vers le <destination path>.
• Inconvénients d'ADD : il ne peut pas copier les fichiers compressés tar sans les décompresser. Cela invalidera le cache de construction de l'image, ce qui peut rendre la construction de l'image relativement lente. L'opportunité de l'utiliser peut être déterminée selon qu'une décompression automatique est nécessaire.

CMD

Semblable à l'instruction RUN, elle est utilisée pour exécuter des programmes, mais les deux s'exécutent à des moments différents :

• CMD s'exécute pendant docker run.
• RUN s'exécute pendant docker build.

Fonction: Spécifie le programme par défaut à exécuter pour le conteneur démarré. Lorsque le programme termine son exécution, le conteneur se termine également. Le programme spécifié par l'instruction CMD peut être remplacé par le programme spécifié dans les paramètres de ligne de commande de docker run.

Remarque: S'il y a plusieurs instructions CMD dans le Dockerfile, seule la dernière prend effet.

Format :

CMD <shell 命令> 
CMD ["<可执行文件或命令>","<param1>","<param2>",...] 
CMD ["<param1>","<param2>",...]  # 该写法是为 ENTRYPOINT 指令指定的程序提供默认参数

Le deuxième format est recommandé car le processus d'exécution est relativement clair. En pratique, le premier format sera également automatiquement converti au deuxième format, et le fichier exécutable par défaut est sh.

ENTRYPOINT

Semblable à l'instruction CMD, mais il ne sera pas remplacé par la commande spécifiée par les arguments de ligne de commande de docker run. De plus, ces arguments de ligne de commande seront transmis comme paramètres au programme spécifié par l'instruction ENTRYPOINT.

Cependant, si l'option --entrypoint est utilisée lors de l'exécution de docker run, elle remplacera le programme spécifié par l'instruction ENTRYPOINT.

Avantages: lors de l'exécution de docker run, vous pouvez spécifier les paramètres nécessaires à l'exécution d'ENTRYPOINT.

Remarque: si plusieurs instructions ENTRYPOINT se trouvent dans le Dockerfile, seule la dernière prend effet.

Format :

ENTRYPOINT ["<executeable>","<param1>","<param2>",...]

Il peut être utilisé conjointement avec la commande CMD : généralement, CMD est utilisé pour les paramètres variables. Ici, CMD équivaut à transmettre des paramètres à ENTRYPOINT, ce qui sera mentionné dans l'exemple ci-dessous.

Exemple :

Supposons que l'image nginx:test ait été construite à partir du Dockerfile :

FROM nginx

ENTRYPOINT ["nginx", "-c"] # 定参
CMD ["/etc/nginx/nginx.conf"] # 变参 

1. Exécuter sans passer de paramètres

$ docker run  nginx:test

Le conteneur exécutera par défaut la commande suivante pour démarrer le processus principal.

nginx -c /etc/nginx/nginx.conf

2. Exécuter avec des paramètres

$ docker run  nginx:test -c /etc/nginx/new.conf

Le conteneur exécutera par défaut la commande suivante pour démarrer le processus principal (/etc/nginx/new.conf : en supposant que ce fichier existe déjà dans le conteneur).

nginx -c /etc/nginx/new.conf

ENV

Définir des variables d'environnement. Une fois qu'une variable d'environnement est définie, elle peut être utilisée dans les instructions suivantes.

Format :

ENV <key> <value>
ENV <key1>=<value1> <key2>=<value2>...

L'exemple suivant définit NODE_VERSION = 7.2.0, qui peut être référencé via $NODE_VERSION dans les instructions suivantes :

ENV NODE_VERSION 7.2.0

RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \
  && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc"

ARG

Paramètres de construction, avec le même effet que ENV. Cependant, la portée est différente. Les variables d'environnement définies par ARG ne sont valides que dans le Dockerfile, c'est-à-dire uniquement pendant le processus de docker build. Cette variable d'environnement n'existe pas dans l'image construite.

Dans la commande de construction `docker build`, il peut être remplacé par `--build-arg <parameter-name>=<value>`.

Format :

ARG <参数名>[=<默认值>]

VOLUME

Définir un volume de données anonyme. Si vous oubliez de monter un volume de données lors du démarrage du conteneur, il sera automatiquement monté sur le volume anonyme.

Fonction :

• Éviter que des données importantes soient perdues à cause des redémarrages du conteneur, ce qui est très critique.
• Éviter que le conteneur ne devienne de plus en plus volumineux.

Format :

VOLUME ["<路径1>", "<路径2>"...]
VOLUME <路径>

Lors du démarrage du conteneur avec docker run, nous pouvons modifier le point de montage à l'aide du paramètre -v.

EXPOSE

Déclare uniquement des ports.

Fonction :

• Aide les utilisateurs de l'image à comprendre le port du démon de ce service d'image, ce qui facilite la configuration du mappage.
• Lors de l'utilisation du mappage de ports aléatoire à l'exécution, c'est-à-dire docker run -P, il mappera automatiquement et de manière aléatoire les ports exposés par EXPOSE.

Format :

EXPOSE <端口1> [<端口2>...]

WORKDIR

Spécifie le répertoire de travail. Le répertoire de travail spécifié avec WORKDIR existera dans chaque couche de la construction de l'image. Le répertoire courant pour les couches suivantes sera changé pour le répertoire spécifié. Si le répertoire n'existe pas, WORKDIR le créera pour vous.

Pendant le processus docker build, chaque commande RUN crée une nouvelle couche. Seuls les répertoires créés via WORKDIR existeront toujours.

Format :

WORKDIR <工作目录路径>

USER

Utilisé pour spécifier l'utilisateur et le groupe d'utilisateurs pour l'exécution des commandes suivantes. Ici, il ne fait que changer l'utilisateur pour l'exécution des commandes suivantes (l'utilisateur et le groupe d'utilisateurs doivent déjà exister au préalable).

Format :

USER <用户名>[:<用户组>]

HEALTHCHECK

Utilisé pour spécifier un programme ou une instruction pour surveiller l'état d'exécution du service de conteneur docker.

Format :

HEALTHCHECK [选项] CMD <命令>：设置检查容器健康状况的命令
HEALTHCHECK NONE：如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令

HEALTHCHECK [选项] CMD <命令> : 这边 CMD 后面跟随的命令使用，可以参考 CMD 的用法。

ONBUILD

Utilisé pour retarder l'exécution des commandes de construction. En termes simples, les commandes spécifiées avec ONBUILD dans le Dockerfile ne seront pas exécutées pendant le processus de construction de l'image actuelle (en supposant que l'image soit test-build). Lorsqu'un nouveau Dockerfile utilise l'image précédemment construite FROM test-build, alors, lors de la construction du Dockerfile de la nouvelle image, les commandes spécifiées par ONBUILD dans le Dockerfile de test-build seront exécutées.

Format :

ONBUILD <其它指令>

LABEL

L'instruction LABEL est utilisée pour ajouter des métadonnées à l'image, sous forme de paires clé-valeur. La syntaxe est la suivante :

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

Par exemple, nous pouvons ajouter l'auteur de l'image :

LABEL org.opencontainers.image.authors="example"