Docker Dockerfile
Qu'est-ce que Dockerfile?
Dockerfile est un fichier texte utilisé pour créer une image. Le contenu du texte contient des instructions et des instructions pour créer une image.
Utilisez Dockerfile pour personnaliser l'image
Ici, nous expliquons uniquement comment exécuter le fichier Dockerfile pour personnaliser un miroir. Les instructions détaillées dans le fichier Dockerfile spécifique seront présentées dans la section suivante. Ici, il vous suffit de connaître le processus de construction.
1. Ce qui suit est de personnaliser un miroir nginx (le miroir construit aura 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 FROM, où nginx est l'image de base requise pour la personnalisation. Les opérations suivantes sont basées sur nginx.
RUN: utilisé pour exécuter les commandes de ligne de commande qui suivent. Il existe deux formats:
format de coque:
RUN <命令行命令>
# <命令行命令> 等同于，在终端操作的 shell 命令。
format exec:
RUN ["可执行文件", "参数1", "参数2"]
# 例如：
# RUN ["./test.php", "dev", "offline"] 等价于 RUN ./test.php dev offline
Remarque: chaque fois que les instructions du Dockerfile sont exécutées, un nouveau calque est créé sur le Docker. Trop de calques sans signification entraîneront une trop grande expansion de l'image. Par exemple:
FROM centos
RUN yum install wget
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"
RUN tar -xvf redis.tar.gz
以上执行会创建 3 层镜像。可简化为以下格式：
FROM centos
RUN yum install wget \
&& wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \
&& tar -xvf redis.tar.gz
Comme ci-dessus, connectez les commandes avec le symbole &&, de sorte qu'après l'exécution, une seule couche de mise en miroir sera créée.
Commencez à construire l'image
Dans le répertoire de stockage du fichier Dockerfile, exécutez l'action de génération.
L'exemple suivant génère un nginx: test (nom de l'image: étiquette de l'image) à partir du Dockerfile dans le répertoire.
Remarque: le dernier. Représente le chemin du contexte de cette exécution, qui sera présenté dans la section suivante.
$ docker build -t nginx:test .
L'affichage ci-dessus indique que la construction a réussi.
Chemin de contexte
Dans la section précédente, la dernière instruction a été mentionnée. C'est le chemin du contexte, alors quel est le chemin du contexte?
$ docker build -t nginx:test .
Le chemin de contexte fait référence au moment où le docker crée une image et souhaite parfois utiliser les fichiers locaux (comme la copie). Une fois que la commande de construction du docker connaît ce chemin, elle conditionnera tout le contenu sous le chemin.
Analyse: Parce que le mode de fonctionnement du docker est C / S. Notre machine native est C et le moteur docker est S. Le processus de construction proprement dit est terminé sous le moteur Docker, de sorte que nos fichiers locaux ne peuvent pas être utilisés pour le moment. Cela nécessite que les fichiers dans le répertoire spécifié de notre machine locale soient regroupés pour être utilisés par le moteur Docker.
Si le dernier paramètre n'est pas spécifié, le chemin de contexte par défaut est l'emplacement du Dockerfile.
Remarque: ne placez pas de fichiers inutiles dans le chemin de contexte, car ils seront empaquetés et envoyés au moteur Docker. S'il y a trop de fichiers, le processus sera lent.
Instructions détaillées
COPIE
Copiez les instructions, copiez les fichiers ou les 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>]：可选参数，用户改变复制到容器内文件的拥有者和属组。
<chemin source>: fichier source ou répertoire source. Il peut s'agir d'une expression générique et sa règle générique doit satisfaire à la règle chemin fichier.Match de Go. Par exemple:
COPY hom* /mydir/
COPY hom?.txt /mydir/
<Chemin cible>: le chemin spécifié dans le conteneur. Le chemin n'a pas besoin d'être créé à l'avance. S'il n'existe pas, il sera créé automatiquement.
AJOUTER
L'instruction ADD et COPY utilisent le même format (sous les mêmes exigences, la recommandation officielle est d'utiliser COPY). Les fonctions sont également similaires, les différences sont les suivantes:
L'avantage d'ADD: si le <fichier source> est un fichier compressé tar et que le format de compression est gzip, bzip2 et xz, il sera automatiquement copié et décompressé dans le <chemin cible>.
L'inconvénient d'ADD: il est impossible de copier des fichiers compressés tar sans décompresser. Cela invalidera le cache de création d'image, ce qui peut ralentir la création d'image. Son utilisation ou non peut être déterminée selon qu'elle doit être automatiquement décompressée.
CMD
Semblable à la commande RUN, elle est utilisée pour exécuter le programme, mais le point temporel des deux exécutions est différent:
CMD s'exécute pendant l'exécution du docker.
RUN est exécuté pendant la construction du docker.
Fonction: spécifiez le programme à exécuter par défaut pour le conteneur démarré, et le conteneur se terminera lorsque le programme s'exécutera. Le programme spécifié par l'instruction CMD peut être écrasé par le programme à exécuter spécifié dans le paramètre de ligne de commande docker run.
Remarque: s'il y a plusieurs instructions CMD dans le Dockerfile, seule la dernière prendra effet.
format:
CMD <shell 命令>
CMD ["<可执行文件或命令>","<param1>","<param2>",...]
CMD ["<param1>","<param2>",...] # 该写法是为 ENTRYPOINT 指令指定的程序提供默认参数
Le deuxième format est recommandé et le processus d'exécution est relativement clair. Le premier format sera en fait automatiquement converti au second format pendant l'opération, et le fichier exécutable par défaut est sh.
POINT D'ACCÈS
Similaire à la commande CMD, mais il ne sera pas écrasé par la commande spécifiée par les paramètres de ligne de commande de docker run, et ces paramètres de ligne de commande seront utilisés comme paramètres du programme spécifié par la commande ENTRYPOINT.
Cependant, si l'option --entrypoint est utilisée lors de l'exécution de docker run, le paramètre de cette option peut être utilisé comme programme à exécuter pour remplacer le programme spécifié par l'instruction ENTRYPOINT.
Avantages: lors de l'exécution de docker run, vous pouvez spécifier les paramètres requis pour l'opération ENTRYPOINT.
Remarque: s'il existe plusieurs instructions ENTRYPOINT dans le Dockerfile, seule la dernière prendra effet.
format:
ENTRYPOINT ["<executeable>","<param1>","<param2>",...]
Il peut être utilisé avec la commande CMD: Généralement, CMD n'est utilisé que lorsque les paramètres sont modifiés Le CMD équivaut ici à passer des paramètres à ENTRYPOINT, ce qui sera mentionné dans les exemples suivants.
Exemple:
En supposant que l'image nginx: test a été construite via le Dockerfile:
FROM nginx
ENTRYPOINT ["nginx", "-c"] # 定参
CMD ["/etc/nginx/nginx.conf"] # 变参
1. Exécuter sans transfert de paramètres
$ docker run nginx:test
La commande suivante sera exécutée dans le conteneur par défaut pour démarrer le processus principal.
nginx -c /etc/nginx/nginx.conf
2. Opération de transfert de paramètres
$ docker run nginx:test -c /etc/nginx/new.conf
La commande suivante sera exécutée dans le conteneur par défaut 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éfinissez la variable d'environnement, définissez la variable d'environnement, puis dans les instructions suivantes, vous pouvez utiliser cette variable d'environnement.
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é par $ 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
Les paramètres de construction sont les mêmes que ENV. Mais la portée est différente. La variable d'environnement définie par ARG n'est valide que dans le Dockerfile, ce qui signifie qu'elle n'est valide que pendant le processus de création du docker. Cette variable d'environnement n'existe pas dans l'image générée.
La construction du docker de la commande de construction peut être remplacée par --build-arg <nom du paramètre> = <valeur>.
format:
ARG <参数名>[=<默认值>]
LE VOLUME
Définissez un volume de données anonyme. Si vous oubliez de monter le volume de données lors du démarrage du conteneur, il sera automatiquement monté sur le volume anonyme.
effet:
Évitez de perdre des données importantes en raison du redémarrage du conteneur, ce qui est très fatal.
Évitez les contenants qui ne cessent de grossir.
format:
VOLUME ["<路径1>", "<路径2>"...]
VOLUME <路径>
Lors du démarrage de l'exécution du docker du conteneur, nous pouvons modifier le point de montage via le paramètre -v.
EXPOSER
Déclarez simplement le port.
effet:
Aidez les utilisateurs du miroir à comprendre le port de garde de ce service de mise en miroir pour faciliter le mappage de configuration.
Lorsque vous utilisez un mappage de port aléatoire au moment de l'exécution, c'est-à-dire lorsque le docker exécute -P, le port EXPOSE sera automatiquement mappé de manière aléatoire.
format:
EXPOSE <端口1> [<端口2>...]
WORKDIR
Spécifiez le répertoire de travail. Le répertoire de travail spécifié par WORKDIR existera dans chaque couche de l'image. (Le répertoire de travail spécifié par WORKDIR doit être créé à l'avance).
Dans le processus de construction de docker pour créer l'image, chaque commande RUN est un nouveau calque. Seuls les répertoires créés via WORKDIR existeront toujours.
format:
WORKDIR <工作目录路径>
UTILISATEUR
Il est utilisé pour spécifier l'utilisateur et le groupe d'utilisateurs qui exécutent les commandes suivantes. Il s'agit simplement de changer l'utilisateur qui exécute les commandes suivantes (l'utilisateur et le groupe d'utilisateurs doivent déjà exister à l'avance).
format:
USER <用户名>[:<用户组>]
BILAN DE SANTÉ
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, la commande spécifiée avec ONBUILD dans le Dockerfile ne sera pas exécutée pendant le processus de construction de l'image (en supposant que l'image est test-build). Lorsqu'un nouveau Dockerfile utilise l'image précédemment construite FROM test-build, qui consiste à exécuter la construction Dockerfile de la nouvelle image, la commande spécifiée par ONBUILD dans le Dockerfile de test-build sera exécutée.
format:
ONBUILD <其它指令>