How To Build And Deploy Java Apps in Kubernetes Cluster?

Are you planning to deploy your Java application in a Kubernetes cluster? Whether you have an existing or new app, you need a deep understanding of the Kubernetes Cluster and the deployment options!

Kubernetes has become the de facto standard for container orchestration. It has a powerful platform for deploying and scaling containerized applications. Let’s explore the technical details of deploying a Java application in a Kubernetes cluster. We'll start with the deployment prerequisite and move to the technical steps individually!

Before we get started, you need to make sure that you have the following prerequisites in place:

1. A running Kubernetes cluster. You can set up a local cluster using tools like Minikube or a cloud-based Kubernetes service if you don't have one.
2. Docker, install it on your development machine.
3. Helm, install the Kubernetes package manager.
4. Java Development Kit (JDK) for building and compiling Java code.

You'll need a Java application to deploy. You can either use your code or create a new Java application. Here, we will use a simple Java App that prints “Hello, World!”.

As a thought leader, I actively engage in industry events and contribute to the development of cloud computing standards and best practices. My commitment to excellence has earned me recognition as an influential figure in the industry. Through my strategic vision and unwavering determination, I continue to drive Cloudtechstack towards new heights, positioning the company as a global leader in cloud computing solutions.

In case you have the Java source file, you can use the following commands in the local machine’s command prompt to create the JAR file:

javac NewJavaApp.java

jar cvfe NewJavaApp.jar NewJavaApp NewJavaApp.class

This command assumes that the entry point for your Java application is in the class NewJavaApp. If the main class is different, replace NewJavaApp with the correct name.

Before we begin the application deployment in Kubernetes, you must create a local copy of your remote Git repository. Here is the command you can use to clone your Git Repository:

git clone < Repository URL >

Once the clone repository is ready, open it either using the GitHub Desktop or The Editor you are using. Save the JAR and all the files in the local cloned Git Repository.

To deploy your Java application in a Kubernetes cluster, you must first containerize it using Docker. Docker allows you to package your application and its dependencies into a single container image. Here's a step-by-step guide on how to do this:

• Open your terminal or command prompt and navigate to your project directory:

cd <Repository Directory Name>

• Create a Dockerfile: In your project directory, create a Docker File. This file contains instructions on how to build your Docker image. You can use a text editor to create and edit the Dockerfile. Here's a sample Dockerfile content for a simple Java application:

  
                        # Use an official OpenJDK runtime as a parent image  
                        FROM openjdk:11-jre-slim  
                        # Set the working directory in the container  
                        WORKDIR /app  
                        # Copy your application JAR file into the container  
                        COPY NewJavaApp.jar /app/NewJavaApp.jar  
                        # Run the Java application when the container starts  
                        CMD ["java", "-jar", "NewJavaApp.jar"]  
                        

Here, we start with an official OpenJDK 11 runtime image as the base image. We set the working directory within the container to /app. We copy the Java application JAR file into the container. Finally, we specify the command to run your Java application when the container starts.

• Once you navigate to the directory containing your Dockerfile, execute the following command in the local command prompt:

docker build -t my-java-app .

This command builds a Docker image. “-t my-java-app” assigns a tag name to the image. Here, we are using "my-java-app.". The dot represents the build context, which is the current directory.

Here is the output you will see:

You can check if the Docker image was successfully created by running the below command:

docker images

This command will list all the Docker images on your system, and you should see your newly created image with the "my-java-app" tag. Now that you have a Docker image of your Java application, you're ready to move on to the next steps in deploying it in a Kubernetes cluster. Stay tuned for the next steps, where we'll explore creating Kubernetes manifests and deploying your application within the cluster.

You can use Helm to simplify deploying your Java application in Kubernetes. Helm provides a convenient way to package and deploy applications in Kubernetes. It uses charts, which are pre-configured templates for Kubernetes resources. It simplifies the deployment process by abstracting away much of the complexity.

But, before that, you must ensure that you have already set up your Kubernetes Cluster. We will use “minikube” as a local Kubernetes cluster for this project.

You check the Kubernetes configuration on your system using the following command:

kubectl config current-context

Now you are clear with what Kubernetes cluster you will be using, let’s move on to preparing the Helm chart for deployment. You can create a Helm chart for your Java application using PowerShell or any other Command Line Interface:

.\helm create java-app-chart

It will create the chart as you expected:

You must modify the chart's values in java-app-chart/values.yaml to suit your application's needs. In the chart templates, you can add a Kubernetes Deployment and Service for your Java application. You can also modify the values.yaml file to add the intended Docker Image and Docker Hub Repository details.

Next, use the following command to install the Helm chart in your Kubernetes cluster:

helm install your-app-release your-app-chart/

For this project, the output is as follows:

Summary of this step: We set up Helm, a Kubernetes package manager, and created a Helm chart for our Java application. The Helm chart contains pre-configured templates for Kubernetes resources to simplify application deployment. We adjusted chart values to specify the Docker image details. The installation command (helm install your-app-release your-app-chart/) deploys the Java application into the Kubernetes cluster, providing a convenient and standardized way to manage the application's lifecycle.

Once the Helm deployment is successful, you can access your Java application through the exposed Kubernetes Service. To find the service's IP address, you can use the following command and run it in PowerShell:

kubectl get svc

In the aftermath of Helm deployment, accessing the Java application involves querying the Kubernetes Service. Your Java application should be accessible at the service's external IP address. This IP is the gateway to interact with your deployed Java application. You can seamlessly communicate with the Kubernetes cluster and facilitate further monitoring and management tasks.

We've covered building and deploying a Java application in a Kubernetes cluster. You started by cloning a Git repository, containerized the Java application using Docker, and simplified the deployment with Helm. It is just the beginning of your journey with Kubernetes and Java. You can enhance your deployment with additional configurations and features based on your application requirements. Happy coding and deploying!

Comments