J'ai une application avec les services suivants:

• web/ - contient et exécute un serveur Web flask python 3 sur le port 5000. Utilise sqlite3.
• worker/- a un index.jsfichier qui est un ouvrier pour une file d'attente. le serveur Web interagit avec cette file d'attente à l'aide d'une API json sur le port 9730. Le travailleur utilise redis pour le stockage. Le travailleur stocke également les données localement dans le dossierworker/images/

Or cette question ne concerne que le worker.

worker/Dockerfile

FROM node:0.12

WORKDIR /worker

COPY package.json /worker/
RUN npm install

COPY . /worker/

docker-compose.yml

redis:
    image: redis
worker:
    build: ./worker
    command: npm start
    ports:
        - "9730:9730"
    volumes:
        - worker/:/worker/
    links:
        - redis

Quand je cours docker-compose build, tout fonctionne comme prévu et tous les modules npm sont installés /worker/node_modulescomme je m'y attendais.

npm WARN package.json unfold@1.0.0 No README data

> phantomjs@1.9.2-6 install /worker/node_modules/pageres/node_modules/screenshot-stream/node_modules/phantom-bridge/node_modules/phantomjs
> node install.js

<snip>

Mais quand je le fais docker-compose up, je vois cette erreur:

worker_1 | Error: Cannot find module 'async'
worker_1 |     at Function.Module._resolveFilename (module.js:336:15)
worker_1 |     at Function.Module._load (module.js:278:25)
worker_1 |     at Module.require (module.js:365:17)
worker_1 |     at require (module.js:384:17)
worker_1 |     at Object.<anonymous> (/worker/index.js:1:75)
worker_1 |     at Module._compile (module.js:460:26)
worker_1 |     at Object.Module._extensions..js (module.js:478:10)
worker_1 |     at Module.load (module.js:355:32)
worker_1 |     at Function.Module._load (module.js:310:12)
worker_1 |     at Function.Module.runMain (module.js:501:10)

Il s'avère qu'aucun des modules n'est présent dans /worker/node_modules(sur l'hôte ou dans le conteneur).

Si sur l'hôte, je npm install, alors tout fonctionne très bien. Mais je ne veux pas faire ça. Je veux que le conteneur gère les dépendances.

Qu'est-ce qui ne va pas ici?

(Inutile de dire que tous les packages sont inclus package.json.)

Cela se produit parce que vous avez ajouté votre workerrépertoire en tant que volume à votre docker-compose.yml, car le volume n'est pas monté pendant la construction.

Lorsque docker crée l'image, le node_modulesrépertoire est créé dans le workerrépertoire et toutes les dépendances y sont installées. Ensuite, lors de l'exécution, le workerrépertoire de l'extérieur du docker est monté dans l'instance de docker (qui n'a pas installé node_modules), masquant le fichier que node_modulesvous venez d'installer. Vous pouvez le vérifier en supprimant le volume monté de votre docker-compose.yml.

Une solution de contournement consiste à utiliser un volume de données pour stocker tous les node_modules, car les volumes de données sont copiés dans les données de l'image Docker générée avant le workermontage du répertoire. Cela peut être fait de la manière docker-compose.ymlsuivante:

redis:
    image: redis
worker:
    build: ./worker
    command: npm start
    ports:
        - "9730:9730"
    volumes:
        - ./worker/:/worker/
        - /worker/node_modules
    links:
        - redis

Je ne suis pas tout à fait certain que cela pose des problèmes pour la portabilité de l'image, mais comme il semble que vous utilisez principalement docker pour fournir un environnement d'exécution, cela ne devrait pas être un problème.

Si vous souhaitez en savoir plus sur les volumes, il y a un joli guide de l'utilisateur disponible ici: https://docs.docker.com/userguide/dockervolumes/

EDIT: Docker a depuis changé sa syntaxe pour exiger un ./début pour le montage dans les fichiers par rapport au fichier docker-compose.yml.

Le node_modulesdossier est écrasé par le volume et n'est plus accessible dans le conteneur. J'utilise la stratégie de chargement du module natif pour retirer le dossier du volume:

/data/node_modules/ # dependencies installed here
/data/app/ # code base

Dockerfile:

COPY package.json /data/
WORKDIR /data/
RUN npm install
ENV PATH /data/node_modules/.bin:$PATH

COPY . /data/app/
WORKDIR /data/app/

Le node_modulesrépertoire n'est pas accessible depuis l'extérieur du conteneur car il est inclus dans l'image.

La solution fournie par @FrederikNS fonctionne, mais je préfère nommer explicitement mon volume node_modules.

Mon project/docker-compose.ymlfichier (docker-compose version 1.6+):

version: '2'
services:
  frontend:
    ....
    build: ./worker
    volumes:
      - ./worker:/worker
      - node_modules:/worker/node_modules
    ....
volumes:
  node_modules:

ma structure de fichiers est:

project/
   │── worker/
   │     └─ Dockerfile
   └── docker-compose.yml

Il crée un volume nommé project_node_moduleset le réutilise à chaque fois que j'utilise mon application.

Mon docker volume lsressemble à ceci:

DRIVER              VOLUME NAME
local               project1_mysql
local               project1_node_modules
local               project2_postgresql
local               project2_node_modules

J'ai récemment eu un problème similaire. Vous pouvez installer node_modulesailleurs et définir la NODE_PATHvariable d'environnement.

Dans l'exemple ci-dessous, j'ai installé node_modulesdans/install

worker / Dockerfile

FROM node:0.12

RUN ["mkdir", "/install"]

ADD ["./package.json", "/install"]
WORKDIR /install
RUN npm install --verbose
ENV NODE_PATH=/install/node_modules

WORKDIR /worker

COPY . /worker/

docker-compose.yml

redis:
    image: redis
worker:
    build: ./worker
    command: npm start
    ports:
        - "9730:9730"
    volumes:
        - worker/:/worker/
    links:
        - redis

Il existe une solution élégante:

Ne montez pas tout le répertoire, mais uniquement le répertoire de l'application. De cette façon, vous n'aurez aucun problème avec npm_modules.

Exemple:

  frontend:
    build:
      context: ./ui_frontend
      dockerfile: Dockerfile.dev
    ports:
    - 3000:3000
    volumes:
    - ./ui_frontend/src:/frontend/src

Dockerfile.dev:

FROM node:7.2.0

#Show colors in docker terminal
ENV COMPOSE_HTTP_TIMEOUT=50000
ENV TERM="xterm-256color"

COPY . /frontend
WORKDIR /frontend
RUN npm install update
RUN npm install --global typescript
RUN npm install --global webpack
RUN npm install --global webpack-dev-server
RUN npm install --global karma protractor
RUN npm install
CMD npm run server:dev

MISE À JOUR: utilisez la solution fournie par @FrederikNS.

J'ai rencontré le même problème. Lorsque le dossier /workerest monté sur le conteneur - tout son contenu sera synchronisé (ainsi le dossier node_modules disparaîtra si vous ne l'avez pas localement.)

En raison de packages npm incompatibles basés sur le système d'exploitation, je ne pouvais pas simplement installer les modules localement - puis lancer le conteneur, donc ..

Ma solution à cela consistait à envelopper la source dans un srcdossier, puis node_modulesà créer un lien dans ce dossier, en utilisant ce fichier index.js . Donc, le index.jsfichier est maintenant le point de départ de mon application.

Lorsque j'exécute le conteneur, j'ai monté le /app/srcdossier dans mon srcdossier local .

Le dossier du conteneur ressemble donc à ceci:

/app
  /node_modules
  /src
    /node_modules -> ../node_modules
    /app.js
  /index.js

C'est moche , mais ça marche.

En raison de la façon dont Node.js charge les modules , il node_modulespeut se trouver n'importe où dans le chemin de votre code source. Par exemple, placez votre source à /worker/srcet votre package.jsondans /worker, c'est /worker/node_moduleslà où ils sont installés.

L'installation de node_modules dans un conteneur à un autre que le dossier du projet et la définition de NODE_PATH dans votre dossier node_modules m'aide (vous devez reconstruire le conteneur).

J'utilise docker-compose. Ma structure de fichiers de projet:

-/myproject
--docker-compose.yml
--nodejs/
----Dockerfile

docker-compose.yml:

version: '2'
services:
  nodejs:
    image: myproject/nodejs
    build: ./nodejs/.
    volumes:
      - ./nodejs:/workdir
    ports:
      - "23005:3000"
    command: npm run server

Dockerfile dans le dossier nodejs:

FROM node:argon
RUN mkdir /workdir
COPY ./package.json /workdir/.
RUN mkdir /data
RUN ln -s /workdir/package.json /data/.
WORKDIR /data
RUN npm install
ENV NODE_PATH /data/node_modules/
WORKDIR /workdir

Il existe également une solution simple sans mappage de node_modulerépertoire dans un autre volume. Il est sur le point de déplacer l'installation des packages npm dans la commande CMD finale.

Inconvénient de cette approche:

• exécutez npm installchaque fois que vous exécutez le conteneur (le passage de npmà yarnpeut également accélérer un peu ce processus).

worker / Dockerfile

FROM node:0.12
WORKDIR /worker
COPY package.json /worker/
COPY . /worker/
CMD /bin/bash -c 'npm install; npm start'

docker-compose.yml

redis:
    image: redis
worker:
    build: ./worker
    ports:
        - "9730:9730"
    volumes:
        - worker/:/worker/
    links:
        - redis

Il y a deux exigences distinctes que je vois pour les environnements de développement de nœuds ... montez votre code source DANS le conteneur et montez les node_modules À PARTIR du conteneur (pour votre IDE). Pour accomplir le premier, vous faites le montage habituel, mais pas tout ... juste ce dont vous avez besoin

volumes:
    - worker/src:/worker/src
    - worker/package.json:/worker/package.json
    - etc...

(la raison de ne pas faire - /worker/node_modules est que docker-compose conservera ce volume entre les exécutions, ce qui signifie que vous pouvez diverger de ce qui est réellement dans l'image (ce qui va à l'encontre de l'objectif de ne pas simplement lier le montage de votre hôte)).

Le second est en fait plus difficile. Ma solution est un peu hackish, mais ça marche. J'ai un script pour installer le dossier node_modules sur ma machine hôte, et je dois juste me rappeler de l'appeler chaque fois que je mets à jour package.json (ou l'ajouter à la cible make qui exécute docker-compose build localement).

install_node_modules:
    docker build -t building .
    docker run -v `pwd`/node_modules:/app/node_modules building npm install

À mon avis, nous ne devrions pas RUN npm installdans le Dockerfile. Au lieu de cela, nous pouvons démarrer un conteneur en utilisant bash pour installer les dépendances avant d'exécuter le service de nœud formel

docker run -it -v ./app:/usr/src/app  your_node_image_name  /bin/bash
root@247543a930d6:/usr/src/app# npm install

Vous pouvez essayer quelque chose comme ça dans votre Dockerfile:

FROM node:0.12
WORKDIR /worker
CMD bash ./start.sh

Ensuite, vous devez utiliser le volume comme ceci:

volumes:
  - worker/:/worker:rw

Le startscript doit faire partie de votre référentiel de travail et ressemble à ceci:

#!/bin/sh
npm install
npm start

Ainsi, les node_modules font partie de votre volume de travail et sont synchronisés et les scripts npm sont exécutés lorsque tout est en place.

Vous pouvez également abandonner votre Dockerfile, en raison de sa simplicité, utilisez simplement une image de base et spécifiez la commande dans votre fichier de composition:

version: '3.2'

services:
  frontend:
    image: node:12-alpine
    volumes:
      - ./frontend/:/app/
    command: sh -c "cd /app/ && yarn && yarn run start"
    expose: [8080]
    ports:
      - 8080:4200

C'est particulièrement utile pour moi, car j'ai juste besoin de l'environnement de l'image, mais j'opère sur mes fichiers en dehors du conteneur et je pense que c'est ce que tu veux faire aussi.