Le processus de déploiement et d’exécution d’applications dans différents environnements peut s’avérer fastidieux car il y a un certain nombre de facteurs à prendre en compte, tels que la configuration des variables d’environnement, des dépendances nécessaires et des versions spécifiques de différents logiciels.


Cependant, en utilisant la technologie de conteneurisation de Docker, vous pouvez déployer des applications dans différents environnements avec un minimum d’effort, avec toutes les dépendances nécessaires dans l’image Docker. En d’autres termes, vous n’avez pas à vous soucier de la configuration. Le processus de déploiement et d’exécution des applications dans différents environnements devient ainsi un jeu d’enfant.

Qu’est-ce que Docker ?

Docker est une plateforme de développement qui fournit les outils et l’environnement nécessaires pour conditionner des applications sous forme d’images portables qui peuvent être exécutées en tant que composants exécutables autonomes dans des conteneurs.

Ces conteneurs constituent le code de l’application et les dépendances requises pour que l’application s’exécute avec succès sur différents environnements d’exécution sans aucun problème.

cargos alignés près d'un quai

Avant de commencer, installez Docker sur votre machine locale. Vérifiez les prérequis et les instructions d’installation spécifiques à la plateforme dans la documentation officielle.

Créer une API REST Node.js

Pour commencer, créez un serveur web Node.js.

Vous pouvez trouver le code de cette application dans son dépôt GitHub.

Ensuite, installez les paquets requis pour ce projet.

 npm install morgan pg knex

Le pg est utilisé pour établir une connexion avec une base de données PostgreSQL. knexfournit quant à lui une API simple pour interagir avec PostgreSQL – vous l’utiliserez pour écrire des requêtes SQL.

Enfin, vous utiliserez morganL’application Docker est un intergiciel qui enregistre les requêtes et les réponses HTTP sur la console, afin de déboguer et de surveiller votre application fonctionnant dans un conteneur Docker.

Enfin, ouvrez le fichier index.js et ajoutez le code ci-dessous qui implémente une API REST simple avec trois routes.

 const express = require("express")
const morgan = require("morgan")
const app = express()
const db = require('./db')
const PORT = process.env.PORT || 5000

app.use(morgan('dev'))
app.use(express.json())
app.use(express.urlencoded({ extended: true }))

app.get("https://www.makeuseof.com/", (req, res) => res.send('Hello World!' ))

app.get('/users', async (req, res) => {
  const users = await db.select().from('users')
  res.json(users)
})

app.post('/users', async (req, res) => {
  const user = await db('users').insert({ name: req.body.name }).returning('*')
  res.json(user)
})

app.listen(PORT, () => console.log(`Server up at PORT:${PORT}`))

Configurer la connexion à la base de données

L’API REST interagira avec l’instance PostgreSQL de Docker, mais vous devez d’abord configurer la connexion à la base de données dans votre application. Dans le répertoire racine de votre dossier de projet, créez un fichier db.js et ajoutez le code ci-dessous.

 const knex = require('knex')
module.exports = knex({
  client: 'postgres',
  connection: {
    host: 'db',
    user: 'testUser',
    password: 'mypassword123',
    database: 'testUser',
    
  },
})

Configuration des fichiers migrate.js et seed.js

Ces deux fichiers permettront de créer une table dans la base de données et de l’alimenter avec des données de test via l’API. Créez un nouveau dossier, scriptsdans le répertoire racine de votre projet et ajoutez deux fichiers : migrate.js et seed.js.

Dans le migrate.js ajoutez le code ci-dessous :

 const db = require('../db');
(async () => {
  try {
    await db.schema.dropTableIfExists('users')
    await db.schema.withSchema('public').createTable('users', (table) => {
      table.increments()
      table.string('name')
    })
    console.log('Created users table!')
    process.exit(0)
  } catch (err) {
    console.log(err)
    process.exit(1)
  }
})()

Ce code créera un fichier utilisateurs avec une colonne id auto-incrémentée et une colonne nom dans la base de données.

Ensuite, dans la colonne seed.js ajoutez le code ci-dessous :

 const db = require('../db');
(async () => {
  try {
    await db('users').insert({ name: 'Test User1' })
    await db('users').insert({ name: 'Test User2' })
    console.log('Added dummy users!')
    process.exit(0)
  } catch (err) {
    console.log(err)
    process.exit(1)
  }
})()

Ce code implémente une fonction asynchrone qui insère deux utilisateurs dans la base de données PostgreSQL.

Enfin, ajoutez ces commandes à votre package.json fichier.

   "scripts": {
    "start": "node index.js",
    "migrate": "node scripts/migrate.js",
    "seed": "node scripts/seed.js"

  },

Comme vous n’avez pas de client configuré, pour tester l’API, vous devrez exécuter les deux fichiers en tant que scripts à côté de l’application npm run commande.

Configurer un fichier Docker

Un Dockerfile définit les instructions requises par le moteur Docker pour construire une image Docker. Dans le répertoire racine de votre projet, créez un nouveau fichier et nommez-le, Dockerfile. Ensuite, ajoutez les instructions suivantes pour construire une image Docker pour l’application Node.js.

 FROM node:16.3.0-alpine3.13
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 8000
CMD [ "node", "index.js" ]

Décomposons :

  • DE – Cette instruction définit l’image de base de l’application, qui est l’image Node.js Alpine, une version allégée de l’image Node.js qui peut être trouvée dans le registre Docker.
  • WORKDIR – jeux /app comme répertoire de travail.
  • COPY package*.json./ – demande à Docker de copier tous les fichiers ayant ce format de fichier depuis le répertoire actuel vers le répertoire /app dossier.
  • RUN – exécute et construit l’image.
  • COPIE . . – copie les fichiers sources dans le répertoire /app dossier.
  • EXPOSER – indique à Docker d’exposer un port du conteneur à l’environnement externe, en l’occurrence la machine hôte.
  • CMD – spécifie la commande à exécuter lorsque le conteneur Docker est créé à partir de l’image.

Créer le fichier Docker Compose

Pour que l’application Node.js interagisse avec l’instance PostgreSQL de Docker, les deux applications doivent s’exécuter dans des conteneurs Docker au sein du même environnement réseau.

Pour cette raison, vous devez définir et construire l’image de l’application et l’instance PostgreSQL en utilisant Docker Compose – un outil qui vous permet de construire et de gérer plusieurs conteneurs Docker.

En termes simples, en utilisant un Docker Compose, vous pouvez définir les services qui composent votre application comme une seule unité, dans ce cas, l’API REST Node.js et la base de données PostgreSQL.

Créer un nouveau fichier, docker-compose.ymldans le répertoire racine et ajoutez le code ci-dessous :

 version: '3.9'

services:
  server:
    build: .
    ports:
      - '5000:5000'
    depends_on:
      - db
  db:
    image: 'postgres'
    ports:
      - '4321:5432'
    environment:
      POSTGRES_PASSWORD: 'mypassword123'
      POSTGRES_USER: 'testUser'
    volumes:
      - data:/var/lib/postgresql/data

volumes:
  data:

Ce code créera et exécutera deux conteneurs Docker. Le premier conteneur, serveurDocker Compose utilise le fichier Dockerfile pour construire l’image de ce conteneur.

Il précise également que le conteneur de serveur dépend de l’élément db conteneur. En d’autres termes, le conteneur serveur Le conteneur doit être démarré après le db pour s’y connecter.

Le second conteneur est un conteneur de base de données PostgreSQL. Vous n’avez pas besoin de spécifier un Dockerfile pour ce conteneur puisqu’il sera créé à partir de l’image PostgreSQL sur le registre d’images de Docker.

Construire les images Docker

Utilisez la commande Docker Compose pour construire les images et démarrer les deux conteneurs.

 docker-compose up -d

Vous devriez voir une réponse similaire une fois le processus terminé avec succès.

deux conteneurs docker créés et démarrés sur docker engine

Tester l’API REST

Exécutez la commande ci-dessous pour tester l’API REST fonctionnant dans le conteneur Docker. Elle devrait créer une table dans la base de données PostgreSQL.

 docker exec docker_node-server-1 npm run migrate

Vous devriez voir une réponse similaire.

Réponse du serveur sur la console après l'exécution du script de migration et la création d'une table

Partage des images Docker

La dernière étape consiste à pousser l’image Docker de votre application Node.js vers Docker Hub. Cette étape est similaire à celle qui consiste à pousser vos projets sur GitHub.

  • Rendez-vous sur Docker Hub, ouvrez un compte et connectez-vous au tableau de bord de l’utilisateur.
  • Ensuite, cliquez sur Créer un référentiel. Indiquez le nom de votre référentiel et définissez sa visibilité à Public ou Privé puis cliquez sur Créer.
  • Pour pousser l’image Docker de votre application vers Docker Hub, vous devez d’abord vous connecter à votre compte via le terminal, puis fournir votre nom d’utilisateur et votre mot de passe. 

 docker login
  • Ensuite, mettez à jour le nom de votre image Docker pour qu’il corresponde à ce format : <your docker username>/<repo name&gt ;. Exécutez la commande ci-dessous pour effectuer ce changement : 

  docker tag <image> <your docker username>/<repo name>
  • Enfin, poussez votre image Docker. 

  docker push <image>/< repo name>

Utiliser Docker dans le développement

Ce guide n’a abordé qu’une fraction du potentiel offert par Docker. Cependant, vous pouvez désormais utiliser la technologie de conteneurisation de Docker pour emballer n’importe quelle application et toutes ses dépendances sous forme d’images qui peuvent être déployées dans différents environnements de développement et de production, comme le cloud, sans aucun problème.