Micronaut #

Micronaut adalah framework JVM modern yang sejak awal dirancang untuk:

Startup sangat cepat
Konsumsi memori rendah
Dependency Injection berbasis compile-time (bukan reflection)

Micronaut sering disejajarkan dengan Quarkus dan Spring Boot, namun memiliki filosofi yang sedikit berbeda, terutama dalam cara ia menangani build-time processing.

Dalam konteks local development, penggunaan Docker pada Micronaut sering kali keliru karena:

Dockerfile production (JAR / native) dipaksakan untuk development.

Artikel ini akan membahas secara mendetail dan rinci:

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

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

Filosofi Docker Micronaut #

Tujuan utama Docker di local development Micronaut adalah:

Konsistensi environment JVM & OS
Iterasi cepat (edit → reload → test)
Menyamakan setup antar developer

Bukan untuk:

Image sekecil mungkin
Native image
Multi-stage build kompleks

Prinsip sederhananya:

Local dev mengutamakan feedback loop, bukan optimasi runtime.

Gambaran Arsitektur #

Setup Micronaut lokal umumnya terdiri dari:

Aplikasi Micronaut
Database (PostgreSQL / MySQL)
(Opsional) Redis / Kafka

Diagram sederhana:

Developer
   |
   v
Docker Compose
   |
   +--> micronaut-app
   |
   +--> database

Struktur Project Micronaut #

Contoh struktur Micronaut berbasis Maven:

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

Karakteristik Dockerfile Micronaut #

Aspek	Local Development	Production
Mode	Maven run	JAR / native
Reload	Restart cepat	Tidak perlu
Build	On-the-fly	Multi-stage
Tool	Lengkap	Minimal

Micronaut tidak memiliki dev mode seagresif Quarkus, sehingga strategi reload sedikit berbeda.

Dockerfile untuk Micronaut #

Prinsip Dasar #

Gunakan JDK
Jalankan via Maven
Cache dependency
Hindari build JAR

Contoh Dockerfile #

FROM eclipse-temurin:21-jdk-alpine

WORKDIR /app

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

# Copy Maven wrapper & descriptor
COPY pom.xml mvnw ./
COPY .mvn .mvn

# Cache dependency
RUN ./mvnw dependency:go-offline

# Copy source code
COPY src src

EXPOSE 8080

CMD ["./mvnw", "mn:run"]

Penjelasan Dockerfile #

1. Base Image #

FROM eclipse-temurin:21-jdk-alpine

JDK diperlukan karena Micronaut melakukan annotation processing saat compile
Java 21 LTS

2. Working Directory #

WORKDIR /app

Menjaga struktur path tetap konsisten.

3. Tool Tambahan #

RUN apk add --no-cache bash curl

Berguna untuk debugging dan health check manual.

4. Copy pom.xml & Maven Wrapper #

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

Langkah krusial untuk Docker layer caching.

5. Preload Dependency #

RUN ./mvnw dependency:go-offline

Menghindari download dependency berulang saat iterasi code.

6. Copy Source Code #

COPY src src

Source code sengaja diletakkan di layer terakhir karena sering berubah.

7. Menjalankan Micronaut #

CMD ["./mvnw", "mn:run"]

Menjalankan Micronaut via Maven plugin
Cocok untuk local development

Docker Compose #

Peran Docker Compose #

Docker Compose digunakan untuk:

Menjalankan Micronaut + database
Mengelola environment variable
Menyatukan stack lokal dalam satu perintah

Contoh docker-compose.yml #

version: "3.9"

services:
  app:
    container_name: micronaut-app
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    volumes:
      - .:/app
      - maven_cache:/root/.m2
    env_file:
      - .env
    depends_on:
      - db
    command: ./mvnw mn: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 Micronaut App #

Port Mapping #

ports:
  - "8080:8080"

Akses API melalui http://localhost:8080.

Volume Mount #

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

Sinkronisasi source code
Cache dependency Maven
Restart lebih cepat

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
Micronaut restart otomatis

Anti-Pattern #

Menggunakan Dockerfile production untuk local
Tidak mount .m2
Menggunakan JRE image
Menganggap Micronaut punya dev mode seperti Quarkus

Best Practice #

1. Pisahkan Dockerfile Dev & Prod #

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

2. Jangan Build JAR di Local Dev #

Build JAR hanya untuk production
Local dev fokus iterasi cepat

3. Cache `.m2` Selalu #

Tanpa cache, waktu build akan sangat lambat.

4. Database Retry Logic #

depends_on tidak menjamin database siap.

Penutup #

Dockerfile dan Docker Compose untuk local development Micronaut harus disusun dengan pemahaman bahwa Micronaut mengandalkan compile-time processing dan startup cepat.

Dengan setup yang tepat:

Iterasi development tetap cepat
Environment konsisten
Tidak mengorbankan kenyamanan developer