Learn Quarkus - Modern Tooling & Build Automation

#Introduction

Developer experience isn't an afterthought — it determines how quickly you deliver value. Quarkus is known for tooling that makes the development loop very short: a complete CLI, tightly integrated Maven and Gradle plugins, Dev Services that spin up infrastructure automatically, and the Dev UI as a live dashboard.

Episode 19 covers modern tooling and build automation in Quarkus: the Quarkus CLI, Maven and Gradle plugins, Dev Services, live coding and the Dev UI, as well as reproducible artifacts and native image pipelines.

#The Quarkus CLI, Maven Plugin, and Gradle Plugin

#The Quarkus CLI

The Quarkus CLI unifies almost every operation into a single command:

quarkus create app com.example:proyek-baru
quarkus extension list
quarkus extension add cache
quarkus dev
quarkus build
quarkus build --native

From create to build, everything goes through the CLI. The command quarkus dev is the equivalent of ./mvnw quarkus:dev for both Maven and Gradle projects.

#The Maven and Gradle Plugins

The same functionality is available through each build tool's plugin:

./mvnw quarkus:dev
./mvnw quarkus:add-extension -Dextensions=redis-client
./mvnw quarkus:build -Dquarkus.package.type=native
 
./gradlew quarkusDev
./gradlew addExtension --extensions="redis-client"
./gradlew build -Dquarkus.package.type=native

Pick one build tool and stay consistent. The Quarkus CLI is usually the most convenient because it hides the differences between Maven and Gradle.

#Dev Services for Databases, Kafka, and Observability

#Automatic Databases

Dev Services is one of Quarkus' most striking features. In dev mode, a database extension without a URL configuration automatically runs the database in Docker:

quarkus.datasource.db-kind=postgresql

Without a jdbc.url, Quarkus starts PostgreSQL in a container when dev mode begins and stops it when dev mode ends. Containers also spin up for Kafka, Redis, and many other services.

#Kafka and Other Infrastructure

mp.messaging.incoming.orders-in.connector=smallrye-kafka
quarkus.kafka.devservices.enabled=true

With quarkus.kafka.devservices.enabled=true, Quarkus runs Redpanda or Kafka in a container. You get a real broker with no manual setup — ideal for testing reactive messaging (episode 15).

#Live Coding and the Dev UI

#The Fast Development Loop

Live coding (episode 2) is already the default in dev mode. Changes to code, resources, or configuration are applied almost instantly. The Dev UI at http://localhost:8080/q/dev provides visual inspection:

Config      : view and edit configuration
Dev Services: status of running containers
HTTP        : list endpoints and test requests
Health      : health check status

The Dev UI is a debugging tool few other frameworks have. Use it to inspect beans, config, and endpoints without writing tests.

#Enabling and Restricting the Dev UI

The Dev UI is active automatically in the dev profile. For production, the Dev UI isn't bundled by default — make sure quarkus.dev-ui.enabled stays aligned with your security policy.

#Reproducible Build Artifacts and the Native Image Pipeline

#Reproducible Builds

A reproducible build produces identical output from the same source. Enable it in application.properties:

quarkus.package.reproducible=true

quarkus.package.reproducible=true makes timestamps and metadata reproducible, so build results can be verified and cached safely.

#The Native Image Pipeline

For continuous integration, a native pipeline needs specific steps:

./mvnw -B verify -DskipTests=false
./mvnw -B package -Pnative \
    -Dquarkus.native.container-build=true \
    -Dquarkus.native.native-image-xmx=3g

Native builds in CI use container-build so they don't depend on a local GraalVM, and limit the compilation memory with native-image-xmx. Episode 21 will cover full CI/CD integration.

#Verifying Artifacts

After the build, verify the artifact contents:

ls -lh target/*-runner
ls -lh target/quarkus-app/
./target/*-runner --version

The *-runner file is the native executable; the quarkus-app folder contains the JVM-mode application. --version confirms the executable runs.

#Wrap-Up

Episode 19 sharpens your workflow: understanding the Quarkus CLI, Maven plugin, and Gradle plugin, Dev Services that spin up infrastructure automatically, live coding and the Dev UI as a developer dashboard, as well as reproducible artifacts and native image pipelines.

Key takeaways:

• The Quarkus CLI unifies create, extension, dev, and build.
• The Maven and Gradle plugins provide the same functionality.
• Dev Services runs databases and Kafka in Docker with no setup.
• The Dev UI at /q/dev makes inspecting the application easy during development.
• quarkus.package.reproducible=true produces reproducible builds.
• Native builds in CI use -Dquarkus.native.container-build=true.
• Always verify build artifacts before deploying.

In episode 20 we'll cover cloud-native deployment — Dockerizing Quarkus for container-ready deployment, Kubernetes deployment and Helm charts, Knative and serverless concepts, as well as integration with the AWS, GCP, Azure, and Kubernetes platforms.