OpenShift: Bringing to life a SpringBoot binary

This article promises on bringing a SpringBoot binary file to life and make from it a fully running application on OpenShift.

Our today’s Use-Case: Deploy to Openshift a resultant artifact of an already built packaged springboot application. This is useful for software built on a platform different from the one where the application is going to run.

Prerequisites for our Experiments

First, we need a running OpenShift cluster on which we can do our experiments. I invite you then to run the next steps using either a free account on or download & run an OpenShift cluster locally using minishift.

Our Project

OpenShift provides natively with different options for building and deploying containers, which includes building/deploying applications either from source code or from binaries.

Platforms like Java allows developers to package all the dependencies, resources and configuration files in a single archive file, which we call JAR binary files.

Our project is based on an OpenSource SpringBoot project. The JAR file can be downloaded from hereHelloWorld-2.0.jar”. I renamed the file to “springboot.jar” and placed it in a deployments folder.

Build Process

For our use-case, we need a builder image that contains tools like Maven to build our artifacts provided as a jar file.

In OpenShift, an OpenJDK Image stream is already provided in the “openshift” namespace.

Let’s check what images are available for us:

oc get is -n openshift | grep -i openjdk

Create a new Project

Let’s start by creating an OpenShift project.

oc new-project springproject --display-name "Spring Project"

Create a new Build

We’re going to use a builder image, so we’ll use the “redhat-openjdk18-openshift”. The following creates a build, and accept a binary content as a source.

Here we are naming the application as myspringboot.

oc new-build --name=myspringboot --strategy=source --binary \

Executing the Build

Once the BuildConfig is created in OpenShift, we can then take care of the creation of a final docker container image. This image is based on OpenJDK as a Base-Image and our artifact file, which is mainly a binary JDK file.

oc start-build myspringboot --from-file=myspringboot.jar --follow

The command starts by uploading/copying the binary file into the appropriate location within the destination container.

You can check the builds history by launching this command:

oc get builds

Create the Application

Now we already have the image built, including the application artifcats. One easy step is remaining to make the application deployed and up & running.

Let’s launch the creation of our spring boot application:

oc new-app myspringboot

As a result, this command dynamically generates a DeploymentConfig, make the application run as pods and expose it using a Service. However, there is no route for this application yet. So you cannot access this application from outside.

Expose your application

Let’s create an OpenShift route to make the “myspringboot” service exposed to the internet.

oc expose svc/myspringboot

We can check the exposed routes:

oc get route myspringboot

Let’s curl our application:

curl $(oc get route myspringboot \
-o jsonpath=’{.status.ingress[0].host}’)

What’s next?

We’ve succeeded in building, and deploying a basic JAR file. Now there’s an opportunity to improve these experiments and I have some suggestions for you:

  • Set up a Github webhooks to react to source code changes,
  • Make the exposed route secure,
  • Make it repeatable and configurable: abstract all the complexities in one template and then instantiate the template by providing the location of the artifacts.

This how you can export / create a template file from an existing OpenShift resources:

oc get bc myspringboot -o yaml > myspringboot-bc.yaml

Please do not hesitate to tweet me with your valuables comments/questions.

Is a DevOps & Cloud enthusiast with 10 plus years of experience. He’s continuously immersing himself in the latest technologies trends & projects.