Docker : Dockerfile - NodeJS

bogotobogo.com site search:

Introduction

In this post, we'll learn how to get a Node.js application into a Docker container.

On local machine, let's check the versions of node and npm:

$ node -v
v11.9.0

$ npm -v
6.5.0

Application file

Before we build our Docker images, we need to create a simple web application in Node.js.

Let's create a directory ('node') for our project in our non-root user's home directory.

$ mkdir node

$ cd node

This will be the root directory of our project.

Next, create a package.json file with our project's dependencies and other information:

{
  "name": "docker_nodejs_app",
  "version": "1.0.0",
  "description": "Node.js on Docker",
  "author": "Ki Hong <first.bogo@example.com>",
  "license": "MIT",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.16.4"
  }
}

As we can see, the file specifies:

"main": The entrypoint of the application, server.js (not created yet).
"dependencies": The project dependencies, express 4.16.4 or above.

With our new package.json file, run npm install:

$ npm install

This will generate a package-lock.json file which will be copied to our Docker image.

Then, we need to create a server.js file that defines a web app using the Express.js framework:

var http = require('http');
var handleRequest = function(request, response) {
  response.writeHead(200);
  response.end("Hello world");
}
var www = http.createServer(handleRequest);
www.listen(8080);

Since on our local machine, the node executable installed, we may want to run this command to start the node server (the command produces no output):

$ node server.js

Open a new browser tab and make a request for a page from the local app we just started on port 8080:

Creating a Dockerfile

Our Dockerfile should look like this:

FROM node:8

# Create app directory
WORKDIR /usr/src/app

# Install app dependencies
COPY package*.json ./

RUN npm install

# Bundle app source
COPY . .

EXPOSE 8080
CMD [ "npm", "start" ]

Let's look into the file line by line.

As a base image, we will use the latest LTS (long term support) version 8 of node available from the Docker Hub:

FROM node:8

Then, we create a directory to hold the application code inside the image, this will be the working directory for our application:

WORKDIR /usr/src/app

This image comes with Node.js and npm already installed. The "COPY" instruction will copy package-lock.json and package.json to the working directory.

COPY package*.json ./

After copying the project dependencies, we install our app dependencies using npm into node_modules folder:

RUN npm install

Then, copy our application code (server.sj) to the working application directory on the container:

COPY . .

Our app binds to port 8080 so we use the EXPOSE instruction to have it mapped by the docker daemon:

EXPOSE 8080

Then, define the command to run our app using CMD which defines our runtime using npm start which will run node server.js to start our server:

CMD [ "npm", "start" ]

We may need to create a . dockerignore:

node_modules
npm-debug.log

This will prevent our local modules and debug logs from being copied onto our Docker image.

Dockerfile - minimal

If we do not have any dependencies, the simples Dockerfile could be like this:

FROM node:8
EXPOSE 8080
COPY server.js .
CMD node server.js

But we will not use this Dockerfile but will use the Dockerfile created earlier.

Building Docker image

Run the following command to build the Docker image:

$ docker build -t dockerbogo/docker_nodejs_app .

The -t flag lets us tag our image.

Running the Docker image

Let's run our previously built image in detached mode with -d so that the container running in the background. The -p flag redirects a host port to a private container port:

$ docker run -p 80:8080 -d dockerbogo/docker_nodejs_app

$ docker ps
CONTAINER ID  IMAGE                         COMMAND      CREATED        STATUS         PORTS                     NAMES
70f3ff442a57  dockerbogo/docker_nodejs_app  "npm start"  14 seconds ago Up 13 seconds  0.0.0.0:80->8080/tcp   zealous_hopper

$ docker logs 691a226706e1

> docker_nodejs_app@1.0.0 start /usr/src/app
> node server.js

Running on http://0.0.0.0:8080

Docker has mapped the 8080 port inside of the container to the port 80 on our machine:

If we need to go inside the container we can use the exec command:

$ docker exec -it <container id> /bin/bash

$ docker exec -i -t 70f3ff442a57 /bin/bash 

root@70f3ff442a57:/usr/src/app# ls
Dockerfile  node_modules  package-lock.json  package.json  server.js

root@70f3ff442a57:/usr/src/app#