How to build and deploy Node project with Docker

I did a full-stack node project some time ago, and the server-side technology stack was nginx + koa + postgresql. It was quite troublesome to set up the environment and deploy on CentOS. I deployed the test server and then deployed the production environment server when it went online. There are a lot of "physical work" involved that is boring, energy-consuming and thankless. So we started thinking about how to automate this part of the build and deployment work, which led to Docker.

What is Docker

Docker is a virtualization technology that is even lighter than a virtual machine. The entity it virtualizes is called a container. The container itself is a sandbox with isolated scope. It only contains basic libraries and the services it carries, which is very streamlined. Once the container is running, it is just a process in the host machine and occupies very few resources. This creates conditions for running container clusters on the operating system, with excellent operability and flexibility.

What is the relationship between images and containers? You can think of an image as a class and a container as an object. A container is generated by instantiating an image. Of course, one image can generate multiple containers.

Client-side Docker

If not on the server, how do we use Docker on the client? Docker Desktop can be used on Windows and OSX, plus Kitematic, both of which are desktop management tools and are very convenient for general operations. Docker Desktop and Kitematic only visualize some operations, and the command line is still necessary because many operations can only be performed using the command line.

Basic Docker Operations

Image Name

Regarding the image tag, for example, nginx:1.19.0-alpine, 1.19.0 is the version number of nginx, and alpine is the code name of the OS.

• Jessie: debian 8
• Stretch: debian 9
• Buster: debian 10
• Alpine: Alpine is recommended because it is very small.

Alpine is the smallest version, and some are even a quarter of the size of other versions. This means that images are built faster and run more efficiently because fewer components are loaded, which in turn means fewer vulnerabilities and greater security.

Pull the image

docker pull nginx:1.19.0-alpine

Start the container

• --name web: specifies the container name as web
• -p 8080:80: The container nginx listens on port 80, which is mapped to the local port 8080
• -v xxxx:xxxx: Here is the local configuration file mapped to the container nginx configuration file
• -d: Run in the background
• nginx:1.19.0-alpine: the image used

docker run --name web -p 8080:80 -v /usr/etc/nginx/nginx.conf:/etc/nginx/nginx.conf:ro -d nginx:1.19.0-alpine

Other operations

• docker images #Show images
• docker rmi xxx #delete the image
• docker ps #Show running containers
• docker rm xxx #delete container

Dockerfile

A more convenient way to build an image is to use Dockerfile, which is the configuration file of the image. As long as you have Dockerfile, you can build the image at any time. The following is to build a very simple nginx image, from is the base image used during construction:

FROM nginx
COPY nginx.conf /etc/nginx/nginx.conf

Docker-compose

When our project has not only a single container, but needs to run multiple containers, and the containers need to communicate with each other, more powerful management tools are needed. For example, k8s, but for our current small project, the official Docker-compose is enough.

First, you need a docker-compose.yml configuration file. For example, the following is a template for two containers. Image indicates the image used, ports indicates port mapping, and volumes indicates the data volumes that need to be mapped:

version: "3"

services:
  webapp:
    image: web
    ports:
      - "8080:80"
    volumes:
      - "/data"
  redis:
    image: "redis:alpine"

Then you can use the following command line:

docker-compose build [options] [SERVICE...] #Build (rebuild) the service container in the project docker-compose up -d # Run the compose project, background execution

docker-compose up is a very powerful command that will try to automatically complete a series of operations including building images, (re)creating services, starting services, and associating service-related containers. The linked services will be started automatically unless they are already running. It can be said that most of the time you can directly start a project through this command.

Build the nginx-node-postgres project

With the above foundation, we can then build our own project. First, the Dockerfile of the node service mainly does the following steps

• Create a container working directory
• Copy the relevant configuration files to the container
• Install npm packages in the container
• Run pm2 to start the container

FROM node:14.5.0-alpine3.12
# Working directory WORKDIR /usr/src/app
# Copy the configuration file COPY package*.json ./
COPY process.yml ./
RUN npm set registry https://registry.npm.taobao.org/ \
  && npm install pm2 -g \
  && npm install
# Use pm2 to manage CMD ["pm2-runtime", "process.yml", "--only", "app", "--env", "production"]
EXPOSE 3010

Then configure docker-compose.yml

• The db configuration is the postgres database, where the data volumes maps the database directory and initialization steps
• app is configured with node service, where build is the directory where the dockerfile is located; depends_on indicates the dependent container and the order of startup. Here, db is started first and then node; links indicates mapping the db name to the app container
• The nginx container depends_on on the app container and configures the service of the forwarding node

version: '3'

services:
  db:
    image: postgres:12.3-alpine
    container_name: postgres
    environment:
      - TZ=Asia/Shanghai
      - POSTGRES_PASSWORD=xxxx
    volumes:
      - ./postgres/data:/var/lib/postgresql/data
      - ./postgres/init:/docker-entrypoint-initdb.d
    ports:
      -5432:5432
    restart: always #Always restart, the recommended configuration in production environment is always
    expose:
      - 5432
      
  app: 
    image: koa-pg
    container_name: koa
    volumes:
      - ./dist:/usr/src/app/dist
      - ./logs:/usr/src/app/logs
    build: ./
    environment:
      - TZ=Asia/Shanghai
    restart: always
    depends_on:
      -db
    links:
      -db
    expose:
      - 3010
      
  nginx:
    image: nginx:1.19.0-alpine
    container_name: nginx
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    ports:
      -8080:80
    environment:
      - TZ=Asia/Shanghai
    restart: always
    depends_on:
      - app
    links: # host name instead of ip to configure nginx forwarding - app
    expose:
      - 8080

After configuring our project, the next step is to run it

docker-compose up

This is the case on our local development machine, and it is also the case when deploying to a server. You can deploy as many servers as you want. As long as Docker is installed, it can be solved with just one command line.

To start a few containers, modify the configuration of docker-compose.yml and run docker-compose up again. So easy!

This is the end of this article about the steps to build and deploy a Node project with Docker. For more information about building and deploying Node with Docker, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!