Deploy Jakarta EE application to Kubernetes

Posted by Hayri Cicek on October 14, 2019


In this tutorial, I will show you how to deploy Jakarta EE application to Kubernetes.
Kubernetes doesn't run containers directly, instead it uses something called pod, which is a group of containers deployed together on the same host.
To follow this tutorial, you will need Docker, Kubernetes, Maven and of course Java installed on your machine.
I will use my custom maven archetype to generate the Jakarta EE application.

Generate the application.


$> mvn archetype:generate -DarchetypeGroupId=com.kodnito \
-DarchetypeArtifactId=kodnito-jakartaee-archetype \
-DarchetypeVersion=1.0.5 -DgroupId=com.kodnito \
-DartifactId=hello-jakartaee -Dversion=1.0-SNAPSHOT


This command will generate a Jakarta EE application called hello-jakartaee.
Open the project in your IDE or editor of your choice.
The first file we will look at is the Dockerfile, you find the file in the root of the project.
This will create a Docker image based on the Payara Micro and will add the war file into a directory inside the Docker image.


FROM payara/micro
COPY target/hello-jakartaee.war $DEPLOY_DIR


Next file is the deployment.yml file, which is the Kubernetes deployment definition.

kind: Service
apiVersion: v1
metadata:
  name: hello-jakartaee
  labels:
    app: hello-jakartaee
spec:
  type: NodePort
  selector:
    app: hello-jakartaee
  ports:
  - port: 8080
    targetPort: 8080
    name: http
---
kind: Deployment
apiVersion: apps/v1
metadata:
  name: hello-jakartaee
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-jakartaee
  template:
    metadata:
      labels:
        app: hello-jakartaee
        version: v1
    spec:
      containers:
        - name: hello-jakartaee
          image: hello-jakartaee
          imagePullPolicy: Always
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 45
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 45
      restartPolicy: Always


Service is a REST object and here we create a service called hello-jakartaee and targets port 8080 on any pod labeled app:hello-jakarta-ee.
type: NodePort means that any traffic sent to this port is forwarded to the service.
replicas: 2 specifies several pods replicas are running and here we specified two.
image: hello-jakartaee specifies the name of the image we are trying to pull from the Docker images.
Make sure to update this to look like this, because we are deploying locally.

image: localhost:5000/hello-jakartaee


imagePullPolicy: Always will force pull the image.
readinessProbe will check if the container is ready to use.
livenessProbe will check if the container has started an is alive.

When we are deploying locally, we will create our own Docker registry where we will deploy our images, before that you should run the following command to build the war file.


$> mvn clean package


We create our Docker registry with the following command.

$> docker run -d -p 5000:5000 --restart=always --name registry registry:2

The following command will build the image from the Dockerfile.

$> docker build -t hello-jakartaee .

Next command is used to tag the image so it points to our registry.

$> docker tag hello-jakartaee localhost:5000/hello-jakartaee

Now we can push the image.

$> docker push localhost:5000/hello-jakartaee

Now that we have Docker registry setup, we can move on to Kubernetes.
With this command, we will create the deployment.

$> kubectl apply -f deployment.yml

Now run the following command to see if the deployment was created.

$> kubectl get deployments

NAME              READY   UP-TO-DATE   AVAILABLE   AGE
hello-jakartaee   2/2     2            2           3m11s

The following command will list all the services.

$> kubectl get services

NAME              TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)          AGE
hello-jakartaee   NodePort    10.105.7.16           8080:30811/TCP   4m3s
kubernetes        ClusterIP   10.96.0.1             443/TCP          2d1h

When you run this command, you will see which port the app is running on Kubernetes.
Now is our Jakarta EE application deployed to Kubernetes.
Open your browser and point it to http://localhost:30811/hello-jakartaee/api/hello

You can find the source code on GitHub.


Share this: