Ho un'app con i seguenti servizi:

• web/ - contiene ed esegue un server web di fiaschi Python 3 sulla porta 5000. Utilizza sqlite3.
• worker/- ha un index.jsfile che è un lavoratore per una coda. il web server interagisce con questa coda usando un'API json su porta 9730. Il lavoratore utilizza redis per l'archiviazione. Il lavoratore archivia anche i dati localmente nella cartellaworker/images/

Ora questa domanda riguarda solo il 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

Quando corro docker-compose build, tutto funziona come previsto e tutti i moduli npm sono installati /worker/node_modulescome previsto.

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>

Ma quando lo faccio docker-compose up, vedo questo errore:

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)

Risulta che nessuno dei moduli è presente in /worker/node_modules(sull'host o nel contenitore).

Se sull'host, io npm install, allora tutto funziona bene. Ma non voglio farlo. Voglio che il contenitore gestisca le dipendenze.

Cosa non va qui?

(Inutile dire che tutti i pacchetti sono presenti package.json.)

Ciò accade perché hai aggiunto la tua workerdirectory come volume al tuo docker-compose.yml, poiché il volume non è montato durante la compilazione.

Quando la finestra mobile crea l'immagine, la node_modulesdirectory viene creata all'interno della workerdirectory e tutte le dipendenze vengono installate lì. Quindi in fase di esecuzione la workerdirectory dalla finestra mobile esterna viene montata nell'istanza della finestra mobile (che non ha installato node_modules), nascondendo il file node_modulesappena installato. Puoi verificarlo rimuovendo il volume montato dal tuo docker-compose.yml.

Una soluzione alternativa consiste nell'utilizzare un volume di dati per archiviare tutti node_modules, poiché i volumi di dati copiano i dati dall'immagine docker integrata prima che workervenga montata la directory. Questo può essere fatto in docker-compose.ymlquesto modo:

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

Non sono del tutto sicuro se ciò imponga problemi per la portabilità dell'immagine, ma poiché sembra che tu stia utilizzando principalmente la finestra mobile per fornire un ambiente di runtime, questo non dovrebbe essere un problema.

Se vuoi saperne di più sui volumi, c'è una bella guida per l'utente disponibile qui: https://docs.docker.com/userguide/dockervolumes/

EDIT: Docker da allora ha cambiato la sua sintassi per richiedere un lead ./per il montaggio in file relativi al file docker-compose.yml.

La node_modulescartella viene sovrascritta dal volume e non è più accessibile nel contenitore. Sto usando la strategia di caricamento del modulo nativo per estrarre la cartella dal 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/

La node_modulesdirectory non è accessibile dall'esterno del contenitore perché è inclusa nell'immagine.

La soluzione fornita da @FrederikNS funziona, ma preferisco dare un nome esplicito al mio volume node_modules.

Il mio project/docker-compose.ymlfile (docker-compose versione 1.6+):

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

la mia struttura dei file è:

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

Crea un volume denominato project_node_modulese lo riutilizza ogni volta che utilizzo l'applicazione.

Il mio docker volume lsassomiglia a questo:

DRIVER              VOLUME NAME
local               project1_mysql
local               project1_node_modules
local               project2_postgresql
local               project2_node_modules

Di recente ho avuto un problema simile. È possibile installare node_modulesaltrove e impostare la NODE_PATHvariabile di ambiente.

Nell'esempio seguente ho installato node_modulesin/install

lavoratore / 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/

finestra mobile-compose.yml

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

C'è una soluzione elegante:

Basta montare non l'intera directory, ma solo la directory dell'app. In questo modo non avrai problemi npm_modules.

Esempio:

  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

AGGIORNAMENTO: utilizzare la soluzione fornita da @FrederikNS.

Ho riscontrato lo stesso problema. Quando la cartella /workerviene montata sul contenitore, tutto il suo contenuto verrà sincronizzato (quindi la cartella node_modules scomparirà se non è disponibile localmente).

A causa di pacchetti npm incompatibili basati sul sistema operativo, non potevo semplicemente installare i moduli localmente, quindi avviare il contenitore, quindi ...

La mia soluzione a questo, era di avvolgere l'origine in una srccartella, quindi collegarlo node_modulesa quella cartella, usando questo file index.js . Quindi, il index.jsfile è ora il punto di partenza della mia applicazione.

Quando eseguo il contenitore, ho montato la /app/srccartella nella mia srccartella locale .

Quindi la cartella del contenitore è simile alla seguente:

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

È brutto , ma funziona ..

A causa del modo in cui Node.js carica i moduli , node_modulespuò trovarsi ovunque nel percorso del codice sorgente. Per esempio, mettere la vostra fonte in /worker/srce la vostra package.jsonin /worker, in modo da /worker/node_modulesè dove sono installati.

L'installazione di node_modules nel container su un diverso dalla cartella del progetto e l'impostazione di NODE_PATH sulla cartella node_modules mi aiuta (devi ricostruire il container).

Sto usando la finestra mobile-componi. La struttura del mio file di progetto:

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

finestra mobile-compose.yml:

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

File Docker nella cartella 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

C'è anche qualche soluzione semplice senza mappare la node_moduledirectory in un altro volume. Sta per spostare l'installazione dei pacchetti npm nel comando CMD finale.

Svantaggio di questo approccio:

• eseguire npm installogni volta che si esegue il contenitore (il passaggio da npma yarnpotrebbe anche accelerare un po 'questo processo).

lavoratore / Dockerfile

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

finestra mobile-compose.yml

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

Esistono due requisiti separati che vedo per gli ambienti di sviluppo dei nodi ... montare il codice sorgente nel contenitore e montare node_modules DAL contenitore (per il proprio IDE). Per realizzare il primo, fai la solita cavalcatura, ma non tutto ... solo le cose che ti servono

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

(il motivo per non farlo - /worker/node_modulesè perché docker-compose manterrà quel volume tra le esecuzioni, il che significa che puoi divergere da ciò che è effettivamente nell'immagine (sconfiggendo lo scopo di non solo legare il montaggio dal tuo host)).

Il secondo è in realtà più difficile. La mia soluzione è un po 'hacker, ma funziona. Ho uno script per installare la cartella node_modules sul mio computer host e devo solo ricordarmi di chiamarlo ogni volta che aggiorno package.json (o, aggiungerlo al target make che esegue localmente docker-compose build).

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

Secondo me, non dovremmo RUN npm installnel Dockerfile. Invece, possiamo avviare un contenitore usando bash per installare le dipendenze prima di eseguire il servizio nodo formale

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

Puoi provare qualcosa del genere nel tuo Dockerfile:

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

Quindi dovresti usare il Volume in questo modo:

volumes:
  - worker/:/worker:rw

Il codice di avvio dovrebbe far parte del repository di lavoro e ha il seguente aspetto:

#!/bin/sh
npm install
npm start

Quindi i node_modules fanno parte del volume di lavoro e vengono sincronizzati e gli script npm vengono eseguiti quando tutto è attivo.

Puoi anche abbandonare il tuo Dockerfile, per la sua semplicità, basta usare un'immagine di base e specificare il comando nel tuo file di composizione:

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

Questo è particolarmente utile per me, perché ho solo bisogno dell'ambiente dell'immagine, ma opero sui miei file all'esterno del contenitore e penso che sia quello che vuoi fare anche tu.