Introduction to Eclipse JKube: Java tooling for Kubernetes and Red Hat OpenShift

Introduction to Eclipse JKube: Java tooling for Kubernetes and Red Hat OpenShift

We as Java developers are often busy working on our applications by optimizing application memory, speed, etc. In recent years, encapsulating our applications into lightweight, independent units called containers has become quite a trend, and almost every enterprise is trying to shift its infrastructure onto container technologies like Docker and Kubernetes.

Kubernetes is an open source system for automating deployment, scaling, and management of containerized applications, but it has a steep learning curve, and an application developer with no background in DevOps can find this system a bit overwhelming. In this article, I will talk about tools that can help when deploying your Maven applications to Kubernetes/Red Hat OpenShift.

Everything you need to grow your career.

With your free Red Hat Developer program membership, unlock our library of cheat sheets and ebooks on next-generation application development.


Background: Eclipse JKube

This project was not built from scratch. It’s just a refactored and rebranded version of the Fabric8 Maven plugin, which was a Maven plugin used in the Fabric8 ecosystem. Although the Fabric8 project was liked and appreciated by many people in the open source community, due to unfortunate reasons it could not become successful, and the idea of Fabric8 as an integrated development platform on top of Kubernetes died. Although the main project is archived, there are still active repositories used by the community, such as the Fabric8 Docker Maven plugin, the Fabric8 Kubernetes client, and of course the Fabric8 Maven plugin.

As maintainers of the Fabric8 Maven plugin, we started decoupling the Fabric8 ecosystem related pieces from the plugin to make a general-purpose Kubernetes/OpenShift plugin. We also felt there was a need for rebranding because most people were confused about whether this plugin had something to do with Fabric8. Hence, we decided to rebrand it, and fortunately, someone from the Eclipse foundation approached us to take in our project. Now, the project is being renamed to Eclipse JKube and can be found in the Eclipse Foundation repos on GitHub.

Eclipse JKube can be seen as a reincarnation of the Fabric8 Maven plugin. It contains the good parts of this plugin and offers a clean and smooth workflow with the tooling it provides. We refactored this plugin into three components:

  • The JKube Kit
  • The Kubernetes Maven plugin
  • The OpenShift Maven plugin

The JKube Kit contains the core logic for building Docker images, generating Kubernetes/OpenShift manifests, and applying them onto Kubernetes/OpenShift clusters. Plugins consume this library for their operations. In the future, we also plan to add support for Gradle plugins.


Now, let’s have a look at Eclipse JKube in action. For the demo, I will deploy a simple Spring Boot project onto Kubernetes using the Eclipse Kubernetes Maven plugin. Let’s walk through this process:

  1. Add the Kubernetes Maven plugin as a dependency in your pom.xml file, as shown in Figure 1:

Figure 1: The Kubernetes Maven plugin added as a dependency in pom.xml.

  1. Build your Docker images. The Eclipse JKube Kubernetes Maven plugin offers a zero-config mode, in which it builds your Docker image with opinionated defaults. However, you can customize it by providing an image configuration in the plugin configuration. In order to build a Docker image, you just need to run the following (the results are shown in Figure 2):
mvn k8s:build
Building Docker Image

 Figure 2: Building Docker Image.

  1. Generate your Kubernetes resource manifests. Eclipse JKube plugins have a powerful and configurable resource generation mechanism in which they can generate Kubernetes resources in zero-config mode. This feature can also be configured using XML configuration or by placing customized resource fragments in the src/main/jkube directory. The results are merged with the finally generated resource fragments. In order to generate resources, run the following (the results are shown in Figure 3):
mvn k8s:resource

Figure 3: Generating Kubernetes Manifests.

  1. Apply generated Kubernetes resources onto the Kubernetes cluster. In order to apply resources onto this cluster, you just need to run one of the following (the results are shown in Figure 4):
mvn k8s:apply


mvn k8s:deploy

Figure 4: Applying generated Kubernetes/Openshift manifests onto Kubernetes Cluster

  1. Undeploy your Maven application from Kubernetes. We have a cleanup goal, too, which just deletes all resources created during the deploy phase. To use this feature, run the following (the results are shown in Figure 5):
mvn k8s:undeploy

Figure 5: Undeploying your Maven application from Kubernetes

  1. Debug your Java application inside Kubernetes. Apart from these goals, we also have a goal for remote debugging. Suppose that you see a bug inside your application that’s running inside Kubernetes and you want to debug its behavior. You can simply run our debug goal, which does port forwarding for debugging:
mvn k8s:debug
  1. Configure your IDE in order to connect to this open port for debugging, as shown in Figure 6:

Figure 6: Configuring your IDE to debug application inside Kubernetes.

  1. Set a breakpoint in the application code and hit the application endpoint. We can see the breakpoint being hit in IDE as shown in Figure 7:

Figure 7: Configuring your IDE to debug an application running inside Kubernetes.

With this result, I wrap up this article. We do have more in our pipeline, so stay tuned for new updates. If you want to get involved, please reach out to us via our mailing list at, or our Gitter channel at