Creating Uber JAR with Payara Micro 5

But what if we want to configure an application instance HTTP port and/or cluster configuration at runtime instead? Fear not, we can still pass these properties as arguments when running the application’s JAR:

java -jar test-app.jar --port 10080 --noCluster

Also, we are not limited to bundling only one application in this Uber JAR, since we can package more applications by using the --deploy option multiple times:

And when you start the packaged applications in this JAR, the server will inform you how many applications were deployed:

With this you can create self-contained environments for your applications and deploy them easily! Since Payara Micro is small in size, packaging and moving the resulting JAR is cost-effective and saves time.

The Maven Way

Usually, when creating self-contained applications; one of the most common scenarios is to create an Uber JAR using Maven, generally through the use of the shade plugin. When using the Payara Micro Maven plugin, this task becomes very easy and you can specify all the command line options you need in the Maven configuration. The following example generates the Uber JAR file in the package phase of the Maven lifecycle:

With this plugin declaration, we configure the execution of the bundle goal which runs the Payara Micro Uber JAR creation. We can specify multiple Command Line options and configuration parameters like the contact root. All the configuration parameters are described in our document of the plugin.

Dockerizing our Uber JAR

What if developers want to create a Docker container based on a Payara Micro Uber JAR? Although there are multiple options for this scenario, the easiest one is to use a Java based Docker image to acquire the Uber JAR and execute it. For example, we can structure the following Dockerfile:

FROM azul/zulu-openjdk-alpine:8

ENV APP_LOCATION ./test-app.jar
ENV APP_NAME application.jar

ADD $APP_LOCATION $APP_NAME
RUN chmod +x $APP_NAME

EXPOSE 8080

ENTRYPOINT java -jar $APP_NAME

And build a new image:

docker build -t payara-uber-jar .

Notice that we are using the azul:zulu-openjdk-alpine:8 as a base image for our example. This is the Zulu Java 8 image based on the Alpine Linux Operating system, which is a very small sized distribution since we want this container to be as light as possible (this is the same base image we use for our official Payara Micro Docker image). We are using the Dockerfile ADD instruction to download our Uber JAR from an external source (in this case an uberjar in the same directory as th Dockerfile) and then simply setting our endpoint for this container to run our test application with the downloaded Uber JAR.

To start this container, we would simply execute the following command:

docker run -d -p 8080:8080 --name uber-jar payara-uber-jar

Note however that using an Uber JAR with Docker images is not efficient  and is a bad practice. With every change in your code, you need to build the Uber JAR and create a new Docker image where not only the application changes are picked up but a much larger JAR file including the unchanged Payara Micro code.

A better solution is just to start a Payara Micro Instance and point to the application that needs to be installed. More information can be found on our Payara Micro Docker Image documentation.

Conclusion

Payara Micro introduces a new set of possibilities for application developers, and with the advent of complex concepts such as Microservices and DevOps, the ability to create a self-contained JAR that can run the server and application at the same time is something many developers need.

Java developers should feel at ease, since with this approach Payara Server can be easily integrated with many continuous integration workflows.