The Project Setup#

In this setup, we’ll create a simple Dockerized environment for your Spring Boot application and MySQL database. Additionally, we will use Localtunnel to forward traffic from the public URL to your local Spring Boot application.

Here’s how we structure it:

1. MySQL Database – Running inside a Docker container.
2. Spring Boot Application – Running in a Docker container connected to the MySQL database.
3. Localtunnel – Exposes the Spring Boot app to the internet using a public URL.

Docker Compose Configuration#

We will use Docker Compose to define the services (MySQL and Spring Boot) and set them up for easy deployment.

1
networks:
2
  my_network:
3
    driver: bridge
4

5
services:
6
  db:
7
    image: lcaohoanq/sample-mysql-db:2.0
8
    container_name: mysql-db
9
    ports:
10
      - "3311:3306" # Host port 3311 -> Container port 3306 (MySQL)
11
  env_file:
12
      - .env          # Include your MySQL environment variables here
13
  volumes:
14
      - db_data:/var/lib/mysql  # Persistent volume for MySQL data
15
  networks:
16
      - my_network
17
    healthcheck:
18
      test:
19
        [
20
          "CMD",
21
          "mysqladmin",
22
          "ping",
23
          "-h",
24
          "localhost",
25
          "-u",
26
          "root",
27
          "--password=Luucaohoang1604^^",
28
        ]
29
      interval: 10s
30
      timeout: 5s
31
      retries: 5
32

33
  springboot-app:
34
    container_name: springboot-app
35
    build:
36
      context: .
37
      dockerfile: Dockerfile
38
    restart: on-failure
39
    networks:
40
      - my_network
41
    ports:
42
      - "8080:8080" # Host port 8080 -> Container port 8080 (Spring Boot)
43
  depends_on:
44
      - db            # Ensure Spring Boot app waits for MySQL to be ready
45
  env_file:
46
      - .env          # Use the same .env file for database credentials
47
  environment:
48
      - SPRING_DATASOURCE_URL=jdbc:mysql://db:3306/${MYSQL_DATABASE} # Use the MySQL service name as the hostname
49
  - SPRING_DATASOURCE_USERNAME=${MYSQL_USER}
50
      - SPRING_DATASOURCE_PASSWORD=${MYSQL_PASSWORD}
51

52
  nginx:
53
    image: nginx:latest
54
    container_name: nginx-proxy
55
    ports:
56
      - "80:80" # Expose Nginx on port 80
57
  volumes:
58
      - ./nginx.conf:/etc/nginx/nginx.conf  # Custom Nginx configuration file
59
  depends_on:
60
      - springboot-app
61
    networks:
62
      - my_network
63

64
  portainer:
65
    image: portainer/portainer-ce:latest
66
    container_name: portainer
67
    ports:
68
      - "9443:9443"
69
  volumes:
70
      - data:/data
71
      - /var/run/docker.sock:/var/run/docker.sock
72
    restart: unless-stopped
73

74
volumes:
75
  db_data:  # Docker volume to persist MySQL data
76
  data:     # Docker volume to persist Portainer data

How It Works#

1. MySQL Database Service (db):

   • Runs MySQL in a container with persistent data stored in a Docker volume.
   • Exposes port 3306 internally and maps it to port 3311 on the host.

2. Spring Boot Application Service (springboot-app):

   • Your Spring Boot app runs in a Docker container connected to the MySQL container.
   • The application listens on port 8080.

3. Optional (portainer): Help Docker management more ease

Setting Up Localtunnel#

Now comes the fun part! To expose your Spring Boot app to the public internet, we’ll use Localtunnel. This will create a publicly accessible URL that tunnels to your local machine.

1. Start the Docker containers:

   First, make sure your containers are up and running with:

   1
   docker-compose up -d
   

   1
   - Or this, if you need to integrate with CI-CD pipeline
   

docker compose -f docker-compose.yml up -d —build —remove-orphans ```

2. Install Localtunnel:

   If you haven’t installed Localtunnel yet, you can do so globally using npm: Document here

   1
   npm install -g localtunnel
   

3. Expose the Spring Boot application:

   Use Localtunnel to expose your app running on localhost:8080:

   1
   lt --port 8080
   

   This will give you a URL like https://example.loca.lt, which is publicly accessible from anywhere.

4. Provide Password to access:

• Usually the password is the server’s public IP address

Accessing the App#

• To access your Spring Boot app locally, visit http://localhost:8080.
• To access it externally, use the Localtunnel URL (e.g., https://example.loca.lt), and your Spring Boot app will be accessible from anywhere.

Setting Up Environment Variables#

Ensure your .env file includes the necessary environment variables for MySQL and Spring Boot:

1
MYSQL_ROOT_PASSWORD=Luucaohoang1604^^
2
MYSQL_DATABASE=mysql_starter
3
MYSQL_PASSWORD=Luucaohoang1604^^
4
MYSQL_USER=root
5
DB_USERNAME=root

Conclusion#

By using Docker to manage your containers and Localtunnel to expose your local Spring Boot application, you can easily self-host your web app without the need for a domain name or expensive hosting solutions. This setup is perfect for development, testing, or even small production environments where cost is a concern.

With just a few tools, you’ve created a fully functional self-hosted application that can be accessed from anywhere—without breaking the bank!