DEV Community: Abraham Mekonnen

Optimizing Serverless Lambda with GraalVM Native Image

Abraham Mekonnen — Tue, 24 Dec 2024 02:37:55 +0000

Introduction

Following the development of a scalable email-sending service using AWS SES, Spring Boot, and AWS Lambda, I set out to optimize its performance. The focus was to address the cold start latency and memory usage inherent to Java applications on AWS Lambda. To achieve this, I turned to GraalVM Native Image, a technology designed to compile Java applications into native executables. This article outlines the implementation and results of this optimization.

Why GraalVM Native Image?

GraalVM Native Image compiles Java applications ahead of time (AOT) into standalone executables. By doing so, it eliminates the need for a JVM at runtime, resulting in:

Reduced Cold Start Times: Applications start almost instantly, a crucial factor for serverless environments.
Lower Memory Usage: By stripping unnecessary components, it creates a lightweight application footprint.

These advantages make GraalVM an ideal solution for improving serverless application performance.

Implementation Steps

1. Project Setup

I began with AWS’s pet-store-native project, which provides a reference implementation for converting Spring Boot 3 applications into GraalVM-native images. This served as the foundation for integrating native image capabilities into the email-sending service.

2. Adapting for ARM Architecture

Since my environment uses an ARM-based architecture, the Dockerfile required modifications:

Updated the base image to align with ARM.
Configured the GraalVM compiler for ARM compatibility. These changes ensured the native image was optimized for the target system.

3. Runtime Configuration

Creating a custom bootstrap file for the runtime environment is essential to ensure the proper initialization and startup of the application. This file defines the entry point for the Lambda function and initializes the runtime environment. It also provides flexibility in configuring application parameters, enabling seamless integration with AWS Lambda.

I also enabled HTTP protocol support in the GraalVM Maven plugin and integrated the AWS Java Container for Spring Boot to handle API Gateway events. These configurations ensured the application could efficiently process HTTP requests and responses in its native image form.

4. Deploying the Application

Using the AWS Serverless Application Model (SAM), I deployed the native image as a Lambda function. Key customizations included:

Switching from HTTP API Gateway to a standard API Gateway to enable API key-based authentication.
Implementing usage plans for secure and scalable API access. These adjustments not only enhanced security but also allowed better resource allocation for the function.

Results

The transition to GraalVM Native Image yielded significant improvements:

Cold Start Times: Reduced by eliminating JVM initialization.
Memory Usage: Minimized due to the compact nature of native executables.
Performance Scaling: Faster response times and better handling of concurrent requests.

Native image

SpringBoot3

Additionally, the API Gateway integration provided robust control over access and usage, enabling the service to function as a secure and scalable endpoint.

Lessons Learned

Through this implementation, I gained a deeper understanding of the interplay between GraalVM, Spring Boot, and AWS Lambda. The process highlighted the importance of:

Optimizing for specific architectures to maximize performance.
Configuring runtime environments to balance flexibility and efficiency.
Leveraging tools like AWS SAM for streamlined deployment.

This project reinforced the potential of GraalVM Native Image as a powerful optimization tool for serverless Java applications, offering a compelling path forward for enhancing performance and reducing costs in production environments.

GitHub Repo for this project

Resources

Replatforming Java Applications with the Updated AWS Serverless Java Container

Quick Start Guide: Spring Boot 3

GraalVM Native Image: Faster, Smarter, Leaner

Going AOT: A Comprehensive Guide to GraalVM for Java Applications by Alina Yurenko | SpringIO

Going Native: Building Fast and Lightweight Spring Boot Applications with GraalVM by Alina Yurenko

Sending Emails with Spring Boot, AWS SES, and Serverless Lambda for Scalable Solutions

Abraham Mekonnen — Thu, 19 Dec 2024 00:25:29 +0000

In the course of developing a Next.js authentication project, I encountered the need to send verification emails. While there are many email-sending services available, most come with subscription fees or limited free-tier plans. To maintain control and reduce costs, I decided to build my own email sender using Spring Boot, which provides a powerful framework for Java-based backend development.

Initially, I used Gmail’s SMTP server to send emails. While functional, it lacked the professionalism of domain-specific emails, particularly for production environments. My goal was to send emails using my own domain, hosted on AWS Route 53. This led me to leverage AWS Simple Email Service (SES), which provides an SMTP interface for seamless integration.

In this article, I will outline my journey and provide an overview of the tools and resources I used to implement this solution.

Why AWS SES?

AWS SES stands out as the most cost-effective option, offering the ability to send up to 100,000 emails for just $10, compared to estimated costs of around $8 for 5,000 emails with Bravo or approximately $20 for 75,000 emails with SendGrid. Along with its scalability, reliability, and support for domain-specific emails, AWS SES becomes the ideal choice for transactional and marketing needs. Its superior deliverability rates and seamless integration with other AWS services further enhance its value, making it a robust and budget-friendly solution for businesses aiming to optimize their email campaigns.

Setting Up AWS SES

To use AWS SES, you need an AWS account. Setting up SES involves domain verification and creating an SMTP user. While I won’t cover the full step-by-step process here, I recommend the following YouTube tutorial, which I found incredibly helpful. Additionally, refer to the official AWS documentation for best practices and the most up-to-date setup instructions.

Moving forward his tutorial guided me through:

Verifying my domain in AWS SES.
Configuring DNS records in AWS Route 53 for domain authentication (DKIM and SPF).
Setting up SES in production mode (moving out of the SES sandbox).

Integrating AWS SES with Spring Boot

After setting up AWS SES, the next step was to build an email sender in Spring Boot. For this, I referred to another excellent YouTube tutorial. However, additional documentation can be found here.

Key Steps in Implementation

1.Spring Boot Dependencies
Add the following dependencies to your pom.xml for email functionality:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

2.Configuring SMTP Properties
In the application.properties or application.yml, configure the SMTP settings for AWS SES:

spring:
  application:
    name:
      MailSender
  mail:
    host: email-smtp.<region>.amazonaws.com
    port: 587
    username: ${mail-username}
    password: ${mail-password}
    protocol: smtp
    properties:
      mail:
        debug: true
        smtp:
          auth: true
          starttls:
            enable: true
            required: true

3.Building the Email Service
To handle email sending, I created a service class. For email content, I utilized Mustache templates to design the email in HTML format, making it dynamic and visually appealing. The service simply injects the verification token into the template before sending the email.

Optimizing with AWS Lambda

After successfully implementing the email sender in Spring Boot, I decided to take it further by deploying the service as a Lambda function. Lambda provides serverless capabilities, reducing infrastructure overhead and costs.

Steps to Deploy with AWS Lambda

Base Project I referred to the official AWS GitHub repository for serverless Java projects
Deploying with AWS SAM Using the Serverless Application Model (SAM) CLI, I packaged and deployed the Lambda function. The setup included an API Gateway with API key-based authentication to secure the endpoint.
Performance Enhancements While the initial deployment worked well, I sought to optimize the solution by:

Reducing memory consumption.
Improving cold start times for faster execution and lower costs.

Next Steps: GraalVM Native Image

To achieve even greater performance, my next goal is to use GraalVM Native Image. This technology compiles Java applications into native executables, eliminating the JVM’s startup time and significantly reducing memory usage. Stay tuned for my next article, where I’ll dive into this optimization and share how it further enhanced my email-sending service.

Conclusion

By integrating AWS SES with Spring Boot and deploying it using AWS Lambda, I built a scalable, cost-efficient email-sending service tailored to my domain-specific needs. This project not only met the immediate requirement of sending verification emails but also provided a learning opportunity in serverless architecture and performance optimization.

If you’re looking to implement a similar solution or have questions, feel free to reach out!

AI-Powered Resume Builder with Dynamic PDF Generation and Customization

Abraham Mekonnen — Fri, 25 Oct 2024 17:29:48 +0000

In today’s fast-paced, competitive job market, having a resume that stands out is crucial. To help professionals streamline this process, I developed an AI-powered resume management system that allows users to create, customize, and optimize resumes based on their career objectives and job descriptions. The system integrates cutting-edge technologies to generate dynamic PDFs, giving users a polished, professional resume in seconds.

Project Overview

The project is built using Spring Boot, with several key libraries and tools that enhance its functionality:

OpenPDF for PDF generation.
Spring Doc OpenAPI for comprehensive API documentation.
Flyway for database migrations.
PostgreSQL for data persistence.
JPA (Java Persistence API) for managing database entities.
Spring AI to integrate with the OpenAI API for resume enhancements based on job descriptions.

The core objective of this project was to create an intuitive system that allows users to manage every aspect of their resume by adding, deleting, or modifying sections such as skills, certifications, education, professional experience, and projects. Additionally, the integration of AI enables the system to analyze job descriptions and adjust the content of the resume accordingly, ensuring it aligns with specific job requirements.

Steps Taken in Development

Template Creation: A professional resume template was designed using OpenPDF to serve as the foundation for the final PDF generation.
PDF Generation Logic: A dedicated class was created to map the template to the resume sections, allowing the dynamic generation of a PDF document.
CRUD Operations: A comprehensive management system was built to allow users to perform CRUD (Create, Read, Update, Delete) operations on their resume data, ensuring that every section can be easily modified.
Data Migrations with Flyway: Implemented Flyway to manage database migrations, making the system adaptable and easy to maintain.
Docker Integration: Used Docker to containerize the application and databases, allowing for easy deployment and scalability. This also ensures consistency across different environments.
AI-Powered Resume Enhancement: The project leverages Spring AI to integrate with the OpenAI API. Users can submit their resume along with a job description, and the AI tailors the resume content, ensuring it highlights the most relevant skills and experiences. Here is a good YouTube video resource, I used to learn about Spring AI.
Docker Image Creation: The final application is containerized into a Docker image, allowing it to be easily accessed and deployed by others through Docker Hub.

How to Use the System

To generate a personalized, AI-powered resume, simply provide the following details before generating the PDF:

User Details: Basic information such as name, contact details, and other personal data.
Descriptions: A brief overview of your professional summary or objectives.
Skills: A list of relevant technical and soft skills.
Certifications: Any certifications that add value to your expertise.
Education: Details of your educational background.
Projects: Key projects that showcase your experience and contributions.
Professional Experience: A detailed account of your previous job roles and accomplishments.
Prompt for OpenAI API: Provide instructions on how the AI should edit and enhance the resume based on the job description, ensuring that the content is tailored to match the role’s requirements.

Before starting the Docker image, you’ll need to provide your OpenAI API key as an environment variable to enable the AI-powered resume enhancement feature. Once all the necessary fields are filled out, the system generates a customized, professional resume in PDF format that’s ready for use.

Areas for Improvement

While the current system is highly functional, there are areas that could be enhanced:

Error Handling: Implementing more robust error-handling mechanisms to ensure smoother operation and better user experience.
Unit Testing: Expanding unit tests to cover more scenarios and ensure system reliability.

Future Plans

AWS Lambda Deployment: To improve scalability and reduce operational costs, I plan to deploy the application on AWS Lambda, allowing for serverless operation and automatic scaling.
GraalVM Integration: Integrating GraalVM to optimize the application’s performance, reducing its memory footprint and improving cold startup times, especially in cloud environments.

Conclusion

This AI-powered resume management system represents a step forward in how professionals can craft and optimize their resumes. By automating the process and allowing for easy customization, it saves time and ensures that users always present the best possible version of themselves to potential employers. With planned improvements and future deployments on AWS, this project will continue to evolve and meet the needs of modern professionals.

GitHub-link

Here’s the docker-compose-template file for deploying the AI-Powered Resume Generator application, complete with a Postgres database and optional pgAdmin service. This setup uses environment variables to manage database credentials and integrates the OpenAI API for resume enhancements. Feel free to customize the values as needed for your deployment. Here is the GitHub-repo.

Key Concepts to Understand Before Starting with Spring Boot and AI

Abraham Mekonnen — Tue, 22 Oct 2024 20:21:46 +0000

Before diving into the world of AI within Spring Boot, it's essential to grasp some fundamental concepts. Especially before referring to any Spring Boot AI documentation, it's helpful to understand these basics. In this guide, I'll explain these ideas in the way that I understand them, and I hope it proves useful to anyone reading.
Let's start with the core technology behind many text-based AI chat tools, including image generation systems - LLMs (Large Language Models). According to IBM, "Large Language Models (LLMs) are a category of foundation models trained on vast amounts of data, enabling them to understand and generate natural language and other types of content for a wide range of tasks." So, how do we integrate them into projects using Spring Boot AI? Before answering that, let's discuss some important points about LLMs that will provide a deeper understanding.
The first thing to know is that LLMs have a training data cutoff date. This means that the model is trained only up until a specific point in time, and it won't be aware of anything that happened after that date. To address this limitation, several solutions have been developed, including:

Prompt Stuffing
RAG (Retrieval Augmented Generation)
Function Calling
Fine-tuning

Before diving into these solutions, let's talk about tokens. In the world of LLMs, tokens are essentially the currency. LLMs process tokens rather than raw words, so everything inputted has to be converted into tokens. Every prompt sent to an LLM gets converted into tokens, and there is a limit to how many tokens an LLM can handle in a single request.
Now, let's explore the solutions mentioned earlier:

1. Prompt Stuffing:

This involves adding relevant information along with the user's question. For example, if a user asks about the dosage of a specific medication, you include additional data about that medication in the prompt. This allows the LLM to refer to the provided information when formulating its response.

2. RAG (Retrieval Augmented Generation):

This technique helps overcome the token limit in LLMs. Suppose a user wants to ask a question about a 900-page book, but the LLM has a token limit of 90,000 tokens (approximately 120,000 tokens for a 900-page book). It's impossible to stuff the entire content into the prompt. Enter embedding, a method of converting digital content into vectors, which are then stored in a vector database. This type of database, unlike traditional ones, performs similarity searches. When a question is asked, relevant data is retrieved from the vector database using similarity search, and this data is used in the prompt to help the LLM generate an answer.

3. Function Calling:

In this approach, the LLM is provided with several functions it can call upon to answer user queries. When the LLM encounters a question it cannot answer with its trained data, it calls an appropriate function to fetch the necessary information. The response from the function is then used to answer the question.

4. Fine-Tuning:

Fine-tuning involves training an already pre-trained LLM for a specific role or use case. This technique is mainly used by data scientists and, as of this writing, is not typically necessary when working with Spring Boot AI projects.

Understanding Key Concepts of Large Language Models (LLMs) before delving into spring AI

Abraham Mekonnen — Thu, 12 Sep 2024 22:29:34 +0000

Prompt Stuffing
RAG (Retrieval Augmented Generation)
Function Calling
Fine-tuning

1. Prompt Stuffing:

2. RAG (Retrieval Augmented Generation):

3. Function Calling:

4. Fine-Tuning:

Conclusion

In summary, integrating AI into Spring Boot requires a solid grasp of the foundational concepts behind Large Language Models (LLMs) and their limitations. By understanding how LLMs process tokens, and recognizing their inherent training data cutoff, developers can leverage various techniques like Prompt Stuffing, RAG, Function Calling, and Fine-Tuning to enhance their models' performance. While some solutions like RAG and embedding are crucial for overcoming token limits, others like Function Calling allow LLMs to extend beyond their training data. With this knowledge in hand, you'll be better prepared to navigate the complexities of building AI-powered systems within Spring Boot, ensuring more efficient and effective AI integrations.