Multistage builds make use of one Dockerfile with multiple FROM instructions. Each of these FROM instructions is a new build stage that can COPY artifacts from the previous stages. By going and copying the build artifact from the build stage, you eliminate all the intermediate steps such as downloading of code, installing dependencies, and testing. All these steps create additional layers, and you want to eliminate them from the final image.
The build stage is named by appending AS name-of-build to the FROM instruction. The name of the build stage can be used in a subsequent FROM and COPY command by providing a convenient way to identify the source layer for files brought into the image build. The final image is produced from the last stage executed in the Dockerfile.
Try taking the example from the previous section that used more than one Dockerfile for the React application and replacing the solution with one file that uses a multistage build.
Dockerfile
FROM node:12.13.0-alpine as build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
FROM nginx
EXPOSE 3000
COPY ./nginx/default.conf /etc/nginx/conf.d/default.conf
COPY --from=build /app/build /usr/share/nginx/htmlThis Dockerfile has two FROM commands, with each one constituting a distinct build stage. These distinct commands are numbered internally, stage 0 and stage 1 respectively. However, stage 0 is given a friendly alias of build. This stage builds the application and stores it in the directory specified by the WORKDIR command. The resultant image is over 420 MB in size.
The second stage starts by pulling the official Nginx image from Docker Hub. It then copies the updated virtual server configuration to replace the default Nginx configuration. Then the COPY –from command is used to copy only the production-related application code from the image built by the previous stage. The final image is approximately 127 MB.
Case Study Lab: Dockerize an Angular Application with Ngnix
we will go through a step-by-step guide on how to write a multi-stage dockerfile to build an angular application using Docker and host the production-ready code in an NGINX container. We will also walk through some of the docker commands used to build, run and monitor the status of containers.
Creating an Angular Application:
In order to proceed with this step, ensure that you have Node.js and Angular CLI installed in your ec2 instance. Installation instructions can be found below
Step 1 – Install Node.js
First of all, you need to install node.js on your system. If you don’t have node.js installed use the following set of commands to add node.js PPA in your Ubuntu system and install it.
Make sure you have successfully installed node.js and NPM on your system
Step 2 – Install Angular/CLI
After installation of node.js and npm on your system, use following commands to install Angular cli tool on your system.
Once the prerequisites are installed, you can start by executing the following commands to create an angular application in a local directory of your preference.
Navigate to the project’s directory, to run the application.
Go to your ipaddress:8001 . Make sure port 8001 is open in your security group
Now that we have an angular application successfully running, let’s start writing a dockerfile for it.
Writing a Dockerfile
Below is the dockerfile snippet we will use to dockerize our angular application with a NGINX server. The dockerfile comprises of a multi-stage docker build, which is divided into the following stages:
- Building the angular source code into production ready output
- Serving the application using a NGINX web server
Stage 1:
FROM– Initializes a new build stage, and sets the latest node image from DockerHub registry as the base image for executing subsequent instructions relevant to the angular app’s configuration. The stage is arbitrarily named asbuild, to reference this stage in the nginx configuration stage.WORKDIR– Sets the default working directory in which the subsequent instructions are executed. The directory is created, if the path is not found. In the above snippet, an arbitrary path ofusr/local/appis chosen as the directory to move the angular source code into.COPY– Copies the source files from the project’s root directory on the host machine to the specified working directory’s path on the container’s filesystem.RUN– Executes the angular build in a new layer on top of the base node image. After this instruction is executed, the build output is stored underusr/local/app/dist/sample-angular-appand the compiled image will be used for the subsequent steps in theDockerfile.
Stage 2:
FROM– Initializes a secondary build stage, and sets the latest nginx image from dockerhub registry as the base image for executing subsequent instructions relevant to nginx configuration.COPY– Copies the build output generated in stage 1 (--from=build) to replace the default nginx contents.EXPOSE– Informs Docker that the nginx container listens on network port 80 at runtime. By default, the nginx server runs on port 80, hence we are exposing that specific port.
Running the Docker Container
In order to build and run the docker container, open up a command prompt and navigate to the location of your Dockerfile in your project’s directory.
Execute the following command to build the docker image.
The file path . defines the location of the Dockerfile in the current directory, and the -t argument tags the resulting image, where the repository name is krish186/sample-angular-app-image and the tag is latest.
After the build is successfully finished, we can check to see if it appears in the list of docker images available locally. To do so, we can execute the below command.
Output:
Now that we see our container is in the list, we can run the image using following command.
The -d option, causes Docker to detach the container and have it run in the background. The -p argument establishes a port mapping, which defines that port 80 of the docker container (as specified in dockerfile), should be exposed to port 8080 of our host machine.
To check the details of our running container, type in the following command:
Output:
As per the above output, we see that the container is up and running. If we now head to ipaddress:8080/ we can see the angular application is successfully dockerized.
Now that the application is running as expected, our next step would be to push our image to an image repository, to deploy our containers to a cloud service.
If you have a DockerHub account you can execute the following commands:
Your image should now be pushed successfully to the Dockerhub registry.
+ kubectl get nodes /var/lib/jenkins/workspace/test@tmp/durable-fd334313/script.sh: line 1: kubectl: command not found