Vfrdtyky

I am currently developing a Node backend for my application.
When dockerizing it (docker build .) the longest phase is the RUN npm install. The RUN npm install instruction runes on every small server code change, impacting the productivity by making the developer wait for the build to finish each time.

I found that running npm install where the application code lives and adding the node_modules to the container with the ADD instruction solves this issue,
but it is far from best practice. It kind of breaks the whole idea of dockerizing it and it cause the container to weight much more.

Any other solution?

Ok so I found this great article about efficiency when writing a docker file.

This is an example of a bad docker file adding the application code before running the RUN npm install instruction:

FROM ubuntu



RUN echo "deb http://archive.ubuntu.com/ubuntu precise main universe" > /etc/apt/sources.list

RUN apt-get update

RUN apt-get -y install python-software-properties git build-essential

RUN add-apt-repository -y ppa:chris-lea/node.js

RUN apt-get update

RUN apt-get -y install nodejs



WORKDIR /opt/app



COPY . /opt/app

RUN npm install

EXPOSE 3001



CMD ["node", "server.js"]

By dividing the copy of the application into 2 COPY instructions (one for the package.json file and the other for the rest of the files) and running the npm install instruction before adding the actual code, any code change wont trigger the RUN npm install instruction, only changes of the package.json will trigger it. Better practice docker file:

FROM ubuntu

MAINTAINER David Weinstein <david@bitjudo.com>



# install our dependencies and nodejs

RUN echo "deb http://archive.ubuntu.com/ubuntu precise main universe" > /etc/apt/sources.list

RUN apt-get update

RUN apt-get -y install python-software-properties git build-essential

RUN add-apt-repository -y ppa:chris-lea/node.js

RUN apt-get update

RUN apt-get -y install nodejs



# use changes to package.json to force Docker not to use the cache

# when we change our application's nodejs dependencies:

COPY package.json /tmp/package.json

RUN cd /tmp && npm install

RUN mkdir -p /opt/app && cp -a /tmp/node_modules /opt/app/



# From here we load our application's code in, therefore the previous docker

# "layer" thats been cached will be used if possible

WORKDIR /opt/app

COPY . /opt/app



EXPOSE 3000



CMD ["node", "server.js"]

This is where the package.json file added, install its dependencies and copy them into the container WORKDIR, where the app lives:

ADD package.json /tmp/package.json

RUN cd /tmp && npm install

RUN mkdir -p /opt/app && cp -a /tmp/node_modules /opt/app/

To avoid the npm install phase on every docker build just copy those lines and change the ^/opt/app^ to the location your app lives inside the container.

Weird! No one mentions multi-stage build.

# ---- Base Node ----

FROM alpine:3.5 AS base

# install node

RUN apk add --no-cache nodejs-current tini

# set working directory

WORKDIR /root/chat

# Set tini as entrypoint

ENTRYPOINT ["/sbin/tini", "--"]

# copy project file

COPY package.json .



#

# ---- Dependencies ----

FROM base AS dependencies

# install node packages

RUN npm set progress=false && npm config set depth 0

RUN npm install --only=production 

# copy production node_modules aside

RUN cp -R node_modules prod_node_modules

# install ALL node_modules, including 'devDependencies'

RUN npm install



#

# ---- Test ----

# run linters, setup and tests

FROM dependencies AS test

COPY . .

RUN  npm run lint && npm run setup && npm run test



#

# ---- Release ----

FROM base AS release

# copy production node_modules

COPY --from=dependencies /root/chat/prod_node_modules ./node_modules

# copy app sources

COPY . .

# expose port and define CMD

EXPOSE 5000

CMD npm run start

Awesome tuto here: https://codefresh.io/docker-tutorial/node_docker_multistage/

I've found that the simplest approach is to leverage Docker's copy semantics:

The COPY instruction copies new files or directories from and adds them to the filesystem of the container at the path .

This means that if you first explicitly copy the package.json file and then run the npm install step that it can be cached and then you can copy the rest of the source directory. If the package.json file has changed, then that will be new and it will re-run the npm install caching that for future builds.

A snippet from the end of a Dockerfile would look like:

# install node modules

WORKDIR  /usr/app

COPY     package.json /usr/app/package.json

RUN      npm install



# install application

COPY     . /usr/app

I imagine you may already know, but you could include a .dockerignore file in the same folder containing

node_modules

npm-debug.log

to avoid bloating your image when you push to docker hub

you don't need to use tmp folder, just copy package.json to your container's application folder, do some install work and copy all files later.

COPY app/package.json /opt/app/package.json

RUN cd /opt/app && npm install

COPY app /opt/app