Spring Boot Microservices with Docker | Dockerfile |docker-compose.yml

As you can see we have successfully pushed spring boot docker image to Docker Hub.

4. Run the docker image with and without profiles

Let's run the docker image which we have build in the previous step.

1docker run -p 8080:8080 -t rahulwagh17/jhooq-docker-demo:jhooq-docker-demo

Run the docker image using profiles

1docker run -e "SPRING_PROFILES_ACTIVE=prod" -p 8080:8080 -t rahulwagh17/jhooq-docker-demo:jhooq-docker-demo

5. Using docker-compose build and docker-compose up -d

Before we go ahead and start digging into docker-compose there is a couple of question which might pop-up in your mind.

Why we need docker-compose when we have Dockerfile ?

What docker-compose do?

We will answer this question later but the first thing about docker-compose is not shipped along with the Docker. This means you need to install the docker-compose separately onto your machine based on the operating system you are using.

Here is the official docker-compose installation document from Docker

Since I am using Ubuntu, so this is how I installed it on my Ubuntu machine

For Ubuntu

1sudo apt  install docker-compose

Mac

There is Docker Desktop for Mac which can be download from here

Windows

For windows also there is Docker Desktop and it can be download from here

So now we have installed docker-compose, next we need to create docker-compose.yml

docker-compose.yml

 1version: '3'
 2
 3services:
 4  jhooq-springboot-container:
 5    image: jhooq-spring-boot-docker-compose:1
 6    build:
 7      context: ./
 8      dockerfile: Dockerfile
 9    volumes:
10      - /data/jhooq-springboot-container
11    ports:
12      - "8080:8080"</code></pre>

1. Understanding the docker-compose.yml

1. services - We have defined service with the name jhooq-springboot-container
2. Dockerfile - It is using existing Docker and the image build from it
3. 8080:8080 - It's port forwarding we are going to forward the docker container port to the host machine(ubuntu).
4. volumes - In short, it's a directory to save the image data and this directory can be used by multiple containers. In our case, we are going to create directory /data/jhooq-springboot-container and we are going to store the data for image - jhooq-spring-boot-docker-compose:1

Lets run some docker-compose commands on your terminal

2. Build and tag the image using docker-compose build

 1docker-compose build
 2```bash
 3
 4```bash
 5Building jhooq-springboot-container
 6Step 1/6 : FROM openjdk:8-jdk-alpine
 78-jdk-alpine: Pulling from library/openjdk
 8Digest: sha256:94792824df2df33402f201713f932b58cb9de94a0cd524164a0f2283343547b3
 9Status: Downloaded newer image for openjdk:8-jdk-alpine
10 ---> a3562aa0b991
11Step 2/6 : ARG JAR_FILE=build/libs/*.jar
12 ---> Using cache
13 ---> 524b6f520504
14Step 3/6 : COPY ${JAR_FILE} app.jar
15 ---> Using cache
16 ---> 9a77a2eb4a48
17Step 4/6 : RUN mkdir destination-dir-for-add
18 ---> Using cache
19 ---> 495906d31e45
20Step 5/6 : ADD sample.tar.gz /destination-dir-for-add
21 ---> Using cache
22 ---> 1fcfc28fa92a
23Step 6/6 : ENTRYPOINT ["java","-jar","/app.jar"]
24 ---> Using cache
25 ---> 348e0d3e7309
26Successfully built 348e0d3e7309
27Successfully tagged jhooq-spring-boot-docker-compose:1

As you can see from the logs we have successfully build the image and tagged it with - jhooq-spring-boot-docker-compose:1

3. Run the docker container using docker-compose up -d

After building the image successfully now you can run the container using the following command

1docker-compose up -d

1Creating network "jhooq-k8s_default" with the default driver
2Creating jhooq-k8s_jhooq-springboot-container_1 ... done

Now you can check the status of the container as well as the port on which it running

1docker ps -a

1CONTAINER ID        IMAGE                                COMMAND                CREATED             STATUS              PORTS                    NAMES
2794e4a93f514        jhooq-spring-boot-docker-compose:1   "java -jar /app.jar"   18 minutes ago      Up 18 minutes       0.0.0.0:8080->8080/tcp   jhooq-k8s_jhooq-springboot-container_1

As you can see your container is up and running using docker-compose commands.

Let's test our microservice

1curl http://localhost:8080/hello

1Hello - Jhooq-k8s

Now we can answer our question - Why we need docker-compose when we have Dockerfile?

Answer -

1. docker-compose is helpful when you want to create more than one container using the same docker-compose.yml
2. docker-compose helps you to create multi-container application
3. Using docker-compose you can spin desired number of containers but on the other hand it is not possible with simple Dockerfile
4. It also helps you to define the volume so that volume can be shared by multiple containers.

Dockerfile - It will hep you manage single container docker-compose - You can manage multiple container using single docker-compose

5. docker-compose scale service

With docker-compose you can scale up the kubernetes services using the same docker-compose.yml. The only thing which you need to be careful is port number because once you start scaling up your services, you will need more ports to run your service.

So to overcome the problem of defining new ports for scaling up the service, docker-compose provides port ranges which can be defined in the docker-compose.yml

Here is docker-compose.yml with port range 8080-8100

 1version: '3'
 2
 3services:
 4  jhooq-springboot-container:
 5    image: jhooq-spring-boot-docker-compose:1
 6    build:
 7      context: ./
 8      dockerfile: Dockerfile
 9    volumes:
10      - /data/jhooq-springboot-container
11    ports:
12      - "8080-8100:8080"

Now you can easily scale up the service.

But before you scale up it is always recommended to build the image once again

1docker-compose build

Here is command to scale up the service

1docker-compose scale jhooq-springboot-container=2

1WARNING: The scale command is deprecated. Use the up command with the --scale flag instead.
2WARNING: The "jhooq-springboot-container" service specifies a port on the host. If multiple containers for this service are created on a single host, the port will clash.
3Starting jhooq-k8s_jhooq-springboot-container_1 ... done
4Creating jhooq-k8s_jhooq-springboot-container_2 ... done

Now we have scaled up our service ”jhooq-springboot-container” and its running two containers on port 8080 and 8081.

6. docker-compose stop and docker-compose rm

After you are done with your container and you no longer need that container. So you can use stop and then remove the container.

Here the docker-compose commands which can be used -

1. Stop container using docker-compose stop

1docker-compose stop

1Stopping jhooq-k8s_jhooq-springboot-container_2 ... done
2Stopping jhooq-k8s_jhooq-springboot-container_1 ... done

As you can see it had stopped both the container

2. Remove the container using docker-compose rm

Here is the command to remove

1docker-compose rm

1Going to remove jhooq-k8s_jhooq-springboot-container_2, jhooq-k8s_jhooq-springboot-container_1

1Are you sure? [yN] y

1Removing jhooq-k8s_jhooq-springboot-container_2 ... done
2Removing jhooq-k8s_jhooq-springboot-container_1 ... done

Now we have removed all the container.

7. Lab Session

{#step-6}