Deploy Simple Java Application using Docker Compose.

divine kenechukwu — Sat, 14 Sep 2024 21:28:37 +0000

Goal
The goal of this project is to create Docker Compose Stack to deploy a simple Java application running in Containers 3-Tier Architecture.

Pre-Requisites

Create AWS EC2 (Amazon Linux) Instance in Public Subnet with any desired Instance Type
Allow Port 80 in Security Group
Apache Maven Build Artifact (.war)
Install docker and run docker service
Install docker-compose
Application Source Code Java

Step 1: Set Up the Environment:

1. Create an Amazon Linux EC2 Instance:

Launch an EC2 instance in a public subnet.
Choose any instance type, such as t2.micro for testing.
Allow port 80 (HTTP) in the security group.

2. Install Docker and Docker Compose on the EC2 Instance:

- Docker:

sudo yum update -y

sudo yum install -y docker

sudo service docker start

sudo usermod -a -G docker ec2-user

- docker-compose:

sudo curl -L https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

docker-compose version

3. Install Java and Apache Maven (for building the Java application):

curl -LO https://corretto.aws/downloads/latest/amazon-corretto-11-x64-linux-jdk.tar.gz

sudo tar -xvzf amazon-corretto-11-x64-linux-jdk.tar.gz -C /usr/java/

cd /usr/java/amazon-corretto-*-linux-x64/bin

for i in java javac jfr; do path=$(find `pwd`/$i -type f); echo $path; sudo alternatives --install /usr/bin/$i $i $path 20000 ; sudo update-alternatives --config $i ; done

java -version

Step 2: Clone the Java Source Code:

To deploy this application, clone the source code into the Amazon Linux instance created using git clone command.

git clone https://github.com/Divine4212/java-login-app

Step 3: Write Dockerfiles:
Dockerfiles are the blueprints for creating Docker images. In a Docker Compose project, they define the environment for each service. Docker Compose uses these Dockerfiles to build the images and then run them as containers.

- Dockerfile-sql:
The Dockerfile-sql will create custom MySQL container image by taking docker.io/mysql:8.0 as reference image from Docker Hub registry.

FROM mysql:8.0

ENV MYSQL_ROOT_PASSWORD=rootpassword
ENV MYSQL_DATABASE=UserDB
ENV MYSQL_USER=admin
ENV MYSQL_PASSWORD=Admin123

COPY init.sql /docker-entrypoint-initdb.d/

- init.sql:

init.sql:
CREATE TABLE Employee (
  id int unsigned auto_increment not null,
  first_name varchar(250),
  last_name varchar(250),
  email varchar(250),
  username varchar(250),
  password varchar(250),
  regdate timestamp,
  primary key (id)
);

- Dockerfile-app:
The Dockerfile-app is a simplified and optimized version for your Java Login App that takes docker.io/openjdk:11-jre-slim as base image from Docker Hub registry.. It installs unzip, vim, telnet and mysql-client and copy .war artifact to /app.war and start the application.

# Use OpenJDK 11 as the base image
FROM openjdk:11-jre-slim

# Install necessary packages (unzip, vim, telnet, mysql-client)
RUN apt-get update && \
    apt-get install -y unzip vim telnet mysql-client && \
    rm -rf /var/lib/apt/lists/*

# Set volume for temporary files
VOLUME /tmp

# Copy the WAR file to the container
COPY target/dptweb-1.0.war /app.war

# Expose the port Tomcat will run on
EXPOSE 8080

# Run the application using the JAR command
ENTRYPOINT ["java", "-jar", "/app.war"]

- Dockerfile-nginx:
The Dockerfile creates a custom Nginx container image by taking docker.io/amazonlinux as reference image from Docker Hub registry. Will installs Nginx server, telnet and also copy the custom nginx.conf file with proxy_pass rule to forward the traffic to the app container.

FROM amazonlinux:2

RUN yum update -y && \
    amazon-linux-extras install nginx1 -y && \
    yum install -y telnet

COPY nginx.conf /etc/nginx/nginx.conf

EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

- nginx.conf:

events {
    worker_connections 1024;
}

http {
    upstream app {
        server app:8080;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://app;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

Step 4: Write the Docker Compose File (docker-compose.yml):

- docker-compose.yml:
Docker Compose Stack Builds and Runs the Nginx, MySQL, App containers.

services:
  db:
    build:
      context: .
      dockerfile: Dockerfile-mysql
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: UserDB
      MYSQL_USER: admin
      MYSQL_PASSWORD: Admin123
    networks:
      - app-network

  app:
    build:
      context: .
      dockerfile: Dockerfile-app
    depends_on:
      - db
    networks:
      - app-network
    ports:
      - "8080:8080"  # Expose port 8080

  nginx:
    build:
      context: .
      dockerfile: Dockerfile-nginx
    ports:
      - "80:80"
    depends_on:
      - app
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

After creating these files in your cloned application folder, run mvn clean package command to build your application with Maven, run docker-compose build command to verify if container images are getting created and the run Run docker-compose up -d command to verify if all containers are running.

Validation

docker exec -it 'container-id-nginx' /bin/sh

curl http://app:8080

docker exec -it 'container-id-app' /bin/sh

telnet db 3306

docker exec -it 'container-id-app' /bin/sh

mysql -h db -u admin -p

Browse the application from public internet browser to verify the application is accessible.

Conclusion

Once the project setup has been completed, do not forget to clean up resources to avoid the billing for your test environment. Run docker-compose down command to stop and remove the containers and finally, terminate the instance from AWS Console.

Forem: divine kenechukwu

Deploy Simple Java Application using Docker Compose.