Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/krishnalagad/learn-helidon-framework
Helidon is a lightweight Java framework for building microservices.
https://github.com/krishnalagad/learn-helidon-framework
Last synced: about 11 hours ago
JSON representation
Helidon is a lightweight Java framework for building microservices.
- Host: GitHub
- URL: https://github.com/krishnalagad/learn-helidon-framework
- Owner: krishnalagad
- Created: 2023-11-09T08:45:40.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2023-11-12T08:47:17.000Z (about 1 year ago)
- Last Synced: 2023-11-12T13:08:53.416Z (about 1 year ago)
- Language: Java
- Homepage:
- Size: 57.6 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# project
Sample Helidon SE project that includes multiple REST operations.
## Build and run
With JDK21
```bash
mvn package
java -jar target/project.jar
```
## Exercise the application
Basic:
```
curl -X GET http://localhost:8080/simple-greet
Hello World!
```
JSON:
```
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!"}
```
## Try metrics
```
# Prometheus Format
curl -s -X GET http://localhost:8080/metrics
# TYPE base:gc_g1_young_generation_count gauge
. . .
# JSON Format
curl -H 'Accept: application/json' -X GET http://localhost:8080/metrics
{"base":...
. . .
```
## Try health
This example shows the basics of using Helidon SE Health. It uses the
set of built-in health checks that Helidon provides plus defines a
custom health check.
Note the port number reported by the application.
Probe the health endpoints:
```bash
curl -X GET http://localhost:8080/observe/health
curl -X GET http://localhost:8080/observe/health/ready
```
## Building a Native Image
The generation of native binaries requires an installation of GraalVM 22.1.0+.
You can build a native binary using Maven as follows:
```
mvn -Pnative-image install -DskipTests
```
The generation of the executable binary may take a few minutes to complete depending on
your hardware and operating system. When completed, the executable file will be available
under the `target` directory and be named after the artifact ID you have chosen during the
project generation phase.
Make sure you have GraalVM locally installed:
```
$GRAALVM_HOME/bin/native-image --version
```
Build the native image using the native image profile:
```
mvn package -Pnative-image
```
This uses the helidon-maven-plugin to perform the native compilation using your installed copy of GraalVM. It might take a while to complete.
Once it completes start the application using the native executable (no JVM!):
```
./target/project
```
Yep, it starts fast. You can exercise the application’s endpoints as before.
## Building the Docker Image
```
docker build -t project .
```
## Running the Docker Image
```
docker run --rm -p 8080:8080 project:latest
```
Exercise the application as described above.
## Run the application in Kubernetes
If you don’t have access to a Kubernetes cluster, you can [install one](https://helidon.io/docs/latest/#/about/kubernetes) on your desktop.
### Verify connectivity to cluster
```
kubectl cluster-info # Verify which cluster
kubectl get pods # Verify connectivity to cluster
```
### Deploy the application to Kubernetes
```
kubectl create -f app.yaml # Deploy application
kubectl get pods # Wait for quickstart pod to be RUNNING
kubectl get service project # Get service info
```
Note the PORTs. You can now exercise the application as you did before but use the second
port number (the NodePort) instead of 8080.
After you’re done, cleanup.
```
kubectl delete -f app.yaml
```
## Building a Custom Runtime Image
Build the custom runtime image using the jlink image profile:
```
mvn package -Pjlink-image
```
This uses the helidon-maven-plugin to perform the custom image generation.
After the build completes it will report some statistics about the build including the reduction in image size.
The target/project-jri directory is a self contained custom image of your application. It contains your application,
its runtime dependencies and the JDK modules it depends on. You can start your application using the provide start script:
```
./target/project-jri/bin/start
```
Class Data Sharing (CDS) Archive
Also included in the custom image is a Class Data Sharing (CDS) archive that improves your application’s startup
performance and in-memory footprint. You can learn more about Class Data Sharing in the JDK documentation.
The CDS archive increases your image size to get these performance optimizations. It can be of significant size (tens of MB).
The size of the CDS archive is reported at the end of the build output.
If you’d rather have a smaller image size (with a slightly increased startup time) you can skip the creation of the CDS
archive by executing your build like this:
```
mvn package -Pjlink-image -Djlink.image.addClassDataSharingArchive=false
```
For more information on available configuration options see the helidon-maven-plugin documentation.