In the fast-paced world of Node.js development, efficiency and consistency are paramount. Setting up Node.js environments across different machines can be a daunting task, often plagued by configuration issues and dependency conflicts. However, with Docker, developers can simplify the process and ensure a seamless development experience. In this guide, we’ll explore how to set up a Node.js environment using Docker, enabling you to streamline your development workflow and focus on building great applications.

Before we delve into setting up Node.js with Docker, let’s ensure you have Docker installed on your system.

Below is a screenshot illustrating the basic file structure of my demo project.

Here’s a breakdown of what i’ve done with the docker-compose.yml file:

version: "3"
services:
  santest:
    build:
      context: /Users/username/PROJECTS/DEMO/Demo/santest
      dockerfile: Dockerfile
      args:
        - PORT=${API_GATEWAY_PORT}
    restart: always
    hostname: santest
    env_file:
      - .env
    ports:
      - ${PORT}:${PORT}
      - ${INSPECTOR_PORT}:${INSPECTOR_PORT}
    volumes:
      - /Users/username/PROJECTS/DEMO/Demo/santest:/var/www/santest
      - /var/www/santest/node_modules

1. Version Declaration: You’re using version 3 of the Docker Compose file syntax.
2. Service Definition: You define a service named “santest” which represents your demo project.
3. Build Configuration:
   • context: Specifies the build context directory containing the Dockerfile and any files needed for the build process.
   • dockerfile: Specifies the name of the Dockerfile to use for building the image.
   • args: Passes arguments to the Docker build process, here setting the PORT variable using the value of API_GATEWAY_PORT.
4. Restart Policy: restart: always ensures that the container restarts automatically if it stops for any reason.
5. Hostname: Sets the hostname of the container to “santest”.
6. Environment Variables: Loads environment variables from the .env file into the container.
7. Port Mapping: Maps the ports specified by ${PORT} and ${INSPECTOR_PORT} on the host machine to the same ports inside the container.
8. Volume Mapping: Maps directories on the host machine to directories inside the container, allowing for persistent storage. Specifically, it maps the project directory and the node_modules directory to corresponding directories within the container.

This configuration sets up your Docker environment to run your demo project with the specified settings and dependencies.

NODE_ENV=local
BASE_URI=http://localhost
PORT=3000
INSPECTOR_PORT=9233
API_GATEWAY_PORT=3000

Here’s the code:

FROM node:14.8.0-alpine

# Create project directory in the container
RUN mkdir -p /var/www/santest/

# Copy package.json and package-lock.json to project directory
COPY package*.json ./var/www/santest/

# Set working directory
WORKDIR /var/www/santest

# Install global npm packages
RUN npm install -g npm@6.14.7 nodemon

# Install project dependencies
RUN npm install

# Set PATH environment variable
ENV PATH /var/www/santest/node_modules/.bin:$PATH

# Copy all files from current directory to project directory in container
COPY . .

# Expose the port specified in the .env file
EXPOSE ${PORT}

# Command to start the application
CMD ["npm", "start"]

Users/username/PROJECTS/DEMO/Demo/

Run the following command to build the Docker image and start the container:

docker-compose up --build

This command will instruct Docker Compose to:

• Build the Docker image using the instructions specified in the docker-compose.yml file.
• Create and start a container based on the built image.

Make sure you have Docker Compose installed and configured properly on your system. Once the process completes, your demo project should be up and running inside a Docker container, accessible as per the configurations you’ve set up.

Please refer to the screenshot below, captured after executing Docker Compose in my environment.

After successfully building the container, I can view it in the Docker Desktop application. The project’s container name is visible in the Docker Desktop interface, as shown in the screenshot below:

You’re welcome to explore my GitHub repository, where you’ll find the source code for this demo project, offering a valuable reference point for your own projects. Github Link

Conclusion

In this blog post, we’ve explored the process of deploying a Node.js project using Docker, a popular containerization platform. Here’s a summary of the key points covered:

1. Setting Up Docker Environment:
   • Installed Docker Desktop on MacOS or Windows.
   • Created a docker-compose.yml file defining the project’s Docker configuration, including service definitions, environment variables, port mappings, and volume mappings.
2. Project Structure and Dockerfile:
   • Examined the project folder structure, including the presence of an .env file containing basic environment parameters.
   • Created a Dockerfile specifying the steps to build the Docker image for the Node.js project, including setting up the project directory, installing dependencies, and defining the command to start the application.
3. Building and Running the Docker Container:
   • Used the docker-compose up --build command to build the Docker image and start the container based on the defined configuration.
   • Verified the successful creation and running of the container using Docker Desktop application.
4. Accessing the Application:
   • Accessed the running application via the specified URL (e.g., localhost:3000), confirming that the application is successfully deployed and accessible.

By leveraging Docker, we’ve streamlined the process of deploying our Node.js project, ensuring consistency across different environments and simplifying the deployment workflow. Docker’s containerization approach offers portability, scalability, and ease of management, making it an invaluable tool for modern application development and deployment.