🚀 왜 지금 Docker인가?

친구야, 혹시 이런 경험 있어? 로컬에서는 완벽하게 돌아가던 애플리케이션이 서버에 올리니까 갑자기 안 돌아가는 상황 말이야. 😱

"어? 내 컴퓨터에서는 잘 됐는데..."라는 말은 이제 개발자들 사이에서 밈이 되어버렸지. 바로 이런 문제를 해결하기 위해 등장한 게 Docker야.

Docker는 애플리케이션을 컨테이너라는 표준화된 단위로 패키징해서, 어디서든 동일하게 실행할 수 있게 해주는 플랫폼이야. 마치 배송용 컨테이너가 어떤 배에 실어도 똑같이 운송되는 것처럼 말이야. 🚢

☕ Spring Boot와 Docker의 환상 궁합

Spring Boot는 Java 기반의 웹 애플리케이션을 빠르게 개발할 수 있게 해주는 프레임워크야. 그리고 Docker는 이렇게 만든 애플리케이션을 어디서든 실행할 수 있게 해주지.

이 둘의 조합이 왜 좋냐고? Spring Boot는 이미 내장 톰캣을 가지고 있어서 JAR 파일 하나로 실행 가능한 애플리케이션을 만들어. 이걸 Docker 이미지로 만들면 정말 완벽한 배포 단위가 되는 거야! 🎯

🛠️ 실전! Spring Boot 애플리케이션 Docker화하기

자, 이제 본격적으로 실습을 해보자! 간단한 Spring Boot 애플리케이션을 Docker 컨테이너로 만드는 전 과정을 함께 따라가보자. 😊

📦 1단계: Spring Boot 프로젝트 준비

먼저 간단한 Spring Boot 애플리케이션이 필요해. Spring Initializr(start.spring.io)에서 프로젝트를 생성하거나, 기존 프로젝트를 사용해도 돼.

여기서는 간단한 REST API를 만들어볼게:

// Application.java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
    @GetMapping("/")
    public String hello() {
        return "Hello from Docker Container! 🐳";
    }
    
    @GetMapping("/health")
    public String health() {
        return "Application is running smoothly!";
    }
}

🏗️ 2단계: Dockerfile 작성하기

Dockerfile은 Docker 이미지를 만들기 위한 레시피야. 프로젝트 루트 디렉토리에 Dockerfile이라는 이름으로 파일을 만들어보자:

# 기본 방식 - 간단하지만 이미지 크기가 큼
FROM openjdk:17-jdk-slim

WORKDIR /app

COPY target/*.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

위 Dockerfile을 한 줄씩 설명해볼게:

FROM openjdk:17-jdk-slim - OpenJDK 17 기반 이미지를 사용해. slim 버전은 불필요한 패키지를 제거해서 용량이 작아.

WORKDIR /app - 컨테이너 내부에서 작업할 디렉토리를 /app으로 설정해.

COPY target/*.jar app.jar - 빌드된 JAR 파일을 컨테이너로 복사해.

EXPOSE 8080 - 컨테이너가 8080 포트를 사용한다고 문서화해. (실제로 포트를 여는 건 아니고 힌트를 주는 거야)

ENTRYPOINT - 컨테이너가 시작될 때 실행할 명령어를 지정해.

🎯 3단계: 멀티 스테이지 빌드로 최적화하기

멀티 스테이지 빌드는 Docker의 강력한 기능 중 하나야. 빌드 환경과 실행 환경을 분리해서 최종 이미지 크기를 대폭 줄일 수 있어. 🚀

# 멀티 스테이지 빌드 - 최적화된 방식
# Stage 1: Build
FROM maven:3.8.5-openjdk-17 AS build

WORKDIR /app

# pom.xml 먼저 복사해서 의존성 캐싱
COPY pom.xml .
RUN mvn dependency:go-offline

# 소스 코드 복사 및 빌드
COPY src ./src
RUN mvn clean package -DskipTests

# Stage 2: Runtime
FROM openjdk:17-jdk-slim

WORKDIR /app

# 빌드 스테이지에서 생성된 JAR만 복사
COPY --from=build /app/target/*.jar app.jar

# 보안을 위한 non-root 사용자 생성
RUN addgroup --system spring && adduser --system spring --ingroup spring
USER spring:spring

EXPOSE 8080

# JVM 옵션 최적화
ENTRYPOINT ["java", \
    "-XX:+UseContainerSupport", \
    "-XX:MaxRAMPercentage=75.0", \
    "-Djava.security.egd=file:/dev/./urandom", \
    "-jar", "app.jar"]

이 방식의 장점을 정리해볼게:

✨ 이미지 크기 감소: Maven과 소스 코드가 최종 이미지에 포함되지 않아
✨ 빌드 캐싱: pom.xml을 먼저 복사해서 의존성 다운로드를 캐싱할 수 있어
✨ 보안 강화: non-root 사용자로 실행해서 보안 리스크를 줄여
✨ 성능 최적화: JVM 옵션으로 컨테이너 환경에 최적화

🔨 4단계: Docker 이미지 빌드하기

Dockerfile이 준비됐으면 이제 이미지를 빌드할 차례야. 터미널에서 프로젝트 루트 디렉토리로 이동한 다음 아래 명령어를 실행해:

# 기본 빌드
docker build -t my-spring-app:1.0 .

# 빌드 캐시 없이 새로 빌드
docker build --no-cache -t my-spring-app:1.0 .

# 특정 Dockerfile 사용
docker build -f Dockerfile.prod -t my-spring-app:1.0 .

명령어를 분석해보면:

-t my-spring-app:1.0 - 이미지에 태그를 붙여. 여기서는 이름이 my-spring-app이고 버전이 1.0이야.

. - 현재 디렉토리를 빌드 컨텍스트로 사용한다는 의미야.

빌드가 진행되면 각 단계별로 로그가 출력돼. 처음에는 시간이 좀 걸리지만, 두 번째부터는 캐시 덕분에 훨씬 빠르게 빌드돼! ⚡

target/
.git/
.idea/
*.md
.env
node_modules/

🚀 5단계: 컨테이너 실행하기

이미지가 빌드됐으면 이제 컨테이너로 실행해보자:

# 기본 실행
docker run -p 8080:8080 my-spring-app:1.0

# 백그라운드에서 실행 (detached mode)
docker run -d -p 8080:8080 --name my-app my-spring-app:1.0

# 환경 변수와 함께 실행
docker run -d \
  -p 8080:8080 \
  -e SPRING_PROFILES_ACTIVE=prod \
  -e DATABASE_URL=jdbc:mysql://db:3306/mydb \
  --name my-app \
  my-spring-app:1.0

# 볼륨 마운트와 함께 실행
docker run -d \
  -p 8080:8080 \
  -v /path/to/logs:/app/logs \
  --name my-app \
  my-spring-app:1.0

주요 옵션들을 살펴보자:

-p 8080:8080 - 호스트의 8080 포트를 컨테이너의 8080 포트로 매핑해.

-d - 백그라운드에서 실행해. (detached mode)

--name my-app - 컨테이너에 이름을 붙여. 이름이 없으면 랜덤으로 생성돼.

-e - 환경 변수를 설정해. Spring Boot의 프로파일이나 설정을 오버라이드할 수 있어.

-v - 볼륨을 마운트해. 로그 파일이나 데이터를 호스트에 저장할 수 있어.

🔍 6단계: 컨테이너 관리하기

컨테이너가 실행되면 다양한 명령어로 관리할 수 있어:

# 실행 중인 컨테이너 확인
docker ps

# 모든 컨테이너 확인 (중지된 것 포함)
docker ps -a

# 컨테이너 로그 확인
docker logs my-app

# 실시간 로그 확인
docker logs -f my-app

# 컨테이너 내부 접속
docker exec -it my-app /bin/bash

# 컨테이너 중지
docker stop my-app

# 컨테이너 시작
docker start my-app

# 컨테이너 재시작
docker restart my-app

# 컨테이너 삭제
docker rm my-app

# 강제 삭제 (실행 중이어도)
docker rm -f my-app

HEALTHCHECK --interval=30s --timeout=3s --start-period=40s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1

🎼 Docker Compose로 멀티 컨테이너 관리하기

실제 애플리케이션은 보통 여러 서비스로 구성돼 있어. 예를 들어 Spring Boot 앱, MySQL 데이터베이스, Redis 캐시 등이 함께 동작하지. 이럴 때 Docker Compose를 사용하면 여러 컨테이너를 한 번에 관리할 수 있어! 🎵

📝 docker-compose.yml 작성하기

프로젝트 루트에 docker-compose.yml 파일을 만들어보자:

version: '3.8'

services:
  # Spring Boot 애플리케이션
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - SPRING_DATASOURCE_URL=jdbc:mysql://db:3306/mydb
      - SPRING_DATASOURCE_USERNAME=root
      - SPRING_DATASOURCE_PASSWORD=secret
      - SPRING_REDIS_HOST=redis
    depends_on:
      - db
      - redis
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  # MySQL 데이터베이스
  db:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=secret
      - MYSQL_DATABASE=mydb
    ports:
      - "3306:3306"
    volumes:
      - db-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Redis 캐시
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

networks:
  app-network:
    driver: bridge

volumes:
  db-data:
  redis-data:

이 설정 파일의 주요 포인트를 살펴보자:

services: 실행할 컨테이너들을 정의해. 여기서는 app, db, redis 세 개의 서비스가 있어.

depends_on: 서비스 간 의존성을 정의해. app은 db와 redis가 먼저 시작되어야 해.

networks: 컨테이너들이 서로 통신할 수 있는 네트워크를 만들어.

volumes: 데이터를 영구적으로 저장할 볼륨을 정의해. 컨테이너가 삭제되어도 데이터는 남아있어.

healthcheck: 각 서비스의 상태를 모니터링해.

🎮 Docker Compose 명령어

Docker Compose를 사용하는 주요 명령어들이야:

# 모든 서비스 시작 (백그라운드)
docker-compose up -d

# 특정 서비스만 시작
docker-compose up -d app

# 빌드와 함께 시작
docker-compose up -d --build

# 로그 확인
docker-compose logs

# 특정 서비스 로그 확인
docker-compose logs -f app

# 실행 중인 서비스 확인
docker-compose ps

# 서비스 중지
docker-compose stop

# 서비스 중지 및 컨테이너 삭제
docker-compose down

# 볼륨까지 삭제
docker-compose down -v

# 특정 서비스 재시작
docker-compose restart app

# 서비스 스케일링
docker-compose up -d --scale app=3

🔐 보안과 최적화 베스트 프랙티스

Docker 컨테이너를 프로덕션 환경에서 사용하려면 보안과 성능 최적화가 정말 중요해. 실전에서 꼭 알아야 할 팁들을 정리해봤어! 🛡️

🔒 보안 강화 전략

⚡ 성능 최적화 기법

1. 레이어 캐싱 최적화

Dockerfile의 명령어 순서가 중요해. 자주 변경되지 않는 것을 먼저 배치하면 빌드 캐시를 효율적으로 사용할 수 있어:

# ❌ 비효율적인 방식
COPY . /app
RUN mvn clean package

# ✅ 효율적인 방식
COPY pom.xml /app/
RUN mvn dependency:go-offline
COPY src /app/src
RUN mvn clean package

2. 멀티 스테이지 빌드 활용

앞에서 봤듯이 멀티 스테이지 빌드를 사용하면 최종 이미지 크기를 대폭 줄일 수 있어. 이건 정말 필수야!

3. JVM 메모리 설정

컨테이너 환경에서는 JVM 메모리 설정이 중요해:

# Dockerfile에서 JVM 옵션 설정
ENTRYPOINT ["java", \
    "-XX:+UseContainerSupport", \
    "-XX:MaxRAMPercentage=75.0", \
    "-XX:InitialRAMPercentage=50.0", \
    "-Xms512m", \
    "-Xmx2g", \
    "-XX:+UseG1GC", \
    "-XX:MaxGCPauseMillis=200", \
    "-jar", "app.jar"]

4. 불필요한 파일 제거

.dockerignore 파일을 적극 활용해서 빌드 컨텍스트를 최소화하자:

# .dockerignore
target/
.git/
.gitignore
.idea/
*.iml
*.md
.env
.DS_Store
node_modules/
logs/
*.log

📊 모니터링과 로깅

컨테이너 환경에서는 로깅과 모니터링이 더욱 중요해. Spring Boot 애플리케이션의 로그를 효과적으로 관리하는 방법을 알아보자:

# application.yml
logging:
  level:
    root: INFO
    com.example: DEBUG
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} - %msg%n"
  file:
    name: /app/logs/application.log
    max-size: 10MB
    max-history: 30

# Docker Compose에서 로그 드라이버 설정
services:
  app:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

🌐 Docker Hub와 이미지 배포

이미지를 만들었으면 이제 다른 사람들과 공유하거나 다른 서버에 배포할 차례야. Docker Hub는 GitHub처럼 Docker 이미지를 저장하고 공유할 수 있는 레지스트리야. 🚀

📤 Docker Hub에 이미지 푸시하기

# 1. Docker Hub 로그인
docker login

# 2. 이미지에 태그 붙이기
docker tag my-spring-app:1.0 username/my-spring-app:1.0
docker tag my-spring-app:1.0 username/my-spring-app:latest

# 3. 이미지 푸시
docker push username/my-spring-app:1.0
docker push username/my-spring-app:latest

# 4. 다른 서버에서 이미지 가져오기
docker pull username/my-spring-app:latest
docker run -d -p 8080:8080 username/my-spring-app:latest

🔄 CI/CD 파이프라인 통합

Docker를 CI/CD 파이프라인에 통합하면 자동화된 빌드와 배포가 가능해. GitHub Actions를 예로 들어볼게:

# .github/workflows/docker-build.yml
name: Docker Build and Push

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up JDK 17
      uses: actions/setup-java@v3
      with:
        java-version: '17'
        distribution: 'temurin'
    
    - name: Build with Maven
      run: mvn clean package -DskipTests
    
    - name: Log in to Docker Hub
      uses: docker/login-action@v2
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}
    
    - name: Build and push Docker image
      uses: docker/build-push-action@v4
      with:
        context: .
        push: true
        tags: |
          username/my-spring-app:latest
          username/my-spring-app:${{ github.sha }}
    
    - name: Deploy to production
      run: |
        ssh user@server "docker pull username/my-spring-app:latest"
        ssh user@server "docker-compose up -d"

이렇게 설정하면 main 브랜치에 코드를 푸시할 때마다 자동으로 Docker 이미지가 빌드되고 배포돼! 🎉

🐛 트러블슈팅과 디버깅

Docker를 사용하다 보면 여러 가지 문제에 부딪힐 수 있어. 자주 발생하는 문제들과 해결 방법을 정리해봤어! 🔧

❌ 자주 발생하는 문제들

# 종료된 컨테이너 확인
docker ps -a

# 로그 확인
docker logs container-name

# 일반적인 원인
# - 애플리케이션 시작 실패
# - 포트 충돌
# - 환경 변수 누락
# - 데이터베이스 연결 실패

# 포트 사용 중인 프로세스 확인 (Linux/Mac)
lsof -i :8080

# 포트 사용 중인 프로세스 확인 (Windows)
netstat -ano | findstr :8080

# 다른 포트로 매핑
docker run -p 8081:8080 my-spring-app:1.0

# Docker Compose 사용 시 서비스 이름으로 연결
spring.datasource.url=jdbc:mysql://db:3306/mydb

# 네트워크 확인
docker network ls
docker network inspect app-network

# 컨테이너 간 통신 테스트
docker exec -it app ping db

# BuildKit 활성화 (더 빠른 빌드)
export DOCKER_BUILDKIT=1
docker build -t my-spring-app:1.0 .

# 빌드 캐시 활용
# - .dockerignore 파일 작성
# - 레이어 순서 최적화
# - 멀티 스테이지 빌드 사용

🔍 디버깅 팁

컨테이너 내부에서 문제를 디버깅하는 유용한 명령어들이야:

# 컨테이너 내부 접속
docker exec -it container-name /bin/bash

# 컨테이너 리소스 사용량 확인
docker stats

# 컨테이너 상세 정보 확인
docker inspect container-name

# 컨테이너 프로세스 확인
docker top container-name

# 컨테이너 파일 시스템 변경 사항 확인
docker diff container-name

# 실시간 로그 스트리밍
docker logs -f --tail 100 container-name

# 특정 시간대 로그 확인
docker logs --since 30m container-name

# Dockerfile에 디버그 옵션 추가
ENTRYPOINT ["java", \
    "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005", \
    "-jar", "app.jar"]

# 디버그 포트와 함께 실행
docker run -p 8080:8080 -p 5005:5005 my-spring-app:1.0

🚀 실전 프로젝트 예제

이제 배운 내용을 종합해서 실전 프로젝트를 만들어보자! REST API, 데이터베이스, 캐시를 모두 포함한 완전한 예제야. 💪

📁 프로젝트 구조

my-spring-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       ├── Application.java
│   │   │       ├── controller/
│   │   │       │   └── UserController.java
│   │   │       ├── service/
│   │   │       │   └── UserService.java
│   │   │       ├── repository/
│   │   │       │   └── UserRepository.java
│   │   │       └── model/
│   │   │           └── User.java
│   │   └── resources/
│   │       ├── application.yml
│   │       └── application-prod.yml
├── Dockerfile
├── docker-compose.yml
├── .dockerignore
├── pom.xml
└── README.md

💻 핵심 코드

User 엔티티:

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private String email;
    
    @CreatedDate
    private LocalDateTime createdAt;
    
    // getters, setters, constructors
}

UserController:

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    @Cacheable(value = "users", key = "#id")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
    
    @DeleteMapping("/{id}")
    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}

application.yml:

spring:
  application:
    name: my-spring-app
  
  datasource:
    url: jdbc:mysql://${DB_HOST:localhost}:3306/${DB_NAME:mydb}
    username: ${DB_USER:root}
    password: ${DB_PASSWORD:secret}
    driver-class-name: com.mysql.cj.jdbc.Driver
  
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
  
  redis:
    host: ${REDIS_HOST:localhost}
    port: 6379
  
  cache:
    type: redis
    redis:
      time-to-live: 600000

server:
  port: 8080

logging:
  level:
    root: INFO
    com.example: DEBUG

🐳 완전한 docker-compose.yml

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: spring-app
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - DB_HOST=db
      - DB_NAME=mydb
      - DB_USER=root
      - DB_PASSWORD=secret123
      - REDIS_HOST=redis
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  db:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      - MYSQL_ROOT_PASSWORD=secret123
      - MYSQL_DATABASE=mydb
    ports:
      - "3306:3306"
    volumes:
      - db-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-psecret123"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  redis:
    image: redis:7-alpine
    container_name: redis-cache
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - app-network
    restart: unless-stopped
    command: redis-server --appendonly yes
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - app
    networks:
      - app-network
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  db-data:
  redis-data:

이 설정으로 docker-compose up -d 명령어 하나면 전체 스택이 실행돼! 정말 편리하지? 😊

☁️ 클라우드 배포 전략

로컬에서 완벽하게 동작하는 컨테이너를 이제 클라우드에 배포해보자! AWS, Azure, GCP 모두 Docker를 지원해. 🌥️

🎯 AWS ECS (Elastic Container Service)

AWS ECS는 Docker 컨테이너를 쉽게 실행하고 관리할 수 있는 서비스야:

# 1. ECR에 이미지 푸시
aws ecr get-login-password --region ap-northeast-2 | \
  docker login --username AWS --password-stdin \
  123456789.dkr.ecr.ap-northeast-2.amazonaws.com

docker tag my-spring-app:1.0 \
  123456789.dkr.ecr.ap-northeast-2.amazonaws.com/my-spring-app:1.0

docker push 123456789.dkr.ecr.ap-northeast-2.amazonaws.com/my-spring-app:1.0

# 2. ECS Task Definition 생성 (JSON)
{
  "family": "my-spring-app",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "containerDefinitions": [
    {
      "name": "app",
      "image": "123456789.dkr.ecr.ap-northeast-2.amazonaws.com/my-spring-app:1.0",
      "portMappings": [
        {
          "containerPort": 8080,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {
          "name": "SPRING_PROFILES_ACTIVE",
          "value": "prod"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/my-spring-app",
          "awslogs-region": "ap-northeast-2",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}

☸️ Kubernetes 배포

Kubernetes는 컨테이너 오케스트레이션의 표준이야. 복잡하지만 강력해:

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-app
  labels:
    app: spring-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: spring-app
  template:
    metadata:
      labels:
        app: spring-app
    spec:
      containers:
      - name: app
        image: username/my-spring-app:1.0
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        - name: DB_HOST
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: db.host
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 20
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: spring-app-service
spec:
  type: LoadBalancer
  selector:
    app: spring-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

📈 성능 모니터링과 관찰성

프로덕션 환경에서는 애플리케이션의 상태를 실시간으로 모니터링하는 게 정말 중요해. Spring Boot Actuator와 Prometheus, Grafana를 조합하면 강력한 모니터링 시스템을 구축할 수 있어! 📊

🔍 Spring Boot Actuator 설정

// pom.xml에 의존성 추가
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  endpoint:
    health:
      show-details: always
  metrics:
    export:
      prometheus:
        enabled: true

📊 Prometheus + Grafana 설정

# docker-compose.yml에 추가
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    networks:
      - app-network
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
    depends_on:
      - prometheus
    networks:
      - app-network
    restart: unless-stopped

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['app:8080']

이제 Grafana(http://localhost:3000)에 접속해서 Prometheus를 데이터 소스로 추가하고, 대시보드를 만들면 실시간으로 애플리케이션 메트릭을 볼 수 있어! 📈

🎓 학습 로드맵과 다음 단계

여기까지 따라왔다면 정말 대단해! 🎉 이제 Spring Boot와 Docker의 기본은 마스터했어. 다음 단계로 나아가기 위한 로드맵을 정리해봤어:

📚 추천 학습 자료

공식 문서:
• Docker 공식 문서: https://docs.docker.com
• Spring Boot 공식 문서: https://spring.io/projects/spring-boot
• Kubernetes 공식 문서: https://kubernetes.io/docs

실습 플랫폼:
• Play with Docker: https://labs.play-with-docker.com
• Katacoda: 무료 인터랙티브 학습
• Docker Hub: 다양한 이미지 탐색

커뮤니티:
• Docker Community Forums
• Stack Overflow
• Reddit r/docker
• 한국 Docker 사용자 모임

🎬 마무리하며

자, 여기까지 Spring Boot와 Docker를 활용한 컨테이너화에 대해 알아봤어! 처음에는 복잡해 보일 수 있지만, 하나씩 따라하다 보면 어느새 Docker 전문가가 되어 있을 거야. 😊

Docker는 단순히 배포 도구가 아니라, 현대적인 소프트웨어 개발의 필수 요소야. 개발 환경의 일관성, 빠른 배포, 효율적인 리소스 관리 등 Docker가 제공하는 이점은 정말 많아.

특히 Spring Boot와의 조합은 Java 개발자에게 최고의 선택이야. Spring Boot의 간편함과 Docker의 이식성이 만나면 정말 강력한 시너지를 발휘하거든! 🚀

기억해야 할 핵심 포인트들:

🎯 멀티 스테이지 빌드로 이미지 크기 최적화
🎯 Docker Compose로 멀티 컨테이너 관리
🎯 보안을 항상 최우선으로 고려
🎯 모니터링과 로깅 시스템 구축
🎯 CI/CD 파이프라인 자동화

이제 당신도 Docker 컨테이너의 세계로 떠날 준비가 됐어! 실습하면서 막히는 부분이 있다면 공식 문서를 참고하거나, 커뮤니티에 질문하거나, 전문가의 도움을 받아보는 것도 좋아.

마지막으로, 학습은 끝이 없어. 계속해서 새로운 기술을 배우고, 실전 프로젝트에 적용해보면서 성장해나가자! 💪

Happy Dockerizing! 🐳✨