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:
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:
Creating a Dockerfile
Create an empty file called
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
node available from the Docker Hub:
Next we create a directory to hold the application code inside the image, this will be the working directory for your application:
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.
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
Your app binds to port
8080 so you'll use the
EXPOSE instruction to have it mapped by the
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:
Dockerfile should now look like this:
.dockerignore file in the same directory as your
Dockerfile with following content:
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:
Your image will now be listed by Docker:
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:
Print the output of your app:
If you need to go inside the container you can use the
To test your app, get the port of your app that Docker mapped:
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):
I 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:
- Official Node.js Docker Image
- Node.js Docker Best Practices Guide
- Official Docker documentation
- Docker Tag on Stack Overflow
- Docker Subreddit