How to Dockerize Web Application using Docker Compose

Enhancing the application development process in all its phases—building, scaling, shipping, deploying
and running—plays a vital role in today’s competitive IT industry by shortening the time between writing
code and running it. Moreover, the methodologies of DevOps and such container virtualization tech-
nologies as Docker make adopting microservice architecture style with reduced risk and complexity vir-
tually effortless. It is significantly easier to achieve the state of continuous deployment, monitoring and
delivery using Docker.
Before we look into the steps of dockerizing web applications, let us quickly understand some of
Docker’s fundamentals.
Shipping an application into containers is popularly known as “Dockerizing”. Dockerizing offers several
substantial benefits. Here are some ways Docker container technology proves beneficial in day-to-day
software development and testing:
Containers provide an isolated and secure
application platform for running an applica-
tion. They also isolate applications from one
another and the underlying infrastructure,
while providing an added layer of protec-
tion for the application.
Containers can help eliminate a lot of
issues related to configuration, environment
setup, application setup and more. Most of
these issues tend to occur due to configu-
ration differences in development, testing
and production environment stages, and
cause the deployment to fail.
Containers enhance the overall process of
developing, shipping, testing and deploying
the code in different environments, and
make the process very convenient for
various stakeholders. This convenience
creates self-service development and
testing environments, and enhances overall
productivity of software developers and testproductivity of software developers and test
engineers.
Copyright © 2016 Evoke Technologies. All rights reserved 1

Docker Client
Containers Containers
Docker Host
Docker Daemon
Docker build
Docker pull
Docker run
Docker Registry
Tomcat
Ubuntu
CentOS
The diagram below represents a high level architecture of Docker, showing these key Docker building
blocks:
Docker Client
Docker Images
Docker Daemon
Docker Containers
Docker Registry
------------
---------------
----------
---------------
----------------------------
---------------------
-----------------------------------
..............
...
.........
......
....

Here are some of the common commands one would come across while working with Docker images:
One of the biggest advantages of using Docker containers is the creation of self-service development
and test environments, along with the deployment of software packages. To realize this advantage,
one must first figure out distinct ways in which Docker containers representing multiple application
components (web servers, hosting web application and services, databases and so on) can be
orchestrated.
Two approaches for orchestrating multiple containers to create self-service development and testing
environments are:
In this white paper, we will demonstrate how to use Docker compose to orchestrate multiple contain-
ers for creating self-service development/test environments.
The application use case demonstrated in this paper is a Java-based web application that calls a
microservice to retrieve data from MongoDB. A traditional scenario would use dedicated software
development and testing environments that need to be configured as appropriate whenever new
releases are made. This white paper will demonstrate the following, Dockerized method:
We will use Docker compose to orchestrate these containers. The outline below represents required
steps in dockerizing a RESTful web service built using a Spring Boot application.
Docker containers with configuration management tools such as Ansible/Chef/Puppet
Docker compose tool to orchestrate Docker containers
A Java web application will run within a Docker container. This web application will invoke a Spring
Boot microservice.
The Spring Boot microservice will run within another container. This RESTful service preserves its data
in MongoDB.
The MongoDB will run within another container.
Used to build images using
the instructions from
Dockerfile.
Used to fetch the Docker
image from the Docker regis-
tries. In the example shown in
this white paper, the Docker
client interacts with Docker
registries via the Docker
daemon to pull the existing
CentOS image.CentOS image.

Build a Maven-based Spring Boot employee microservice RESTful application. The service will be
exposed over a certain URI (Uniform Resource Identifier). The service saves the data in MongoDB that
runs in another container. Build a WAR file of the above application and place it in a desired location,
specified in the Dockerfile.
To run the application in a Docker container, create a Dockerfile consisting of a set of instructions to
build the image. Once the Dockerfile is created, it could be used to build an image for this service.
Here is a sample Dockerfile representing the image of this service.
Note these important points about the Dockerfile above:
FROM java:8
MAINTAINER apandiri@evoketechnologies.com
VOLUME /tmp
ADD build/libs/ microservice-employee-service.jar app.jar
EXPOSE 8181
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Dspring.data.mongodb.uri=mongodb://mongodb/micros", "-ENTRYPOINT ["java","-Dspring.data.mongodb.uri=mongodb://mongodb/micros", "-
Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

[“java”,"-Dspring.data.mongodb.uri=mongodb://mongodb/micros" ,“-Djava.security.egd=-
file:/dev/./urandom”,“-jar”,“/app.jar”]: execute our fat-jar (urandom is for Tomcat source of entropy)
"-Dspring.data.mongodb.uri=mongodb://mongodb/micros", this environment variable for connecting
to mongodb service which we are going to create using Docker-Compose and the data base name
is micros.
A variable dev/./urandom added to reduce the tomcat start time /app.jar is our jar file to be run.
Djava.security.egd=file:/dev/./urandom for running Spring Boot application
Dockerfile consists of a set of instructions to build an image.
As represented in the diagram above, the build command is used to build an image A, per the
instruction provided in Dockerfile. Additionally, the image A can be pushed in Docker hub using the
push command.
The pushed image A can be fetched using the Docker pull command.
A container can be created from the run command. The above illustration depicts how the run
command was used to create container A from the image A.
Operations that can be performed on container A include start, stop and restart
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-----------------------------------
-----------------------------------
----------------------------------
- - -
Start, Stop, Restart
Commit
Build
Run
Pull
Push
Docker Host
Repository
Image A
Docker Hub
Docker Daemon
Image A
Container ADocker File

Dockerizing a Spring web application would simply mean starting a Spring web application within a
Docker container. One of the key benefits of this approach is that one could build an image once
and then start the Spring web application container as and when required for development and
training purposes. In cases where the Spring web application is part of a bigger enterprise applica-
tion, it brings a lot of benefits in terms of self-service, on-demand development and testing setup,
thereby enhancing the overall productivity of software developers and test engineers.
In this white paper, we have shown how one can build a maven-based Spring web application that
runs on Tomcat. For this, one would be required to build a WAR file and place it in a desired location
(by default, webapps) under Tomcat installation.
$ docker build –t <username>/
<Repositoryname>:<tagname>.
Specifying the <username>/<Repositoryname>
:<tagname> as employee and “.”to look for
Dockerfile in the current directory.
$ docker images
$ docker run –d –name container_name
image_name
$ docker exec -it container_name /bin/bash
$ docker ps
$ docker ps -a
$ docker stop $(docker ps)
$ docker rm $(docker ps -a)
$ docker rmi $(docker images)
FROM tomcat
MAINTAINER apandiri@evoketechnologies.com
ADD build/libs/ microservice-employee-web.war /usr/local/tomcat/webapps/
EXPOSE 8989
CMD ["catalina.sh", "run"]

Dockerizing MongoDB would mean starting a MongoDB within a Docker container. This is accom-
plished using one of the following methods:
In most cases, the first method would suffice. The following commands represent the steps to docker-
ize MongoDB:
Using the Docker compose technique, one could easily start MongoDB within a container and also
link it with other containers. Take a look at the command below:
# Usage: docker pull <user-name>/<repository>
$ docker pull mongo
# Usage: docker build –t <user-name>/<repository> <Dockerfile_location>
$ docker build –t mongo .
# dot “.”defines the Dockerfile in current directory location
# Usage: docker run - p <port mapping> --name <name for container> -d <user-name>/<repository>
$ docker run -p 27017:27017 --name mongo_container -d mongo_image
version: '2'
services:
#Creating MongoDB container from mongo image
mongodb:
image: mongo
container_name: mongodb
expose:expose:
- "27017"
Using Docker compose, one can orchestrate more than one container. The following can be defined
in a YAML file in relation with running multiple containers:
Pulling a MongoDB image directly from the public Docker registry and running a container using
this image.
Building a custom MongoDB image using Dockerfile and then running a container using this
image.

To demonstrate the benefits of Docker compose, the example below specifies three containers,
namely employee, web app and MongoDB containers in a docker-compose.yml file.
Docker Compose file defines services which get started in an interactive mode using “docker-com-
pose up”command. Based on the order the dependencies are declared under “depends_on”in the
docker-compose.yml file, the chosen service, starts first followed by others. In docker-compose file
shown below, the service creation order will be first MongoDB, followed by employee service and
To run all the containers at once interactively and also to find out in which order containers are being
created, use the below command and use –d to start all the containers in the background:
To monitor log output of all the containers, make use of the following command:
$ docker-compose up
$ docker-compose up –d
$ docker-compose logs
In order to stop the running containers, one could use the command given below. Further, it should
be noted that the order of exiting the containers is in the reverse order of their creation.
Specify images,
Specify configurations,
Specify how containers will link,
Specify container dependencies
Specify all ports that needed to be exposed

version: '2'
services:
# Dockerized employee microservice container for exposing services
employee:
build: employee/
dockerfile: Employee_Dockerfile
container_name: employeecontainer_name: employee
ports:
- "8181:8080"
depends_on:
- mongodb
#MongoDB container
mongodb:
image: mongoimage: mongo
container_name: mongodb
expose:
- "27017"
#Dockerized webapp container acting as external web client for consuming restful web services
webapp:
build: webapp/
dockerfile: Webapp_Dockerfiledockerfile: Webapp_Dockerfile
container_name: webapp
ports:
- "8989:8080"
depends_on:
- employee
$ docker-compose stop
$ docker-compose rm --all
To remove all the containers

example quoted above MongoDB and employee containers will be created first and subsequently
webapp is created.
Here MongoDB container is created by consuming the Mongo image published by another in Docker
hub and this will get exposed on port 27017. Navigate to the folder where docker-compose.yml file, all
the respective dockerfiles and JAR files of webapp and RESTful services application have been placed.
Copyright © 2016 Evoke Technologies. All rights reserved
Stay Connected: /EvokeTechnologies | /EvokeUS | /company/evoke-technologies | /+EvoketechnologiesUS
7106 Corporate Way, Dayton, OH - 45459, United States
Sales: +1 (937) 660-4925
Email: sales@evoketechnologies.com
10

How to Dockerize Web Application using Docker Compose

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to How to Dockerize Web Application using Docker Compose (20)

Recently uploaded (20)

How to Dockerize Web Application using Docker Compose