Platform: Azure Linux VM Tools: Docker • Docker Compose • GitHub Actions • Spring Boot • Nginx

This project demonstrates the full containerization and deployment of a two-tier web application using Docker, Docker Compose, and Azure Cloud Virtual Machine (VM). It consists of:

• A Java Spring Boot backend providing REST APIs for student data management.
• A frontend web interface served through Nginx.
• Both services containerized, orchestrated, and deployed together using Docker Compose.

The project validates practical knowledge in containerization, CI/CD automation, and cloud-based deployment workflows.

1. Containerize backend (Java) and frontend (HTML/JS) services.
2. Use Docker Compose to orchestrate both containers.
3. Build and push Docker images to Docker Hub.
4. Automate builds and pushes using GitHub Actions CI/CD.
5. Deploy and run containers on an Azure Linux VM.
6. Validate container communication and public accessibility.

docker-project/
│
├── backend/
│   ├── src/main/java/com/example/demo/
│   │   ├── model/Student.java
│   │   ├── service/StudentService.java
│   │   └── controller/StudentController.java
│   ├── pom.xml
│   └── Dockerfile
│
├── frontend/
│   ├── index.html
│   ├── style.css
│   ├── script.js
│   └── Dockerfile
│
├── docker-compose.yml
└── .github/workflows/docker-publish.yml

API Endpoints

GET     /api/students
POST    /api/students
PUT     /api/students/{id}
DELETE  /api/students/{id}

Dockerfile

# Build stage
FROM maven:3.9.6-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn -B clean package -DskipTests

# Run stage
FROM eclipse-temurin:17-jdk
WORKDIR /app
COPY --from=builder /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Dockerfile

FROM nginx:alpine
COPY . /usr/share/nginx/html
EXPOSE 80

Frontend connects to backend using:

fetch("http://20.0.250.3:8080/api/students")

services:
  backend:
    image: dukeyico/java-backend:latest
    build: ./backend
    container_name: java-backend
    ports:
      - "8080:8080"
  frontend:
    image: dukeyico/web-frontend:latest
    build: ./frontend
    container_name: web-frontend
    ports:
      - "5173:80"
    depends_on:
      - backend

services:
  backend:
    image: dukeyico/java-backend:latest
    container_name: java-backend
    restart: always
    ports:
      - "8080:8080"

  frontend:
    image: dukeyico/web-frontend:latest
    container_name: web-frontend
    restart: always
    ports:
      - "5173:80"
    depends_on:
      - backend

docker compose up --build
docker ps

Access:

• Frontend → http://localhost:5173
• Backend → http://localhost:8080/api/students

ssh [email protected]
sudo docker compose up -d
docker ps

Access:

• Frontend → http://20.0.250.3:5173
• Backend → http://20.0.250.3:8080/api/students

Option 1: Clone Repository and Deploy

ssh [email protected]
git clone https://github.com/dukeyico/docker-project.git
cd docker-project
sudo docker compose up -d

Option 2: Manual Compose File Creation

ssh [email protected]
nano docker-compose.yml
# Paste YAML content
sudo docker compose up -d

• dukeyico/java-backend
• dukeyico/web-frontend

docker build -t dukeyico/java-backend:latest ./backend
docker build -t dukeyico/web-frontend:latest ./frontend
docker push dukeyico/java-backend:latest
docker push dukeyico/web-frontend:latest

File: .github/workflows/docker-publish.yml

name: CI/CD Pipeline - Build, Push, Deploy

on:
  push:
    branches:
      - main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Build and push backend image
        uses: docker/build-push-action@v6
        with:
          context: ./backend
          push: true
          tags: dukeyico/java-backend:latest

      - name: Build and push frontend image
        uses: docker/build-push-action@v6
        with:
          context: ./frontend
          push: true
          tags: dukeyico/web-frontend:latest

      - name: Deploy on Azure VM
        uses: appleboy/[email protected]
        with:
          host: ${{ secrets.VM_HOST }}
          username: ${{ secrets.VM_USER }}
          key: ${{ secrets.VM_SSH_KEY }}
          script: |
            sudo docker compose down
            sudo docker pull dukeyico/java-backend:latest
            sudo docker pull dukeyico/web-frontend:latest
            sudo docker compose up -d

How to Create Secrets

1. Go to your GitHub repository → Settings
2. Navigate to Secrets and variables → Actions
3. Click New repository secret
4. Add all five secrets listed above

docker ps
curl http://localhost:8080/api/students
curl http://localhost:5173

Expected Result:

• Both containers run successfully.
• The frontend communicates properly with backend APIs.

✅ Containers deployed successfully on Azure VM ✅ Backend and frontend images published on Docker Hub ✅ CI/CD pipeline automates builds and pushes ✅ System accessible via public IP with working API calls

• Deployed containers visible via docker ps
• Images published on Docker Hub
• Successful GitHub Actions workflow runs
• Browser access to frontend and backend endpoints

• End-to-end Docker workflow from build to deployment
• Importance of automation in CI/CD pipelines
• Managing cloud infrastructure using Docker Compose
• Debugging network and permission issues on VMs
• Secure handling of GitHub secrets

This project achieved complete automation of container build, deployment, and orchestration. Using Docker, Compose, and GitHub Actions, a reproducible two-tier web application was created and hosted on Azure Cloud VM. It demonstrates real-world DevOps, cloud deployment, and CI/CD best practices that align with enterprise standards.

• Docker Documentation
• Spring Boot Guide
• Nginx Docs
• GitHub Actions Docs
• Azure Documentation