Comment utiliser Node.js avec Docker

Node.js permet de développer des applications rapides et capables de monter en charge. Pourtant, le fameux « ça fonctionne sur ma machine » peut vite devenir un casse-tête dès que l’application quitte votre ordinateur. Les différences de système d’exploitation, de version de Node.js ou de dépendances installées peuvent empêcher une application de fonctionner correctement, même si elle fonctionnait parfaitement pendant le développement.

Docker résout ce problème en regroupant votre application et tout ce dont elle a besoin pour fonctionner dans un seul conteneur léger. Vous gagnez ainsi en portabilité et en cohérence : le même conteneur fonctionne de manière identique sur votre ordinateur, sur celui d’un collègue et sur votre VPS de production. Il consomme également moins de ressources qu’une machine virtuelle et simplifie le déploiement, puisqu’une seule image suffit.

Prérequis pour utiliser Node.js avec Docker

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Serveur privé virtuel (VPS). Vous pouvez suivre ce guide sur votre ordinateur, mais vous aurez besoin d’un VPS pour héberger votre application en production. Le pack KVM 2 de Hostinger constitue un excellent point de départ pour les projets de petite et moyenne envergure. Il comprend 2 cœurs vCPU, 8 Go de RAM et 100 Go de stockage NVMe pour 7,79 €/mois.
• Docker installé. Vérifiez qu’il fonctionne avec la commande docker –version. Si vous êtes client Hostinger, vous pouvez installer Docker sur votre VPS en quelques clics grâce à notre template préconfiguré.
• Node.js et npm installés. Vérifiez leur installation avec les commandes node –version et npm –version. Si ce n’est pas encore fait, consultez notre guide pour installer Node.js sur Ubuntu.
• Connaissances de base des commandes Docker. Il est utile de connaître des commandes comme docker build et docker run, car vous les exécuterez régulièrement dans le terminal.

Comment configurer une application Node.js dans Docker

Suivez les étapes ci-dessous pour créer un conteneur Docker dans lequel exécuter une application Node.js simple. Vous commencerez par choisir une image de base, puis lancerez votre première application conteneurisée.

1. Choisissez l’image Docker adaptée à Node.js

Commencez par choisir une image de base pour votre conteneur. L’image Docker officielle de Node.js se décline en plusieurs variantes préconfigurées, adaptées à différents besoins.

Voici les principales :

• Images complètes. Plus volumineuses, elles contiennent de nombreux outils et bibliothèques, ce qui les rend utiles pour le développement et le débogage. Exemple : node:24.
• Images Slim. Plus légères que les images complètes, elles contiennent uniquement les composants essentiels au fonctionnement de Node.js. Exemple : node:24-slim.
• Images Alpine. Extrêmement légères, elles reposent sur Alpine Linux. Leur petite taille réduit la surface d’attaque, ce qui en fait le meilleur choix pour une image Docker Node.js en production. Exemple : node:24-alpine.

Pour la production, nous recommandons les images Alpine afin de conserver des conteneurs légers, rapides et sécurisés.

2. Créez une application Node.js simple

Créez ensuite une application Node.js simple. Ouvrez votre terminal et connectez-vous à votre VPS via SSH :

ssh root@your_vps_ip

Si vous utilisez un VPS Hostinger, vous trouverez l’adresse IP de votre serveur dans Tableau de bord Hostinger → VPS → Gérer → Aperçu → Détails du VPS.

Une fois connecté, créez un répertoire pour votre projet, puis accédez-y :

mkdir node-docker-app && cd node-docker-app

Initialisez le projet avec npm. Cette commande génère un fichier package.json qui permet de gérer les métadonnées et les dépendances de votre application :

npm init -y

Créez maintenant un fichier nommé app.js à l’aide d’un éditeur de texte comme nano :

nano app.js

Collez le code suivant dans le fichier. Ce script crée un serveur HTTP simple qui renvoie le message « Hello, Docker! » :

const http = require("http");

const port = 3000;

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello, Docker!");
});

server.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

Enregistrez le fichier et quittez nano en appuyant sur Ctrl + X → Y → Entrée.

3. Créez un Dockerfile simple

Un Dockerfile est un fichier texte qui contient les instructions nécessaires à la création d’une image Docker, étape par étape. Créez un fichier nommé Dockerfile, sans extension, à la racine de votre projet :

nano Dockerfile

Ajoutez le contenu suivant. Il s’agit d’un exemple de Dockerfile simple pour Node.js :

# Utiliser une image Node.js basée sur Alpine
FROM node:24-alpine

# Définir le répertoire de travail dans le conteneur
WORKDIR /app

# Copier les fichiers package.json et package-lock.json
COPY package*.json ./

# Installer les dépendances de l'application
RUN npm install

# Copier le reste du code source de l'application
COPY . .

# Exposer le port 3000 vers l'extérieur
EXPOSE 3000

# Commande pour exécuter l'application
CMD ["node", "app.js"]

Une fois terminé, enregistrez et fermez le fichier.

4. Créez l’image Docker

Après avoir créé le Dockerfile, exécutez la commande suivante depuis le répertoire du projet pour créer votre image Docker :

docker build -t node-docker-app .

L’option -t attribue le nom node-docker-app à l’image. Si la création de l’image réussit, Docker affiche un message de confirmation.

5. Lancez le conteneur

Une fois l’image créée, exécutez votre application Node.js dans un conteneur Docker avec la commande suivante :

docker run -d -p 3000:3000 node-docker-app

L’option -p 3000:3000 associe le port 3000 de votre serveur au port 3000 du conteneur, tandis que l’option -d permet d’exécuter le conteneur en mode détaché, c’est-à-dire en arrière-plan.

Ouvrez votre navigateur et accédez à http://your_vps_ip:3000 pour vérifier que l’application fonctionne. Le message « Hello, Docker! » devrait s’afficher.

Après avoir créé et exécuté cette première application, voyons comment conteneuriser une application Node.js plus complexe.

Comment conteneuriser une application Node.js existante

Pour conteneuriser un projet Node.js existant, vous devez préparer votre application, créer un fichier .dockerignore pour limiter la taille de l’image, puis rédiger un Dockerfile optimisé.

1. Préparez l’application pour Docker

Avant de commencer, vérifiez que votre projet est prêt à être conteneurisé.

• Vérifiez le fichier package.json. Assurez-vous qu’il répertorie correctement toutes les dépendances et contient un script start permettant de lancer l’application.
• Verrouillez les versions des dépendances. Exécutez npm install pour créer ou mettre à jour le fichier package-lock.json. Ce fichier garantit l’utilisation des mêmes versions de dépendances dans les différents environnements.
• Testez l’application en local. Exécutez npm start sur votre ordinateur pour vérifier que tout fonctionne comme prévu avant de poursuivre.

2. Créez un fichier .dockerignore

Le fichier .dockerignore empêche la copie de certains fichiers et répertoires dans votre image Docker. Vous évitez ainsi d’y inclure des éléments inutiles, ce qui contribue à réduire sa taille et à renforcer sa sécurité.

À l’aide de nano, créez un fichier nommé .dockerignore à la racine de votre projet, puis ajoutez le contenu suivant :

node_modules
npm-debug.log
.env
.DS_Store
logs/
tmp/
dist/
coverage/

Ce fichier exclut les éléments suivants :

• node_modules. Les dépendances sont installées dans le conteneur. Il est donc inutile d’y copier le répertoire local.
• npm-debug.log, logs/, tmp/. Ces journaux et fichiers temporaires ne sont pas nécessaires en production.
• .env. Ce fichier contient des clés sensibles et ne doit jamais être intégré à une image.
• dist/, coverage/. Les fichiers générés lors de la compilation et les rapports de test ne sont pas nécessaires à l’exécution de l’application.

3. Créez un Dockerfile adapté à la production

Un Dockerfile adapté à la production optimise la sécurité et les performances de votre application. Il repose sur une image de base minimale, installe uniquement les dépendances de production et définit les variables d’environnement appropriées.

Voici un exemple :

# Utiliser une image de base Node.js légère
FROM node:24-alpine

# Définir le répertoire de travail
WORKDIR /usr/src/app

# Copier les fichiers de gestion des dépendances et installer uniquement les dépendances de production
COPY package*.json ./
RUN npm ci --omit=dev

# Copier les fichiers de l'application
COPY . .

# Définir les variables d'environnement pour la production
ENV NODE_ENV=production

# Exposer le port de l'application
EXPOSE 3000

# Commande pour démarrer l'application
CMD ["node", "app.js"]

Chaque instruction du Dockerfile remplit une fonction précise :

4. Optimisez l’image avec une construction multi-étapes

Pour les applications qui nécessitent une étape de compilation, par exemple pour transpiler du TypeScript ou regrouper des fichiers avec Webpack, un Dockerfile multi-étapes constitue la meilleure solution.

Cette technique sépare l’environnement de compilation de l’environnement d’exécution final, ce qui permet d’obtenir une image de production beaucoup plus légère.

Une construction multi-étapes utilise plusieurs instructions FROM. La première étape permet de compiler l’application et ses ressources, tandis que la seconde ne copie que les fichiers compilés nécessaires dans une nouvelle image.

Voici un exemple de Dockerfile multi-étapes :

# Étape 1 : Compiler l'application
FROM node:24-alpine AS builder

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

RUN npm run build

# Étape 2 : Créer l'image de production
FROM node:24-alpine

WORKDIR /usr/src/app

# Copier les fichiers compilés et les dépendances de production
COPY --from=builder /usr/src/app/dist ./dist

COPY package*.json ./

RUN npm ci --omit=dev

# Définir les variables d'environnement
ENV NODE_ENV=production

# Exposer le port de l'application
EXPOSE 3000

# Démarrer l'application
CMD ["node", "dist/app.js"]

Cette méthode permet d’obtenir une image finale qui ne contient que les éléments nécessaires à l’exécution de l’application, ce qui la rend plus légère, plus rapide et plus sécurisée.

Une fois votre Dockerfile optimisé prêt, utilisez les mêmes commandes docker build et docker run que précédemment pour créer l’image et lancer le conteneur. Vous pouvez maintenant tester votre conteneur.

Comment tester votre conteneur Docker exécutant Node.js

Une fois votre application Node.js en cours d’exécution dans un conteneur, vous devez la tester pour vérifier qu’elle fonctionne comme prévu dans un environnement proche de celui de production.

Commencez par envoyer une requête à l’aide de curl ou d’un navigateur web. Dans votre terminal, exécutez :

curl http://your_vps_ip:3000

Cette commande devrait renvoyer le message « Hello, Docker! ».

Consultez ensuite les journaux du conteneur pour surveiller son fonctionnement et diagnostiquer d’éventuels problèmes :

docker logs container_id_or_name

Si vous ne connaissez pas l’identifiant du conteneur, affichez la liste des conteneurs en cours d’exécution avec la commande suivante :

docker ps

Pour effectuer un débogage interactif, ouvrez un shell dans le conteneur en cours d’exécution avec docker exec :

docker exec -it container_id_or_name sh

Cette commande vous permet d’explorer directement le système de fichiers du conteneur et de résoudre les problèmes rencontrés.

Si vous rencontrez des problèmes d’autorisation lors de l’exécution des commandes Docker, consultez notre guide pour corriger l’erreur « Docker permission denied ».

Enfin, ajoutez un contrôle d’état reposant sur un point de terminaison léger, par exemple /health, qui indique l’état de votre application. Configurez Docker pour qu’il interroge régulièrement ce point de terminaison afin de vérifier que le conteneur fonctionne correctement et de détecter toute défaillance.

Une fois votre conteneur entièrement testé, vous pouvez appliquer les bonnes pratiques pour qu’il reste efficace et prêt pour la production.

Quelles sont les bonnes pratiques pour utiliser Node.js avec Docker ?

En suivant ces bonnes pratiques, vous pouvez créer des images Docker sécurisées, efficaces et faciles à maintenir pour vos applications Node.js. Voici les principales recommandations :

• Utilisez des images de base légères. Privilégiez les images Alpine ou Slim plutôt que les images complètes en production. Les images plus petites se construisent plus rapidement et présentent une surface d’attaque réduite.
• Installez uniquement les dépendances de production. Utilisez npm ci –omit=dev dans votre Dockerfile pour éviter d’installer les dépendances de développement, comme les bibliothèques de test. Ces dernières ne sont pas nécessaires dans l’image finale, et leur exclusion permet d’en réduire la taille.
• Définissez NODE_ENV=production. Cette variable d’environnement indique aux bibliothèques comme Express d’activer certaines optimisations, notamment la mise en cache des templates de vue et la réduction des traitements liés au débogage.
• Limitez la taille des images. Utilisez des constructions multi-étapes pour séparer les outils de compilation de l’environnement d’exécution. Ajoutez également un fichier .dockerignore pour exclure du contexte de construction les journaux, les modules locaux et les autres fichiers inutiles.
• Mettez régulièrement à jour les images de base. Récupérez périodiquement la dernière version de votre image de base, puis recréez l’image de votre application pour bénéficier des correctifs de sécurité et des améliorations de performances.
• Exécutez l’application avec un utilisateur non-root. Pour renforcer la sécurité, évitez d’exécuter votre application en tant qu’utilisateur root dans le conteneur. Créez plutôt un utilisateur dédié dans votre Dockerfile et passez à ce compte avant de démarrer l’application.
• Faites évoluer votre application pour gérer davantage de charge. Utilisez des outils d’orchestration comme Docker Swarm pour répartir les conteneurs sur plusieurs serveurs et assurer une haute disponibilité, ou Docker Stack pour déployer des applications composées de plusieurs conteneurs en production.

Points clés à retenir sur l’utilisation de Node.js avec Docker

En associant Node.js à Docker, vous bénéficiez d’une méthode efficace pour développer et déployer des applications dont le fonctionnement est cohérent d’un environnement à l’autre, qui sont portables et qui consomment peu de ressources.

Vous avez configuré un projet, créé un Dockerfile optimisé avec une construction multi-étapes et appliqué les bonnes pratiques pour obtenir un conteneur prêt pour la production.

Pour aller plus loin, vous pouvez intégrer Docker Compose afin de gérer des applications composées de plusieurs conteneurs ou mettre en place un pipeline d’intégration et de déploiement continus (CI/CD) pour automatiser vos processus de construction.

Vous pouvez également utiliser des variables d’environnement et des fichiers de secrets pour gérer les données sensibles, ajouter un proxy inverse comme NGINX pour activer HTTPS, ou publier votre image sur Docker Hub afin de la partager et de la déployer où vous le souhaitez.

Cet article est une version localisée de How to use Node.js with Docker, initialement publié en anglais.

Tout le contenu des tutoriels de ce site est soumis aux normes éditoriales et aux valeurs rigoureuses de Hostinger.

L'auteur

Faradilla Ayunindya

Add Hostinger as a preferred source on Google

Faradilla, plus connue sous le nom de Ninda, possède 10 ans d’expérience en tant que linguiste et 5 ans en tant que spécialiste du marketing de contenu chez Hostinger. Elle aime suivre les tendances technologiques et aider les autres à résoudre leurs problèmes. Pendant son temps libre, Ninda aime apprendre de nouvelles langues et s’intéresser aux sciences de la vie, ainsi que regarder des vidéos d’animaux. Pour en savoir plus sur Ninda, retrouvez-la sur LinkedIn.

Plus d'informations sur Faradilla Ayunindya