Docker Compose를 활용하여 Nginx + Spring Boot + MySQL 구축 (Ubuntu - Local)

1. 폴더 구조

docker-compose-practice/
│── docker-compose-test-app/    # Spring Boot 애플리케이션 (JAR 파일 빌드)
│   ├── Dockerfile
│   ├── src/ (Spring Boot 코드)
│── nginx/                 # Nginx 설정
│   ├── default.conf
│   ├── Dockerfile
│── docker-compose.yml

• 작업 디렉토리 생성

mkdir -p ~/docker-compose-practice
cd ~/docker-compose-practice

2. Docker-Compose & Java 설치

• Docker 깔렸있다는 가정 하에

sudo apt update
sudo apt install -y docker.io docker-compose
sudo systemctl start docker
sudo systemctl enable docker

sudo apt install -y openjdk-17-jdk

3. Spring Boot 애플리케이션 만들기

• Spring Initializr에서 Spring Boot 프로젝트 다운로드
• zip 풀고, ~/docker-compose-practice 로 이동시키기
• Build.gradle 파일 추가 설정

plugins {
        id 'java'
        id 'org.springframework.boot' version '3.4.2'
        id 'io.spring.dependency-management' version '1.1.7'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
        toolchain {
                languageVersion = JavaLanguageVersion.of(17)
        }
}

dependencies {
    // Spring Boot 기본 의존성
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

    // MySQL Connector
    implementation 'mysql:mysql-connector-java:8.0.33'

    // Lombok (자동 코드 생성)
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'

    // 개발 편의성 (DevTools)
    developmentOnly 'org.springframework.boot:spring-boot-devtools'

    // 테스트 관련
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

• src/main/resources/application.yml → MySQL 설정

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://mysql-db:3306/testdb?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
    username: root
    password: rootpassword
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

• Entity, Repository, Controller 작성
  • src/main/java/com/example/docker_compose_test_app/entity/User.java

package com.example.docker_compose_test_app.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;
}

- src/main/java/com/example/docker_compose_test_app/repository/UserRepository.java

package com.example.docker_compose_test_app.repository;

import com.example.docker_compose_test_app.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

- src/main/java/com/example/docker_compose_test_app/controller/UserController.java

package com.example.docker_compose_test_app.controller;

import com.example.docker_compose_test_app.entity.User;
import com.example.docker_compose_test_app.repository.UserRepository;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserRepository userRepository;

    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @GetMapping
    public List<User> getUsers() {
        return userRepository.findAll();
    }
}

- src/main/java/com/example/docker_compose_test_app/controller/HomeController.java

package com.example.docker_compose_test_app.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HomeController {

    @GetMapping("/")
    public String home() {
        return "Spring Boot API is running!";
    }
}

4. Nginx 설정

• nginx/default.conf

server {
    listen 80;

    location / {
        proxy_pass http://springboot-app:8080/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

5. Dockerfile 작성 : Spring Boot용 & Nginx용

• Spring Boot 애플리케이션용 Dockerfile
  • docker-compose-test-app/Dockerfile

# 1. OpenJDK 17 설치된 Gradle 이미지 사용
FROM gradle:8.0-jdk17 AS build

# 2. 작업 디렉토리 설정
WORKDIR /app

# 3. 프로젝트 파일 복사 (Gradle 캐시 활용)
COPY --chown=gradle:gradle . .

# 4. Gradle 빌드 실행 (테스트 제외)
RUN ./gradlew build -x test

# 5. OpenJDK 17 기반의 실행용 이미지 사용
FROM openjdk:17-jdk-slim

# 6. 작업 디렉토리 설정
WORKDIR /app

# 7. 빌드된 JAR 파일 복사
COPY --from=build /app/build/libs/*.jar app.jar

# 8. 애플리케이션 실행
ENTRYPOINT ["java", "-jar", "app.jar"]

• Nginx용 Dockerfile
  • nginx/Dockerfile

# 1. Nginx 최신 이미지 사용
FROM nginx:latest

# 2. 설정 파일 복사
COPY default.conf /etc/nginx/conf.d/default.conf

6. Docker Compose 설정

• docker-compose.yml 생성
  • ~/docker-compose-practice/docker-compose.yml

version: "3.8"

services:
  mysql-db:
    image: arm64v8/mysql:8.0
    container_name: mysql-db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: testdb
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - app-network
    healthcheck:  # MySQL이 정상적으로 실행될 때까지 기다리도록 설정
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uroot", "-prootpassword"]
      interval: 10s
      retries: 5
      start_period: 20s

  springboot-app:
    build: ./docker-compose-test-app
    container_name: springboot-app
    restart: always
    depends_on:
      mysql-db:
        condition: service_healthy  # MySQL이 완전히 실행될 때까지 대기
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql-db:3306/testdb?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
      SPRING_DATASOURCE_USERNAME: root
      SPRING_DATASOURCE_PASSWORD: rootpassword
    ports:
      - "8080:8080"
    networks:
      - app-network

  nginx:
    build: ./nginx
    container_name: nginx
    restart: always
    ports:
      - "80:80"
    depends_on:
      - springboot-app
    networks:
      - app-network

volumes:
  mysql-data:

networks:
  app-network:
    driver: bridge

✅ 설명:

• 주의
  • (이전에 Apache나 로컬 Nginx를 사용중이었다면 80포트 끄기)
  • (Mysql도 마찬가지)
  • MySQL 8.0 설치 문제
  1. https://stackoverflow.com/questions/54470921/is-there-a-mysql-docker-image-for-arm64-that-works-like-the-official-image
  2. ARM64 is being supported with mySQL 8.0 (only);

7. 실행

docker-compose up --build -d

✅ Nginx, Spring Boot, MySQL, Redis 컨테이너가 한 번에 실행됨! 🚀

📌 웹 브라우저에서 확인

• http://localhost:8080 → Spring Boot 앱이 Nginx를 통해 연결됨
  

  

8. (추가) API TEST

• curl을 통해 API 테스트를 해보자.

1. POST /user 요청
   
2. GET /users 요청