Install Nodejs Docker


Node.js is a JavaScript-based platform for server-side and networking applications. Install node and npm with nvm using Docker. #!/usr/bin/env bash. # confirm docker daemon is running and connected. # build the image based on the Dockerfile and name it `nvm`. Containerizing your Node.js applications with Docker Dockerize your Node.js application, go throuh each steps below. Why you should use docker and containers Docker is a powerful tool for creating and deploying applications. It is a container management service. Install the latest versions of Node.js and npm, into a Docker container, with or without the need for root access. Easily update both applications to the latest versions. Ubuntu and Node. Recently, I was setting up a new development laptop with Ubuntu 14.10 (Utopic Unicorn).

Installed Docker ToolBox in Windows 2010/2012 but Server is showing as OS/Arch: linux/amd64. So i was not able to install any Windows related OS. Can we have any other options to install Docker Toolbox with OS/Arch showing as Windows so that we can install Windows operation system on top of it? Thank you in Advance for your help.

Estimated reading time: 14 minutes


Work through the orientation and setup in Get started Part 1 to understand Docker concepts.

Enable BuildKit

Before we start building images, ensure you have enabled BuildKit on your machine.BuildKit allows you to build Docker images efficiently. For more information,see Building images with BuildKit.

BuildKit is enabled by default for all users on Docker Desktop. If you haveinstalled Docker Desktop, you don’t have to manually enable BuildKit. If you arerunning Docker on Linux, you can enable BuildKit either by using an environmentvariable or by making BuildKit the default setting.

To set the BuildKit environment variable when running the docker build command,run:

To enable docker BuildKit by default, set daemon configuration in /etc/docker/daemon.json feature to true and restart the daemon.If the daemon.json file doesn’t exist, create new file called daemon.json and then add the following to the file.

Restart the Docker daemon.


Now that we have a good overview of containers and the Docker platform, let’s take a look at building our first image. An image includes everything you need to run an application - the code or binary, runtime, dependencies, and any other file system objects required.

To complete this tutorial, you need the following:

  • Node.js version 12.18 or later. Download Node.js
  • Docker running locally: Follow the instructions to download and install Docker.
  • An IDE or a text editor to edit files. We recommend using Visual Studio Code.

Sample application

Let’s create a simple Node.js application that we can use as our example. Create a directory in your local machine named node-docker and follow the steps below to create a simple REST API.


Now, let’s add some code to handle our REST requests. We’ll use a mock server so we can focus on Dockerizing the application.

Open this working directory in your IDE and add the following code into the server.js file.

The mocking server is called Ronin.js and will listen on port 8000 by default. You can make POST requests to the root (/) endpoint and any JSON structure you send to the server will be saved in memory. You can also send GET requests to the same endpoint and receive an array of JSON objects that you have previously POSTed.

Test the application

Let’s start our application and make sure it’s running properly. Open your terminal and navigate to your working directory you created.

To test that the application is working properly, we’ll first POST some JSON to the API and then make a GET request to see that the data has been saved. Open a new terminal and run the following curl commands:

Switch back to the terminal where our server is running. You should now see the following requests in the server logs.

Great! We verified that the application works. At this stage, you’ve completed testing the server script locally.

Press CTRL-c from within the terminal session where the server is running to stop it.

We will now continue to build and run the application in Docker.

Create a Dockerfile for Node.js

A Dockerfile is a text document that contains the instructions to assemble aDocker image. When we tell Docker to build our image by executing the docker buildcommand, Docker reads these instructions, executes them, and creates a Dockerimage as a result.

Let’s walk through the process of creating a Dockerfile for our application. Inthe root of your project, create a file named Dockerfile and open this file inyour text editor.

What to name your Dockerfile?

The default filename to use for a Dockerfile is Dockerfile (without a file-extension). Using the default name allows you to run the docker build commandwithout having to specify additional command flags.

Some projects may need distinct Dockerfiles for specific purposes. A commonconvention is to name these Dockerfile.<something> or <something>.Dockerfile.Such Dockerfiles can then be used through the --file (or -f shorthand)option on the docker build command. Refer to the“Specify a Dockerfile” sectionin the docker build reference to learn about the --file option.

We recommend using the default (Dockerfile) for your project’s primaryDockerfile, which is what we’ll use for most examples in this guide.

The first line to add to a Dockerfile is a # syntax parser directive.While optional, this directive instructs the Docker builder what syntax to usewhen parsing the Dockerfile, and allows older Docker versions with BuildKit enabledto upgrade the parser before starting the build. Parser directivesmust appear before any other comment, whitespace, or Dockerfile instruction inyour Dockerfile, and should be the first line in Dockerfiles.

We recommend using docker/dockerfile:1, which always points to the latest releaseof the version 1 syntax. BuildKit automatically checks for updates of the syntaxbefore building, making sure you are using the most current version.

Next, we need to add a line in our Dockerfile that tells Docker what base imagewe would like to use for our application.

Docker images can be inherited from other images. Therefore, instead of creating our own base image, we’ll use the official Node.js image that already has all the tools and packages that we need to run a Node.js application. You can think of this in the same way you would think about class inheritance in object oriented programming. For example, if we were able to create Docker images in JavaScript, we might write something like the following.

class MyImage extends NodeBaseImage {}

This would create a class called MyImage that inherited functionality from the base class NodeBaseImage.

In the same way, when we use the FROM command, we tell Docker to include in our image all the functionality from the node:12.18.1 image.


If you want to learn more about creating your own base images, see Creating base images.

The NODE_ENV environment variable specifies the environment in which an application is running (usually, development or production). One of the simplest things you can do to improve performance is to set NODE_ENV to production.

To make things easier when running the rest of our commands, let’s create a working directory. This instructs Docker to use this path as the default location for all subsequent commands. This way we do not have to type out full file paths but can use relative paths based on the working directory.

Usually the very first thing you do once you’ve downloaded a project written in Node.js is to install npm packages. This ensures that your application has all its dependencies installed into the node_modules directory where the Node runtime will be able to find them.

Before we can run npm install, we need to get our package.json and package-lock.json files into our images. We use the COPY command to do this. The COPY command takes two parameters. The first parameter tells Docker what file(s) you would like to copy into the image. The second parameter tells Docker where you want that file(s) to be copied to. We’ll copy the package.json and package-lock.json file into our working directory /app.

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.Once we have our files inside the image, we can use the RUN command to execute the command npm install. This works exactly the same as if we were running npm install locally on our machine, but this time these Node modules will be installed into the node_modules directory inside our image.

At this point, we have an image that is based on node version 12.18.1 and we have installed our dependencies. The next thing we need to do is to add our source code into the image. We’ll use the COPY command just like we did with our package.json files above.

The COPY command takes all the files located in the current directory and copies them into the image. Now, all we have to do is to tell Docker what command we want to run when our image is run inside of a container. We do this with the CMD command.

Here’s the complete Dockerfile.

Create a .dockerignore file

To use a file in the build context, the Dockerfile refers to the file specified in an instruction, for example, a COPY instruction. To increase the build’s performance, exclude files and directories by adding a .dockerignore file to the context directory. To improve the context load time create a .dockerignore file and add node_modules directory in it.

Build image

Now that we’ve created our Dockerfile, let’s build our image. To do this, we use the docker build command. The docker build command builds Docker images from a Dockerfile and a “context”. A build’s context is the set of files located in the specified PATH or URL. The Docker build process can access any of the files located in the context.

The build command optionally takes a --tag flag. The tag is used to set the name of the image and an optional tag in the format ‘name:tag’. We’ll leave off the optional “tag” for now to help simplify things. If you do not pass a tag, Docker will use “latest” as its default tag. You’ll see this in the last line of the build output.

Windows docker install nodejs

Let’s build our first Docker image.

Windows Docker Install Nodejs

View local images

To see a list of images we have on our local machine, we have two options. One is to use the CLI and the other is to use Docker Desktop. Since we are currently working in the terminal let’s take a look at listing images with the CLI.

To list images, simply run the images command.

Your exact output may vary, but you should see the image we just built node-docker:latest with the latest tag.

Tag images

An image name is made up of slash-separated name components. Name components may contain lowercase letters, digits and separators. A separator is defined as a period, one or two underscores, or one or more dashes. A name component may not start or end with a separator.

An image is made up of a manifest and a list of layers. In simple terms, a “tag” points to a combination of these artifacts. You can have multiple tags for an image. Let’s create a second tag for the image we built and take a look at its layers.

To create a new tag for the image we built above, run the following command.

The Docker tag command creates a new tag for an image. It does not create a new image. The tag points to the same image and is just another way to reference the image.

Now run the docker images command to see a list of our local images.

You can see that we have two images that start with node-docker. We know they are the same image because if you look at the IMAGE ID column, you can see that the values are the same for the two images.

Let’s remove the tag that we just created. To do this, we’ll use the rmi command. The rmi command stands for “remove image”.

Notice that the response from Docker tells us that the image has not been removed but only “untagged”. Verify this by running the images command.

Our image that was tagged with :v1.0.0 has been removed but we still have the node-docker:latest tag available on our machine.

Next steps

In this module, we took a look at setting up our example Node application that we will use for the rest of the tutorial. We also created a Dockerfile that we used to build our Docker image. Then, we took a look at tagging our images and removing images. In the next module, we’ll take a look at how to:


Help us improve this topic by providing your feedback. Let us know what you think by creating an issue in the Docker Docs GitHub repository. Alternatively, create a PR to suggest updates.

containers, images, node.js, node, dockerfiles, node, coding, build, push, run

In the Dockerfile introduction post I introduced a simple Node.js Dockerfile example:

Install Nodejs Docker

NOTE: use double quotes in the CMD line. Single quotes will result in an error.

Let’s use this Dockerfile to build an image, and then run the container.

I’m going to create this file in the dev/docker/examplenode folder. I create a simple Node.js app in the app.js file, using Express:

Super simple, but we have one dependency. I need to add it to the package.json file, so I run

Now you can run node app.js and make sure it works:

Stop this process and let’s create a Docker Image from this.


All you need are the app.js, package.json and package-lock.json files.

And the Dockerfile. Create a Dockerfile file in the same folder, with no extension (not Dockerfile.txt).

You can freely delete the node_modules folder that now contains the Express library and its dependencies, but you can also create a .dockerignore file and add node_modules inside it, to make Docker ignore this folder completely.

Install Nodejs Debian Docker

It works like .gitignore in Git.

Run the command

It will take a while to download the Node image and run npm install, then you’ll get a successful message.

Dockerfile Install Nodejs

It’s important to note that after you first download a base image like the node one we use here, that will be cached locally, so you don’t need to download it again and the image building process will be much faster.

Now we can run a container from the image:

Now you can see the image running in Docker Desktop:

And you can click the “Open in browser” button to open the app running on port 3000:

Just like before! Except now the app is running in its own container, completely isolated, and we can run whatever version of Node we want in the container, with all the benefits Docker gives us.


Install Express

For example you can remove the container and run it on port 80 instead of 3000, with:

Install Nodejs Docker Windows 10

The image does not need to change, all you change is the port mapping. Here’s the result:

  • Most Viewed News

    • Utorrent Not Downloading Mac 2019
    • Nextcloud Docker Tutorial
    • How To Download Google Chrome Macbook Air