Skip to main content

Spring Boot on EC2

This article is about installing a Spring Boot Application on AWS using this technology stack:

  • EC2 to run the Java program

  • systemctl to control start/stop/restart the application

  • Configuration of the Spring Boot application using environment variables


We start from the assumption that a jar file has been created and is available on AWS S3 or some other artifact repository.

Step 1: Create the EC2 Instance


Prerequisites:

  • AWS account

  • 1 VPC - dev-vpc

  • 1 subnet -  dev-apps-subnet


I created an EC2 instance of size small with an Amazon Linux image.

In that instance, I created a folder for the application and copied the jar file genova-1.0.jar containing the Spring Boot application to that folder.

Step 2: Configure the Process to Run the Java Application


SystemD is a Linux facility that automatically starts, restarts, and stops processes.

In this case, it consists of a file in /etc/systemd/system:



Also, it is possible to configure other environment variables in the file genova.conf:


JAVA_HOME=/usr/lib/jvm/java-11-openjdk-11.0.13.0.8-1.amzn2.0.3.x86_64
JAVA_OPTS="-Xms256m -Xmx256m"


Because we want to use the same approach on multiple deployments (EC2, Docker, Elastic Beanstalk), we will remove the configuration from the .conf file and move it all to the .service file. It is shown in this article as an option.


Commands used:


  • sudo systemctl daemon-reload - reload the configuration

  • sudo systemctl start  genova.service - start the service

  • sudo journalctl -u genova.service - list recent log entries

Step 3: API Gateway Configuration

The EC2 instance is in a private subnet for security purposes and is inaccessible directly over the public Internet. To provide access to the application, we used the AWS API Gateway, which acts in this case like a load balancer:










Popular posts from this blog

View - A Functor for Web App Design

This blog is about practical applications of Category Theory to the development of Java + Spring applications. I am looking at a design approach to simplify the development of web applications. Traditionally, this kind of back-office application is based on the Web 1.0 technology stack, using Spring Boot and Thymeleaf. My approach is to keep using Spring Boot but replace the generation of HTML with J2HTML and higher-order views. From a Category Theory point of view, we can look at web applications as mappings from the Category of Business Entities and the Category of UI Widgets. If we go one step further, both business entities and UI widgets are mapped to Java classes. Thus, we can view a web application (or a part of it) as an endofunctor in the Category of Java Classes. We define the View-functor as follows: domain(V) - Java classes representing business entities - e.g., Invoice, User - and, codomain(V) - Java functions that render the business entity as a DomContent object (DomCont...
Read more

Web Application Development following Functional Programming Principles

After studying category theory and functional programming, I decided to put these concepts into practice by developing a simple web application. This project was inspired by the example in Chapter 11 of 'Programming in Haskell' by Graham Hutton. My goal was to take these theoretical programming ideas and see how they work in creating a real-world web application. The key concepts of functional programming are: Prioritize creating pure functions as much as possible. These are functions without side effects, making them simpler to test Use composition of pure functions to construct more intricate functions Use Functors, Applicatives, and Monads in scenarios that require pure functions, such as error handling or managing missing values, and when working with collections like trees and lists. I wrote this application in Java, utilizing the Spring Boot framework. This decision was influenced by my previous work in developing enterprise applications with this technology stack. My obj...
Read more

Reading J2HTML

J2HTML (j2html) is a Java library used to generate HTML I have been using it to create Web 1.0 applications in Java. Web 1.0 is server-side rendering pages with minimal Javascript. As I got deeper into using the library I started to read the actual source code of this library with an eye on following Java best practices and to my pleasant surprise, this code follows many of them. I am going to show here some examples of using interesting Java features, beyond the basics. 1. Functional Interface People are aware that Java supports some form of Functional Programming, and here is an example of using it: @FunctionalInterface public interface Indenter {     String indent( int level , String text ); } public static Indenter indenter = ( level , text ) -> String. join ( "" , Collections. nCopies ( level , FOUR_SPACES )) + text ; Things that I noticed: String has a method called join. I used before StringUtils.join, but now that is in the standard library I don’t n...
Read more