Comment utiliser Node.js avec Docker

Ce tutoriel démontre les avantages de l'utilisation de conteneurs Docker pour les applications Node.js et établit un flux de travail de développement efficace.

Node.js permet de créer des applications Web rapides et évolutives à l'aide de JavaScript sur les côtés du serveur et du client. Bien que votre application puisse fonctionner parfaitement sur votre machine de développement, ses performances cohérentes dans différents environnements (machines de collègues, serveurs de production) ne sont pas garanties. Considérez ces problèmes potentiels:

• Variations du système d'exploitation: Votre environnement de développement peut être MacOS, tandis que les collègues utilisent Windows, et le serveur de production exécute Linux.
• Node.js Version Incohérence: Vous pouvez utiliser Node.js 20, mais d'autres utilisent diverses versions.
• Différences de dépendance: Les bases de données et autres dépendances peuvent varier ou être indisponibles sur différentes plates-formes.
• Préoccupations de sécurité: Les risques de sécurité imprévus pourraient survenir lors du déploiement du code vers divers systèmes d'exploitation.

Avantages clés

• Compatibilité multiplateforme: docker résout le problème "il fonctionne sur ma machine" en activant les applications Node.js à exécuter dans des environnements de conteneurs isolés.
• Déplacement de l'application Node.js simplifié dans Docker: Nous vous guiderons en créant un script Node.js de base et en l'exécutant dans un conteneur Docker.
• Film de travail de développement Node.js amélioré: Nous montrerons comment Docker rationalise le processus de développement des applications Node.js.

Solution de Docker

Docker relève efficacement les défis de compatibilité susmentionnés. Au lieu d'installer directement des applications, vous les exécutez dans des environnements de type virtuel légèrement légers et isolés appelés conteneurs.

Contrairement aux machines virtuelles qui imitent le matériel et les systèmes d'exploitation PC entier, Docker émule un système d'exploitation, vous permettant d'installer des applications directement. Il est courant d'exécuter une application par conteneur basé sur Linux et de les connecter via un réseau virtuel pour la communication HTTP.

Les avantages sont nombreux:

• Environnement cohérent: Votre configuration Docker reflète votre serveur Linux de production, simplifiant le déploiement.
• Gestion simplifiée de la dépendance: Télécharger, installer et configurer les dépendances en quelques minutes.
• cohérence multiplateforme: Votre application conteneurisée se comporte de manière identique sur toutes les plateformes.
• Sécurité améliorée: Si votre application fonctionne mal dans un conteneur, cela n'affectera pas votre machine hôte; Vous pouvez facilement redémarrer le conteneur.

avec docker, installer node.js localement ou utiliser des gestionnaires d'exécution comme NVM devient inutile.

Votre premier script Node.js

Installez Docker Desktop (Windows, MacOS ou Linux). Créez un script simple nommé version.js:

<code class="language-javascript">console.log(`Node.js version: ${process.version}`);</code>

Si Node.js est installé localement, exécutez-le pour voir la version. Maintenant, exécutez-le dans un conteneur Docker (en utilisant la dernière version LTS Node.js):

(macOS / Linux)

<code class="language-bash">$ docker run --rm --name version -v $PWD:/home/node/app -w /home/node/app node:lts-alpine version.js</code>

(Windows PowerShell)

<code class="language-powershell">> docker run --rm --name version -v ${PWD}:/home/node/app -w /home/node/app node:lts-alpine version.js</code>

La première exécution pourrait prendre quelques instants car Docker télécharge les dépendances. Les courses suivantes sont beaucoup plus rapides. Vous pouvez facilement changer les versions Node.js (par exemple, node:21-alpine). Le script s'exécute dans un conteneur Linux avec une version spécifique Node.js.

Réflexion de commande:

• docker run: démarre un conteneur à partir d'une image.
• --rm: supprime le conteneur lors de la terminaison.
• --name version: attribue un nom au conteneur.
• -v $PWD:/home/node/app: monte le répertoire actuel en tant que volume à l'intérieur du conteneur.
• -w /home/node/app: Définit le répertoire de travail dans le conteneur.
• node:lts-alpine: Spécifie l'image docker (LTS Node.js sur Alpine Linux).
• version.js: la commande à exécuter.

Les images Docker sont disponibles sur Docker Hub, offrant diverses versions marquées avec des identifiants comme :lts-alpine, 20-bullseye-slim, ou latest. Alpine Linux est une distribution légère idéale pour les projets simples.

exécutant des applications plus complexes

Pour les applications avec des dépendances et des étapes de construction (en utilisant NPM), une image Docker personnalisée est nécessaire. Cet exemple utilise Express.js:

Créer un répertoire nommé simple, Ajouter package.json:

<code class="language-json">{
  "name": "simple",
  "version": "1.0.0",
  "description": "simple Node.js and Docker example",
  "type": "module",
  "main": "index.js",
  "scripts": {
    "debug": "node --watch --inspect=0.0.0.0:9229 index.js",
    "start": "node index.js"
  },
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2"
  }
}</code>

et index.js:

<code class="language-javascript">// Express application
import express from 'express';

// configuration
const cfg = {
  port: process.env.PORT || 3000
};

// initialize Express
const app = express();

// home page route
app.get('/:name?', (req, res) => {
  res.send(`Hello ${req.params.name || 'World'}!`);
});

// start server
app.listen(cfg.port, () => {
  console.log(`server listening at http://localhost:${cfg.port}`);
});</code>

Créer un Dockerfile:

<code class="language-dockerfile"># base Node.js LTS image
FROM node:lts-alpine

# define environment variables
ENV HOME=/home/node/app
ENV NODE_ENV=production
ENV NODE_PORT=3000

# create application folder and assign rights to the node user
RUN mkdir -p $HOME && chown -R node:node $HOME

# set the working directory
WORKDIR $HOME

# set the active user
USER node

# copy package.json from the host
COPY --chown=node:node package.json $HOME/

# install application modules
RUN npm install && npm cache clean --force

# copy remaining files
COPY --chown=node:node . .

# expose port on the host
EXPOSE $NODE_PORT

# application launch command
CMD [ "node", "./index.js" ]</code>

construire l'image: docker image build -t simple .

Exécutez le conteneur: docker run -it --rm --name simple -p 3000:3000 simple

Accédez à l'application à http://localhost:3000/.

a .dockerignore Le fichier peut empêcher les fichiers inutiles d'être copiés dans l'image.

Amélioration du flux de travail de développement avec Docker Compose

La méthode précédente est inefficace pour le développement. Docker Compose fournit une meilleure solution. Créer docker-compose.yml:

<code class="language-yaml">version: '3'

services:

  simple:
    environment:
      - NODE_ENV=development
    build:
      context: ./
      dockerfile: Dockerfile
    container_name: simple
    volumes:
      - ./:/home/node/app
    ports:
      - "3000:3000"
      - "9229:9229"
    command: /bin/sh -c 'npm install && npm run debug'</code>

Commencez par docker compose up. Modifications à index.js Déclencher les redémarrages automatiques. Utilisez le débogueur de VS Code (attachez au port 9229) pour un débogage amélioré. Arrêtez-vous avec docker compose down.

Conclusion

Bien que Docker nécessite une configuration initiale, les avantages à long terme du code distribuable fiable sont significatifs. Ce tutoriel couvre les fondamentaux; Explorez d'autres ressources pour une utilisation avancée. Les images sont conservées pour la brièveté.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!