Docker is an open-source tool designed to help programmers in development and deployment. It makes use of a structure called "container" which wraps the application and its dependencies together so that it can be executed on any machine. This is particularly important when have to deal with different servers - testing, integration, production - where the applications must run without any error or compatibility issue.
In this tutorial I will explain how to dockerize an Angular application for different target environments.
Set up custom environments in Angular
By default, Angular provides two different environment files, that can be found in the environments
folder:
Let's add a couple more! Create two new files named environment.test.ts
and environment.int.ts
and replace in there your urls with the ones you want to use for the target environment. Here is my environment.int.ts
:
export const environment = {
production: false,
name: 'int',
functionUrls: {
data1: 'my-data1-int-url',
data2: 'my-data2-int-url'
}
};
Then we need to tell Angular that we have new build configurations: edit the angular.json
file and create new entries under architect → build → configuration
. As you can see, the production and local (serve) entries are already present.
When inserting a custom environment we only need to notify the framework to replace the default environment.ts
with the one we want at build-time, so in principle it is sufficient to add the following:
"int": {
"fileReplacements": [
{
"replace": "src/environments/environment.ts",
"with": "src/environments/environment.int.ts"
}
],
},
We can customize the build options by adding extra settings. Refer to the official documentation for further details.
As a last step, let's edit the package.json
and write some commands to build the app more easily:
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build",
"build-test": "ng build --configuration=test",
"build-int": "ng build --configuration=int",
"build-prod": "ng build --prod",
"test": "ng test",
"lint": "ng lint",
"e2e": "ng e2e"
},
Let's build our app!
Open a terminal and from the main project folder run npm build-int
. This will build the application for the int environment. Your output is located into the dist
folder in your project, ready to be deployed on a server.
If you want, you can test it using http-server
. Install it with:
npm install http-server -g
Run it with:
http-server ./dist
It will start serving your project from the dist
folder.
Integrate Docker
Now that we can build a project for different environments, it's time to integrate Docker and run the application in a container. First, create a docker
folder inside the project, which will contain all the docker-related files. Then create a docker-compose
file for each environment: docker-compose.int.yml
for integration , docker-compose.test.yml
for testing and so on. These files look like the following:
version: '3.3'
services:
myapp:
image: myapp
build:
context: ../
dockerfile: docker/Dockerfile
args:
PROFILE: int
ports:
- "8080:80"
What's important to notice here is the line
PROFILE: int
were we define the environment we want to use: we'll inject this variable in the Dockerfile
in a moment.
Let's create the Dockerfile
:
FROM node:12.16.1-alpine As builder
### STAGE 1: Build ###
WORKDIR /usr/src/app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
ARG PROFILE
ENV PROFILE $PROFILE
RUN echo "Environment: ${PROFILE}"
RUN npm run build-${PROFILE}
### STAGE 2: Run ###
FROM nginx:1.15.8-alpine
COPY --from=builder /usr/src/app/dist/myapp/ /usr/share/nginx/html
COPY --from=builder /usr/src/app/docker/nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
In stage one we build the application and restore the node_modules
. As you can see, we use the PROFILE
variable we defined above to retrieve the correct environment.
In stage two we run the application using nginx, which is an http and reverse proxy server. By default, nginx http server listens for incoming connection on port 80, which represents the standard web port. In the docker-compose
we match that port with 8080.
In addition, note that here
COPY --from=builder /usr/src/app/docker/nginx.conf /etc/nginx/conf.d/default.conf
we replace the default nginx configuration with ours. To do so, we need to create one last file in our docker
folder, called nginx.conf
:
server {
listen 80;
location / {
root /usr/share/nginx/html;
index index.html index.htm;
try_files $uri $uri/ /index.html =404;
}
}
All games are done! Let's try to make this work.
If we want to build and run the configuration for integration, we only need to run the following commands in a terminal:
docker-compose -f docker/docker-compose-int.yml build
docker-compose -f docker/docker-compose-int.yml up
The up
command will append the console at a message saying Attaching to...
, then it goes to print logs.
Navigate to localhost:8080
to check the outcome.
Top comments (0)