Docker expliqué : utilisation de Dockerfiles pour automatiser la création d'images

Introduction

Les conteneurs Docker sont créés à l'aide d'images de base. Une image peut être basique, ne contenant rien d’autre que les principes fondamentaux du système d’exploitation, ou elle peut consister en une pile d’applications sophistiquées prédéfinies prêtes à être lancées.

Lors de la création de vos images avec Docker, chaque action entreprise (c'est-à-dire une commande exécutée telle que apt-get install) forme une nouvelle couche au-dessus de la précédente. Ces images de base peuvent ensuite être utilisées pour créer de nouveaux conteneurs.

Dans cet article de DigitalOcean, nous verrons comment automatiser ce processus autant que possible, ainsi que démontrerons les meilleures pratiques et méthodes pour tirer le meilleur parti de Docker et des conteneurs via Dockerfiles : scripts pour créer des conteneurs, étape- étape par étape, couche par couche, automatiquement à partir d'une image de base.

Glossaire

1. Docker en bref

2. Fichiers Docker

3. Syntaxe du fichier Docker

1. Qu’est-ce que la syntaxe ?
2. Exemple de syntaxe de fichier Dockerfile

4. Commandes Dockerfile

1. AJOUTER
2. CMD
3. POINT D'ENTRÉE
4. ENV
5. EXPOSER
6. DEPUIS
7. MAINTENANT
8. COURIR
9. UTILISATEUR
10. VOLUME
11. RÉPERT TRAVAIL

5. Comment utiliser les fichiers Docker

6. Exemple Dockerfile : création d'une image pour installer MongoDB

1. Création du fichier Docker vide
2. Définir notre dossier et sa finalité
3. Définition de l'image de base à utiliser
4. Définir le responsable (Auteur)
5. Mise à jour de la liste du référentiel d'applications
6. Définition des arguments et des commandes pour le téléchargement de MongoDB
7. Définition du port par défaut pour MongoDB
8. Enregistrer le fichier Docker
9. Construire notre première image
10. Exécuter une instance MongoDB

Docker en bref

Le projet Docker propose des outils de niveau supérieur qui fonctionnent ensemble, construits sur certaines fonctionnalités du noyau Linux. L'objectif est d'aider les développeurs et les administrateurs système à porter des applications - avec toutes leurs dépendances conjointement - et à les faire fonctionner sur tous les systèmes et machines sans maux de tête.

Docker y parvient en créant des environnements sécurisés basés sur LXC (c'est-à-dire des conteneurs Linux) pour les applications appelées « conteneurs Docker ». Ces conteneurs sont créés à l'aide d'images Docker, qui peuvent être créées en exécutant des commandes manuellement ou automatiquement via des Dockerfiles.

Remarque : Pour en savoir plus sur Docker et ses composants (par exemple, le démon Docker, la CLI, les images, etc.), consultez notre article d'introduction au projet : Comment installer et utiliser Docker sur Ubuntu 16.04.

Fichiers Docker

Chaque Dockerfile est un script, composé de différentes commandes (instructions) et arguments listés successivement pour effectuer automatiquement des actions sur une image de base afin d'en créer (ou former) une nouvelle. Ils sont utilisés pour organiser les choses et facilitent grandement les déploiements en simplifiant le processus du début à la fin.

Les Dockerfiles commencent par définir une image FROM à laquelle le processus de construction démarre. Suivi de diverses autres méthodes, commandes et arguments (ou conditions), en retour, fournissez une nouvelle image qui doit être utilisée pour créer des conteneurs Docker.

Ils peuvent être utilisés en fournissant le contenu d'un Dockerfile - de différentes manières - au démon Docker pour créer une image (comme expliqué dans la section Comment utiliser).

Syntaxe du fichier Docker

Avant de commencer à parler des Dockerfiles, passons rapidement en revue sa syntaxe et ce que cela signifie réellement.

Qu’est-ce que la syntaxe ?

Très simplement, la syntaxe en programmation désigne une structure permettant d'ordonner les commandes, les arguments et tout ce qui est nécessaire pour programmer une application afin d'exécuter une procédure (c'est-à-dire une fonction/une collection d'instructions).

Ces structures sont basées sur des règles, clairement et explicitement définies, et elles doivent être suivies par le programmeur pour s'interfacer avec toute application informatique (par exemple interprètes, démons, etc.) qui les utilise ou les attend. Si un script (c'est-à-dire un fichier contenant une série de tâches à effectuer) n'est pas correctement structuré (c'est-à-dire une mauvaise syntaxe), le programme informatique ne pourra pas l'analyser. L'analyse grossière peut être comprise comme l'examen d'une entrée dans le but final de comprendre ce que cela signifie.

Les Dockerfiles utilisent une syntaxe simple, propre et claire, ce qui les rend étonnamment faciles à créer et à utiliser. Ils sont conçus pour être explicites, notamment parce qu'ils permettent de commenter tout comme le code source d'une application correctement écrit.

Exemple de syntaxe de fichier Dockerfile

La syntaxe Dockerfile se compose de deux types de blocs de ligne principaux : commentaires et commandes + arguments.

# Line blocks used for commenting
command argument argument ..

Un exemple simple :

# Print "Hello docker!"
RUN echo "Hello docker!"

Commandes Dockerfile (instructions)

Actuellement, il existe environ une douzaine d'ensembles de commandes différents que les Dockerfiles peuvent contenir pour permettre à Docker de créer une image. Dans cette section, nous les passerons tous en revue, individuellement, avant de travailler sur un exemple de Dockerfile.

Remarque : Comme expliqué dans la section précédente (Syntaxe Dockerfile), toutes ces commandes doivent être répertoriées (c'est-à-dire écrites) successivement, à l'intérieur d'un seul fichier texte brut (c'est-à-dire Dockerfile), dans l'ordre que vous souhaitez. les exécutés (c'est-à-dire exécutés) par le démon docker pour créer une image. Cependant, certaines de ces commandes (par exemple MAINTAINER) peuvent être placées n'importe où bon vous semble (mais toujours après la commande FROM), car elles ne constituent pas une exécution mais plutôt une valeur d'une définition (c'est-à-dire juste quelques Informations Complémentaires).

AJOUTER

La commande ADD obtient deux arguments : une source et une destination. Il copie essentiellement les fichiers de la source sur l'hôte dans le propre système de fichiers du conteneur à la destination définie. Toutefois, si la source est une URL (par exemple http://github.com/user/file/), le contenu de l'URL est téléchargé et placé à la destination.

Exemple :

# Usage: ADD [source directory or URL] [destination directory]
ADD /my_app_folder /my_app_folder

CMD

La commande CMD, comme RUN, peut être utilisée pour exécuter une commande spécifique. Cependant, contrairement à RUN, il n'est pas exécuté lors de la construction, mais lorsqu'un conteneur est instancié à l'aide de l'image en cours de construction. Par conséquent, elle doit être considérée comme une commande initiale par défaut qui est exécutée (c'est-à-dire exécutée) avec la création de conteneurs basés sur l'image.

Pour clarifier : un exemple pour CMD serait d'exécuter une application lors de la création d'un conteneur déjà installé à l'aide de RUN (par exemple RUN apt-get install …) à l'intérieur de l'image. Cette commande d'exécution d'application par défaut définie avec CMD devient la commande par défaut et remplace toute commande passée lors de la création.

Exemple :

# Usage 1: CMD application "argument", "argument", ..
CMD "echo" "Hello docker!"

POINT D'ENTRÉE

L'argument ENTRYPOINT définit l'application concrète par défaut qui est utilisée chaque fois qu'un conteneur est créé à l'aide de l'image. Par exemple, si vous avez installé une application spécifique dans une image et que vous utiliserez cette image pour exécuter uniquement cette application, vous pouvez l'indiquer avec ENTRYPOINT et chaque fois qu'un conteneur est créé à partir de cette image, votre application sera la cible.

Si vous couplez ENTRYPOINT avec CMD, vous pouvez supprimer « application » de CMD et simplement laisser « arguments » qui seront transmis à ENTRYPOINT.

Exemple :

# Usage: ENTRYPOINT application "argument", "argument", ..Remember: arguments are optional. They can be provided by CMD          or during the creation of a container.
ENTRYPOINT echo
Usage example with CMD:Arguments set with CMD can be overridden during *run*
CMD "Hello docker!"
ENTRYPOINT echo  

ENV

La commande ENV permet de définir les variables d'environnement (une ou plusieurs). Ces variables sont constituées de paires « clé-valeur » accessibles dans le conteneur par les scripts et les applications. Cette fonctionnalité de Docker offre une énorme flexibilité pour exécuter des programmes.

Exemple :

# Usage: ENV key value
ENV SERVER_WORKS 4

EXPOSER

La commande EXPOSE est utilisée pour associer un port spécifié afin de permettre la mise en réseau entre le processus en cours d'exécution à l'intérieur du conteneur et le monde extérieur (c'est-à-dire l'hôte).

Exemple :

# Usage: EXPOSE [port]
EXPOSE 8080

Pour en savoir plus sur la mise en réseau Docker, consultez la documentation sur la mise en réseau des conteneurs Docker.

DEPUIS

La directive FROM est probablement la plus cruciale parmi toutes les autres pour les Dockerfiles. Il définit l'image de base à utiliser pour démarrer le processus de construction. Il peut s'agir de n'importe quelle image, y compris celles que vous avez créées précédemment. Si une image FROM n'est pas trouvée sur l'hôte, Docker essaiera de la trouver (et de la télécharger) à partir du Docker Hub ou d'un autre référentiel de conteneurs. Il doit s'agir de la première commande déclarée dans un Dockerfile.

Exemple :

# Usage: FROM [image name]
FROM ubuntu

MAINTENANT

L'une des commandes qui peuvent être définies n'importe où dans le fichier - même s'il serait préférable qu'elle soit déclarée en haut - est MAINTAINER. Cette commande non exécutable déclare l'auteur, définissant ainsi le champ auteur des images. Il devrait néanmoins venir après FROM.

Exemple :

# Usage: MAINTAINER [name]
MAINTAINER authors_name

COURIR

La commande RUN est la directive d'exécution centrale des Dockerfiles. Il prend une commande comme argument et l’exécute pour former l’image. Contrairement à CMD, il est en fait utilisé pour construire l'image (formant un autre calque au-dessus du précédent qui est validé).

Exemple :

# Usage: RUN [command]
RUN aptitude install -y riak

UTILISATEUR

La directive USER est utilisée pour définir l'UID (ou le nom d'utilisateur) qui doit exécuter le conteneur en fonction de l'image en cours de construction.

Exemple :

# Usage: USER [UID]
USER 751

VOLUME

La commande VOLUME est utilisée pour permettre l'accès depuis votre conteneur à un répertoire sur la machine hôte (c'est-à-dire le monter).

Exemple :

# Usage: VOLUME ["/dir_1", "/dir_2" ..]
VOLUME ["/my_files"]

RÉPERT TRAVAIL

La directive WORKDIR est utilisée pour définir où la commande définie avec CMD doit être exécutée.

Exemple :

# Usage: WORKDIR /path
WORKDIR ~/

Comment utiliser les fichiers Docker

Utiliser Dockerfiles est aussi simple que de demander au démon Docker d'en exécuter un. La sortie après l'exécution du script sera l'ID de la nouvelle image Docker.

Utilisation :

# Build an image using the Dockerfile at current locationExample: docker build -t [name] .
docker build -t my_mongodb .    

Exemple Dockerfile : création d'une image pour installer MongoDB

Dans cette dernière section pour Dockerfiles, nous allons créer un document Dockerfile et le remplir étape par étape avec le résultat final d'avoir un Dockerfile, qui peut être utilisé pour créer une image Docker pour exécuter des conteneurs MongoDB.

Remarque : Après avoir commencé à modifier le fichier Docker, tout le contenu et les arguments des sections ci-dessous doivent être écrits (ajoutés) successivement à l'intérieur, en suivant notre exemple et les explications de la Syntaxe Docker<. section. Vous pouvez voir à quoi ressemblera le résultat final dans la dernière section de cette procédure pas à pas.

Création du fichier Docker vide

À l’aide de l’éditeur de texte nano, commençons à éditer notre Dockerfile.

nano Dockerfile

Définir notre dossier et sa finalité

Bien que facultatif, il est toujours judicieux de vous laisser, ainsi qu'à tout le monde, comprendre (si nécessaire) ce qu'est ce fichier et ce à quoi il est destiné. Pour cela, nous commencerons notre Dockerfile par des commentaires fantaisistes (#) pour le décrire.

############################################################Dockerfile to build MongoDB container imagesBased on Ubuntu
############################################################

Définition de l'image de base à utiliser

# Set the base image to Ubuntu
FROM ubuntu

Définir le responsable (Auteur)

# File Author / Maintainer
MAINTAINER Example McAuthor

Définition des arguments et des commandes pour le téléchargement de MongoDB

################## BEGIN INSTALLATION ######################Install MongoDB Following the Instructions at MongoDB DocsRef: http://docs.mongodb.org/manual/tutorial/install-mongodb-on-ubuntu/
Add the package verification key
RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10
Add MongoDB to the repository sources list
RUN echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | tee /etc/apt/sources.list.d/mongodb.list
Update the repository sources list
RUN apt-get update
Install MongoDB package (.deb)
RUN apt-get install -y mongodb-10gen
Create the default data directory
RUN mkdir -p /data/db

##################### INSTALLATION END #####################

Définition du port par défaut pour MongoDB

# Expose the default port
EXPOSE 27017
Default port to execute the entrypoint (MongoDB)
CMD ["--port 27017"]
Set default container command
ENTRYPOINT usr/bin/mongod

Enregistrer le fichier Docker

Après avoir tout ajouté au fichier, il est temps de sauvegarder et de quitter. Appuyez sur CTRL+X puis sur Y pour confirmer et enregistrer le Dockerfile.

Voici à quoi devrait ressembler le fichier final :

############################################################Dockerfile to build MongoDB container imagesBased on Ubuntu
############################################################
Set the base image to Ubuntu
FROM ubuntu
File Author / Maintainer
MAINTAINER Example McAuthor

################## BEGIN INSTALLATION ######################Install MongoDB Following the Instructions at MongoDB DocsRef: http://docs.mongodb.org/manual/tutorial/install-mongodb-on-ubuntu/
Add the package verification key
RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10
Add MongoDB to the repository sources list
RUN echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | tee /etc/apt/sources.list.d/mongodb.list
Update the repository sources list
RUN apt-get update
Install MongoDB package (.deb)
RUN apt-get install -y mongodb-10gen
Create the default data directory
RUN mkdir -p /data/db

##################### INSTALLATION END #####################
Expose the default port
EXPOSE 27017
Default port to execute the entrypoint (MongoDB)
CMD ["--port 27017"]
Set default container command
ENTRYPOINT usr/bin/mongod

Construire notre première image

En utilisant les explications précédentes, nous sommes prêts à créer notre première image MongoDB avec docker !

docker build -t my_mongodb .

Remarque : L'indicateur -t [nom] est utilisé ici pour baliser l'image. Pour en savoir plus sur ce que vous pouvez faire d'autre pendant la construction, exécutez docker build --help.

Exécuter une instance MongoDB

En utilisant l'image que nous avons construite, nous pouvons maintenant passer à l'étape finale : créer un conteneur exécutant une instance MongoDB à l'intérieur, en utilisant un nom de notre choix (si vous le souhaitez avec -name [name]).

docker run -name my_first_mdb_instance -i -t my_mongodb

Remarque : Si aucun nom n'est défini, nous devrons gérer des identifiants alphanumériques complexes qui peuvent être obtenus en répertoriant tous les conteneurs à l'aide de docker ps -l.

Remarque : Pour vous détacher du conteneur, utilisez la séquence d'échappement CTRL+P suivie de CTRL+Q.

Apprécier!