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 test productivity 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 ClientDocker ImagesDocker DaemonDocker ContainersDocker 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/PuppetDocker 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:8MAINTAINER [email protected] /tmpADD build/libs/ microservice-employee-service.jar app.jarEXPOSE 8181RUN 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 HubDocker 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 forDockerfile 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 tomcatMAINTAINER [email protected] build/libs/ microservice-employee-web.war /usr/local/tomcat/webapps/EXPOSE 8989CMD ["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 dependenciesSpecify 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: employee container_name: employee ports: - "8181:8080" depends_on: - mongodb#MongoDB container mongodb: image: mongo image: mongo container_name: mongodb expose: - "27017"#Dockerized webapp container acting as external web client for consuming restful web services webapp: build: webapp/ dockerfile: Webapp_Dockerfile dockerfile: 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-4925Email: [email protected]

10

how to dockerize web application using docker compose

Technology