Feedback Edit

Deploy a Java application with Open Liberty/WebSphere Liberty on an ARO cluster

  • Article
  • 16 minutes to read

This guide demonstrates how to run your Java, Java EE, Jakarta EE, or MicroProfile application on the Open Liberty/WebSphere Liberty runtime and then deploy the containerized application to an Azure Red Hat OpenShift (ARO) 4 cluster using the Open Liberty Operator. This article will walk you through preparing a Liberty application, building the application Docker image and running the containerized application on an ARO 4 cluster. For more information on Open Liberty, see the Open Liberty project page.For more information on WebSphere Liberty, see the WebSphere Liberty product page.

Important

While ARO is jointly engineered, operated, and supported by Red Hat and Microsoft to provide an integrated support experience, the software you run on top of ARO, including that described in this article, is subject to its own support and license terms. For details about support of ARO, see Support lifecycle for Azure Red Hat OpenShift 4. For details about support of the software described in this article, see the main pages for that software as listed in the article.

Prerequisites

Note

Azure Red Hat OpenShift requires a minimum of 40 cores to create and run an OpenShift cluster. The default Azure resource quota for a new Azure subscription does not meet this requirement. To request an increase in your resource limit, see Standard quota: Increase limits by VM series. Note that the free trial subscription isn't eligible for a quota increase, upgrade to a Pay-As-You-Go subscription before requesting a quota increase.

Complete the following prerequisites to successfully walk through this guide.

  1. Prepare a local machine with Unix-like operating system installed (for example, Ubuntu, macOS).

  2. Install a Java SE implementation (for example, AdoptOpenJDK OpenJDK 8 LTS/OpenJ9).

  3. Install Maven 3.5.0 or higher.

  4. Install Docker for your OS.

  5. Install Azure CLI 2.0.75 or later.

  6. Check and install envsubst if it's not pre-installed in your operating system.

  7. Clone the code for this sample on your local system. The sample is on GitHub.

  8. Follow the instructions in Create an Azure Red Hat OpenShift 4 cluster.

    Though the "Get a Red Hat pull secret" step is labeled as optional, it is required for this article. The pull secret enables your Azure Red Hat OpenShift cluster to find the Open Liberty Operator.

    If you plan to run memory-intensive applications on the cluster, specify the proper virtual machine size for the worker nodes using the --worker-vm-size parameter. For example, Standard_E4s_v3 is the minimum virtual machine size to install the Elasticsearch Operator on a cluster. For more information, see:

  9. Connect to the cluster by following the steps in Connect to an Azure Red Hat OpenShift 4 cluster.

    • Be sure to follow the steps in "Install the OpenShift CLI" because we'll use the oc command later in this article.
    • Write down the cluster console URL. It will look like https://console-openshift-console.apps.<random>.<region>.aroapp.io/.
    • Take note of the kubeadmin credentials.
    • Be sure to follow the steps in "Connect using the OpenShift CLI" with the kubeadmin credentials.

Install the Open Liberty OpenShift Operator

After creating and connecting to the cluster, install the Open Liberty Operator. The main starting page for the Open Liberty Operator is on GitHub.

  1. Sign in to the OpenShift web console from your browser using the kubeadmin credentials.

  2. Navigate to Operators > OperatorHub and search for Open Liberty.

  3. Select Open Liberty from the search results.

  4. Select Install.

  5. In the page Install Operator, check beta2 for Update channel, All namespaces on the cluster (default) for Installation mode, and Automatic for Update approval:

    Screenshot of creating operator subscription for Open Liberty Operator.

  6. Select Install and wait a minute or two until the installation completes.

  7. Observe the Open Liberty Operator is successfully installed and ready for use. If you don't, diagnose and resolve the problem before continuing.

    Installed Operators showing Open Liberty is installed.

Create an OpenShift namespace for the Java app

Follow the instructions below to create an OpenShift namespace for use with your app.

  1. Make sure you have signed in to the OpenShift web console from your browser using the kubeadmin credentials.

  2. Navigate to Administration > Namespaces > Create Namespace.

  3. Fill in open-liberty-demo for Name and select Create, as shown next.

    Screenshot of creating namespace.

Create an Azure Database for MySQL

Follow the instructions below to set up an Azure Database for MySQL for use with your app. If your application doesn't require a database, you can skip this section.

  1. Create a single database in Azure SQL Database by following the steps in: Quickstart: Create an Azure Database for MySQL server by using the Azure portal. Return to this document after creating the database.

    Note

    • At the Basics step, write down the Server name.mysql.database.azure.com, Server admin login and Password.

  2. Once your database is created, open your SQL server > Connection security and complete the following settings:

    1. Set Allow access to Azure services to Yes.
    2. Select Add current client IP address.
    3. Set Minimal TLS Version to >1.0 and select Save.

    Screenshot of configuring mysql database connection security rule.

  3. Open your SQL database > Connection strings > Select JDBC. Write down the Port number following sql server address. For example, 3306 is the port number in the example below.

    String url ="jdbc:mysql://<Server name>.mysql.database.azure.com:3306/{your_database}?useSSL=true&requireSSL=false"; myDbConn = DriverManager.getConnection(url, "<Server admin login>", {your_password});

  4. If you didn't create a database in above steps, follow the steps in Quickstart: Create an Azure Database for MySQL server by using the Azure portal#connect-to-the-server-by-using-mysqlexe to create one. Return to this document after creating the database.

    Note

    • Write down the Database name you created.

Prepare the Liberty application

We'll use a Java EE 8 application as our example in this guide. Open Liberty is a Java EE 8 full profile compatible server, so it can easily run the application. Open Liberty is also Jakarta EE 8 full profile compatible.

Run the application on Open Liberty

To run the application on Open Liberty, you need to create an Open Liberty server configuration file so that the Liberty Maven plugin can package the application for deployment. The Liberty Maven plugin is not required to deploy the application to OpenShift. However, we'll use it in this example with Open Liberty’s developer (dev) mode. Developer mode lets you easily run the application locally. Complete the following steps on your local computer.

Follow the steps in this section to prepare the sample application for later use in this article. These steps use Maven and the liberty-maven-plugin. To learn more about the liberty-maven-plugin, see Building a web application with Maven.

Check out the application

Clone the sample code for this guide. The sample is on GitHub. There are three samples in the repository. We will use open-liberty-on-aro/3-integration/connect-db/mysql. Here is the file structure of the application.

open-liberty-on-aro/3-integration/connect-db/mysql
├─ src/main/
│  ├─ aro/
│  │  ├─ db-secret.yaml
│  │  ├─ openlibertyapplication.yaml
│  ├─ docker/
│  │  ├─ Dockerfile
│  │  ├─ Dockerfile-local
│  │  ├─ Dockerfile-wlp
│  │  ├─ Dockerfile-wlp-local
│  ├─ liberty/config/
│  │  ├─ server.xml
│  ├─ java/
│  ├─ resources/
│  ├─ webapp/
├─ pom.xml

The directories java, resources, and webapp contain the source code of the sample application. The code declares and uses a data source named jdbc/JavaEECafeDB.

In the aro directory, we placed two deployment files. db-secret.xml is used to create Secrets with DB connection credentials. The file openlibertyapplication.yaml is used to deploy the application image.

In the docker directory, we placed four Dockerfiles. Dockerfile-local is used for local debugging, and Dockerfile is used to build the image for an ARO deployment. These two files work with Open Liberty. Dockerfile-wlp-local and Dockerfile-wlp are also used for local debugging and to build the image for an ARO deployment respectively, but instead work with WebSphere Liberty.

In the liberty/config directory, the server.xml is used to configure the DB connection for the Open Liberty and WebSphere Liberty cluster.

Build project

Now that you have gathered the necessary properties, you can build the application. The POM file for the project reads many properties from the environment.

cd <path-to-your-repo>/open-liberty-on-aro/3-integration/connect-db/mysql

# The following variables will be used for deployment file generation
export DB_SERVER_NAME=<Server name>.mysql.database.azure.com
export DB_PORT_NUMBER=3306
export DB_NAME=<Database name>
export DB_USER=<Server admin username>@<Server name>
export DB_PASSWORD=<Server admin password>
export NAMESPACE=open-liberty-demo

mvn clean install

Test your application locally

Use the liberty:devc command to run and test the project locally before dealing with any Azure complexity. For more information on liberty:devc, see the Liberty Plugin documentation. In the sample application, we've prepared Dockerfile-local and Dockerfile-wlp-local for use with liberty:devc.

  1. Start your local docker environment if you haven't done so already. The instructions for doing this vary depending on the host operating system.

  2. Start the application in liberty:devc mode

    cd <path-to-your-repo>/open-liberty-on-aro/3-integration/connect-db/mysql

# If you are running with Open Liberty
mvn liberty:devc -Ddb.server.name=${DB_SERVER_NAME} -Ddb.port.number=${DB_PORT_NUMBER} -Ddb.name=${DB_NAME} -Ddb.user=${DB_USER} -Ddb.password=${DB_PASSWORD} -Ddockerfile=target/Dockerfile-local

# If you are running with WebSphere Liberty
mvn liberty:devc -Ddb.server.name=${DB_SERVER_NAME} -Ddb.port.number=${DB_PORT_NUMBER} -Ddb.name=${DB_NAME} -Ddb.user=${DB_USER} -Ddb.password=${DB_PASSWORD} -Ddockerfile=target/Dockerfile-wlp-local

  3. Verify the application works as expected. You should see a message similar to [INFO] [AUDIT] CWWKZ0003I: The application javaee-cafe updated in 1.930 seconds. in the command output if successful. Go to http://localhost:9080/ in your browser and verify the application is accessible and all functions are working.

  4. Press Ctrl+C to stop liberty:devc mode.

Prepare the application image

To deploy and run your Liberty application on an ARO 4 cluster, containerize your application as a Docker image using Open Liberty container images or WebSphere Liberty container images.

Complete the following steps to build the application image:

Build the application and push to the image stream

Since you have already successfully run the app in the Liberty Docker container, you're going to build the image remotely on the cluster by executing the following commands.

  1. Make sure you have already signed in to the OpenShift CLI using the kubeadmin credentials.

  2. Identify the source directory and Dockerfile.

    cd <path-to-your-repo>/open-liberty-on-aro/3-integration/connect-db/mysql

# Fetch maven artifactId as image name, maven build version as image version
IMAGE_NAME=$(mvn -q -Dexec.executable=echo -Dexec.args='${project.artifactId}' --non-recursive exec:exec)
IMAGE_VERSION=$(mvn -q -Dexec.executable=echo -Dexec.args='${project.version}' --non-recursive exec:exec)
cd <path-to-your-repo>/open-liberty-on-aro/3-integration/connect-db/mysql/target

# If you are building with Open Liberty base image, the existing Dockerfile is ready for you

# If you are building with WebSphere Liberty base image, uncomment and execute the following two commands to rename Dockerfile-wlp to Dockerfile
# mv Dockerfile Dockerfile.backup
# mv Dockerfile-wlp Dockerfile

  3. Create an image stream.

    oc create imagestream ${IMAGE_NAME}

  4. Create a build configuration which specifies the image stream tag of the build output.

    oc new-build --name ${IMAGE_NAME}-config --binary --strategy docker --to ${IMAGE_NAME}:${IMAGE_VERSION}

  5. Start the build to upload local contents, containerize, and output to the image stream tag specified before.

    oc start-build ${IMAGE_NAME}-config --from-dir . --follow

Deploy application on the ARO 4 cluster

Now you can deploy the sample Liberty application to the Azure Red Hat OpenShift 4 cluster you created earlier when working through the prerequisites.

Deploy the application from the web console

Because we use the Open Liberty Operator to manage Liberty applications, we need to create an instance of its Custom Resource Definition, of type "OpenLibertyApplication". The Operator will then take care of all aspects of managing the OpenShift resources required for deployment.

  1. Sign in to the OpenShift web console from your browser using the kubeadmin credentials.
  2. Expand Home, Select Projects > open-liberty-demo.
  3. Navigate to Operators > Installed Operators.
  4. In the middle of the page, select Open Liberty Operator.
  5. In the middle of the page, select Open Liberty Application. The navigation of items in the user interface mirrors the actual containment hierarchy of technologies in use. Diagram of ARO Java Containment.
  6. Select Create OpenLibertyApplication
  7. Replace the generated yaml with yours, which is located at <path-to-repo>/3-integration/connect-db/mysql/target/openlibertyapplication.yaml.
  8. Select Create. You'll be returned to the list of OpenLibertyApplications.
  9. Navigate to Workloads > Secrets.
  10. Select Create > From YAML.
  11. Replace the generated yaml with yours, which is located at <path-to-repo>/3-integration/connect-db/mysql/target/db-secret.yaml.
  12. Select Create. You'll be returned to the Secret details page.
  13. Select Add Secret to workload, then select javaee-cafe-mysql from the dropdown box, then select Save.
  14. Navigate to Operators > Installed Operators > Open Liberty Operator > Open Liberty Application.
  15. Select javaee-cafe-mysql.
  16. In the middle of the page, select Resources.
  17. In the table, select the link for javaee-cafe-mysql with the Kind of Route.
  18. On the page that opens, select the link below Location.

You'll see the application home page opened in the browser.

Clean up resources

Delete the ARO cluster by following the steps in Tutorial: Delete an Azure Red Hat OpenShift 4 cluster

Next steps

In this guide, you learned how to:

  • Prepare the Liberty application
  • Build the application image
  • Run the containerized application on an ARO 4 cluster using the GUI and the CLI

You can learn more from references used in this guide: