Use CLI to generate your spring starter projects

EI Akoji — Wed, 17 Apr 2024 04:13:53 +0000

In the world of Spring Boot development, starting a new project with spring.io, manually downloading and extracting the starter-template can be cumbersome. Fortunately, Spring CLI (Command Line Interface) provides a convenient solution to streamline this process. In this article, we'll explore how to leverage Spring CLI to generate a Spring Boot project template quickly and efficiently.

Spring CLI allows you to quickly bootstrap and develop Spring-based applications using Groovy scripts. Here's a step-by-step guide to create a new project:

Step 1: Install Spring CLI

If you haven't installed Spring CLI yet, you can download it from the official Spring website or use SDKMAN! (The Software Development Kit Manager). Here's how to install it using SDKMAN!:

   sdk install springboot

This command installs the Spring Boot CLI along with the Spring CLI.

Step 2: Create a New Project
Once you have Spring CLI installed, you can create a new project using the spring init command followed by the project name and the dependencies you want to include. For example:

   spring init --dependencies=web,data-jpa my-spring-project

This command creates a new Spring Boot project named my-spring-project with web and data JPA dependencies. You can obtain detailed information on the different options available to use with the spring init command viz:

Step 3: Customize Project Settings:
You can customize your project settings by specifying additional options in the spring init command. For instance, you can specify the project's language, build system, and packaging format. Here's an example:

   spring init --java-version=21 \
   --build=gradle \
   --packaging=jar \
   --type=gradle-project \
   --artifact-id=demo \
   --group-id=com.example \
   --dependencies=actuator,data-jdbc,postgresql,web \
   --extract \
   my-spring-app

This command creates a new Spring Boot project with Java 21, Gradle as the build system, JAR packaging with actuator, data-jdbc, postgresql, web as dependencies. To view more customizable options, do:

   sdk --help init

Command	Description
--dependencies, -d	Comma-separated list of dependencies to include
--version, -v	Version of Spring Boot to use (e.g., 2.6.0, 2.5.4.RELEASE)
--build, -b	Build tool to use (maven or gradle)
--java, -j	Java version (e.g., 1.8, 11, 17)
--language, -l	Language for the project (java, groovy, kotlin)
--package-name, -p	Base package name for the project
--groupId, -g	Group ID for the project
--artifactId, -a	Artifact ID for the project
--boot-version	Version of Spring Boot to use
--force, -f	Overwrite any existing files
--extract, -x	Extracts the given archive to the project directory
--list, -ls	List all available Spring Boot versions
--list-modules, -lm	List the modules for a given version
--list-templates, -lt	List all available project templates
--no-overwrite	Skips writing files if they already exist
--packaging, -P	Packaging to use for the project (e.g., jar, war)
--name, -n	Project name
--description, -d	Project description
--force, -f	Overwrite existing files without prompting
--format, -of	Format the output using the given format (e.g., json, yaml)
--list, -ls	List all available versions
--list-boot, -lb	List all available Spring Boot versions
--list-all	List all available Spring Boot versions
--list-templates, -lt	List all available project templates
--yes, -y	Always use the default value for prompts
--no-color, -nc	Disable color output
--quiet, -q	Quiet output mode (no progress bar)
--stacktrace, -st	Print stack trace on application failure
--version, -v	Print the version number
--help, -h	Print this help message

This table summarizes the options available for the spring init command, along with their descriptions. You can use these options to customize the generation of your Spring Boot project according to your requirements. Here are some examples:

To list all the capabilities of the service:
    $ spring init --list

To creates a default project:
    $ spring init

To create a web my-app.zip:
    $ spring init -d=web my-app.zip

To create a web/data-jpa gradle project unpacked:
    $ spring init -d=web,jpa --build=gradle my-dir

Available Spring Initializr Dependencies/Templates

Dependencies:

actuator: Actuator: Production-ready features to help you monitor and manage your application
batch: Batch: Support for Spring Batch including HSQLDB database
data-cassandra: Spring Data Cassandra: Apache Cassandra database support
data-jdbc: Spring Data JDBC: Simplified database access via JDBC
data-jpa: Spring Data JPA: Simplified database access via JPA
data-ldap: Spring Data LDAP: Simplified LDAP access
data-mongodb: Spring Data MongoDB: MongoDB database support
data-rest: Spring Data REST: Expose Spring Data repositories over REST via Spring Data REST
data-solr: Spring Data Solr: Apache Solr search platform support
jersey: Jersey: RESTful Web Services with JAX-RS and Jersey
jms: JMS: Java Messaging Service
jmx: JMX: Java Management Extensions
mail: Mail: Sending email using Spring Framework's email abstraction
mobile: Mobile: Support for mobile web applications with jQuery Mobile
mqtt: MQTT: MQTT support
security: Security: Authentication and Authorization with Spring Security
thymeleaf: Thymeleaf: Thymeleaf engine
web: Web: Full-stack web development with Tomcat and Spring MVC
websocket: WebSocket: WebSocket support

Templates:

activiti: Activiti: Business Process Modeling
batch: Batch Service
cloud-config-client: Config Client: Distributed Versioned Configuration
cloud-config-server: Config Server: Centralized External Configuration Management
cloud-eureka: Eureka Discovery: Service Registration and Discovery
cloud-gateway: Gateway: API Gateway
cloud-hystrix: Hystrix: Circuit Breaker
cloud-zuul: Zuul: API Gateway
kafka: Apache Kafka: Kafka Support
kotlin: Kotlin: Kotlin Programming Language Support
mongodb: MongoDB: MongoDB Support
restdocs: Spring REST Docs: Documentation generation for RESTful services
security-oauth2: OAuth2: OAuth 2.0 Support
webflux: WebFlux: Reactive Web Support

Project types (* denotes the default)

Id	Description	Tags
gradle-build	Generate a Gradle build file.	build:gradle,format:build
gradle-project *	Generate a Gradle based project archive using the Groovy DSL.	build:gradle,dialect:groovy,format:project
gradle-project-kotlin	Generate a Gradle based project archive using the Kotlin DSL.	build:gradle,dialect:kotlin,format:project
maven-build	Generate a Maven pom.xml.	build:maven,format:build
maven-project	Generate a Maven based project archive.	build:maven,format:project

Parameters

Id	Description	Default value
artifactId	project coordinates (infer archive name)	demo
bootVersion	spring boot version	3.2.4
description	project description	Demo project for Spring Boot
groupId	project coordinates	com.example
javaVersion	language level	17
language	programming language	java
name	project name (infer application name)	demo
packageName	root package	com.example.demo
packaging	project packaging	jar
type	project type	gradle-project
version	project version	0.0.1-SNAPSHOT

Step 4: Navigate to the Project Directory
Once the project is created, navigate to the project directory:

   cd my-spring-project

Step 5: Open the Project in Your Preferred IDE:
Open the project in your favorite Integrated Development Environment (IDE) such as IntelliJ IDEA, Eclipse, or Visual Studio Code.

Step 6: Start Developing:
You can now start developing your Spring application. The project structure is set up with a basic application class and directory structure, allowing you to add your own controllers, services, repositories, etc.

Step 7: Run Your Application:
To run your Spring Boot application, use the following command:

   ./mvnw spring-boot:run

If you're using Gradle, you can run your application with:

   ./gradlew bootRun

Your Spring Boot application will start, and you can access it at http://localhost:8080.

That's it! You've successfully created a new Spring Boot project using Spring CLI and can now start building your application.

Run Springboot application with Elastic Beanstalk, SSH and EC2

EI Akoji — Sun, 17 Mar 2024 08:04:24 +0000

Recently, I worked on a PoC to create an automated build pipeline for a springboot rest api in elastic beanstalk. Based on prior knowledge related to the use of Amazon EBS, this was expected to be a trivial tasks. Turns out that without a solid knowledge on setting up and managing configurations for AWS resources, doing this can be challenging.

There are a host of pages and videos explaining how to deploy spring/springboot applications to elastic beanstalk. however, I was not lucky enough to find one explaining details of the underlying computing resource for this configuration.

For this post, I am focusing on the configuration required to deploy a java application on elastic bean stalk, using Amazon EBS CLI. This can also be done with AWSCLI, though, EBS CLI is tailored to meet our needs.

Infrastructure Diagram

To run java applications with EBS, we can use several configurations. Deploying an application that runs on scalable EC2 instances is common, hence is used in this guide.

Requirements

You'll obviously need to have an AWS account with the required access level to AWS console.
If you have not done so, install AWSCLI and configure your credentials.

You can create named profiles with your aws credentials and configuration using this guide.

Install EBS CLI
Follow this tutorial to create and deploy a simple springboot application with AWS Elastic Beanstalk. Remember to select "create a new SSH public, private key pair" when prompted to.

Implementation Notes

I noticed that the eb create command fails when the following line is added:

deploy:
  artifact: target/spring-boot-bootstrap-eb.jar

If you get the following error message: ERROR: NotFoundError - Application Version does not exist locally (target/spring-boot-bootstrap-eb.jar). Try uploading the Application Version again.

Remove the deploy artifact configuration and use the following command to create your environment:

$ eb create --source target/spring-boot-bootstrap-eb.jar --$ version spring-boot-bootstrap-eb

Similarly run the following command to deploy

$ eb deploy --version spring-boot-bootstrap-eb

You can review the CLI documentation or use eb command_name --help to view usage of different commands.

SSH to your EC2 Instance

Now you're all set to go!

$ eb ssh
$ cd /var/app/current
$ java -jar application.jar