For this 5 minute tutorial, you will need the following:

java -version
mvn --version
docker --version
kubectl version

# On Mac
export JAVA_HOME=`/usr/libexec/java_home -v 21`

# On Linux
# Use the appropriate path to your JDK
export JAVA_HOME=/usr/lib/jvm/jdk-21

Generate the project sources using the Helidon Maven archetype. The result is a simple project that shows the basics of a Helidon SE application using simple WebServer routing rules.

mvn -U archetype:generate -DinteractiveMode=false \
    -DarchetypeGroupId=io.helidon.archetypes \
    -DarchetypeArtifactId=helidon-quickstart-se \
    -DarchetypeVersion=4.3.3 \
    -DgroupId=io.helidon.examples \
    -DartifactId=helidon-quickstart-se \
    -Dpackage=io.helidon.examples.quickstart.se

helidon init --batch -Dflavor=mp -Dapp-type=quickstart

The archetype generates a Maven project in your current directory (for example, helidon-quickstart-se). Change into this directory.

cd helidon-quickstart-se

mvn package

The project builds an application jar for the example and saves all runtime dependencies in the target/libs directory. This means you can easily start the application by running the application jar file:

java -jar target/helidon-quickstart-se.jar

The example is a very simple "Hello World" greeting service. It supports GET requests for generating a greeting message, and a PUT request for changing the greeting itself. The response is encoded using JSON. For example:

curl -X GET http://localhost:8080/greet
{"message":"Hello World!"}

curl -X GET http://localhost:8080/greet/Joe
{"message":"Hello Joe!"}

curl -X PUT -H "Content-Type: application/json" -d '{"greeting" : "Hola"}' http://localhost:8080/greet/greeting

curl -X GET http://localhost:8080/greet/Jose
{"message":"Hola Jose!"}

Helidon provides built-in support for health and metrics endpoints.

curl -sv -X GET http://localhost:8080/observe/health

Notice we use the -v option to curl so that you can see that the health endpoint returns 204 (No Content) by default.

curl -s -X GET http://localhost:8080/observe/metrics

curl -H 'Accept: application/json' -X GET http://localhost:8080/observe/metrics

The project also contains a Dockerfile so that you can easily build and run a Docker image. To build the Docker image, you need to have Docker installed and running on your system.

docker build -t helidon-quickstart-se .

docker run --rm -p 8080:8080 helidon-quickstart-se:latest

Then you can try the application as you did before.

If you don’t have access to a Kubernetes cluster, you can install one on your desktop. Then deploy the example:

kubectl cluster-info
kubectl get nodes

kubectl create -f app.yaml
kubectl get pods # Wait for quickstart pod to be RUNNING

The step above created a service that is exposed into any node port. Lookup the service to find the port.

kubectl get service helidon-quickstart-se

Note the PORTs. You can now exercise the application as you did before but use the second port number (the NodePort) instead of 8080. For example:

curl -X GET http://localhost:31431/greet

After you’re done, cleanup.

kubectl delete -f app.yaml

Helidon also includes support for GraalVM Native Images and Java Custom Runtime Images. For more information see:

• GraalVM Native Images

• Custom Runtime Images using jlink

With the Helidon CLI you can create additional types of Helidon applications and use the "dev loop" to do fast, iterative development. Try it now.