Quarkus #

Quarkus dikenal sebagai Supersonic Subatomic Java — framework Java yang sejak awal didesain dengan filosofi container-first dan cloud-native. Dibandingkan Spring Boot, Quarkus menawarkan:

Startup time sangat cepat
Memory footprint lebih kecil
Developer mode yang agresif (hot reload hampir instan)

Namun, justru karena Quarkus sangat “dekat” dengan container, kesalahan paling umum adalah:

Menggunakan Dockerfile production (JVM / native) untuk local development.

Artikel ini membahas secara mendetail dan rinci bagaimana menyusun:

Dockerfile Quarkus yang tepat untuk local development
Docker Compose sebagai local orchestrator
Workflow development harian yang efisien
Best practice serta anti-pattern yang sering terjadi

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

Filosofi Docker Quarkus #

Untuk local development, tujuan Docker bukan:

Image sekecil mungkin
Native binary
Multi-stage build kompleks

Tujuan utamanya adalah:

Fast feedback loop
Hot reload stabil
Konsistensi environment antar developer

Ringkasnya:

Local dev = kenyamanan developer Production = optimasi runtime

Gambaran Arsitektur #

Setup umum Quarkus local development:

Aplikasi Quarkus (dev mode)
Database (PostgreSQL / MySQL)
(Opsional) Redis / Kafka

Diagram sederhana:

Developer
   |
   v
Docker Compose
   |
   +--> quarkus-app (dev mode)
   |
   +--> database

Struktur Project Quarkus #

Contoh struktur project Maven-based:

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

Karakteristik Dockerfile #

Aspek	Local Development	Production
Mode	quarkus:dev	JVM / native
Reload	Hot reload	Tidak perlu
Build	Maven langsung	Multi-stage
Tool	Lengkap	Minimal

Menggunakan quarkus:dev di container adalah kunci utama.

Dockerfile untuk Quarkus #

Prinsip Dasar #

Gunakan JDK (bukan JRE)
Jalankan Quarkus di dev mode
Manfaatkan cache dependency Maven
Hindari build JAR

Contoh Dockerfile #

FROM eclipse-temurin:21-jdk-alpine

WORKDIR /app

# Tool tambahan untuk debugging
RUN apk add --no-cache bash curl

# Copy Maven wrapper & descriptor 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", "quarkus:dev"]

Penjelasan Dockerfile #

1. Base Image #

FROM eclipse-temurin:21-jdk-alpine

JDK diperlukan untuk compile on-the-fly
Java 21 adalah LTS terbaru
Alpine cukup ringan untuk local dev

2. Working Directory #

WORKDIR /app

Menjaga path konsisten dan sederhana.

3. Tool Tambahan #

RUN apk add --no-cache bash curl

Digunakan untuk:

Debug endpoint
Health check manual

4. Copy Maven Wrapper & pom.xml #

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

Langkah ini sangat krusial untuk performa:

Dependency jarang berubah
Docker layer cache bisa dimanfaatkan

5. Dependency Preload #

RUN ./mvnw dependency:go-offline

Keuntungan:

Startup container lebih cepat
Tidak download dependency berulang

6. Copy Source Code #

COPY src src

Source code sering berubah
Sengaja di layer terakhir

7. Menjalankan Quarkus Dev Mode #

CMD ["./mvnw", "quarkus:dev"]

Inilah inti local development Quarkus:

Hot reload hampir instan
Config reload otomatis
Dev UI aktif

Docker Compose #

Peran Docker Compose #

Docker Compose berfungsi sebagai:

Orchestrator seluruh stack lokal
Pengelola environment variable
Penghubung antar container

Satu perintah untuk semuanya.

Contoh docker-compose.yml #

version: "3.9"

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

  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 Quarkus App #

Port Mapping #

ports:
  - "8080:8080"

API: http://localhost:8080
Dev UI: http://localhost:8080/q/dev

Volume Mount #

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

Fungsi penting:

Sinkronisasi source code
Hot reload real-time
Cache dependency Maven

Environment Variable #

env_file:
  - .env

Memisahkan konfigurasi dari source code.

2. Service Database #

Image resmi PostgreSQL
Data persisten via volume

Workflow Development #

Jalankan stack:
```
docker compose up --build
```
Akses aplikasi:
```
http://localhost:8080
```
Edit source code
Quarkus reload hampir instan

Anti-Pattern #

Build native image untuk local dev
Tidak mount .m2
Menggunakan JRE image
Menghilangkan dev mode

Best Practice #

1. Gunakan Dev Mode, Selalu #

Jangan jalankan JAR di local dev
Dev mode adalah kekuatan utama Quarkus

2. Pisahkan Dockerfile Dev & Prod #

Dockerfile → dev
Dockerfile.jvm / Dockerfile.native → prod

3. Jangan Gunakan Native Image di Local Dev #

Build lama
Tidak ramah iterasi cepat

4. Database Retry Logic #

depends_on tidak menjamin DB siap.

Penutup #

Dockerfile dan Docker Compose untuk local development Quarkus harus memaksimalkan keunggulan framework itu sendiri: hot reload super cepat dan developer mode yang matang.

Dengan setup yang tepat:

Iterasi development jauh lebih cepat
Environment konsisten
Developer experience meningkat signifikan