Creating Uber JAR with Payara Micro

Jun 15, 2016 12:04:53 PM fish.payara.micro.PayaraMicro packageUberJar
INFO: Building Uber Jar... test-app.jar
Jun 15, 2016 12:05:09 PM fish.payara.micro.PayaraMicro packageUberJar
INFO: Built Uber Jar test-app.jar in 16036 (ms)

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 true

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 the Micro edition of Payara Server 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. How can developers leverage this feature of Payara Micro with a Maven setup? We can use the Maven support for Payara Micro and the exec plugin to generate the Uber JAR file in the package phase of the Maven lifecycle:

    <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.5.0</version>
                <dependencies>
                    <dependency>
                        <groupId>fish.payara.extras</groupId>
                        <artifactId>payara-micro</artifactId>
                        <version>4.1.1.162</version>
                    </dependency>
                </dependencies>
                <executions>
                    <execution>
                        <id>payara-uber-jar</id>
                        <phase>package</phase>
                        <goals>
                            <goal>java</goal>
                        </goals>
                        <configuration>
                            <mainClass>fish.payara.micro.PayaraMicro</mainClass>
                            <arguments>
                               <argument>--deploy</argument>
       <argument>${basedir}/target/${project.build.finalName}.war</argument>
                               <argument>--outputUberJar</argument>                                                  
                               <argument>${basedir}/target/${project.build.finalName}.jar</argument>
                            </arguments>
                            <includeProjectDependencies>false</includeProjectDependencies>
                            <includePluginDependencies>true</includePluginDependencies>
                            <executableDependency>
                                <groupId>fish.payara.extras</groupId>
                                <artifactId>payara-micro</artifactId>
                            </executableDependency>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

With this plugin declaration, we configure an execution for the java goal of the exec plugin to execute the fish.payara.micro.PayaraMicro class (this is the entry point for the Micro server) and pass the corresponding arguments of the WAR to deploy the resulting Uber JAR. Since the exec plugin has access to this class thanks to the Payara Micro Maven dependency, we don’t need to download the server and worry about setting the path of the server executable. With this, the configuration remains portable and easy to implement for continuous integration purposes.

Remember to add other options you want to pass to the Payara Micro server (HTTP port, cluster configuration, etc.) as arguments of the plugin configuration accordingly.

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 java:8-jdk-alpine
MAINTAINER fturizo

ENV APP_LOCATION https://s3-eu-west-1.amazonaws.com/fturizo-support-test/Artifacts/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 fturizo/payara-uber-jar:1.0 ~/uber-jar-docker/

Notice that we are using the java:8-jdk-alpine as a base image for our example. This is the official OpenJDK Image for Java 8 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 AWS S3 hosted file) 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 fturizo/payara-uber-jar:1.0

With this, it’s incredibly easy to set up a CI workflow:

• Generate the application JAR with Maven
• Upload the JAR to an artifact server (S3, Nexus, etc.)
• Build a new version of the Docker image
• Run the image!

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 urgently need.

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