Nebula Graph is an open-source distributed graph database: https://github.com/vesoft-inc/nebula
If there are top ten buzzwords in the technology industry in the year of 2019, container is sure to be one of them. With the popularity of Docker, more and more scenarios are using Docker in the front-end field. This article shows how do we use Docker in the visualization interface of Nebula Graph, a distributed open source graph database.
Docker is widely used in daily front-end development. Nebula Graph Studio (A visualization tool for Nebula Graph) uses Docker based on the following considerations:
We need to build an image first before hosing our services with Docker. Here we need a configuration file named Dockerfile that contains descriptions of the building steps. To be brief, we need to copy the project into the image and set the startup method:
# Select base image FROM node:10 # Set work directory WORKDIR /nebula-web-console # Copy the current project to the /nebula-web-console directory of the image ADD . /nebula-web-console # Download front-end dependency in the image RUN npm install # Run the building RUN npm run build EXPOSE 7001 # Deployment commands executed when the image starts CMD ["npm", "run", "docker-start"]
The above configuration file will build a Docker image with a size of about 1.3GB, which looks a bit scary because downloading is too time-consuming even with a fast network. That is totally unacceptable.
After some research, we learned some tips that help reduce Docker image size.
1. Using Smaller Base Image
Docker base image (for example, the above mentioned node:10) is the basic image on which you add layers and create a final image containing your applications. There are multiple versions of the Node.js image on DockerHub, and each of them share a different internal environment. For example, the alpine version is a more simplified Linux system image that removes some tools like bash, curl etc. to decrease size.
Based on our needs, we change the base image to alpine and rebuild to reduce the docker image from 1.3GB to 500MB+. So if the docker image you are building is too large, you can replace the basic image.
2. Multi-stage Build
Multi-stage build in docker is a new feature introduced in docker 17.05. It is a method to reduce the image size, create a better organization of docker commands, and improve the performance while keeping the dockerfile easy to read and understand.
3. Docker Building Principle
In short, multi-stage build is dividing the dockerfile into multiple stages to pass the required artifact from one stage to another and eventually deliver the final artifact in the last stage. This way, our final image won’t have any unnecessary content except our required artifact. Let’s consider an example:
# Set up the image generated in the first step and name it builder FROM node:10-alpine as builder WORKDIR /nebula-web-console # Copy the current project to the image ADD . /nebula-web-console # Start building RUN npm install RUN npm run build .... # Start the second step build FROM node:10-alpine WORKDIR /nebula-web-console # Copy the product of the first step image to the current image. Only one image layer is used here, which saves the number of image layers in the previous building step. COPY --from=builder . /nebula-web-console CMD ["npm", "run", "docker-start"]
Similar to the well known .gitignore that ignores unnecessary (such as document files, git files, node_modules, etc) files when using COPY or ADD command to copy or add files, we can use .dockerignore to specify files to be ignored.
5. Merging Multiple Layers Into One
When building a Docker image with a Dockerfile, each operation adds a new layer based on the previous step image. We can use & to merge multiple operations to reduce layers. For example:
# The two operations represent two layers RUN npm install RUN npm run build
Merge the above command to one:
# It becomes a single layer with & RUN npm install && npm run build
6. Regular Front-End Optimization
npm install --production
The above suggestions are only for your reference. You can migrate more regular front-end optimizations to the image given that image building itself is an environment for running code.
Also published here.
Create your free account to unlock your custom reading experience.