Forem: Andrii Maliuta

GCP Serverless Function in Java with 15Mb RAM

Andrii Maliuta — Mon, 16 Oct 2023 14:58:39 +0000

The blog is more about experimenting with Java Native build to achieve less RAM use.

Usually, when using Java as a runtime for Google Cloud functions (https://cloud.google.com/functions/docs/concepts/java-runtime) the average RAM footprint is about 140 MB for a simple REST API Jax-RS based endpoint with JSON (text) static response. For example, the same example in Golang (one HTTP GET method) with JSON response is around 30 MB RAM.

To try to achieve less RAM footprint with Java (e.g. to use 128 MB GCP tier), let us try to use:

Java Socket as very simple HTTP server
GraalVM Native build
Docker
Google Cloud Run to use custom Docker image as an app

Java code

Source code: https://github.com/ahndmal/http-simple-sock-native

We create ServerSocket and accept connections on port 8080:

try (ServerSocket serverSocket = new ServerSocket(8080)) {
                System.out.println(">>> Server started on port 8080");

 while(true) {
    Socket accept = serverSocket.accept();

    System.out.println("> client connected");

    InputStream inputStream = accept.getInputStream();
    OutputStream outputStream = accept.getOutputStream();
   ...
}

We create IO streams to get requests and write data to the output (browser) as a static HTTP GET response.

PrintWriter writer = new PrintWriter(new OutputStreamWriter(outputStream));

writer.write("HTTP/1.1 200 OK\n");
writer.write("Content-Type: text/html\r\n\n");
writer.write("""
   <!doctype html><html>
   <head><title>Java</title></head>
   <body>
   <h2>Java Server</h2>
   <div>Test</div>
   </body>
   </html>""");

We can just use any HTML file and read its contents for a response instead of this hardcoded text.

Docker image

We use 3 stages for Docker build:

Build Jar file
Use GraalVM findepi image to build native image from this Jar
Use Debian slim to run the native app

# maven build
FROM maven:3.8.6-amazoncorretto-19 AS BUILD
COPY . .
RUN mvn clean package

# native build
FROM ghcr.io/graalvm/jdk:java
FROM findepi/graalvm:22.3.1-java19-native AS GRAAL
COPY --from=BUILD target/http-sock-3-0.0.2.jar /http-sock.jar
RUN gu install native-image && native-image -jar http-sock.jar

# run app
FROM debian:12-slim
#FROM debian:stable-slim
COPY --from=GRAAL /http-sock /tmp/http-sock
CMD ["/tmp/http-sock"]

Build Docker image locally:

docker build --tag java-http-simple:0.0.1 .

Tag docker image for GCP Artifact registry:

docker tag java-http-simple:0.0.1 us-east1-docker.pkg.dev/{PROJECT}/{ART_REG}/java-http-simple:0.0.2

Deploy image from Artifact Registry to Cloud Run:

gcloud run deploy <service-name> --image <image_name>

Metrics

Trigger the URL of the deployed Cloud Run service and check the results:

HTTP response:

120 byte data
160 ms response time

RAM metrics:

12% of RAM from 128MB service (~15.3 MB)

As we can see, the memory footprint is around 14MB.

Of course this is a silly app with a primitive response, but it is possible to use such an approach to create a simple REST API app with the DB data and JSON parsing with the little use of RAM.

Thank you for reading!

HTTP Client UI with Kotlin and JavaFX

Andrii Maliuta — Sat, 05 Aug 2023 10:25:01 +0000

Sometimes it can be useful to use some UI to perform HTTP requests and not just CLI tools. Od course, there are tools like Postamn or Insomnia and they are great, but it can be good to have some very simple own UI to do this and test some simple thinsgs :)

Code on Github: https://github.com/ahndmal/http-client-ktl-jfx.

We will use Kotlin (https://kotlinlang.org) and OpenJFX (https://openjfx.io) and Gradle to build the app (though javac / kotlinc can be enough).

We add "org.openjfx.javafxplugin" Gradle plugin to build.gradle.kts and add basic configuration:

plugins {
    kotlin("jvm") version "1.9.0"
    application
    **id("org.openjfx.javafxplugin") version "0.0.13"**
}

javafx {
    setVersion("20")
    setModules(listOf("javafx.controls"))
}

group = "com.andmal"
version = "0.0.2"

repositories {
    mavenCentral()
}

kotlin {
    jvmToolchain(20)
}

application {
    mainClass.set("Main")
}

Also, we create Main.kt file to add the basic logic to initiate UI with JavaFX library.

class Main : Application() {
    override fun start(primaryStage: Stage?) {
        val scene = Scene(createContent(), 1200.0, 900.0)
        primaryStage?.title = "HTTP Client"
        primaryStage?.scene = scene
        primaryStage?.show()
    }
}

The Main class extends the javafx.application.Application and implements the start method to initiate the UI. We add the createContent() method as the parameter to start method and add the basic logic to it:

private fun createContent(): Parent {
   // todo
}

To combine the UI we can use basic VBox / HBox classes for vertical and horizonal alignment of elemtns and also GridPane to map the items by rows and columns.

We add basic UI elements:

val mainBox = VBox()
val requestBox = VBox()
val reqPane = GridPane()
val reqBody = TextArea()

// response 
val responsePane = GridPane()
val responseBox = VBox()
val urlLabel = Label("URL")
urlField = TextField()

Add some padding and background:

mainBox.padding = Insets(10.0)
requestBox.border = Border.stroke(Paint.valueOf("orange"))
HBox.setMargin(requestBox, Insets(10.0))
reqBody.minWidth = 500.0
reqBody.minHeight = 200.0

Then we add buttons, headers to the core elements:

reqPane.add(methodType, 0, 2)
reqPane.add(urlField, 1, 2)
reqPane.add(reqButton, 2, 2)
reqPane.add(reqHeaderButton, 2, 3)

requestBox.children.add(reqPane)
responseBox.children.add(responsePane)

mainBox.children.addAll(
    requestBox, responseBox
)

Add listeners to buttons to react to clicking on it:

reqButton.setOnMouseClicked { event ->
     if (urlField.length == 0) {
           infoHeader.text = "Error: please fill in URL"
           infoHeader.background = Background.fill(Paint.valueOf("red"))
           infoHeader.textFill = Paint.valueOf("white")
           infoHeader.font = Font.font(17.0)
           responsePane.add(infoHeader, 0, 0)
            } else {
                // correct request data
             responseBox.children.removeAll()
     }
}

Also, we add "Save file" button to save the response as a file:

saveAsFileBtn.setOnMouseClicked {
    val file = 
Files.createFile(Path.of("./response_${Instant.now().epochSecond}"))
                    file.writeBytes(httpResponse.body().toByteArray())
}

We use java.net.http.CLient (available since Java v.11) as simple and basic HTTP client:

// HTTP client
val client = HttpClient.newBuilder()
      .version(HttpClient.Version.HTTP_1_1).build()

// request
val req = HttpRequest.newBuilder()
   .uri(URI.create(urlField.text))

We want to have some text field for body when using POST or PUT methods:

methodType.setOnAction {
    when (methodType.value.first) {
       "GET" -> reqPane.children.remove(reqBody)
       "POST" ->  reqPane.add(reqBody, 1, 3)
       "PUT" ->  reqPane.add(reqBody, 1, 3)
    }
}

Complete building HTTP request depending on what HTTP method we select:

when(methodType.value.second) {
   "GET" -> req.GET()
   "POST" -> req.POST(BodyPublishers.ofString(reqBody.text))
   "PUT" -> req.PUT(BodyPublishers.ofString(reqBody.text))
   "DELETE" -> req.DELETE()
}

So we have request section with:

Select of reqest type
URL field
Send button to send request

Response:

Text area to show response body
Headers and Status buttons to show additional data when clicking them

Run the app:

Java-based console app as HTTP client

Andrii Maliuta — Fri, 23 Jun 2023 16:08:21 +0000

So here is "Ye another one http client" 🐱 that I created for personal use as practice and just to have own tool to test HTTP requests not to download CURL or HTTpie 🐱.

Source code: https://github.com/ahndmal/http-client-java-cli/

JCurl (very hard to create name 🐱)

So this is the console app in Java to receive some arguments and perform HTTP / Socket requests to the passed web host as an URI. Here Java 11 HTTP client is used as a core. To perform more requests without blocking, async reactive processing of requests is used

// client
 HttpClient client = HttpClient.newBuilder()
      .version(HttpClient.Version.HTTP_2)
      .build();

It is a Native and JDK based HTTP client. To build the app as a native executible, we use GraalVM (https://www.graalvm.org/).

Gradle GraalVM plugin

As a build tool we use Gradle and Gradle GraalVM plugin (https://graalvm.github.io/native-build-tools/latest/gradle-plugin.html) that is flexible and fast to build (relatively 🐱) due to cahing.


graalvmNative {
    binaries {
        named("main") {
            javaLauncher.set(javaToolchains.launcherFor {
                languageVersion.set(JavaLanguageVersion.of(19))
            })
            mainClass.set("com.andmal.Main")
            verbose.set(true)
        }
    }
}

Build manually

To build the app as a JAR file:

gradlew build

Then we can run it as usual JAR file with JRE.

Build as native executable:

./gradlew nativeCompile

Run

As Java

  java -jar build/libs/http-client-java-cli-19.jar --url http://example.com --method GET

As CLI app

    jcurl --url http://example.com --method GET

So the signature is:

jcurl [arguments]

Arguments

request URI:

  --url

Method (GET / POST / PUT / DELETE / HEAD)

 --method

Authorization:

 --auth

-A

as 'USER:PASSWORD'. e.g.

 --auth admin:admin

Headers:

 --headers

request Headers in format of:

 key:value, key2:value2

query parameters

 --query

for the request. will be passed as

 ?query=

Examples

GET

    jcurl --url http://example.com --method GET

POST

    jcurl --url http://example.com --method POST --body '{"name": "Vasyl"}' --headers 'Content-Type: application/json'

WebEx bot with webex-java-sdk and Spring. Part 1

Andrii Maliuta — Sat, 30 Jul 2022 08:02:15 +0000

To use the Webex chat you need to register for a Webex Account at https://developer.webex.com/.

Create WebEx app that will server as your bot

Go to https://developer.webex.com/my-apps and create the app that will be acting as your bot:

Create Spring Java App

It is not mandatory to use Spring - any way of creating Web App with Java framework can do. Also, a serverless apps or lambdas can be used to host the code.

We will use Spring Boot app:

Groovy
Gradle
Spring Web
Gson (parse JSON)
Jsoup (parse HTML messages)

Gradle dependencies code:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'  
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'javax.json:javax.json-api:1.1.4'
    implementation 'org.glassfish:javax.json:1.1'
    implementation 'com.google.code.gson:gson:2.8.9'
    implementation('org.jsoup:jsoup:1.14.3')
    implementation 'org.codehaus.groovy:groovy'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

Install Spark SDK

Not to create models and services to interact with Webex and use HTTP calls, we can use the WebEx Java SDK (https://github.com/webex/webex-java-sdk (Spark Java SDK)).
It can be installed via Gradle - use gradle install to locate the code locally in maven repos.

App code

We will create RoomService that will interact with WebEx Room that exist in WebEx of our account.

RoomService.groovy

import com.anma.wbb.webexbotbsg.Room

interface RoomService {

    List<Room> getRooms(teamId, type, sortBy, max);
    public Room getRoom(String id);

}

RoomServiceImpl class that implements RoomService interface

import com.anma.wbb.webexbotbsg.Room
import com.anma.wbb.webexbotbsg.Spark
import org.springframework.stereotype.Service

@Service
class RoomServiceImpl implements RoomService {

    String testBot = System.getenv("WEBEX_TEST_BOT");
    String myToken = System.getenv("WEBEX_MY_TOKEN");

    Spark spark = Spark.builder()
            .baseUrl(URI.create("https://api.ciscospark.com/v1"))
            .accessToken(bsgBot)
            .build();

    @Override
    public Room getRoom(String id) {
        Room room = spark.rooms().path("/${id}").get()
        return room
    }

    @Override
    List<Room> getRooms(teamId, type, sortBy, max) {

        List<Room> rooms = new ArrayList<>()
        spark.rooms()
                .iterate()
                .forEachRemaining(room -> {
//                    System.out.println(room.getTitle() + ", created " + room.getCreated() + ": " + room.getId());
                    rooms.add(room)
                })

        return rooms
    }
}

So, now we have the service that gets rooms and its implementation. We can also add the services that will interact with messages that are present in rooms.

Minimalistic Kubernetes apps with Microk8s

Andrii Maliuta — Sat, 16 Jul 2022 18:23:22 +0000

When I first started to learn Kubernetes, I tries to figured out how to start quickly and with minimal efforts for bootstrap. At that time I did not find guides how to use K8s locally on own server or in VPS and not in SAAS.

So, the options to use K8s in simple way are:

Install K8s modules (kubectl, apis, proxy, etc.) manually
Minikube
Kind
Kubeadm
Microk8s

Official guide of K8s tools options - https://kubernetes.io/docs/tasks/tools/

All options are good and have nice tooling, but today I will describe using microk8s (https://microk8s.io/). For me it was the simplest way to bootstrap the environment with app running in K8s.

Installation

I will describe use of K8s in Ubuntu OS, but it is easy to use it in most other OS you like.

The simplest way is to use SNAP:

Install microk8s
$ sudo snap install microk8s --classic --channel=1.24
Configure permissions:

sudo usermod -a -G microk8s $USER
sudo chown -f -R $USER ~/.kube

Check for successful installation: microk8s status --wait-ready

Addons

Microk8s has a nice ecosystem of addons that help to minimize manual configuration of APIs. Full list of add-ons:
https://microk8s.io/docs/addons#heading--list

We will use:

microk8s enable dns - for communication with outer world
microk8s enable dashboard - for use of UI

That's it!

You can use usual kubectl commands:

microk8s kubectl get all
microk8s kubcectl get pods

Also, you can check, start and stop service:

microk8s stop
microk8s start
microk8s status

Full list of commands: https://microk8s.io/docs/command-reference

Further I will write how to deploy Spring, Go or other apps in microk8s and VPS.

Thank you for reading!

Interact with Confluence Server via REST API using NodeJS(JS)

Andrii Maliuta — Fri, 06 May 2022 09:04:52 +0000

Sometimes there can be a need to automate some actions in Confluence or perform some action multiple times, etc. For this Confluence REST API can be used together with the programming language and API to interact via HTTP.

Previous example using Groovy - https://dev.to/andriimaliuta/how-to-update-several-pages-in-confluence-via-rest-api-k6c.

In this example we will use JavaScript and axios library (you do not need the very axios and can use core FETCH if you want - this is just one of ways) to initiate Confluence REST endpoints to:

getPage.js
getChildren.js
getDescendants.js
createComment.js
createPage.js
deleteLabel.js
getPageLabels.js

Git repo - https://github.com/ahndmal/js-atlassian-rest-client

Data file

Approximate file structure:

First we create data.js file to store constants with data:

const dotenv = require('dotenv');
dotenv.config();
const username = process.env.username;
const password = process.env.password;
const CONF_URL = process.env.CONF_URL;

module.exports = {
  authData: Buffer.from(`${username}:${password}`).toString('base64'),
  CONF_URL
};

We create Basic Auth Base64 token from username and password.

Get Page information

Request:

GET /rest/content

CONTENT is the entity that represents:

page
comment
blogpost

The example of getPage.js file:

const axios = require('axios');
const https = require('https');
const { authData, CONF_URL } = require('./data');

module.exports = async function getPage(pageId) {
  console.log('>>> Initiating REST request...');

  return axios.get(`${CONF_URL}/rest/api/content/${pageId}`, {
    headers: {
      Authorization: `Basic ${authData}`,
    },
    httpsAgent: new https.Agent({
      rejectUnauthorized: false,
    }),
  });
};

getChildren.js

Request:

GET ${CONF_URL}/rest/api/content/${pageId}/child/page

const axios = require("axios");
const https = require("https");
const { authData, CONF_URL } = require("./data");

module.exports = async function getPageChildren(pageId) {
  console.log(" Initiating REST request...");

  return await axios.get(`${CONF_URL}/rest/api/content/${pageId}/child/page`, {
    headers: {
      Authorization: `Basic ${authData}`,
    },
    httpsAgent: new https.Agent({
      rejectUnauthorized: false,
    }),
  });
};

getDescendants.js

const axios = require("axios");
const https = require("https");
const { authData, CONF_URL } = require("./data");

module.exports = async function getPageChildren(pageId) {
  console.log(">>> Initiating REST request...");

  return await axios.get(
    `${CONF_URL}/rest/api/search?cql=type+=+"page"+and+ancestor+%3D+"${pageId}"`,
    {
      headers: {
        Authorization: `Basic ${authData}`,
      },
      httpsAgent: new https.Agent({
        rejectUnauthorized: false,
      }),
    }
  );
};

Create Page (Blogpost / Comment)

createPage.js

const axios = require('axios');
const https = require('https');
const { authData, CONF_URL } = require('./data');

module.exports = async function createPage(space, title, body, parent_id) {
  console.log(' Initiating REST request...');
  data = {
    type: 'page',
    title: title,
    space: { key: space },
    body: {
      storage: {
        value: body,
        representation: 'storage',
      },
    },
    ancestors: [{ id: parent_id }],
  };

  return await axios.post(`${CONF_URL}/rest/api/content`, {
    headers: {
      Authorization: `Basic ${authData}`,
      'Content-Type': 'application/json',
    },
    httpsAgent: new https.Agent({
      rejectUnauthorized: false,
    }),
    data: data,
  });
};

Making requests

Now we craete index.js file (name is up to you :), of course ) and perform necessary actions. Here we will CONSOLE.LOG the result of requests, but of course you can further adjust, combine and expand code to do what you need.

const getPage = require('./getPage');
const getChildren = require('./getChildren');
const getDescendants = require('./getDescendants');
const createPage = require('./createPage');
const getPageLabels = require('./getPageLabels');
const createComment = require('./createComment');

const PAGE_ID = 123456; // specify the PAGE ID

async function init() {

// GET PAGE
   getPage(PAGE_ID)
     .then((res) => console.log(res.data))
     .catch((err) => console.log(err));

  // GET all descendant pages of the root one
   getDescendants(PAGE_ID).then((res) => console.log(res.data));

  // ====== Create Page =====
const SPACE_KEY = "TEST";
  createPage(SPACE_KEY, 'MY PAGE TITLE', 'this is body', PAGE_ID).then((res) =>
    console.log(res.data)
  );

  // ====== Create comment ======
   createComment('TEST', 'test title', 'rest comment!', 1000, PAGE_ID).then(
     (res) => console.log(res.data)
   );

// labels

   const PAGE_ID = 12345;
   getPageLabels(PAGE_ID).then((res) => {
     for (label of res.data.results) {
       deleteLabel(PAGE_ID, label.name);
     }
   });

   deleteLabel(labelId, "error-template").then((res) => console.log(res.data));

}

// ========= initiate the code !!
init();

That is all. Of course , these are promitive examples , but the sooth is to understand the very principles and then further do almost any actions you need via REST API that to ease your work with Confluence :)

Please let me know if it is helpful.

Thanks!

How to update Contents in Confluence via REST API

Andrii Maliuta — Sun, 06 Mar 2022 13:09:37 +0000

There are some options about how to use Confluence REST API to operate on pages/blogs/comments/etc., but there are some peculiarities of how to use it in some non-standard cases.

The Confluence SERVER REST API link is https://docs.atlassian.com/ConfluenceServer/rest/7.16.2/, and CLOUD REST API - https://developer.atlassian.com/cloud/confluence/rest/. They are almost the same in simple operations like page creation or update, but differ a lot in its use for complex cases.

So, our task is to update the branch of pages in TEST Confluence space, to find and replace Patch008 text to Patch009. Yes, illogical operation, but anyway it is to give the example :) We need to:

Get descendant pages of the root one
Get bodies of those pages
Find and replace the text in page bodies

As we know the ID of the root page (let it be 12345) we can use REST API to to get descendant pages. We will use Groovy language, but the process is pretty the same for other tools. So we use:

Groovy (as the prog. language)
Unirest HTTP library (to communicate over HTTP)
Gson (to operate on JSON)

We first create the models for Gson to convert it to Groovy classes:

// class that represents page/blog/comment
class Content {

    def id
    String title
    def type
    def status
    Ancestor[] ancestors
    Content container
    Version version
    Body body
    Space space
    Links _links

    @Override
    String toString() {
        return "id: ${id} | title: ${title} | type: ${type} | Version: ${version} | Body: ${body} "
    }
}

// Contents class to represent page data
class Contents {

    Content[] results
    def start
    def limit
    def size
    def _links

}

Now, we create the PageService.groovy class and add the method that returns pages array data:

// create GSON instance
Gson gson = new GsonBuilder().setPrettyPrinting().create()

// create getDescendants method
def getDescendants(CONF_URL, TOKEN, id) {

        def Url = "${CONF_URL}/rest/api/content/search?cql=ancestor+%3D+${id}&limit=300"

        def response = Unirest.get(Url)
                .header("Authorization", "Basic ${TOKEN}")
                .asString()

        Contents contents = gson.fromJson(response.body, Contents.class)

        return contents
    }

Now we have the PageService that can be used to return pages data. Let us create the Main.groovy class to run the code.

// method to get the token from USERNAME and PASSWORD
public static getToken(username, password) {
        return new String(Base64.encoder.encode("${username}:${password}".bytes))
    }

  // GET descendants  
def PAGE_ID = 12345 // root page ID

PageService.getDescendants("http://localhost:8090", getToken(), PAGE_ID).results.each {
    def pageVersion = it.version.number
    def title = it.title
    String body = it.body.storage.value

  def newBody = body.replace("Patch008", "Patch009") // replace data in page body

        def updatedPage = new Content() // create the Content object for new updated page model
        def version = new Version()
        version.number = pageVersion + 1 // add +1 to version
        updatedPage.version = version
        updatedPage.title = title
        updatedPage.type = "page"
        def updBody = new Body()
        def storage = new Storage()
        storage.value = newBody
        storage.representation = "storage"
        updBody.storage = storage
        updatedPage.body = updBody

    String pageJSON = gson.toJson(updatedPage)  // convert to JSON

    def url = "${confURL}/rest/api/content/${it.id}"
        def response = Unirest.put(url)
                .header("Authorization", "Basic ${TOKEN}")
                .header("Content-Type", "application/json")
                .asString()
  println(response)

}

That's it!
Please let know if guides like this will be helpful. Thanks :)

Also, NodeJS example - https://dev.to/andriimaliuta/interact-with-confluence-server-via-rest-api-using-nodejsjs-4m93

Ways to use React in Spring app

Andrii Maliuta — Sun, 06 Mar 2022 12:31:56 +0000

There are a lot of examples of use Spring and React in the Internet, but for me when I first wanted to know how to better integrate these frameworks, it was essential to understand how it can work in general. So, as to my humble experience, I wanted to share some examples:

Use of React library as CDN inside HTML file
Use of frontend-maven-plugin
Use of Gradle frontend plugin
Use of JS bundler/builder
Use of Docker as bundler

1. Use of React library as CDN inside HTML file

*Example *- https://github.com/AndriiMaliuta/sb-kotlin-react_inline

It is the "simplest" example as there is no need to use some other tools and you just add ReactJS library from CDN provider in the HTML file and use React object directly in the HTML file rendered by Spring controller. After you add the CDN link, you now have the access to all the objects/functions of React/ReactDOM.

2. Use of frontend-maven-plugin

*Example *- https://github.com/AndriiMaliuta/springboot-react-eirslett-mvn-plugin

The frontend-maven-plugin is useful to install NodeJS and NPM on the phase of Maven project build. First you add it to POM.xml file:

</plugin>

            <plugin>
                <groupId>com.github.eirslett</groupId>
                <artifactId>frontend-maven-plugin</artifactId>
                <version>${frontend-maven-plugin.version}</version>

                <configuration>
                    <nodeVersion>${node.version}</nodeVersion>
                    <npmVersion>${npm.version}</npmVersion>
                </configuration>

                <executions>

                    <execution>
                        <id>install-frontend-tools-cats</id>
                        <goals>
                            <goal>install-node-and-npm</goal>
                        </goals>
                        <configuration>
                            <workingDirectory>${catsAppSrcDir}</workingDirectory>
                        </configuration>
                    </execution>

                    <execution>
                        <id>npm-install-cats-app</id>
                        <goals>
                            <goal>npm</goal>
                        </goals>
                        <configuration>
                            <workingDirectory>${catsAppSrcDir}</workingDirectory>
                            <arguments>install</arguments>
                        </configuration>
                    </execution>

                    <execution>
                        <id>build-cats-app</id>
                        <goals>
                            <goal>npm</goal>
                        </goals>
                        <configuration>
                            <workingDirectory>${catsAppSrcDir}</workingDirectory>
                            <arguments>run build</arguments>
                        </configuration>
                    </execution>

                </executions>

            </plugin>

And now when running the "mvn package" command when compiling the java code, the plugin will install NodeJS and NPM and will translate the JSX code into *.JS where you specify in the plugin config.

3. Use of Gradle frontend plugin

*Example *- https://github.com/AndriiMaliuta/sb-kotlin-react-webpack-gradle

This is the same as use of Front-end plugin or Maven, but Gradle plugin is used to run NodeJS NPM command on Gradle build phase.

4. Use of JS bundler/builder

Example - https://github.com/AndriiMaliuta/sb-kotlin-react-webpack

You can use any bundler like Webpack, Snowpach, Parcel, etc. The main point is to convert the JSX code (or .ts) into .JS.
The Webpack is used to build React app with NPM modules (no Frontend plugin used). When running Maven build Webpack builds bundle.js that is added to .html file in target resources.

Maven org.codehaus.mojo:exec-maven-plugin plugin is used to run npm run build on the build phase.

<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin

Use of Docker as bundler

Docker is very powerful tool for building language/tools agnostic containerized apps. So you do not need any plugin to run NodeJS/NPM or other tools, but you can directly use Dockerfile commands to make necessary operation.

So, for example you add such a code to Dockerfile:

# to convert JS with webpack
FROM node:13-alpine AS NODE
COPY ./ ./
RUN npm run build

FROM maven:3.6-jdk-8-alpine AS MAVEN_BUILD
COPY --from=NODE ./ ./
RUN mvn clean package -DskipTests

FROM openjdk:8-alpine
COPY --from=MAVEN_BUILD ./target/*.jar ./app.jar
RUN ls -a
#ENTRYPOINT ["java","-jar", "./target/app.jar"]
CMD ["/bin/sh", "-c", "java -jar cloud*.jar"]

First you use Node image to build the JSX as JS, then with Maven image you build JAR file and then with openjdk:8-alpine you run the app.

I did not dig into details not to overwhelm with information, please share your feedback if it would e useful to add some other details or guides like this.

Thanks!

Spring Security without the WebSecurityConfigurerAdapter

Andrii Maliuta — Sun, 06 Mar 2022 11:52:47 +0000

Since Spring Security 5.7.0-M2 the use of WebSecurityConfigurerAdapter was deprecated (link to GitHub - https://github.com/spring-projects/spring-security/issues/10822) to move to component-based security configuration.

To adhere to the best practices of Spring Security, it is better to use lambda DSL and the method HttpSecurity#**authorizeHttpRequests **to define the authorization rules.

So, instead of :

@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((authz) -> authz
                .anyRequest().authenticated()
            )
            .httpBasic(withDefaults());
    }

}

it is better to use:

@Configuration
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((authz) -> authz
                .anyRequest().authenticated()
            )
            .httpBasic(withDefaults());
        return http.build();
    }

}

More details in official Spring blog - https://spring.io/blog/2022/02/21/spring-security-without-the-websecurityconfigureradapter.

Microprofile Starter

Andrii Maliuta — Sun, 06 Mar 2022 11:33:36 +0000

Usually, when using Java for Microservices development, there is a trend to start with existing frameworks like Spring, Quarkus, etc. This is a very productive way, though without knowing the basics of Java Web sphere, it can be more like sticking to one way of development. JavaEE in older times was rather hard to learn and understand that sometimes caused Java Web development to be treated as not the best option. But today, JavaEE or now JakartaEE is a modern and very convenient way for web (in particular, microservices world) development.

MicroProfile (https://microprofile.io/) is a set of implemeted specifications that optimizes Enterprise Java
for a Microservices Architecture. The Microprofile Starter helps to bootstrap the microservices development journey, by selecting the runtime they’re most comfortable with from the list of available implementations for the MicroProfile version selected:

Helidon
Payara
Quarkus
Open Liberty
etc.

The MP starter page (https://start.microprofile.io/) helps to easily create the backbone of the web app:

You just select the necessary options (just like for Spring Starter) and have the archive ready to be loaded into the IDE!

So, in a few steps you have the standardized Java JaxRS web app that adds a lot of JakartaEE and Microprofile specs: Authentication, Metrics, JWT, Health and so on.