Dockerizing a Node.js web app
The goal of this example is to show you how to get a Node.js application into a Docker container. The guide is intended for development, and not for a production deployment. The guide also assumes you have a working Docker installation and a basic understanding of how a Node.js application is structured.
In the first part of this guide we will create a simple web application in Node.js, then we will build a Docker image for that application, and lastly we will instantiate a container from that image.
Docker allows you to package an application with its environment and all of its dependencies into a "box", called a container. Usually, a container consists of an application running in a stripped-to-basics version of a Linux operating system. An image is the blueprint for a container, a container is a running instance of an image.
Create the Node.js app
First, create a new directory where all the files would live. In this directory create a package.json file that describes your app and its dependencies:
{
"name": "docker_web_app",
"version": "1.0.0",
"description": "Node.js on Docker",
"author": "First Last <<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="55333c2726217b3934262115302d34382539307b363a38">[email protected]</a>>",
"main": "server.js",
"scripts": {
"start": "node server.js"
},
"dependencies": {
"express": "^4.16.1"
}
}
With your new package.json file, run npm install. If you are using npm version 5 or later, this will generate a package-lock.json file which will be copied to your Docker image.
Then, create a server.js file that defines a web app using the Express.js framework:
'use strict';
const express = require('express');
// Constants
const PORT = 8080;
const HOST = '0.0.0.0';
// App
const app = express();
app.get('/', (req, res) => {
res.send('Hello World');
});
app.listen(PORT, HOST, () => {
console.log(`Running on http://${HOST}:${PORT}`);
});
In the next steps, we'll look at how you can run this app inside a Docker container using the official Docker image. First, you'll need to build a Docker image of your app.
Creating a Dockerfile
Create an empty file called Dockerfile:
touch Dockerfile
Open the Dockerfile in your favorite text editor
The first thing we need to do is define from what image we want to build from. Here we will use the latest LTS (long term support) version 16 of node available from the Docker Hub:
FROM node:16
Next we create a directory to hold the application code inside the image, this will be the working directory for your application:
# Create app directory
WORKDIR /usr/src/app
This image comes with Node.js and NPM already installed so the next thing we need to do is to install your app dependencies using the npm binary. Please note that if you are using npm version 4 or earlier a package-lock.json file will not be generated.
# Install app dependencies
# A wildcard is used to ensure both package.json AND package-lock.json are copied
# where available (<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="731d031e3346">[email protected]</a>+)
COPY package*.json ./
RUN npm install
# If you are building your code for production
# RUN npm ci --only=production
Note that, rather than copying the entire working directory, we are only copying the package.json file. This allows us to take advantage of cached Docker layers. bitJudo has a good explanation of this here. Furthermore, the npm ci command, specified in the comments, helps provide faster, reliable, reproducible builds for production environments. You can read more about this here.
To bundle your app's source code inside the Docker image, use the COPY instruction:
# Bundle app source
COPY . .
Your app binds to port 8080 so you'll use the EXPOSE instruction to have it mapped by the docker daemon:
EXPOSE 8080
Last but not least, define the command to run your app using CMD which defines your runtime. Here we will use node server.js to start your server:
CMD [ "node", "server.js" ]
Your Dockerfile should now look like this:
FROM node:16
# Create app directory
WORKDIR /usr/src/app
# Install app dependencies
# A wildcard is used to ensure both package.json AND package-lock.json are copied
# where available (<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="1b756b765b2e">[email protected]</a>+)
COPY package*.json ./
RUN npm install
# If you are building your code for production
# RUN npm ci --only=production
# Bundle app source
COPY . .
EXPOSE 8080
CMD [ "node", "server.js" ]
Node.js server secure
running in a Docker container, you should follow best practices for both Node.js and Docker. Here's a basic outline of steps to help you achieve a more secure configuration:
- Create a Dockerfile for your Node.js application:
# Use the official Node.js LTS (Long Term Support) version as the base image
FROM node:lts
# Create a dedicated user to run the app
RUN useradd --user-group --create-home --no-log-init --shell /bin/false appuser
# Create the app directory and set appuser as its owner
RUN mkdir /app && chown appuser:appuser /app
# Set the working directory
WORKDIR /app
# Copy package.json and package-lock.json into the app directory
COPY --chown=appuser:appuser package*.json ./
# Install production dependencies
RUN npm ci --only=production
# Copy the app source code into the app directory
COPY --chown=appuser:appuser . .
# Expose the port your app will run on
EXPOSE 3000
# Switch to the appuser
USER appuser
# Start the Node.js server
CMD ["npm", "start"]
Node.js in server Alpine Linux secure
running in a Docker container, You should use the adduser and addgroup commands instead. Here's the modified version of your Dockerfile: you should follow best practices for both Node.js and Docker. Here's a basic outline of steps to help you achieve a more secure configuration:
# Use the official Node.js LTS (Long Term Support) version as the base image
FROM node:lts-alpine
# Create a dedicated user to run the app
RUN addgroup -S appgroup && adduser -S appuser -G appgroup -h /home/appuser -s /bin/false
# Create the app directory and set appuser as its owner
RUN mkdir /app && chown appuser:appgroup /app
# Set the working directory
WORKDIR /app
# Copy package.json and package-lock.json into the app directory
COPY --chown=appuser:appgroup package*.json ./
# Install production dependencies
RUN npm ci --only=production
# Copy the app source code into the app directory
COPY --chown=appuser:appgroup . .
# Expose the port your app will run on
EXPOSE 3000
# Switch to the appuser
USER appuser
# Start the Node.js server
CMD ["npm", "start"]
.dockerignore file
- Add a .dockerignore file to your project:
Create a .dockerignore file in the same directory as your Dockerfile with following content:
node_modules
npm-debug.log
Dockerfile
.dockerignore
This will prevent your local modules and debug logs from being copied onto your Docker image and possibly overwriting modules installed within your image.
Building your image
Go to the directory that has your Dockerfile and run the following command to build the Docker image. The -t flag lets you tag your image so it's easier to find later using the docker images command:
docker build . -t <your username>/node-web-app
Your image will now be listed by Docker:
$ docker images
# Example
REPOSITORY TAG ID CREATED
node 16 3b66eb585643 5 days ago
<your username>/node-web-app latest d64d3505b0d2 1 minute ago
Run the image
Running your image with -d runs the container in detached mode, leaving the container running in the background. The -p flag redirects a public port to a private port inside the container. Run the image you previously built:
docker run -p 49160:8080 -d --restart unless-stopped --name NAME <your username>/node-web-app
Print the output of your app:
# Get container ID
$ docker ps
# Print app output
$ docker logs <container id>
# Example
Running on http://localhost:8080
If you need to go inside the container you can use the exec command:
# Enter the container
$ docker exec -it <container id> /bin/bash
Test
To test your app, get the port of your app that Docker mapped:
$ docker ps
# Example
ID IMAGE COMMAND ... PORTS
ecce33b30ebf <your username>/node-web-app:latest npm start ... 49160->8080
In the example above, Docker mapped the 8080 port inside of the container to the port 49160 on your machine.
Now you can call your app using curl (install if needed via: sudo apt-get install curl):
$ curl -i localhost:49160
HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 12
ETag: W/"c-M6tWOb/Y57lesdjQuHeB1P/qTV0"
Date: Mon, 13 Nov 2017 20:53:59 GMT
Connection: keep-alive
Hello world
Shut down the image
In order to shut down the app we started, we run the kill command. This uses the container's ID, which in this example was ecce33b30ebf.
# Kill our running container
$ docker kill <container id>
<container id>
# Confirm that the app has stopped
$ curl -i localhost:49160
curl: (7) Failed to connect to localhost port 49160: Connection refused
We hope this tutorial helped you get up and running a simple Node.js application on Docker.
You can find more information about Docker and Node.js on Docker in the following places: