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 17`

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

Generate the project sources using one (or both) of the Helidon Maven archetypes. The result is a simple project that shows the basics of configuring the WebServer and implementing basic routing rules.

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

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

cd helidon-quickstart-mp

The Health and Metrics section below describes how Helidon supports those observability features. Helidon further provides some optional built-in health checks. To include them in your application add the following dependency to your project’s pom.xml file:

<dependency>
    <groupId>io.helidon.health</groupId>
    <artifactId>helidon-health-checks</artifactId>
    <scope>runtime</scope>
</dependency>

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-mp.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 -s -X GET http://localhost:8080/health

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

curl -H 'Accept: application/json' -X GET http://localhost:8080/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-mp .

docker run --rm -p 8080:8080 helidon-quickstart-mp: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-mp

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.