Spring Boot #

Dalam ekosistem Java modern, Spring Boot menjadi framework de-facto untuk membangun aplikasi backend. Namun, tantangan klasik di dunia Java tetap sama: perbedaan environment, versi JDK, konfigurasi OS, dan dependency lokal yang sering kali membuat proses development tidak konsisten.

Di sinilah Docker dan Docker Compose berperan penting. Untuk local development, tujuan Docker bukan sekadar membuat image kecil, melainkan:

• Menyamakan environment antar developer
• Mempermudah setup project baru
• Mendukung siklus edit–run–debug yang cepat
• Mengurangi konfigurasi manual di mesin lokal

Artikel ini akan membahas secara mendetail dan rinci:

• Dockerfile yang tepat untuk Spring Boot (khusus local development)
• Docker Compose sebagai orchestrator environment lokal
• Workflow development yang sehat
• Best practice dan anti-pattern yang sering terjadi

Fokus artikel ini adalah Docker Compose untuk local development, bukan production.

Gambaran Arsitektur #

Setup Spring Boot untuk local development dengan Docker umumnya terdiri dari:

• Spring Boot Application
• Database (PostgreSQL / MySQL)
• (Opsional) Redis / Kafka
• Volume untuk source code & dependency cache

Diagram sederhana:

Developer
   |
   v
Docker Compose
   |
   +--> spring-boot-app
   |
   +--> database

Karakteristik Docker Spring Boot #

Sebelum menulis Dockerfile, penting memahami perbedaannya dengan production:

Kesalahan umum adalah menggunakan Dockerfile production untuk local development.

Struktur Project Spring Boot #

.
├── src/
│   └── main/
│       ├── java/
│       └── resources/
├── pom.xml
├── mvnw
├── mvnw.cmd
├── Dockerfile
├── docker-compose.yml
└── .env

Dockerfile untuk Spring Boot #

Prinsip Utama #

Untuk local development:

• Jangan langsung build JAR
• Gunakan Maven Wrapper
• Manfaatkan layer cache dependency
• Support fast restart / devtools

Contoh Dockerfile #

FROM eclipse-temurin:21-jdk-alpine

WORKDIR /app

# Install tools tambahan
RUN apk add --no-cache bash

# Copy file Maven terlebih dahulu
COPY pom.xml mvnw ./
COPY .mvn .mvn

# Download dependency (cacheable layer)
RUN ./mvnw dependency:go-offline

# Copy source code
COPY src src

EXPOSE 8080

CMD ["./mvnw", "spring-boot:run"]

Penjelasan Dockerfile #

1. Base Image #

FROM eclipse-temurin:21-jdk-alpine

• OpenJDK resmi dari Eclipse Temurin
• JDK (bukan JRE) karena dibutuhkan saat compile
• Java 21 (LTS)

2. Working Directory #

WORKDIR /app

Menjaga struktur path tetap konsisten dan bersih.

3. Tools Tambahan #

RUN apk add --no-cache bash

Berguna untuk:

• Debug manual
• Menjalankan script

4. Copy Maven Wrapper & pom.xml #

COPY pom.xml mvnw ./
COPY .mvn .mvn

Ini adalah langkah paling penting untuk performa build:

• Dependency Maven jarang berubah
• Docker layer cache bisa dimanfaatkan

5. Download Dependency #

RUN ./mvnw dependency:go-offline

Keuntungan:

• Build berikutnya jauh lebih cepat
• Tidak re-download dependency setiap kali code berubah

6. Copy Source Code #

COPY src src

• Source code sering berubah
• Sengaja diletakkan di layer terakhir

7. Run Spring Boot #

CMD ["./mvnw", "spring-boot:run"]

• Cocok untuk local development
• Mendukung Spring Boot DevTools

Docker Compose #

Peran Docker Compose #

Docker Compose menyatukan:

• Aplikasi Spring Boot
• Database
• Konfigurasi environment

Menjadi satu perintah untuk seluruh stack lokal.

Contoh docker-compose.yml #

version: "3.9"

services:
  app:
    container_name: spring-boot-app
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    volumes:
      - .:/app
      - maven_cache:/root/.m2
    env_file:
      - .env
    depends_on:
      - db
    command: ./mvnw spring-boot:run

  db:
    image: postgres:16-alpine
    container_name: postgres-db
    environment:
      POSTGRES_DB: app_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
  maven_cache:

Penjelasan docker-compose.yml #

1. Service Spring Boot #

Build Image #

build:
  context: .

Build image dari Dockerfile lokal.

Port Mapping #

ports:
  - "8080:8080"

Akses aplikasi via http://localhost:8080.

Volume Mount #

volumes:
  - .:/app
  - maven_cache:/root/.m2

Fungsi penting:

• Sinkronisasi source code
• Cache dependency Maven
• Restart lebih cepat

Environment Variable #

env_file:
  - .env

Konfigurasi tetap di luar source code.

2. Service Database #

• Menggunakan image resmi
• Data persisten dengan named volume

Workflow Development #

1. Jalankan stack:

   docker compose up --build
   

2. Akses aplikasi:

   http://localhost:8080
   

3. Edit source code

4. Spring Boot restart otomatis

Anti-Pattern #

1. Menggunakan Dockerfile production untuk local
2. Tidak cache .m2
3. Build JAR setiap code berubah
4. Hardcode env di Dockerfile

Best Practice #

1. Aktifkan Spring Boot DevTools #

Tambahkan dependency:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
</dependency>

2. Pisahkan Dockerfile Dev & Prod #

• Dockerfile → local development
• Dockerfile.prod → production

3. Jangan Build JAR di Local Dev #

• Gunakan spring-boot:run
• Build JAR hanya untuk production

4. Retry Logic ke Database #

depends_on tidak menjamin DB siap.

Penutup #

Dockerfile dan Docker Compose untuk local development Spring Boot seharusnya mengutamakan developer experience, bukan optimasi ekstrem.

Dengan setup yang tepat:

• Waktu setup project berkurang drastis
• Development lebih konsisten
• Debugging lebih mudah