Micronaut Photobook Demo App

Introduction

Recently I followed some Mongo DB courses and attended the Spring I/O 2023.
So I decided to practice a bit. This project is the result.
Currently is just a simple POC integration of Mongo DB and Micronaut

Prerequisites

software	docker compose	local build and run
	no	yes
	no	yes
	no	yes
	no	yes
	yes	no

Quickstart

Start via docker compose

docker-compose -f src/main/docker/docker-compose.yml up -d

Start in dev mode

1. Create mongo db instance with db initialization (script src/test/resources/mongo-db/mongo-init.js) :

docker run --rm -p 27017:27017 --name MONGO8 -v `pwd`/src/test/resources/mongo-db/mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js mongo:8.0.3

This will start a mongo db linked on the default port and with the default username/password (root/example).

2. Start the application in dev mode

The back end

If the Helidon CLI is installed, just run :

mvn mn:run

And front end

cd src/main/react
npm install
npm run start

3. Access home page

http://localhost:8080/photobook-demo/home/index.html

project environment variables

In case you want a custom mongo db connection :

key	dedault
MONGODB_URL	mongodb://localhost:27017/photobook_demo

container environment variables

Other custom environment variables :

key	dedault	description
JAVA_OPTS_APPEND		append java options (for instance '-Xmx1g')

Helidon package

It is possible to compile the application to a single jar package :

mvn package -Pbuildreact

And then run

java -jar target/helidon-photobook.jar

Native image compilation

The code has been set for native compilation with GraalVM (tested with GraalVM 22.3 CE).

Here is the relevant Helidon MP - GraalVM Native Image Guide.

It is possible to compile :

mvn -Pnative-image install -Pbuildreact

And then run

./target/helidon-photobook

Helidon documentation

Refer to Helidon Documentation for more information on Helidon.

Docker image

As stated in the guide micronaut guide : https://guides.micronaut.io/latest/micronaut-docker-image-maven-java.html

It is possible to use a command as simple as

mvn package -Dpackaging=docker

But here I prefer to use classical Dockerfile for setup of github workflow and docker hub push.

docker container (jvm)

Build micronaut application (jar)

mvn package -Pbuildreact

Build container openjdk

docker build -t helidon-photobook-jvm -f src/main/docker/Dockerfile.jvm .

Running the container :

docker run -it -p 8080:8080 --name helidon-photobook-jvm helidon-photobook-jvm

docker container (native)

Building the native image :

mvn package -Dpackaging=native-image -Pbuildreact

Building the container image :

docker build -t helidon-photobook-native -f src/main/docker/Dockerfile.native .

Running the container :

docker run -it -p 8080:8080 --name helidon-photobook-native helidon-photobook-native

Native optimization : PGO

This section is based on https://github.com/alina-yur/native-spring-boot.

One of the most powerful performance optimizations in Native Image is profile-guided optimizations (PGO).

1. Build an instrumented image:

mvn package -Dpackaging=native-image -Pinstrumented

2. Run the app and apply relevant workload:

./target/helidon-photobook-instrumented

hey -n=30000 http://localhost:8080/photobook-demo/api/photobook/view/list

hey -n=30000 http://localhost:8080/photobook-demo/api/photobook/view/images/springio23/language/it/current_page/1/page_size/5

after you shut down the app, you'll see an iprof file in your working directory.

3. Build an app with profiles (they are being picked up via <buildArg>--pgo=${project.basedir}/default.iprof</buildArg>):

mvn package -Dpackaging=native-image -Poptimized

Benchmark scripts

Prerequisites :

• running mongo db
• hey installed
• psrecord installed

At the end of a run, an image will be plotted in the target folder.

1. Benchmark JIT

mvn clean package

./src/main/script/bench-jit.sh

2. Benchmark native

Follow steps in 'Native optimization : PGO' section

./src/main/script/bench-native.sh

3. Benchmark result

Here are shown the result of a run on one of my systems (Multiple runs have been recorded with consistent results) :

Ubuntu 22.04.4 LTS
AMD Ryzen 7 3700X
32 GB of RAM

Sample result of JIT benchmark run :

Sample result of native (AOT) benchmark run :

application stack

Layer	2024 version
Persistence	MongoDB 8
Java version	GraalVM 21
API REST	Micronaut 4.5.x
Node JS	Node 20
Front end package	Vite
Front end UI	React 18.3

Deploy on Google App Engine

Prerequisites :

• google cloud account
• GCloud CLI

Simple app.yaml for AOT and Simple app.yaml for JIT

Customize the app.yaml and run gcloud

gcloud helidon-photobook-*runner.jar --appyaml=src/main/appengine/app-jit.yaml

For JIT version or

gcloud helidon-photobook --appyaml=src/main/appengine/app-aot.yaml

For AOT version

Further reference :

• https://cloud.google.com/sdk/gcloud/reference/app/deploy

Deploy on KNative

Prerequisites :

• container environment (docker / podman)
• Kubernates (for instance minikube)
• Knative

After setting up Knative, Customize the helidon-photobook-jit.yaml or helidon-photobook-aot.yaml service deployment.

And run

kubectl apply -f helidon-photobook-jit.yaml

For JIT version or

kubectl apply -f helidon-photobook-aot.yaml

For AOT version