Victor Thérache

Qu’est-ce que Docker ?

Docker est une plateforme qui permet d’exécuter, de construire, de tester et de déployer nos applications dans des conteneurs. Les étapes de construction, de test, d’exécution et de déploiement étaient/sont généralement effectuées sur des machines locales, mais l’utilisation de conteneurs s’avère plus avantageuse, surtout à long terme. À l’aide de la CLI de Docker, nous pouvons créer des images Docker, ainsi que tirer/imposer des images Docker dans le registre Open Docker. Exécuter/arrêter des conteneurs Docker et bien plus encore !

Qu’est-ce qu’un conteneur ?

Nous pouvons créer des conteneurs à l’aide de la CLI de Docker. Les conteneurs ne sont rien d’autre que des instances d’exécution d’images Docker que nous pouvons modifier et exécuter. Vous pouvez considérer les conteneurs comme une machine virtuelle très allégée, car les images sont généralement basées sur des systèmes d’exploitation et ne contiennent que les paquets/logiciels requis.

Par conséquent, vous pouvez interagir avec le conteneur de la même manière qu’avec une machine virtuelle, vous serez en mesure de voir la sortie du code dans le terminal, et s’il s’agit d’une application web, vous pouvez exposer un port où vous serez en mesure de voir la page web tout comme elle fonctionne sur localhost:port lorsque vous exécutez ces applications localement. Cela peut être un peu confus, c’est pourquoi je ne recommanderais pas de conteneuriser une application avant d’avoir compris comment elle fonctionne, une brève idée suffirait également, et savoir comment déboguer et savoir ce qui ne va pas aiderait beaucoup.

Qu’est-ce qu’une image Docker ?

TLDR ; Les images Docker sont une façon simple d’exécuter un système d’exploitation qui peut être aussi petit que 35mb comme Alpine avec juste le logiciel dont vous avez besoin pour construire et exécuter l’application.

Posons d’abord la question suivante : quel est le besoin d’une image Docker ?

Il existe plusieurs systèmes d’exploitation de bureau et mobiles utilisés par des millions d’utilisateurs, et lorsque nous développons des applications, nous devons nous assurer d’inclure la plupart d’entre eux, sinon tous. Avant la création de Docker, supposons que vous êtes un développeur qui a créé une application de bureau pour Windows sur votre machine Windows, et que vous voulez maintenant la mettre à la disposition de vos amis qui utilisent Linux. Vous avez plusieurs options,

1. Installer Linux sur votre machine – vous ferez probablement un double démarrage de Windows avec une distribution basée sur Linux.
2. Créer une machine virtuelle en utilisant un logiciel comme Virtual Box ou VMware.
3. Utiliser une machine virtuelle d’un fournisseur de Cloud.
4. Obtenir une nouvelle machine pour le développement de Linux.

L’option 1 prend du temps car vous devez redémarrer chaque fois que vous voulez tester votre application sur un système d’exploitation particulier.

L’option 2 a été une option décente pendant assez longtemps, il y a certains inconvénients comme vous seriez essentiellement en cours d’exécution deux OS, de sorte que votre machine – ordinateur portable ou de bureau aurait besoin des ressources pour être utilisable.

L’option 3 est moins chère que l’achat d’un nouveau matériel, mais il y a des étapes supplémentaires lorsque vous voulez télécharger le code pour l’exécuter ailleurs, et pour créer plus d’instances à l’échelle, vous devez d’abord préparer à nouveau le nouvel environnement.

L’option 4 est coûteuse en raison du coût du matériel, elle est également coûteuse pour la mise à l’échelle et doit être configurée manuellement, elle est également coûteuse à remplacer si quelque chose tombe en panne.

Qu’est-ce qu’un Dockerfile ?

Dockerfile est utilisé pour construire une image en fonction de vos besoins. Il existe déjà plusieurs images sur le docker hub que vous pouvez explorer. Nous utilisons ces images comme base pour notre conteneur docker, puis nous devrons probablement le personnaliser selon nos besoins. Dans un Dockerfile, nous pouvons ajouter des instructions pour choisir une image de base, installer des paquets/dépendances, copier des fichiers de la machine hôte vers le système de fichiers du conteneur, exposer des ports qui nous aideront à nous connecter au conteneur depuis notre machine locale. Laissez-moi vous dire pourquoi Dockerfile est puissant. Imaginons que vous déplaciez le code sur un autre ordinateur et que vous ayez besoin d’exécuter l’application localement, vous devrez installer beaucoup de choses. Imaginez maintenant que vous déplaciez un Dockerfile sur cet ordinateur et que vous y installiez simplement Docker. Il ne vous reste plus qu’à construire l’image et à l’exécuter, toutes les dépendances seront installées lors de la phase de construction et l’application fonctionnera. Une fois que vous avez terminé, vous pouvez l’éteindre et les ressources seront libérées. Le mieux, c’est que la machine locale ne sera pas touchée et qu’aucun logiciel ne sera laissé derrière vous pour occuper de l’espace.

Comment obtenir Docker ?

Vous pouvez installer Docker sur votre machine en suivant la documentation ici – Installer Docker. Cette étape est nécessaire pour continuer si Docker n’est pas installé sur votre machine. Les étapes suivantes sont facultatives.

Quelques conseils tirés de mon expérience :

• Utilisez Vscode comme éditeur de code, il n’a pas seulement des plugins qui aident à la coloration syntaxique des fichiers Docker mais aussi un panneau pour visualiser et gérer vos images Docker, vos conteneurs et plus encore. Vous pouvez l’installer à partir du marché des extensions.
• L’extension Remote – Containers est également utile car elle permet de construire et d’exécuter des conteneurs Docker, et également de les ouvrir dans Vscode, n’est-ce pas génial ? C’est utile surtout pour le débogage, par exemple : Quand je voulais changer les fichiers de configuration pour nginx qui sont stockés dans les conteneurs, je pouvais utiliser Vscode pour le faire, il y a d’autres moyens, mais je pense que c’est le plus facile pour les débutants.

Avec ce qui précède prêt selon vos besoins, vous devriez être prêt à aller de l’avant.

Comment conteneuriser une application à l’aide de Docker ?

En général, pour la plupart des applications, il y a certaines étapes à franchir pour pouvoir les exécuter :

1. Télécharger les dépendances/les paquets requis
2. Construire l’application (si nécessaire)
3. Exécuter l’application

Par ex : En Javascript, nous utilisons le gestionnaire de paquets node(npm) pour la plupart de ces étapes à savoir ,

• npm install→ installe les dépendances à partir du fichier package.json.
• npm run build → Construit l’application (Généralement, les applications frontales ont une étape de construction pour créer une construction de production).
• npm run start → va démarrer votre application et elle va très probablement écouter sur un port, vous pouvez aller sur ce port depuis votre navigateur sur localhost:port et si vous servez une certaine page web ici, vous devriez être en mesure de la voir.

En Python, vous utiliserez Pip qui est comme un gestionnaire de paquets équivalent à npm pour Python,

1. pip install -r requirements.txt → Cette commande va installer toutes les dépendances à partir du fichier requirements.txt.
2. et 3. Les étapes de construction et d’exécution dépendront du framework python que votre application utilise.

Une fois que nous avons identifié ces étapes, nous pouvons en outre nous assurer que notre application fonctionne bien localement, car si elle ne fonctionne pas localement, elle ne le fera probablement pas dans un conteneur docker.

Écrire votre fichier Docker

Nous commençons par créer un fichier nommé Dockerfile à la racine de notre projet. Notez qu’il n’y a pas d’extension de fichier.

Nous ouvrons ensuite ce fichier et commençons à travailler. Voici le contenu de mon Dockerfile pour une application FastAPI qui est un framework Python pour serveurs web, similaire à Django/Flask.

Note : Même si vous n’utilisez pas la même installation et configuration, elle devrait être similaire.

FROM alpine:latest
RUN apk add py3-pip python3-dev build-base libffi-dev
WORKDIR /code
COPY . /code/

WORKDIR /code
RUN pip install --upgrade pip
RUN pip install -r requirements.txt
ENTRYPOINT [ "uvicorn" ]
CMD ["index:app", "--host", "0.0.0.0", "--workers", "4"]

FROM alpine:latest

La commande FROM choisit l’image de base, nous choisissons Alpine OS car c’est l’un des plus simples et faciles à utiliser, vous pouvez en lire plus ici.

RUN apk add py3-pip python3-dev build-base libffi-dev


La commande RUN dans un fichier docker est utilisée pour exécuter des commandes dans un conteneur, en d’autres termes, nous passons ces commandes au terminal de notre système d’exploitation alpin. apk est en fait un apt-get pour le système d’exploitation alpin. Nous installons ces dépendances qui se trouvent habituellement dans la plupart des distributions Linux, mais comme alpine est léger, nous devons en installer la plupart si nous en avons besoin. La façon dont j’ai découvert que j’en avais besoin est qu’il y avait des erreurs qui ne construisaient pas le conteneur, en vérifiant les erreurs sur stackoverflow, j’ai facilement trouvé les dépendances requises. Vous pouvez utiliser une image de base ubuntu qui ne devrait pas avoir de problèmes avec cela, mais vous pourriez toujours avoir besoin de quelque chose d’autre, donc une bonne chose à savoir.

WORKDIR /code
COPY . /code/

Avec la commande WORKDIR, nous définissons le répertoire de travail qui sera utilisé par les commandes suivantes telles que COPY. Si ce répertoire n’existe pas, il sera créé. Notez également la différence entre /code, qui est un chemin absolu où l’on cherche /code dans le répertoire racine, et ./code qui cherche le répertoire de code dans le répertoire de travail actuel.

La commande COPY est utilisée pour copier les fichiers de notre machine hôte vers le système de fichiers du conteneur afin que le code et le fichier requirements.txt puissent être utilisés par les commandes suivantes. Les commandes dépendent généralement de la commande précédente, donc s’il y a une erreur, vous devez vérifier les commandes précédant celle qui a provoqué l’erreur.

RUN pip install --upgrade pip
RUN pip install -r requirements.txt

Nous utilisons à nouveau la commande RUN pour utiliser pip, ici je mets à jour pip à la dernière version puis j’utilise pip install pour installer les exigences. La mise à jour de pip est une bonne pratique car parfois certains paquets peuvent avoir des problèmes lorsqu’ils sont utilisés avec une ancienne version de pip.

ENTRYPOINT [ "uvicorn" ]
CMD ["index:app", "--host", "0.0.0.0", "--workers", "4"]

Enfin, je vais utiliser uvicorn pour exécuter et héberger mon application, cela peut être différent pour vous, par exemple : si vous utilisez javascript, cela pourrait être node. ENTRYPOINT permet au conteneur d’être exécuté en tant qu’exécutable, ce qui signifie qu’il va continuer à fonctionner, ce que nous voulons, habituellement si la tâche est terminée, soit avec un code de succès ou d’erreur, le conteneur va arrêter de fonctionner. Le CMD passe des arguments à notre point d’entrée, vous pouvez également utiliser le CMD seul, mais l’utilisation d’un ENTRYPOINT est recommandée, également le dernier ENTRYPOINT défini dans le conteneur continuera à fonctionner dans le conteneur en éclipsant tous les précédents.

Comment construire une image Docker ?

Ok, donc après avoir créé notre dockerfile, nous sommes prêts à construire notre image docker.

docker -t container_name build .


la commande docker build est utilisée pour construire notre image, nous fournissons l’emplacement du Dockerfile en utilisant . (Vous pouvez utiliser le drapeau -help après la commande docker ou docker [commandes] pour afficher l’aide et les drapeaux disponibles dans le terminal.

docker run -p 8000:8000 container_name


La commande docker run est utilisée pour exécuter le conteneur, qui sera à l’écoute sur un port à l’intérieur du conteneur, maintenant si nous voulons être en mesure d’y accéder, nous utilisons le drapeau -p pour transférer le port à notre machine locale, la syntaxe est -p host_port:container_port, où le port du conteneur sera déterminé par l’endroit où votre application est à l’écoute.

Après cela, nous pouvons aller à http://localhost:8000 ou ce que vous avez défini et être en mesure de voir notre application, nous avons réussi à construire et exécuter notre application et je pense que vous méritez une tape dans le dos. Pour que tout changement soit pris en compte, vous devrez suivre à nouveau ces étapes, à savoir construire et exécuter. Notez également que si vous effectuez des changements à l’intérieur du conteneur, ils ne persisteront pas, vous devrez monter un dossier sur l’hôte dans le système de fichiers du conteneur pour cela, ce qui est hors de portée de ce tutoriel, mais vous pouvez le lire ici.

Cet article est une traduction de https://dev.to/levinson2504/how-to-containerize-an-application-using-docker-4931  écrit par Levinson D’Souza