Ich habe eine App mit folgenden Diensten:

• web/ - hält einen Python 3-Flask-Webserver auf Port 5000 und führt ihn aus. Verwendet sqlite3.
• worker/- hat eine index.jsDatei, die ein Arbeiter für eine Warteschlange ist. Der Webserver interagiert mit dieser Warteschlange über eine JSON-API über Port 9730. Der Worker verwendet Redis zur Speicherung. Der Worker speichert Daten auch lokal im Ordnerworker/images/

Jetzt betrifft diese Frage nur die 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

Wenn ich laufe docker-compose build, funktioniert alles wie erwartet und alle npm-Module werden wie erwartet installiert /worker/node_modules.

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>

Aber wenn ich das tue docker-compose up, sehe ich diesen Fehler:

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)

Es stellt sich heraus, dass keines der Module vorhanden ist /worker/node_modules(auf dem Host oder im Container).

Wenn auf dem Host, ich npm install, dann funktioniert alles gut. Aber das will ich nicht. Ich möchte, dass der Container Abhängigkeiten behandelt.

Was läuft hier falsch?

(Unnötig zu erwähnen, dass alle Pakete enthalten sind package.json.)

Dies liegt daran, dass Sie Ihr workerVerzeichnis als Volume zu Ihrem hinzugefügt haben docker-compose.yml, da das Volume während des Builds nicht bereitgestellt wird.

Wenn Docker das Image erstellt, wird das node_modulesVerzeichnis innerhalb des workerVerzeichnisses erstellt und alle Abhängigkeiten werden dort installiert. Zur Laufzeit wird das workerVerzeichnis von außerhalb des Dockers in die Docker-Instanz eingebunden (auf der das Docker nicht installiert ist node_modules), wodurch das node_modulesgerade installierte Verzeichnis ausgeblendet wird . Sie können dies überprüfen, indem Sie das bereitgestellte Volume von Ihrem entfernen docker-compose.yml.

Eine Problemumgehung besteht darin, ein Datenvolume zum Speichern aller Daten zu verwenden node_modules, da Datenvolumes die Daten aus dem erstellten Docker-Image kopieren, bevor das workerVerzeichnis bereitgestellt wird. Dies kann folgendermaßen geschehen docker-compose.yml:

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

Ich bin nicht ganz sicher, ob dies Probleme für die Portabilität des Images mit sich bringt, aber da Sie anscheinend hauptsächlich Docker verwenden, um eine Laufzeitumgebung bereitzustellen, sollte dies kein Problem sein.

Wenn Sie mehr über Volumes erfahren möchten, finden Sie hier eine nette Bedienungsanleitung: https://docs.docker.com/userguide/dockervolumes/

BEARBEITEN: Docker hat seitdem seine Syntax dahingehend geändert, dass ein Leading ./für das Mounten in Dateien relativ zur Datei docker-compose.yml erforderlich ist.

Der node_modulesOrdner wird vom Volume überschrieben und ist im Container nicht mehr zugänglich. Ich verwende die native Modul-Ladestrategie , um den Ordner aus dem Volume zu entfernen:

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

Auf das node_modulesVerzeichnis kann von außerhalb des Containers nicht zugegriffen werden, da es im Bild enthalten ist.

Die von @FrederikNS bereitgestellte Lösung funktioniert, aber ich bevorzuge es, mein node_modules-Volume explizit zu benennen.

Meine project/docker-compose.ymlDatei (Docker-Compose Version 1.6+):

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

Meine Dateistruktur ist:

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

Es erstellt ein Volume mit dem Namen project_node_modulesund verwendet es jedes Mal wieder, wenn ich meine Anwendung starte.

Mein docker volume lssieht so aus:

DRIVER              VOLUME NAME
local               project1_mysql
local               project1_node_modules
local               project2_postgresql
local               project2_node_modules

Ich hatte kürzlich ein ähnliches Problem. Sie können an einer node_modulesanderen Stelle installieren und die NODE_PATHUmgebungsvariable festlegen .

Im Beispiel unten habe ich installiert node_modulesin/install

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

Es gibt eine elegante Lösung:

Mounten Sie einfach nicht das gesamte Verzeichnis, sondern nur das App-Verzeichnis. Auf diese Weise haben Sie keine Probleme npm_modules.

Beispiel:

  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

UPDATE: Verwenden Sie die Lösung von @FrederikNS zur Verfügung gestellt.

Ich bin auf das gleiche Problem gestoßen. Wenn der Ordner /workerin den Container eingebunden wird, wird der gesamte Inhalt synchronisiert (sodass der Ordner node_modules verschwindet, wenn Sie ihn nicht lokal haben.)

Aufgrund inkompatibler npm-Pakete, die auf dem Betriebssystem basieren, konnte ich die Module nicht nur lokal installieren, sondern auch den Container starten.

Meine Lösung bestand darin, die Quelle in einen srcOrdner zu packen und dann node_modulesmit dieser Datei index.js in diesen Ordner zu verlinken . Die index.jsDatei ist nun der Ausgangspunkt meiner Anwendung.

Wenn ich den Container ausführe, habe ich den /app/srcOrdner in meinen lokalen srcOrdner eingebunden.

Der Containerordner sieht also ungefähr so ​​aus:

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

Es ist hässlich , aber es funktioniert ..

Aufgrund der Art und Weise, wie Node.js Module lädt , node_moduleskann es sich an einer beliebigen Stelle im Pfad zu Ihrem Quellcode befinden. Legen Sie beispielsweise Ihre Quelle an /worker/srcund Ihre package.jsonin /worker, also /worker/node_modulesdort, wo sie installiert sind.

Das Installieren von node_modules im Container in einem anderen als dem Projektordner und das Festlegen von NODE_PATH in Ihrem node_modules-Ordner hilft mir (Sie müssen den Container neu erstellen).

Ich benutze Docker-Compose. Meine Projektdateistruktur:

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

Docker-Datei im Ordner 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

Es gibt auch eine einfache Lösung, ohne das node_moduleVerzeichnis einem anderen Volume zuzuordnen. Es geht darum, die Installation von npm-Paketen in den endgültigen CMD-Befehl zu verschieben.

Nachteil dieses Ansatzes:

• npm installJedes Mal ausführen, wenn Sie einen Container ausführen (ein Wechsel von npmzu yarnkann diesen Vorgang ebenfalls etwas beschleunigen).

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

Es gibt zwei separate Anforderungen, die ich für Knotenentwicklungsumgebungen sehe ... Mounten Sie Ihren Quellcode in den Container und mounten Sie die Node_Module aus dem Container (für Ihre IDE). Um das erste zu erreichen, machst du das übliche Reittier, aber nicht alles ... nur die Dinge, die du brauchst

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

(Der Grund dafür - /worker/node_modulesist, dass Docker-Compose dieses Volume zwischen den Läufen beibehält, was bedeutet, dass Sie von dem, was tatsächlich im Image enthalten ist, abweichen können (was den Zweck zunichte macht, nicht nur das Mounten von Ihrem Host zu binden)).

Der zweite ist eigentlich schwieriger. Meine Lösung ist ein bisschen hackisch, aber es funktioniert. Ich habe ein Skript zum Installieren des Ordners node_modules auf meinem Hostcomputer, und ich muss nur daran denken, es aufzurufen, wenn ich package.json aktualisiere (oder es dem make-Ziel hinzufüge, auf dem Docker-Compose Build lokal ausgeführt wird).

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

Meiner Meinung nach sollten wir nicht RUN npm installin die Dockerfile. Stattdessen können wir einen Container mit bash starten, um die Abhängigkeiten zu installieren, bevor der formale Knotendienst ausgeführt wird

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

Sie können so etwas in Ihrer Docker-Datei ausprobieren:

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

Dann sollten Sie das Volume wie folgt verwenden:

volumes:
  - worker/:/worker:rw

Das Startskript sollte Teil Ihres Worker-Repositorys sein und sieht folgendermaßen aus:

#!/bin/sh
npm install
npm start

Die node_modules sind also Teil Ihres Worker-Volumes und werden synchronisiert und die npm-Skripte werden ausgeführt, wenn alles in Betrieb ist.

Sie können Ihre Docker-Datei aufgrund ihrer Einfachheit auch über Bord werfen. Verwenden Sie einfach ein Basisbild und geben Sie den Befehl in Ihrer Erstellungsdatei an:

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

Dies ist besonders nützlich für mich, da ich nur die Umgebung des Bildes benötige, aber meine Dateien außerhalb des Containers bearbeite und ich denke, dass Sie dies auch tun möchten.