What are foundation models?

Large-scale machine learning models trained on massive and diversed dataset to perform general-purpose tasks. One of the use-cases of foundation models are natural language processing tasks which augments the daily activities of human such as the ff:

• Summarization

• Question and Answer

• Translation

• Sentiment Analysis

• Text Generation

• Image Recognition

These activities usually incorporate a specific foundation model to achieve. Below are some scenarios that were considered in Gen AI development.

1. Language Models Models that were trained to generate text, classify text, extract meaning of a text, summarize and generate code based on a textual context. These were trained to analyze the human language and give response based on an initial text input.

2. Image Models Models that were trained to understand, analyze, generate and manipulate visual data to the users. These models accepts images and drawings as an input and generates a response by understanding it.

3. Multi-modal Models Incorporates the capabilities of language and image models. It is trained to different modalities and perform a combination of it. The data that this model can handle can span to text, audio, video and images.

In this article, we will focus on Language Models and Chat applications. Resurfacing again this excellent playlist explaining large language models and chatbots by IBM Technology.

IBM watsonx.ai

The flagship AI and machine learning platform by IBM. It is designed to empower business to build, deploy, scale AI models effectively. This technology is not the foundation model of IBM rather a platform that incorporates multiple foundation models plus the IBM's flagship model called IBM Granite.

To see the table of all supported foundation models, you can check it out here.

Pricing

If you're an organization interested in trying IBM watsonx.ai, you can check-out its pricing table

IBM Granite Models

IBM Granite is the IBM's flagship family of foundation models developed for Generative AI. It is part of the IBM watsonx.ai platform and focuses in giving solutions to enterprises. One of the advantage of using Granite models is that it is optimized for business users, making enterprise organizations competitive using the platform.

Articles related to the capabilities of IBM Granite can be read below:

• IBM Introduces Granite 3.0: High Performing AI Models Built for Business

• IBM’s New Granite 3.0 Generative AI Models Are Small, Yet Highly Accurate and Efficient

The platform will be used to integrate a IBM Granite Model with Spring AI. For this demonstration we will be using a language model for chat applications using IBM granite-13b-chat-v2

What is Spring AI?

Streamlines the creation of generative artificial intelligence in a Java application without unnecessary complexities. The project main focus is to connect your enteprise data and APIs to foundation models.

The Spring AI API provides abstractions that have multiple implementations for easy development and minimal code changes.

The API provids various functionalities that spans from a simple application to a complex one. These functionalities can be combined to build an enterprise-grade full-stack application.

• AI Models (Chat, Image, Audio, Moderation and Embeddings)

• Vector Databases

• Retrieval-Augmented Generation

• Observability

• Prompting

Additional functionalities that Spring AI supports which is significant for AI customizations

• Function Calling

• Structured Output

• Multi-modality

• ETL Pipelines

• Model Context Protocol

In this demonstration, we will not deal in-depth of these concepts. We will show only the features that IBM watsonx.ai API supports on how quickly we can create a simple chat application.

IBM watsonx.ai

The IBM watsonx.ai API supports chat and embedding models in Spring AI context. For chat it supports WatsonxAiChatModel which is both a text generation and text stream generation.

To generate embeddings, the platform supports WatsonxAiEmbeddingModel.

The image above is the UML Diagram of WatsonxAi API. The chat model implements the provided abstraction of Spring AI for basic chat and streaming chat. To provide implementations of these methods, the WatsonxAiChatModel needs to call the corresponding watsonx.ai platform API via REST and HTTP protocol.

Creating IBM watsonx.ai Chat-based Application

Prerequisites

The code that will be demonstrated is already available in watsonx-spring-ai-hilla project. If you're interested to run the demo project, you may fork and run it locally.

Spring AI is already available as a dependency in Spring Initialzr. To add the watsonx.ai Spring Boot starter just specify the following dependency in your build.gradle

implementation 'org.springframework.ai:spring-ai-watsonx-ai-spring-boot-starter'

See the https://github.com/rjtmahinay/watsonx-spring-ai-hilla/blob/main/build.gradle file of the project.

Configurations

The watsonx platform needs the following properties to start the Spring AI application.

spring:
  ai:
    watsonx:
      ai:
        // The project id of your watsonx project
        project-id: ${PROJECT_ID}
        // The API key from IBM Cloud
        i-a-m-token: ${API_KEY}
        // Base URL of the IBM Cloud where watsonx.ai is connected
        base-url: https://us-south.ml.cloud.ibm.com
        // The text endpoint of watsonx.ai service
        text-endpoint: "/ml/v1/text/generation?version=2024-05-31"
        // The streaming text endpoint of watsonx.ai service
        stream-endpoint: "/ml/v1/text/generation_stream?version=2024-05-31"

All Spring AI properties starts with a prefix of spring.ai.<platform>. Every AI platform has their own specific options. For chat properties, watsonx.ai API provides a Chat Options with default values and can be overriden in the properties or yaml file. Below is an example override of the chat options.

Project ID and API key should be stored in a secured vault to prevent security violations.

spring:
  ai:
    watsonx:
      ai:
        chat:
          options:
            // The chat model to be used
            model: "ibm/granite-13b-chat-v2"
            /*
            Sets the decoding strategy either greedy or sampling. For this chat application, we want
            a more factual result rather a creative one. Thus, we will use greedy
            */
            decoding-method: "greedy"
            /*
            The maximum token that the LLM will use. In this case, the granite-13b-chat-v2 has a
            maximum of 8192 limit.
            */
            max-new-tokens: 8191
            // Defaults to 0. Sets how many token does the LLM generate
            min-new-tokens: 0
            /*
            Temperature, top-p, and top-k are used for Sampling Decoding Method. We will not use
            this in this demonstration.
            */
            temperature: 0.0
            top-p: 1.0
            top-k: 1
            // Penalize the LLM for repetition of text. Defaults to 1.0 and has a maximum of 2.0
            repetition-penalty: 1.0

To see the token limits of all available foundation models in watsonx.ai platform, please check the documentation.

Chatbot

The user-interface of the application is created via Hilla Framework. Hilla is part of Spring Initialzr dependencies. To learn more about Hilla, check out this documentation.

The chat application uses the abstracted client called ChatClient. The ChatClient consumes as a parameter an AI model.

@Configuration
public class ChatConfiguration {

    /**curl
     * This method is used to create a ChatClient bean.
     * @param watsonxAiChatModel The chat model to be used
     * @return The ChatClient bean
     */
    @Bean
    ChatClient watsonxChatClient(WatsonxAiChatModel watsonxAiChatModel) {
        return ChatClient.builder(watsonxAiChatModel)
                .defaultSystem("You are a helpful ai assistant").build();
    }
}

I've created a configuration class that creates a ChatClient bean and consumes the WatsonxAiChatModel. I instructed the ChatClient to behave as a helpful AI assistant.

@Endpoint
@AnonymousAllowed
@RequiredArgsConstructor
public class ChatEndpoint {

    private final ChatClient watsonxChatClient;

    /**
     * This method is used to generate a response from the chatbot.
     * @param userInput The user's input to the chatbot
     * @return The chatbot's response
     */
    public String generateMessage(String userInput) {
        return watsonxChatClient.prompt().user(userInput).call().content();
    }

    /**
     * This method is used to generate a streaming response from the chatbot.
     * @param userInput The user's input to the chatbot
     * @return The chatbot's response as a stream of strings
     */
    public Flux<String> generateStreamingMessage(String userInput) {
        return watsonxChatClient.prompt().user(userInput).stream().content();
    }
}

Since we're using Hilla, the controller is called an endpoint. These endpoint class will be converted to a TypeScript file upon invocation of bootRun task.

Below is the example conversion to a TypeScript file. The file is called ChatEndpoint.ts

import { EndpointRequestInit as EndpointRequestInit_1, Subscription as Subscription_1 } from "@vaadin/hilla-frontend";
import client_1 from "./connect-client.default.js";
async function generateMessage_1(userInput: string | undefined, init?: EndpointRequestInit_1): Promise<string | undefined> { return client_1.call("ChatEndpoint", "generateMessage", { userInput }, init); }
function generateStreamingMessage_1(userInput: string | undefined): Subscription_1<string | undefined> { return client_1.subscribe("ChatEndpoint", "generateStreamingMessage", { userInput }); }
export { generateMessage_1 as generateMessage, generateStreamingMessage_1 as generateStreamingMessage };

If you inspect both generateMessage and generateStreamingMessage and Java methods were converted to a JavaScript method. In this case, we don't need to have a network call via REST since we can now call the method from the TypeScript conversion. Below is the example usage of these methods.

ChatView.tsx

const ChatView = () => {

    // Remove other logic for brevity.

    const handleSubmit = async (event: CustomEvent) => {
         // Remove other logic for brevity.

        try {
            const response = await ChatEndpoint.generateMessage(inputMessage);

            console.info('AI response:', response);

            const aiResponse: Message = {
                id: (Date.now() + 1).toString(),
                sender: 'ai',
                content: response,
            };
            setMessages((prevMessages) => [...prevMessages, aiResponse]);
        } catch (error) {
            console.error('Error sending message:', error);
        } finally {
            setIsLoading(false);
        }
    };
}

StreamingChatView.tsx

const StreamingChatView = () => {

    // Remove other logic for brevity.

    const handleSubmit = async (event: CustomEvent) => {
       // Remove other logic for brevity.

        try {
            const response = ChatEndpoint.generateStreamingMessage(inputMessage);

            const aiResponse: Message = {
                id: (Date.now() + 1).toString(),
                sender: 'ai',
                content: '',
            };
            setMessages((prevMessages) => [...prevMessages, aiResponse]);

            response.onNext((chunk: string | undefined) => {
                setMessages((prevMessages) => {
                    const lastMessage = prevMessages[prevMessages.length - 1];
                    return [
                        ...prevMessages.slice(0, -1),
                        {
                            ...lastMessage,
                            content: lastMessage.content + chunk
                        }
                    ];
                });
            });
    };
}

Chat Application

I've showed how quickly it is to create a custom chat application and integrate it to watsonx.ai using Spring AI and Hilla.

Basic Chat

The basic chat waits for the AI platform to fully return the response. Thus, waiting time may be longer.

Streaming Chat

The streaming chat responds by chunks and prevents frustration to the end user.

Summary

watsonx.ai can seamlessly connected to Spring AI and build a chat application with minimal coding changes. Using this platform, we used the IBM Granite model as the foundation model and generated both a basic and streaming response.

For future demonstrations, watsonx.ai can be used for RAG, Function Calling (via MistralAI) and Embeddings.

GitHub

You can access my watsonx.ai Chat application here

References

1. Spring AI Documentation - https://docs.spring.io/spring-ai/reference/index.html

2. watsonx.ai Documentation - https://dataplatform.cloud.ibm.com/docs/content/wsj/getting-started/welcome-main.html?context=wx&locale=en&audience=wdp

3. watsonx Developer Hub - https://www.ibm.com/watsonx/developer

For more contents and discussion about Java, Cloud and AI. You can follow me on social media accounts via LinkTree

Follow and join the Java User Group Philippines for monthly meetups and community discussions.

The presentation can be accessed in my GitHub Repository: The Value of Quarkus

I've discussed the framework in the following sections:

• What is Quarkus?

• Quarkus' Industry Value

• Performance

  • Quarkus vs Spring Boot

  • JIT vs AOT

  • Metrics

  • AWS Lambda SnapStart

• Spring Framework Support

• Sustainability

What is Quarkus?

The framework is called Supersonic. Subatomic. Java. It can be explained into 5 characteristics: Kube-native, Cloud-native, Imperative and Reactive Code, Developer-centric, and Standards.

Kube-native

Quarkus is designed for Kubernetes-based development. It is a framework to leverage the characteristics of Kubernetes specifically for RedHat OpenShift. When developing applications in Quarkus, you're developing as if you're inside the Kubernetes platform due to the usage of YAML files. You can configure the environment directly in Quarkus. Thus, showing Single-step Deployment and Remote Development.

An example YAML file on how to deploy an application and connect to OpenShift automatically.

"%prod":
  quarkus:
    kubernetes-client:
      trust-certs: true
      api-server-url: ${OPENSHIFT_URL}
      token: ${QUARKUS_KUBERNETES_CLIENT_TOKEN}
    openshift:
      route:
        expose: true
      env:
        secrets: mysql
    kubernetes:
      deploy: true
    s2i:
      base-jvm-image: registry.access.redhat.com/ubi8/openjdk-17:1.16-1
    datasource:
      db-kind: mysql
      jdbc:
        url: jdbc:mysql://<SQL Hostname>:3306/demo
      password: ${database-password}
      username: ${database-user}

Cloud-native

Since it is a Kubernetes Java framework, it is optimized to be used in the cloud. It Shows fast startup times, minimal usage of reflection, and support for GraalVM Native compilation. This characteristic is related to the benefits of being a Greener framework.

Imperative and Reactive Code

Quarkus supports both imperative and reactive programming whether in microservices, event-driven microservices, or serverless architectures. You can code HTTP Microservices, Reactive APIs, and Functions. Quarkus has all extensions for that.

Below are some examples of API coding in Quarkus.

AWS Lambda code using API Gateway

@Named("/lambda1")
public class Lambda1 implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent request, Context context) {
        String httpMethod = request.getHttpMethod();
        String result = "";

        if ("GET".equals(httpMethod)) {
            // Business logic
        }

        return new APIGatewayProxyResponseEvent().withBody("Invoked Lambda")
                        .withStatusCode(200);
    }
}

HTTP Microservices

@Path("/employee")
@ApplicationScoped
public class EmployeeResource {
    @Inject
    EmployeeRepository employeeRepository;

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public List<Employee> getEmployee() {
        return employeeRepository.listAll();
    }
}

Reactive Microservices

@Path("/employee")
@ApplicationScoped
public class EmployeeResource {
    @Inject
    EmployeeRepository employeeRepository;

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Multi<Employee> getEmployee() {
        return Multi.createFrom().items(employeeRepository.streamAll());
    }
}

Developer-centric

Quarkus offers a seamless development experience for developers and users. It offers a variety of tools such as live reloading, remote development, Dev UI/Services, Continuous Testing, and Quarkus Extensions.

Dev UI is a local development website typically accessed via http://localhost:8080. It shows the dependency that you've used in your application and the ability to deploy to a cloud platform like RedHat OpenShift automatically.

Dev Services is Quarkus' ability to give an on-demand environment via TestContainers for common development tools like Databases, Kafka, RabbitMQ, etc. You can check out the documentation in Dev Services

Quarkus Extensions are external libraries integrated into Quarkus CDI. These are from the Quarkus Platform and Quarkiverse

Standards

The framework is backed by industry standards and specifications. Some of these are Vert.x, Eclipse Microprofile, Micrometer, and Jakarta EE.

Quarkus Industry Values

The industry values that it can give are based on cost savings, the reduction of the resources needed to deploy an application, and its environmental impact.

• Cost Savings: Less memory footprint, fast start-up time, and less disk footprint

• Speed and Agility: faster time to market using Quarkus Extension and crafted from well-known libraries which can be easily learned

• Standard and Support: RedHat Build Support for Quarkus, an active community with regular releases in GitHub and based on CNCF technologies

• Sustainability: Write Greener applications using Quarkus. Due to the minimal reflection and the small memory footprint of Quarkus, the framework shows characteristics of decarbonization.

Performance Metrics

I've presented a comparison of Quarkus to Spring Boot. I compared it to the following metrics:

• Image Size

  • Spring Boot has a lesser size due to reflection. Quarkus performs build-time compilation causing increased image size.

• Startup Time

  • Quarkus doesn't need anymore to execute always dynamically the metadata of a program. Thus, improving startup times.

• Memory Usage

  • Quarkus is optimized to reduce its memory usage consumption. The CDI process of Quarkus uses Ahead of Time compilation to minimize the use of reflection.

AWS Lambda SnapStart

The performance of Quarkus and Spring Boot in response time decreased significantly. Although, Spring Boot was 6x more efficient when integrated with SnapStart. While Quarkus had it 2x more efficient.

Spring Framework Support

Quarkus support a number of annotations of Spring inside the Quarkus CDI (Quarkus ArC). The documentation can be accessed by clicking the link for each bullet. These can be listed as:

• Spring Boot Properties

• Spring Cache

• Spring Cloud

• Spring Data & Data Rest

• Spring Dependency Injection

• Spring Scheduled

• Spring Security

• Spring Web

Sustainability

Quarkus offer writing greener applications as prescribed by RedHat Greener Application Executive Summary. In this summary, they compare Quarkus to the energy consumption of a single light bulb, startup times, and the carbon dioxide equivalent (CO2-eq) respectively.

Final Thoughts

In this presentation, I've discussed what will be the benefit of using Quarkus from a developer's perspective. It's not just a seamless development experience but the impact that a developer can give on their organization and the environment.

With the increased modernization and migration of legacy applications to the cloud. We can expect that they will consider a developer-friendly and sustainable framework that can optimize their applications in the cloud.

In this post, I'll be sharing my experience in taking the Red Hat certification for Containers and Kubernetes using OpenShift Platform v4.10. The certification is different from other cloud certifications since this contains a series of hands-on tasks.

Since January of 2023, the exam (EX180) is now retired and will be replaced by Red Hat Certified Specialist in Containers (EX188).

Preparation

The most recommended learning path to prepare for this certification is to have a RedHat Learning Subscription but you can take other options like Udemy or A Cloud Guru if a learning path is available. Below is a sample screenshot of the Red Hat Learning Paths.

The subscription contains paths spanning from OpenShift, Camel, Kafka, Ansible, Quarkus and many more. A lab environment is given which gives you the freedom to play around using the terminal commands. The learning path for this certification is called Red Hat OpenShift I: Containers & Kubernetes (DO180). The overall effort for this module is 24 hours but it took me 1 month to prepare since I tried different Podman and OpenShift commands.

If you want to take your RedHat exam in the comfort of your home, you should read the remote exam guide. You should have a flash drive available for burning the remote exam environment ISO file.

Exam Proper

The exam consists of 8 tasks based on the objectives described here. The objectives of the new exam (EX188) can be checked here. The following EX180 objectives are.

• Implement images using Podman

• Manage images

• Run containers locally using Podman

• Basic OpenShift knowledge

• Creating applications in OpenShift

• Troubleshoot applications in OpenShift

The EX188 objectives are quite similar to EX180.

• Implement images using Podman

• Manage images

• Run containers locally using Podman

• Run multi-container applications with Podman

• Troubleshoot containerized applications

Some tasks are dependent on each other like running multi-containers in a pod. Check an example of this here. It is expected that you have a basic understanding of Linux commands and how to modify a shell script. Below is a sample procedure on how to put a podman command in a shell script.

Running a container using Podman. Let's name it start-container.sh

#!bin/bash
# This is a sample shell script

podman run -d --name dbcontainer docker.io/mysql:latest

Running a shell script should be like this.

sh ./start-container.sh

You only have 2 hours to finish the exam. If you decided to take it in your home, be ready to have an external camera, a keyboard and mouse, an external monitor and an optional laptop docker. Every hour of the exam, the proctor will request you to scan your room using your external camera.

Tip: The exam is fond of using scripts so practice using Shell. As much as possible, read the requirements carefully. You don't want to start over again on your configurations.

Exam Results

As mentioned by Red Hat, the results will be given within 3 business days but on my end, it was sent after an hour. They will give you your score based on the percentage of each objective. The passing score is 210 over 300 which is 70%. When I took the exam, I got 249 or 83%.

After a while, Credly will issue you a badge and obtain the title: RedHat Certified Specialist in Containers and Kubernetes. For EX188, it will be RedHat Certified Specialist in Containers.

Final Thoughts

In this exam, you will learn how to use the podman and OpenShift basic commands. You will create applications inside OpenShift and how to troubleshoot. The new exam EX188 I think will be the same as EX180 with some tweaks but overall it will have the same objective of using the podman commands and deploying applications in OpenShift.

When we create applications mostly in enterprise organizations, the first thing that comes to our mind now is how to decouple our applications.

But there will be times when creating too many microservices is not the best way and may cost you time and money.

Because of that, one alternative is to leverage the use of modules.

Modules

Modularity is a concept that is used to build applications to separate logical units through modules, giving you highly cohesive code.

These modules are analogous to a compartment where you put a specific feature of your application.

Creating modules has different benefits during software development, whether ground-up or maintenance.

Modular Monolithic

Modular Monolithic is an architectural style where your code is structured on the concept of modules.

It separates your functions into different logical units but still in a single application.

You can describe this as a composition of directories and those inner directories contain your working code.

In practice, this style is used when you don't want to manage different applications as seen in microservice development. Below are some reasons why to use Modular Monolithic.

• Single deployment - your code can be deployed to the cloud without configuring and maintaining too many applications. These can be seen in batch and some microservice applications.

• Issues of third-party dependency - imagine you have more than 5 applications with library violations using GitLab or JFrog Xray for example, these can be a big pain for the developers.

• Greenfield Development - when starting a new application we wouldn't want to build our applications immediately in microservice. This may cause over-engineering and high maintenance costs for no reason.

• Cost of developers - Too many services are costly to an organization. This can be seen when the organization is in the stage of budgeting and has few developers in place.

Architecture

The architecture of the Modular Monolithic is quite simple. It's in a single project with different components separated into a well-defined logical directory. The modules or projects (for multi-module) define their way to prevent leaking of their implementation. The multi-module can define what to expose via the custom configuration of Gradle while Spring Modulith leverages the use of internal modules.

This can be deployed to the cloud using a single Dockerfile or a Multi-container approach using Docker Compose or Kubernetes-based technology. The application used in this demonstration is Spring and Gradle and a new module under Spring Framework called Spring Modulith.

Multi-Module

If you want to create and deploy a modular monolithic application, you can use a common approach used by developers called multi-module approach. This can be done using the build management tools like Maven or Gradle. In this post, we will be dealing with Gradle.

In the architecture above we can see that the application consists of 3 different projects inside a main project called modular-monolithic-gradle. The 3 projects are called sub-projects and can define what to expose to other projects.

The common project also called shared project which contains global or redundant codes that can be seen when you have too many service modules.

The service project may contain codes for a specific domain. In this case, its sole responsibility is to manage the functionality regarding Employee. You can have many services based on your use case.

The application project is your main project that will invoke your services and behaves like a Service Locator. See a simple introduction to this pattern here. In Spring, the call for different services can be done using @Qualifier annotations and extending a base service.

Sub-modules themselves can have their Gradle lifecycle which is controlled by their build file. In there, you can define what to expose or not.

Spring Modulith

Spring Modulith is an experimental project by Spring that can be used for modular monolithic applications. Its feature is to have a well-defined modular structure for Spring Beans and have control over what to expose or not.

Here we have the same structure as the multi-module above but using different packages and a main project (main package) only. We can hide some functionalities like the code for repositories or the model classes. Thus, controlling how you will expose your beans. You can expose many services here too and hide their respective persistence and view layer via a package called internal.

For scenarios where you want to create another service, you can just create another one under the com.rjtmahinay (main package) and can be called to other services (other service packages).

Although under the hood, Spring Modulith uses the multi-module approach too in its respective sub-functionalities. This technology can help us improve the way we create modules, especially in Spring.

Cloud Deployment

So far I've discussed the approaches to create a modular monolithic application using the common and a new approach. This time the architecture above shows the single deployment benefit of modular monolithic.

To deploy your application to the cloud, you can do the single Dockerfile deployment which contains a single image of your application or deploy it in a multi-container style which can be done by a single image (single jar) or multi-image (multiple jars). The multi-module approach can deploy the sub-projects as a multi-container deployment since it can have its image (jar file). For Spring Modulith, since internally it can be a multi-module, the modulith application can still be deployed in single or multiple deployments.

Final Thoughts

Understandably, developers will opt for microservices since it gives the flexibility of technology to be used, style of deployment and decoupling of functionalities.

But we need to remember that all software requirements don't need to be created in a microservice fashion.

Problems arise when microservices become a Distributed Monolithic, which defeats its purpose.

In this post, I've presented an option called Modular Monolithic which is an alternative for the complexity seen in microservices and how modularity can be integrated into your software requirements.

Further Reading

• Spring Modulith Reference Documentation

• Modular Monolithic by JRebel

• Gradle Multi-module

Originally published on Foojay.io

With the rise of application modernization in the cloud, Java position itself by having different frameworks that can produce lightweight applications in the cloud to minimize memory consumption and quick application start-up.

In this post, I'm gonna explain the codes presented in my demonstration:

Micronaut Demo

What is Micronaut?

Micronaut is a full-stack framework for building microservice and serverless applications. It leverages the use of compile-time inversion of control that results in quick start-up and low memory footprint.

Significant features of this framework to others like Spring Boot:

• Reduced Memory Footprint

• Quick startup time

• Minimal use of runtime reflection and proxies

• Leverages AOT (Ahead of Time) compilation

• Doesn't depend any more to the size of the codebase

As of the writing, the version of Micronaut is 3.8.0. Also, Micronaut's annotation design is very similar to Spring Boot. Thus, a minimal learning curve for Spring Developers 😁

👨🏻‍💻 Create your application!

To create a Micronaut application, you can create it via CLI or the Launcher site.

CLI

You can start by downloading Micronaut CLI here. After installing you can create your app using the command below:

mn create-app  example-app --features <additional dependencies>

the --features option lets you add dependencies other than the Micronaut native features. After creating the app a micronaut-cli.yml file is created where it shows the information about the project you've created. Below is an example of the contents of the YAML file.

applicationType: default
defaultPackage: com.rjtmahinay
testFramework: junit
sourceLanguage: java
buildTool: gradle
features: [annotation-api, app-name, data, data-jpa, gradle, h2, http-client, jackson-databind, java, java-application, jdbc-hikari, junit, logback, micronaut-build, netty-server, openapi, readme, shade, swagger-ui, yaml]

Micronaut Launcher

In this approach, you will be shown a user interface to create your Micronaut application with ease. The launcher can be found here

As you can see the launcher design used is familiar to us and is also similar to Spring Initialzr's website. You can see that it has a feature button where you can add your project's dependencies. A preview is also shown for you to have a glimpse of what files are created. When generating your project either you can download the file or push it to a GitHub repository.

👨🏻‍💻 Let's start coding!

The main entry application of Micronaut will be a class that invokes the Micronaut class. Below is a simple entry code to run the application.

public class Application {

    public static void main(String[] args) {
        Micronaut.run(Application.class, args);
    }
}

If you want to access the different arguments that you can pass to Micronaut's application context. You can use the builder approach.

public class Application {

    public static void main(String[] args) {
        Micronaut.build(args)
                .mainClass(Application.class)
                .eagerInitSingletons(true)
                .start();

    }
}

Creating a Bean

In Micronaut you can create your beans inside a configuration called Factory. This factory class will load your specified beans. It is the counterpart of Configuration in Spring. Below are some used annotations for bean creation.

@Factory // The configuration annotation to create your beans
public class ApplicationConfiguration {

    @Singleton // Create a single instance of a bean
    public EmployeeBean singletonBean() {
        return new EmployeeBean();
    }

    @Bean // Create a copy of bean for every invocation
    public EmployeeBean bean() {
        return new EmployeeBean();
    }

    @Prototype // Similar to @Bean
    public EmployeeBean prototypeBean() {
        return new EmployeeBean();
    }

    @Context // Create a bean upon start of ApplicationContext
    public EmployeeBean contextBean() {
        return new EmployeeBean();
    } 
}

Autowire a bean

In Spring we use the Autowired annotation but in Micronaut it leverages the use of Inject of jakarta annotations library.

@Inject // Autowires your bean in the ApplicationContext
private EmployeeBean singletonBean;

Creating Properties

Just like in Spring Boot, we want to configure our custom property class. It uses the same syntax in Spring called ConfigurationProperties

// The value of the annotation is the name of your property
@ConfigurationProperties("example")
public class EmployeeProperties {
    private String value;
}

You can also get the value directly

// Using an expression language, you can get the value of a property
@Value("${example.value}")
private String value;

Define your DTO

You can use a DTO to map your JSON request and pass it to persistence layer model. Here we encounter the annotations Serdeable and Introspected.

In Java 17, you can now use records as your request/response model. This removes the use of Lombok library for most cases.

Other annotations like NotEmpty and DecimalMin are part of javax validations.

@Serdeable // Used for JSON serialization
@Introspected // Used for introspecting your beans in compile-time
public record EmployeeDto(@JsonProperty @NotEmpty String name, @JsonProperty String address, @JsonProperty String position, @JsonProperty @DecimalMin("1.0") BigDecimal salary) {
}

The Persistence Layer

The persistence layer is composed of the repository and its entity. The library used is the Micronaut Data JPA

Define your entity

Defining your entity is similar to using the basic JPA format where you initialize it using Entity and Table. The difference here is you must annotate your class using Serdeable for compile-time serialization.

@Serdeable // Used for compile-time serialization
@Setter
@Getter
@Entity // Defines your class as a database entity
@Table(name = "EMPLOYEE") // Annotation to map the class as your table
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "ID", nullable = false, insertable = false, updatable = false)
    private Long id;

    @Column(name = "NAME")
    private String name;

    // Removed other attributes for brevity   
}

Define your repository

Micronaut supports Synchronous and Reactive repositories. These can be extended by the following interfaces. The annotation is similar to Spring's repository.

@Repository // Used for defining the class as repository
public interface SynchronousEmployeeRepository extends JpaRepository<Employee, Long> { 

     @Query("SELECT e FROM Employee e") // Use to define your own query
     List<Employee> findAllEmployee();
}

Below can return a type of Reactor's Flux (for list and streams) or Mono (single object).

@Repository // Used for defining the class as repository
public interface ReactiveEmployeeRepository extends ReactorCrudRepository<Employee, Long> {

    @Query("SELECT e FROM Employee e") // Use to define your own query
    Flux<Employee> findAllEmployee();
}

The Service Layer

The concept of the service layer is mostly used in the time of Monolithic Architecture which uses the MVC Design Pattern. Although there is no Service annotation in Micronaut, you can use the existing Singleton to create your service. After all, services are used as beans.

public interface SynchronousEmployeeService {
    Optional<Employee> getEmployee(Long id);

    // Removed other functions for brevity
}

@Singleton // Make your service as a bean
public class SynchronousEmployeeServiceImpl implements SynchronousEmployeeService {
    @Inject
    private SynchronousEmployeeRepository synchronousEmployeeRepository;

    @Override
    public Optional<Employee> getEmployee(Long id) {
        return synchronousEmployeeRepository.findById(id);
    }

    // Removed other logic for brevity
}

The Controller Layer

This consists of your API definitions in Micronaut. It is similar to Spring's Controller but the difference is you need an additional RestController for your return type to be serialized. In Micronaut, it is already done by one annotation.

// Used for making the API managed by Micronaut threading
@ExecuteOn(TaskExecutors.IO)
// The controller annotation with the define root URI
@Controller("/v1/synchronous/employee")
public class SynchronousEmployeeController {
    // Removed logic for brevity
}

GET

This will return a serialized response and may be used using a Query Parameter or Path Parameter. Notice that you don't need an extra annotation for defining a Path Parameter, Micronaut already handles it.

@Get(uri = "/{id}", produces = MediaType.APPLICATION_JSON)
public Optional<Employee> getEmployee(Long id) {
    return employeeService.getEmployee(id);
}

POST

This will invoke an add operation to your persistence layer and custom response. The additional Body annotation can be optionally removed since Micronaut knows that it is your request body. The Valid annotation asserts that your request body should be validated.

@Post(uri = "/add", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
public Employee createEmployee(@Body @Valid EmployeeDto employeeDto) {
    return employeeService.addEmployee(employeeDto);
}

PUT

This will invoke an update to your data. In the case of combining a Path Parameter and Request Body. You can define it using PathVariable (similar to Spring) and Body.

@Put(uri = "/update/{id}", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
public Employee updateEmployee(@PathVariable Long id, @Body @Valid EmployeeDto employeeDto) {
    return employeeService.updateEmployee(id, employeeDto);
}

DELETE

This will invoke a deletion of your data.

@Delete(uri = "/delete/{id}", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
public String deleteEmployee(Long id) {
    employeeService.deleteEmployee(id);
    return "Successfully deleted";
}

Caching

Sometimes you want to put a cache for method calls in your API. This is usually applied to your API methods. This can be done in Micronaut using the annotations below.

// Stores the data in the specified cache name
@CachePut("synchronous-employee")

// Invalidates all the stored cache by name
@CacheInvalidate("synchronous-employee")

Exceptions

Handling exceptions in Micronaut can be done using the Error annotation or the custom one. Below is a method defined in a controller.

@Error
public HttpResponse<JsonError> error(HttpRequest<?> request, Throwable e) {
    JsonError error = new JsonError("Exception in Synchronous Controller: " + e.getMessage())
            .link(Link.SELF, Link.of(request.getUri()));

    return HttpResponse.<JsonError>serverError()
            .body(error);
}

If you want it to be used in all controllers, just set a value of global=true in the annotation.

@Error(global = true)
public HttpResponse<JsonError> error(HttpRequest<?> request, Throwable e) {
    // your logic
}

You can also create your custom exceptions. Here it states that it requires an EmployeeException to invoke.

@Singleton
// Equivalent annotation of @ConditionalOn*** in Spring
@Requires(classes = EmployeeException.class)
public class EmployeeExceptionHandler implements ExceptionHandler<EmployeeException, HttpResponse<?>> {

    @Inject
    private ErrorResponseProcessor<?> errorResponseProcessor;

    @Override
    public HttpResponse<?> handle(HttpRequest request, EmployeeException exception) {
        return errorResponseProcessor.processResponse(
                ErrorContext.builder(request)
                        .cause(exception)
                        .errorMessage("Handled by custom handler").build(),
                HttpResponse.badRequest());
    }
}

For this to work, you must disable the HTTP Client Exception property.

micronaut:
    http:
      client:
        exception-on-error-status: true

👨🏻‍💻 Running the application

You can run the application using the build management tool. For this demo, I've used Gradle as my build management tool. You can run your newly created application via the command below:

./gradlew run

After running you can see that the startup time of Micronaut is as twice low as Spring Boot. This is the power of Ahead of Time compilation.

Micronaut supports docker build images in Gradle Plugin which you can use

For standard docker image

./gradlew dockerBuild

For GraalVM Native Image

./gradlew dockerBuildNative

💭 Final Thoughts

Micronaut is a promising microservice and serverless framework in the Java space. It leverages the use of compile-time inversion of control with very minimal reflection. We want a lightweight and quick startup time application when deploying to the cloud. If you're creating a new service in your organization, Micronaut will be one of the good choices.

📝Further Reading

Check out the Micronaut's documentation for more information

• Micronaut Documentation

• Micronaut Configuration References

• Official Micronaut Blogs

In this post, we'll see how it performs using Micronaut and the JDK runtime version used is Java 11 (Amazon Corretto).

A simple architecture

The architecture above shows that we will invoke a POST request via the API Gateway and it will be processed by our Lambda function using Micronaut. This function will be invoked a thousand times and with the help of AWS CloudWatch Logs and Insights, we can create a conclusion on SnapStart's performance.

How to enable Lambda SnapStart?

Initially, when we create a function, SnapStart is disabled. This is a function called On-Demand.

SnapStart will work in two things, you should Enable SnapStart and publish a new version of it. You can create an alias to be used as a new target of your API Gateway.

An example alias pointing to the new version.

Request Invocation

I've created a simple POST request which has a query parameter, name.

?name=Tristan

The response to this request will be a JSON body with string transformation (concatenate the name with Hi).

{
    "message": "Hi Tristan"
}

Micronaut Code

The string transformation will be handled by a simple Micronaut Lambda code as seen below.

@Slf4j
public class FunctionRequestHandler extends MicronautRequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
    @Inject
    ObjectMapper objectMapper;

    @Override
    public APIGatewayProxyResponseEvent execute(APIGatewayProxyRequestEvent input) {
        Map<String, String> inputParam = input.getQueryStringParameters();
        APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
        try {
            String json = objectMapper.writeValueAsString(
                    Collections.singletonMap("message", "Hi " + inputParam.get("name")));
            response.setStatusCode(200);
            response.setBody(json);
        } catch (JsonProcessingException e) {
            response.setStatusCode(500);
        }
        return response;
    }
}

The function will accept an APIGatewayProxyRequestEvent which holds the query parameter object as a Map. We will retrieve the value via the name key. The response will be the name and the appended Hi word.

Load Testing using Apache JMeter

To test the performance of this new feature. I've used JMeter as my load testing tool to invoke a concurrent request of 50 threads and 1000 loops which spans around ~5-10mins. Both the SnapStart and On-demand invocation of Lambda was tested by these constraints.

Insights

Using CloudWatch logs and insights, I've performed some monitoring metrics for durations as prescribed in SnapStart Monitoring and got the different percentiles for each configuration.

Final Thoughts

This blog post shows the results of a simple Micronaut Function Application for Serverless by comparing the Lambda configuration with or without SnapStart enabled. We can see the app's latency improved due to ahead-of-time initialization optimization.

Further Reading

For more information about Lambda SnapStart you can check out the ff. links

• Improving startup performance with Lambda SnapStart

• Starting up faster with AWS Lambda SnapStart

I recently cleared SAA-CO3 which was updated by AWS last Aug 30, 2022. The exam update comprises of increased enterprise demand for optimizations in fast-changing areas such as security, resiliency, data volume, cost optimization, and the design of high-performance systems by AWS Certification and Training

The exam still consist of 65 questions with 15 unknown unscored questions to be used by AWS for performance evaluation and as a future question, in short 50 questions is the total scored questions. Target takers of this exam may be a developer or architect interested in using AWS services.

Preparation

To prepare for this challenging certification, I highly recommend to take the course of Stephane Maarek below:

This course primarily focuses in the certification questions. He also showed different diagrams that can help you familiarize different AWS architectures (combination of AWS services and how they work). If you want a full practice exam to maximize your chance in passing the exam, you can check out the course below:

Recommendation style for studying this course

This exam is a challenging one and you need time for you to have a better grasp of different AWS services and how they connect to each other. I finished studying the course in a month also spent reading twice the course material for better understanding. To do this I did the following:

• Spent ~1-2 hours of studying each day
• Go back to a specific chapter where you have confusion with
• Give yourself a break to absorb the knowledge of each chapter
• Don't forget to have a good sleep before studying!

Exam Proper Experience

The exam last for 2 hours 10 minutes but you can extend for another 30 minutes if you are a Non-English native speaker by applying ESL in the AWS certification website. The content of the exam showed on my end focuses mostly in the following topics.

• IAM and Security Groups
• AWS KMS, AWS Server-side Encryption and Server-side Encryption - Customer Managed
• VPC
  • VPC Peering
  • VPC Endpoints
• S3
  • Storage Classes
  • Static Website Hosting
  • Cross-region/Same-region replication
• EC2 Instances
  • EC2 Instances Purchasing Options
• CloudFront
  • S3 Origin Access Identity
• Global Accelerator
• AWS Rekognition, Comprehend and Comprehend Medical
• AWS Lambda with combination of AWS Application-Load Balancer and AWS WAF
• AWS Network Load Balancer
• API Gateway
• AWS Shield Standard and Advanced
• CloudWatch, CloudTrail and Amazon Eventbridge
• RDS Databases (Mostly MySQL) and DynamoDB
• Aurora Database
• Elasticache and DynamoDB Accelerator (DAX)
• Amazon Elastic Container Service (ECS)
• Amazon Kinesis Data streams and Data Firehose

The point of the exam is to use the above services with the following domains in this link: AWS Solutions Architect Exam Guide

1. Design Secure Architectures
2. Design Resilient Architectures
3. Design High-Performing Architectures
4. Design Cost-Optimized Architectures

Final thoughts

The exam needs to have a good preparation for you to pass as this was designed for the candidate to fail. Having a thorough understanding of the services and some practice gives you an edge to pass the exam. Fortunately, AWS preparation courses are available on the internet and gives you a higher chance to pass.

What is Cloud Computing

According to NIST (National Institute of Standards and Technology)

a model for enabling ubiquitous, convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications, and services) that can be rapidly provisioned and released with minimal management effort or service provider interaction. This cloud model is composed of five essential characteristics, three service models, and four deployment models

Main characteristics of cloud

• On-demand self-service - Automatic provisioning of the underlying computing resources without human interaction

• Broader network access - Can be access with multiple platforms

• Resource pooling - Multiple customers are served within the same resources with security and privacy

• Rapid Elasticity - Acquire and dispose resources based on demand

• Measure Service - Bill only the used resources by the customers

Service Models

The different models describe who manages the different resources in the cloud. Both the cloud provider and customer shares a responsibility in the platform.

• IaaS (Infrastructure-as-a-Service)

  • The cloud provider is responsible in provisioning the underlying virtualization, servers, storage and networking
  • The customer is responsible in maintaining applications, data, runtime, middleware and OS

• PaaS (Platform-as-a-Service)

  • The cloud provider is responsible in provisioning the underlying runtime, middleware, OS, virtualization, servers, storage and networking
  • The customer is responsible in maintaining applications and data

• SaaS (Infrastructure-as-a-Service)

  • The cloud provider is responsible in provisioning all the underlying resources
  • The customer access the application provided by the provider

Why deal with the cloud now?

Cloud is an exciting domain to pursue and compose of different professions (at least in my organization). Dealing with this now is a great investment to your career also it is fun to use a cloud infrastructure. These are the known professions that I've encountered in a pro-cloud organization.

• Cloud Architects - Obviously, this will be the first role which you will encounter in an organization both big or small. These people handles the tech standards and business side of things. They present the most cost-effective approach using the right Cloud Platform

• Cloud Developers - Develop and maintain applications using cloud technologies

• Cloud Administrators - Configure and maintain the hardware aspects using different cloud services

• Cloud Security Engineers - Builds and maintains security of a cloud platform

Application Modernization

Modernizing applications from on-premise to cloud is a trend right now and most of the organizations are starting to do it. A report from Konveyor showing the current state of modernization in different regions. It stated the six modernization strategies used by different organizations.

• Retire - Decommission applications that are not in used

• Retain - Leave critical applications since it may be refactored

• Rehost - Transfer on-premise applications to cloud with no significant code change

• Replatform - Use cloud migration strategies to enable cloud-specific components in your application

• Refactor - Modify the existing application code to take advantage the Microservice or Serverless architecture

• Repurchase - Use of SaaS (Software-as-a-Service) model

Fundamentals Certifications

There are different cloud certifications that you can take and start to learn with. Most of top certifications are from AWS, Azure, Google Cloud and Oracle Cloud. I took most of the certifications and the required trainings to easily pass them all.

• AWS Cloud Practitioner - AWS CCP Course

• Microsoft Azure - Azure Fundamentals Courses

• Google Cloud - GCP Digital Leader

• Oracle Cloud Infrastructure - OCI Foundations

What are you waiting for?

Join now the club of developers who enthusiastically learn and contribute in the cloud domain. Cloud computing is a promising field and it will be for the next upcoming years. Start your cloud journey now!

As an experienced Java Developer, It was an opportunity for me to take the discounted exam (90% off) starting from February 25 to April 25 of 2021. The discounted exam was due to the Java 25th Anniversary. I ended up scoring 76% and it was a nice experience that made me more understand Java and the new features of version 11.

Preparation

I've prepared for the exam about 1.5 months and I used the book of Boyarsky and Selikoff, OCP 11 Study Guide. This book covers almost all of the topics that you will encounter in the exam. Since some of the chapters of the book was hard to understand, I sometimes re-read again a specific chapter.

Since I've already took an OCA for Java 8. These are the chapters that I've studied for this exam:

Chapter 2 Chapter 11 Chapters 12 - 22 After reading each chapter, I immediately took the review questions so I can assess if I understood the module. Also at the end of the book, you can register and access for the Sybex Online Test Bank which is valid in 1 year upon your registration.

Before The Exam

The exam can be taken in Pearson VUE website where you will schedule and pick if you're going to take via online or onsite. After that, you must do a system check if your current device is working properly.

The Exam

OCP Java 11 SE Developer has no exam prerequisites, unlike the previous exams that you must take first the OCA exam. I took the exam online because of COVID-19 restrictions. But I prefer taking exams onsite.

The exam consist of 50 questions under 90 minutes which is different to previous OCP exams that has 85 questions under 150 minutes. Exam objectives that I've encountered are as follows:

• Concurrency
• Functional Programming (Lambda and Stream API)
• Java Fundamentals (Operators and Core Java API)
• Annotations
• JDBC
• Security
• NIO.2
• I/O
• Exceptions
• Modules

The exam was slightly hard since you need to think of the answer for each question under 2 minutes. I mark a question For review when it took me already more than a minute just to answer. The exam proctor is usually strict for unnecessary movements you make during the exam. After answering and reviewing all the answers, you can submit and can see the results immediately.

Summary

The exam is not easy and you need to prepare for it. Luckily, certification books of Boyarsky and Selikoff exists. Their book contains questions that is already hard and can make you really prepare for the exam. In the end, you must manage and give time in studying for the certification.