Utilisation des instructions Dockerfile ENTRYPOINT et CMD

Si vous avez déjà eu besoin d'exécuter une ou deux commandes dans votre conteneur Docker au démarrage, ce didacticiel est fait pour vous. Utilisation du Dockerfile ENTRYPOINT et CMD instructions, vous pouvez exécuter autant de commandes de démarrage que vous le souhaitez.

Dans ce didacticiel, vous apprendrez à utiliser le ENTRYPOINT et CMD instructions pour exécuter les commandes de démarrage dans un Dockerfile et comprendre les différences entre elles.

Prérequis

Étant donné que ce didacticiel sera une démonstration pratique, assurez-vous d'avoir en place les éléments suivants :

Un PC Windows 10 – Windows 10 v10.0.19042 a été utilisé dans ce didacticiel.
Docker Desktop :ce didacticiel utilise Docker Desktop v3.3.1.

Création d'un Dockerfile

Avant de pouvoir exécuter les commandes de démarrage du conteneur Docker, vous devez d'abord créer un Dockerfile. Un Dockerfile est un document texte qui contient une liste de commandes pour créer des conteneurs, des images Docker et détermine comment une image Docker est créée.

1. Tout d'abord, ouvrez PowerShell en tant qu'administrateur.

2. Créez un nouveau dossier pour stocker le Dockerfile et tous les fichiers associés que ce didacticiel utilisera et accédez à ce répertoire. Ce tutoriel utilise ~/docker .

mkdir ~/docker
cd docker

3. Maintenant, créez un fichier texte vide nommé Dockerfile avec la commande suivante.

cd > Dockerfile

Vous pouvez également créer un Dockerfile avec la commande suivante si vous utilisez Linux ou Mac OS.

touch Dockerfile

4. Enfin, ajoutez le contenu suivant dans le Dockerfile

FROM ubuntu:20.04

Vous avez maintenant créé un futur Dockerfile !

Construire une image Docker

Maintenant que vous avez créé votre Dockerfile, vous devez créer une image Docker pour exécuter les commandes écrites dans vos instructions Dockerfile ENTRYPOINT et CMD. Une façon de construire une image est d'utiliser le build commande.

Dans le ~/docker répertoire, exécutez la commande suivante. La commande ci-dessous crée une image Docker appelée demo (-t demo ) à partir du Dockerfile dans ~/docker en spécifiant le répertoire de travail courant (. ).

docker build -t demo .

Exécuter un conteneur Docker

Après avoir créé l'image Docker, vous aurez besoin d'un conteneur pour exécuter l'image Docker qui exécutera les commandes des instructions Dockerfile ENTRYPOINT et CMD.

Pour exécuter un conteneur Docker, appelez le run commande pour créer une couche de conteneur inscriptible sur l'image Docker (demo ). L'exemple ci-dessous utilise le -it paramètre pour se connecter de manière interactive au conteneur afin que vous puissiez voir l'exemple de sortie.

docker run -it demo

Formulaire Exec contre Shell

Lorsque vous commencez à travailler avec un Dockerfile et que vous comprenez comment exécuter les commandes de démarrage, vous pouvez rencontrer deux méthodes différentes pour définir ces commandes. Chaque méthode invoquera des commandes mais le fera un peu différemment.

Lorsque Docker exécute des commandes, il peut le faire directement appelé exec soit passer par le shell du conteneur (/bin/sh -c sous Linux ou cmd /S /C sous Windows) appelé shell .

Vous remarquerez les commandes exécutées via exec avoir une instruction suivie des exécutables à invoquer suivis d'un ou plusieurs arguments de ligne de commande, comme indiqué ci-dessous.

ENTRYPOINT ["executables", "parameter1", "parameter2", ...]
CMD ["executables", "parameter1", "parameter2:, ...]

Écrire des commandes dans shell form, d'autre part, ne nécessite pas d'envelopper les commandes entre crochets, comme indiqué ci-dessous.

ENTRYPOINT <command> "parameter1"
CMD <command> "parameter1"

Si vous ne spécifiez pas d'argument pour CMD , Docker exécutera toujours la commande sous forme exec, par ex. CMD <command> .

Si vous débutez, différencier ces deux invocations de commande n'aura pas trop d'importance, mais à mesure que vous progresserez, vous verrez bientôt les avantages et les inconvénients de chacun.

Exécution des commandes de démarrage

Entrons maintenant dans le vif du sujet de ce didacticiel et mettons les mains dans le cambouis en parcourant quelques exemples d'exécution de commandes de démarrage dans un Dockerfile ENTRYPOINT et instructions CMD.

1. Ouvrez le Dockerfile que vous avez créé précédemment dans votre éditeur de texte préféré.

2. Copiez et collez l'exemple de contenu Dockerfile dans votre Dockerfile, comme indiqué ci-dessous, et enregistrez-le.

Ce Dockerfile crée une couche en utilisant le ubuntu:20.04 comme image de base. Il dit ensuite à Docker d'invoquer le echo commande en lui passant le Hello world argument pour le Dockerfile CMD et ENTRYPOINT instructions utilisant exec et shell formulaire.

FROM ubuntu:20.04
# CMD Instruction
CMD ["echo", "Hello world"] # Exec Form
CMD echo "Hello world"      # Shell Form
# ENTRYPOINT Instruction
ENTRYPOINT ["echo", "Hello world"] # Exec Form
ENTRYPOINT echo "Hello world"      # Shell Form

3. Dans le ~/docker répertoire, créez la nouvelle image en exécutant docker build et appelez-le demo . La commande sous tags l'image en tant que demo et recherche un Dockerfile dans le répertoire de travail courant (. ).

docker build -t demo .

4. Maintenant, exécutez un conteneur à l'aide de l'image, puis exécutez un conteneur Docker basé sur l'image Docker créée précédemment. Vous verrez maintenant que le conteneur renvoie Hello world qui vient du CMD instruction fournie dans le Dockerfile.

docker run -it demo

Utilisation de variables dans un Dockerfile

Parfois, vous ne connaissez peut-être pas les arguments de ligne de commande exacts à transmettre à la commande à l'avance. Les arguments que vous devez transmettre à une commande ne sont exposés qu'au moment de l'exécution. Plutôt que d'attribuer statiquement des arguments de commande, vous pouvez capturer et transmettre ces arguments aux commandes avec des variables.

Vous ne pouvez utiliser les variables Dockerfile que dans shell formulaire. Docker ne prend pas en charge les variables dans la commande invoquée via exec formulaire.

Ouvrez à nouveau le Dockerfile dans votre éditeur de texte préféré, remplacez tout ce qu'il contient par la série de commandes suivante et enregistrez-le.

Vous remarquerez que cette fois, le Dockerfile utilise des variables d'environnement et s'affiche en utilisant ENV . Dans l'exemple ci-dessous, le Dockerfile définit une variable d'environnement appelée name avec une valeur de friend . Une fois créée, cette variable d'environnement est alors référencée via $name .

Lorsque Docker exécute un conteneur basé sur ce Dockerfile, il invoquera le echo commande et passez l'argument de Welcome, friend .

FROM ubuntu:20.04
ENV name friend

CMD echo "Welcome, $name"
# or
## ENTRYPOINT echo "Welcome, $name"

Maintenant, créez l'image Docker et exécutez à nouveau le conteneur en fournissant éventuellement un nom de balise de shellform . Vous remarquerez que Docker a invoqué le echo commande et a renvoyé la sortie attendue.

Combinaison des instructions Dockerfile ENTRYPOINT et CMD

La plupart du temps, vous invoquerez des commandes de démarrage dans l'instruction CMD ou ENTRYPOINT. Après tout, vous pouvez invoquer autant de commandes que vous le souhaitez en utilisant chaque méthode. Mais, vous pouvez également invoquer une seule commande et « construire dessus » en utilisant les deux instructions.

En vous basant sur les exemples précédents, vous avez peut-être un Dockerfile qui ressemble à l'exemple ci-dessous. Tel quel, si vous créez une image et exécutez un conteneur à partir de cette image, Docker invoquera le echo commande et renvoie Hello .

FROM ubuntu:20.04
ENTRYPOINT ["echo", "Hello"]

Peut-être avez-vous un autre argument que vous aimeriez passer à echo commande mais pas tout de suite. Peut-être aimeriez-vous le faire plus loin dans le Dockerfile. En appelant le CMD instruction sans commande, vous pouvez le faire.

Lorsque vous spécifiez une commande à exécuter via le ENTRYPOINT instruction suivie du CMD instruction, Docker assume automatiquement la valeur transmise à CMD est un argument ; pas une commande.

Maintenant, ajoutez un CMD référence d'instruction sans commande, juste un argument appelé world , comme indiqué ci-dessous.

FROM ubuntu:20.04
ENTRYPOINT ["echo", "Hello"]
CMD ["world"]

Les instructions combinantes doivent toujours être écrites sous forme exec en raison de son comportement de type "tableau" consistant à spécifier des valeurs séparées individuellement par des virgules plutôt que toutes dans une seule chaîne.

Après avoir construit l'image et exécuté le conteneur à partir de l'image, vous pouvez voir qu'au lieu de deux lignes de sortie (Hello et world ), Docker n'en renvoie qu'un, ce qui signifie qu'un seul echo appel de commande.

Conclusion

Vous devriez maintenant avoir une bonne compréhension de l'exécution des commandes de démarrage du conteneur Docker via le CMD et ENTRYPOINT Instructions Dockerfile. Chaque instruction est un peu différente mais accomplit la même tâche et peut même être utilisée ensemble.

Pouvez-vous penser à un scénario dans lequel vous préféreriez utiliser CMD sur ENTRYPOINT exécuter une commande de démarrage ?