Conteneurisation professionnelle des applications Node.js à l'aide de Docker

L'auteur du matériel, dont nous publions la traduction aujourd'hui, est un ingénieur DevOps. Il dit qu'il doit utiliser Docker . En particulier, cette plate-forme de gestion de conteneurs est utilisée à différentes étapes du cycle de vie des applications Node.js. L'utilisation de Docker, une technologie qui a récemment été extrêmement populaire, vous permet d'optimiser le processus de développement et de sortie des projets Node.js en production.



Nous publions maintenant une série d'articles sur Docker, conçus pour ceux qui veulent apprendre cette plate-forme pour son utilisation dans diverses situations. Le même matériel se concentre principalement sur l'utilisation professionnelle de Docker dans le développement de Node.js.

Qu'est-ce qu'un docker?

Docker est un programme conçu pour organiser la virtualisation au niveau du système d'exploitation (conteneurisation). Au cœur des conteneurs se trouvent des images en couches. En termes simples, Docker est un outil qui vous permet de créer, déployer et exécuter des applications à l'aide de conteneurs indépendants du système d'exploitation sur lequel ils s'exécutent. Le conteneur comprend une image du système d'exploitation de base nécessaire au fonctionnement de l'application, la bibliothèque dont dépend cette application et cette application elle-même. Si plusieurs conteneurs s'exécutent sur le même ordinateur, ils utilisent ensemble les ressources de cet ordinateur. Les conteneurs Docker peuvent emballer des projets créés à l'aide de diverses technologies. Nous sommes intéressés par des projets basés sur Node.js.

Création d'un projet Node.js

Avant de compresser un projet Node.js dans un conteneur Docker, nous devons créer ce projet. Faisons-le. Voici le fichier package.json de ce projet:

 { "name": "node-app", "version": "1.0.0", "description": "The best way to manage your Node app using Docker", "main": "index.js", "scripts": {   "start": "node index.js" }, "author": "Ankit Jain <ankitjain28may77@gmail.com>", "license": "ISC", "dependencies": {   "express": "^4.16.4" } } 

Pour installer les dépendances du projet, exécutez la commande npm install . Au cours de cette commande, entre autres, le fichier package-lock.json sera créé. Créez maintenant le fichier index.js , qui contiendra le code du projet:

 const express = require('express'); const app = express(); app.get('/', (req, res) => { res.send('The best way to manage your Node app using Docker\n'); }); app.listen(3000); console.log('Running on http://localhost:3000'); 

Comme vous pouvez le voir, nous avons décrit ici un serveur simple qui renvoie du texte en réponse à des requêtes.

Créer un Dockerfile

Maintenant que l'application est prête, parlons de la façon de l'intégrer dans un conteneur Docker. À savoir, il s'agira de la partie la plus importante de tout projet basé sur Docker, à propos du Dockerfile.

Un Dockerfile est un fichier texte qui contient des instructions pour créer une image Docker pour une application. Les instructions de ce fichier, si elles n'entrent pas dans les détails, décrivent la création de couches d'un système de fichiers à plusieurs niveaux, qui a tout ce dont une application a besoin pour fonctionner. La plate-forme Docker peut mettre en cache des couches d'images, ce qui, lors de la réutilisation de couches qui sont déjà dans le cache, accélère le processus de création d'images.

En programmation orientée objet, il existe une chose telle qu'une classe. Les classes sont utilisées pour créer des objets. Dans Docker, les images peuvent être comparées à des classes et les conteneurs peuvent être comparés à des instances d'images, c'est-à-dire à des objets. Considérez le processus de génération d'un Dockerfile, qui nous aidera à comprendre cela.

Créez un Dockerfile vide:

 touch Dockerfile 

Puisque nous allons créer un conteneur pour l'application Node.js, la première chose que nous devons mettre dans le conteneur sera l'image de base du nœud, qui peut être trouvée sur le Docker Hub . Nous utiliserons la version LTS de Node.js. Par conséquent, la première déclaration de notre Dockerfile sera la déclaration suivante:

 FROM node:8 

Après cela, créez un répertoire pour notre code. En même temps, grâce à l'instruction ARG utilisée ici, nous pouvons, si nécessaire, spécifier le nom du répertoire d'application autre que /app lors de l'assemblage du conteneur. Vous trouverez des détails sur ce manuel ici .

 #   ARG APP_DIR=app RUN mkdir -p ${APP_DIR} WORKDIR ${APP_DIR} 

Puisque nous utilisons l'image Node, les plates-formes Node.js et npm y seront déjà installées. En utilisant ce qui est déjà dans l'image, vous pouvez organiser l'installation des dépendances du projet. En utilisant l'indicateur --production (ou si la NODE_ENV environnement NODE_ENV définie sur production ), npm n'installera pas les modules répertoriés dans la section devDependencies du fichier devDependencies .

 #   COPY package*.json ./ RUN npm install #     # RUN npm install --production 

Ici, nous package*.json fichier package*.json dans l'image, au lieu, par exemple, de copier tous les fichiers du projet. Nous le faisons précisément parce que les instructions Dockerfile RUN , COPY et ADD créent des couches d'image supplémentaires, vous pouvez donc utiliser les fonctionnalités de mise en cache des couches de la plateforme Docker. Avec cette approche, la prochaine fois que nous collecterons une image similaire, Docker cherchera s'il est possible de réutiliser des couches d'images qui sont déjà dans le cache, et si c'est le cas, il tirera parti de ce qui est déjà là, au lieu d'en créer de nouvelles couches. Cela vous permet de gagner sérieusement du temps lors de l'assemblage de couches au cours de travaux sur de grands projets, qui incluent de nombreux modules npm.

Copiez maintenant les fichiers du projet dans le répertoire de travail actuel. Ici, nous n'utiliserons pas l'instruction ADD , mais l'instruction COPY . En fait, dans la plupart des cas, il est recommandé de privilégier l'instruction COPY .

L'instruction ADD , par rapport à COPY , a certaines fonctionnalités qui, cependant, ne sont pas toujours nécessaires. Par exemple, nous parlons d'options pour décompresser les archives .tar et télécharger des fichiers par URL.

 #    COPY . . 

Les conteneurs Docker sont des environnements isolés. Cela signifie que lorsque nous lancerons l'application dans le conteneur, nous ne pourrons pas interagir directement avec elle sans ouvrir le port sur lequel cette application écoute. Afin d'informer Docker qu'il existe une application dans un certain conteneur écoutant sur un certain port, vous pouvez utiliser l'instruction EXPOSE .

 #   ,      EXPOSE 3000 

À ce jour, nous, en utilisant le Dockerfile, avons décrit l'image que l'application contiendra et tout ce dont elle a besoin pour réussir le lancement. Ajoutez maintenant l'instruction au fichier qui vous permet de démarrer l'application. Il s'agit d'une instruction CMD . Il vous permet de spécifier une certaine commande avec des paramètres qui seront exécutés au démarrage du conteneur et, si nécessaire, peuvent être remplacés par des outils de ligne de commande.

 #   CMD ["npm", "start"] 

Voici à quoi ressemblera le Dockerfile fini:

 FROM node:8 #   ARG APP_DIR=app RUN mkdir -p ${APP_DIR} WORKDIR ${APP_DIR} #   COPY package*.json ./ RUN npm install #     # RUN npm install --production #    COPY . . #   ,      EXPOSE 3000 #   CMD ["npm", "start"] 

Assemblage d'images

Nous avons préparé un fichier Dockerfile contenant des instructions pour la construction de l'image, sur la base duquel un conteneur avec une application en cours d'exécution sera créé. Assemblez l'image en exécutant une commande de la forme suivante:

 docker build --build-arg <build arguments> -t <user-name>/<image-name>:<tag-name> /path/to/Dockerfile 

Dans notre cas, cela ressemblera à ceci:

 docker build --build-arg APP_DIR=var/app -t ankitjain28may/node-app:V1 . 

Dockerfile a une instruction ARG qui décrit l'argument APP_DIR . Ici, nous définissons sa signification. Si cela n'est pas fait, il prendra alors la valeur qui lui est affectée dans le fichier, c'est-à-dire app .

Après avoir assemblé l'image, vérifiez si Docker la voit. Pour ce faire, exécutez la commande suivante:

 docker images 

En réponse à cette commande, approximativement les éléments suivants devraient être sortis.


Images Docker

Lancement d'image

Après avoir assemblé l'image Docker, nous pouvons l'exécuter, c'est-à-dire en créer une instance, représentée par un conteneur de travail. Pour ce faire, utilisez une commande de ce type:

 docker run -p <External-port:exposed-port> -d --name <name of the container> <user-name>/<image-name>:<tag-name> 

Dans notre cas, cela ressemblera à ceci:

 docker run -p 8000:3000 -d --name node-app ankitjain28may/node-app:V1 

Nous demanderons au système des informations sur le fonctionnement des conteneurs à l'aide de cette commande:

 docker ps 

En réponse à cela, le système doit produire quelque chose comme ceci:


Conteneurs Docker

Jusqu'à présent, tout se passe comme prévu, bien que nous n'ayons pas encore essayé d'accéder à l'application en cours d'exécution dans le conteneur. À savoir, notre conteneur, nommé node-app , écoute sur le port 8000 . Afin d'essayer d'y accéder, vous pouvez ouvrir un navigateur et y accéder à localhost:8000 . De plus, afin de vérifier l'intégrité du conteneur, vous pouvez utiliser la commande suivante:

 curl -i localhost:8000 

Si le conteneur fonctionne vraiment, quelque chose comme celui illustré dans la figure suivante sera retourné en réponse à cette commande.


Résultat de la vérification de l'état du conteneur

Sur la base de la même image, par exemple, sur la base de tout juste créé, il est possible de créer de nombreux conteneurs. De plus, vous pouvez envoyer notre image au registre Docker Hub, ce qui permettra à d'autres développeurs de télécharger notre image et de lancer les conteneurs appropriés à la maison. Cette approche simplifie le travail avec les projets.

Recommandations

Voici quelques suggestions qui méritent d'être examinées afin de tirer parti de la puissance de Docker et de créer des images aussi compactes que possible.

▍1. Créez toujours un fichier .dockerignore

Dans le dossier de projet que vous prévoyez de placer dans le conteneur, vous devez toujours créer un fichier .dockerignore . Il vous permet d'ignorer les fichiers et dossiers qui ne sont pas nécessaires lors de la création de l'image. Avec cette approche, nous pouvons réduire le soi-disant contexte de construction, ce qui nous permettra d'assembler rapidement l'image et de réduire sa taille. Ce fichier prend en charge les modèles de nom de fichier, en cela il est similaire à un fichier .gitignore . Il est recommandé d'ajouter une commande à .dockerignore raison de laquelle Docker ignorera le dossier /.git , car ce dossier contient généralement de gros matériaux (en particulier pendant le développement d'un projet) et l'ajouter à l'image entraîne une augmentation de sa taille. De plus, copier ce dossier dans une image n'a pas beaucoup de sens.

▍2. Utilisez le processus d'assemblage d'images en plusieurs étapes

Prenons l'exemple lorsque nous collectons un projet pour une certaine organisation. Ce projet utilise de nombreux packages npm, et chacun de ces packages peut installer des packages supplémentaires dont il dépend. L'exécution de toutes ces opérations entraîne une augmentation du temps passé dans le processus d'assemblage de l'image (bien que cela, grâce aux capacités de mise en cache de Docker, ne soit pas si grave). Pire, l'image résultante contenant les dépendances d'un certain projet est assez grande. Ici, si nous parlons de projets frontaux, nous pouvons rappeler que ces projets sont généralement traités à l'aide de bundlers comme webpack, qui permettent de regrouper facilement tout ce dont une application a besoin dans un package de vente. Par conséquent, les fichiers de package npm pour un tel projet ne sont pas nécessaires. Et cela signifie que nous pouvons nous débarrasser de ces fichiers après avoir construit le projet en utilisant le même webpack.

Armé de cette idée, essayez de faire ceci:

 #   COPY package*.json ./ RUN npm install --production # - COPY . . RUN npm run build:production #    npm- RUN rm -rf node_modules 

Une telle approche, cependant, ne nous conviendra pas. Comme nous l'avons déjà dit, les instructions RUN , ADD et COPY créent des couches mises en cache par Docker, nous devons donc trouver un moyen de gérer l'installation des dépendances, de construire le projet, puis de supprimer les fichiers inutiles avec une seule commande. Par exemple, cela pourrait ressembler à ceci:

 #      COPY . . #  ,      RUN npm install --production && npm run build:production && rm -rf node_module 

Dans cet exemple, il n'y a qu'une seule instruction RUN qui installe les dépendances, node_modules projet et supprime le dossier node_modules . Cela conduit au fait que la taille de l'image ne sera pas aussi grande que la taille de l'image qui inclut le dossier node_modules . Nous utilisons les fichiers de ce dossier uniquement pendant le processus de génération du projet, puis nous le supprimons. Certes, cette approche est mauvaise en ce sens que l'installation des dépendances npm prend beaucoup de temps. Vous pouvez éliminer cet inconvénient en utilisant la technologie d'assemblage d'images en plusieurs étapes.

Imaginez que nous travaillons sur un projet frontal qui a de nombreuses dépendances, et que nous utilisons webpack pour construire ce projet. Avec cette approche, nous pouvons, dans le but de réduire la taille de l'image, profiter des capacités de Docker pour l' assemblage d'images en plusieurs étapes .

 FROM node:8 As build #  RUN mkdir /app && mkdir /src WORKDIR /src #   COPY package*.json ./ RUN npm install #     # RUN npm install --production #       COPY . . RUN npm run build:production #    ,     FROM node:alpine #      build   app COPY --from=build ./src/build/* /app/ ENTRYPOINT ["/app"] CMD ["--help"] 

Avec cette approche, l'image résultante est beaucoup plus petite que l'image précédente, et nous utilisons également le node:alpine image node:alpine , qui est elle-même très petite. Et voici une comparaison d'une paire d'images, au cours de laquelle on peut voir que l'image de node:alpine beaucoup plus petite que l'image de node:8 .


Comparaison des images du référentiel Node

▍3. Utiliser Docker Cache

Efforcez-vous d'utiliser les capacités de mise en cache de Docker pour créer vos images. Nous avons déjà prêté attention à cette fonctionnalité lorsque nous travaillions avec un fichier auquel on accédait par le package*.json noms package*.json . Cela réduit le temps de construction de l'image. Mais cette opportunité ne doit pas être utilisée à la légère.

Supposons que nous décrivions dans Dockerfile l'installation de packages dans une image créée à partir de l'image Ubuntu:16.04 base Ubuntu:16.04 :

 FROM ubuntu:16.04 RUN apt-get update && apt-get install -y \   curl \   package-1 \   .   . 

Lorsque le système traitera ce fichier, s'il y a beaucoup de packages installés, les opérations de mise à jour et d'installation prendront beaucoup de temps. Afin d'améliorer la situation, nous avons décidé de tirer parti des capacités de mise en cache des couches de Docker et de réécrire le Dockerfile comme suit:

 FROM ubuntu:16.04 RUN apt-get update RUN apt-get install -y \   curl \   package-1 \   .   . 

Maintenant, lors de l'assemblage de l'image pour la première fois, tout se passe comme prévu, car le cache n'a pas encore été formé. Imaginez maintenant que nous devons installer un autre package, package-2 . Pour ce faire, nous réécrivons le fichier:

 FROM ubuntu:16.04 RUN apt-get update RUN apt-get install -y \   curl \   package-1 \   package-2 \   .   . 

À la suite d'une telle commande, le package-2 ne sera ni installé ni mis à jour. Pourquoi? Le fait est que lors de l'exécution de l'instruction de RUN apt-get update , Docker ne voit aucune différence entre cette instruction et l'instruction exécutée précédemment, par conséquent, il prend les données du cache. Et ces données sont déjà dépassées. Lors du traitement de l'instruction RUN apt-get install système l'exécute, car elle ne ressemble pas à une instruction similaire dans le Dockerfile précédent, mais pendant l'installation, des erreurs peuvent se produire ou l'ancienne version des packages sera installée. En conséquence, il s'avère que les commandes de update et d' install doivent être exécutées dans la même instruction RUN , comme cela est fait dans le premier exemple. La mise en cache est une fonctionnalité intéressante, mais une utilisation imprudente de cette fonctionnalité peut entraîner des problèmes.

▍4. Minimisez le nombre de couches d'image

Il est recommandé, dans la mesure du possible, de s'efforcer de minimiser le nombre de couches d'image, car chaque couche est le système de fichiers de l'image Docker, ce qui signifie que plus les couches de l'image sont petites, plus elles seront compactes. Lors de l'utilisation du processus à plusieurs étapes d'assemblage d'image, une réduction du nombre de couches dans l'image et une réduction de la taille de l'image sont obtenues.

Résumé

Dans cet article, nous avons examiné le processus de conditionnement des applications Node.js dans des conteneurs Docker et l'utilisation de ces conteneurs. De plus, nous avons fait quelques recommandations qui, soit dit en passant, peuvent être utilisées non seulement lors de la création de conteneurs pour les projets Node.js.

Chers lecteurs! Si vous utilisez professionnellement Docker lorsque vous travaillez avec des projets Node.js, veuillez partager des recommandations sur l'utilisation efficace de ce système avec les débutants.