Containerizing, packaging, and running a Spring Boot application

Note	This repository contains the guide documentation source. To view the guide in published form, view it on the Open Liberty website.

Learn how to containerize, package, and run a Spring Boot application on Open Liberty without modification.

What you’ll learn

The starting point of this guide is the finished application from the Building an Application with Spring Boot guide. If you are not familiar with Spring Boot, complete that guide first. Java 17 is required to run this project.

You will learn how to use the springBootUtility command to deploy a Spring Boot application in Docker on Open Liberty without modification. This command stores the dependent library JAR files of the application to the target library cache, and packages the remaining application artifacts into a thin application JAR file.

You will also learn how to run the Spring Boot application locally with Open Liberty, and how to package it so that it is embedded with an Open Liberty server package.

https://raw.githubusercontent.com/OpenLiberty/guides-common/prod/gitclone.adoc

Building and running the application

First, build the initial Spring Boot application into an executable JAR file. Navigate to the start directory and run the Maven package command:

https://raw.githubusercontent.com/OpenLiberty/guides-common/prod/os-tabs.adoc

cd start
mvnw.cmd package

cd start
./mvnw package

You can now run the application in the embedded Tomcat web container by executing the JAR file that you built:

java -jar target/guide-spring-boot-0.1.0.jar

After you see the following messages, the application is ready:

... INFO ... [ main] com.example.springboot.Application : Started Application in 2.511 seconds (process running for 3.24)
Let's inspect the beans provided by Spring Boot:
application
...
welcomePageHandlerMapping
welcomePageNotAcceptableHandlerMapping

Go to the http://localhost:8080/hello URL to access the application.

The following output is displayed in your browser:

Greetings from Spring Boot!

When you need to stop the application, press CTRL+C in the command-line session where you ran the application.

Building and running the application in a Docker container

You will build an Open Liberty Docker image to run the Spring Boot application. Using Docker, you can run your thinned application with a few simple commands. For more information on using Open Liberty with Docker, see the Containerizing microservices guide.

Learn more about Docker on the official Docker website.

Install Docker by following the instructions in the official Docker documentation.

Navigate to the start directory.

Create the Dockerfile in the start directory.
Dockerfile

Dockerfile

link:finish/Dockerfile[role=include]

This Dockerfile is written in two main stages. For more information about multi-stage Dockerfiles, see the documentation on the official Docker website.

The first stage copies the guide-spring-boot-0.1.0.jar Spring Boot application to the /staging temporary directory, and then uses the Open Liberty springBootUtility command to thin the application. For more information about the springBootUtility command, see the springBootUtility documentation.

The second stage begins with the Open Liberty Docker image. The Dockerfile copies the Liberty server.xml configuration file from the /opt/ol/wlp/templates directory, which enables Spring Boot and TLS support. Then, the Dockerfile copies the Spring Boot dependent library JAR files that are at the lib.index.cache directory and the thin-guide-spring-boot-0.1.0.jar file. The lib.index.cache directory and the thin-guide-spring-boot-0.1.0.jar file were both generated in the first stage.

Use the following command to build the Docker image:

docker build -t springboot .

To verify that the images are built, run the docker images command to list all local Docker images:

docker images

Your springboot image appears in the list of Docker images:

REPOSITORY    TAG       IMAGE ID         CREATED           SIZE
springboot    latest    d3ffdaa81854     27 seconds ago    596MB

Now, you can run the Spring Boot application in a Docker container:

docker run -d --name springBootContainer -p 9080:9080 -p 9443:9443 springboot

Before you access your application from the browser, run the docker ps command to make sure that your container is running:

docker ps

You see an entry similar to the following example:

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                            NAMES
e33532aa07d6        springboot          "/opt/ibm/docker/doc…"   7 seconds ago       Up 2 seconds        0.0.0.0:9080->9080/tcp, 0.0.0.0:9443->9443/tcp   springBootContainer

You can watch the application start by monitoring the logs:

docker logs springBootContainer

After the application starts, go to the http://localhost:9080/hello URL to access the application.

Tearing down the Docker container

To stop and remove your container, run the following commands:

docker stop springBootContainer
docker rm springBootContainer

Running the application on Open Liberty

Next, you will run the Spring Boot application locally on Open Liberty by updating the pom.xml file.

The pom.xml was created for you in this directory.

Update the Maven POM file in the start directory.
pom.xml

pom.xml

link:finish/pom.xml[role=include]

Add the liberty-maven-plugin to the pom.xml file.

The liberty-maven-plugin downloads and installs Open Liberty to the target/liberty directory. The installAppPackages configuration element in the pom.xml file typically takes in the following parameters: dependencies, project, or all. The default value is dependencies, but to install the Spring Boot application to Open Liberty, the value must be spring-boot-project. This value allows Maven to package, thin, and copy the guide-spring-boot-0.1.0.jar application to the Open Liberty runtime applications directory and shared library directory.

To run the Spring Boot application, the Open Liberty instance needs to be correctly configured. By default, the liberty-maven-plugin picks up the Liberty server.xml configuration file from the src/main/liberty/config directory.

Create the Liberty server.xml configuration file.
src/main/liberty/config/server.xml

server.xml

link:finish/src/main/liberty/config/server.xml[role=include]

The servlet and springBoot features are required for the Liberty instance to run the Spring Boot application. The application port is specified as 9080 and the application is configured as a springBootApplication element. For more information, see the springBootApplication element documentation.

If you didn’t build the Spring Boot application, run the package goal:

https://raw.githubusercontent.com/OpenLiberty/guides-common/prod/os-tabs.adoc

mvnw.cmd package

./mvnw package

Next, run the liberty:run goal. This goal creates the Open Liberty instance, installs required features, deploys the Spring Boot application to the Open Liberty instance, and starts the application.

https://raw.githubusercontent.com/OpenLiberty/guides-common/prod/os-tabs.adoc

mvnw.cmd liberty:run

./mvnw liberty:run

After you see the following message, your Liberty instance is ready:

The defaultServer server is ready to run a smarter planet.

Go to the http://localhost:9080/hello URL to access the application.

After you finish exploring the application, press CTRL+C to stop the Open Liberty instance. Alternatively, you can run the liberty:stop goal from the start directory in a separate command-line session:

https://raw.githubusercontent.com/OpenLiberty/guides-common/prod/os-tabs.adoc

mvnw.cmd liberty:stop

./mvnw liberty:stop

Packaging the application embedded with Open Liberty

You can update the pom.xml file to bind more Open Liberty Maven goals to the package phase. Binding these goals to the package phase allows the Maven package goal to build a Spring Boot application that is embedded with Open Liberty.

Update the Maven POM file in the start directory.
pom.xml

pom.xml

link:finish/pom.xml[role=include]

Add the include and packageName configuration elements, and the executions element to the pom.xml file.

The include configuration element specifies the minify, runnable values. The runnable value allows the application to be generated as a runnable JAR file. The minify value packages only what you need from your configuration files without bundling the entire Open Liberty install.

The packageName configuration element specifies that the application is generated as a GSSpringBootApp.jar file.

The executions element specifies the required Open Liberty Maven goals to generate the application that is embedded with Open Liberty.

Next, run the Maven package goal:

https://raw.githubusercontent.com/OpenLiberty/guides-common/prod/os-tabs.adoc

mvnw.cmd package

./mvnw package

Run the repackaged Spring Boot application. This JAR file was defined previously in the pom.xml file.

java -jar target/GSSpringBootApp.jar

After you see the following message, your Liberty instance is ready:

The defaultServer server is ready to run a smarter planet.

Go to the http://localhost:9080/hello URL to access the application.

When you need to stop the application, press CTRL+C.

Great work! You’re done!

You just ran a basic Spring Boot application with Open Liberty.

https://raw.githubusercontent.com/OpenLiberty/guides-common/prod/attribution.adoc