DEV Community: zhengchang907

CICD experience: Source-2-image and deploy to Oracle WebLogic Server on AKS

zhengchang907 — Wed, 08 Dec 2021 01:47:50 +0000

My Workflow

Azure-Samples/cargotracker-azure#updateCargoTracker.yml

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code

Azure-Samples / cargotracker-azure

Azure-specific downstream for Cargo Tracker Jakarta EE sample app. The project demonstrates how you can develop applications with Jakarta EE using widely adopted architectural best practices like Domain-Driven Design (DDD).

Eclipse Cargo Tracker - Applied Domain-Driven Design Blueprints for Jakarta EE

The project demonstrates how you can develop applications with Jakarta EE using widely adopted architectural best practices like Domain-Driven Design (DDD). The project is directly based on the well known original Java DDD sample application developed by DDD pioneer Eric Evans' company Domain Language and the Swedish software consulting company Citerus. The cargo example actually comes from Eric Evans' seminal book on DDD. The original application is written in Spring Hibernate and Jetty whereas the application is built on Jakarta EE.

The application is an end-to-end system for keeping track of shipping cargo. It has several interfaces described in the following sections.

For further details on the project, please visit: https://eclipse-ee4j.github.io/cargotracker/.

A slide deck introducing the fundamentals of the project is available on the official Eclipse Foundation Jakarta EE SlideShare account.

Getting Started

The project website has…

View on GitHub

Additional Resources / Info

Story behind it

Real world Java EE on Azure requires industrial strength CI/CD. My team and I started building an example illustrating the path of modernizing a traditional Java EE application(WebLogic + PostgreSQL).

We implemented a GitHub Actions workflow that compiles the Eclipse Cargo Tracker application source, builds the Docker image with help from the WebLogic Kubernetes Operator and uploads it an Azure Container Registry. This image is then deployed to a WebLogic on Azure Kubernetes Service (AKS) environment as part of the CI/CD experience.

This workflow serves as an end-to-end test for an Azure Marketplace offer that lets you easily deploy WebLogic Server to Azure Kubernetes Service. To learn more about this and other offers for Java EE on Azure, please visit < https://aka.ms/wls-aks-contactme >.

What’s interesting in our workflow

We leveraged many existing GitHub Actions such as actions/checkout, azure/CLI and azure/login to build our pipeline. The built-in support for bash scripts provides all the flexibilities we needed to complete it.

Our pipeline contains the following critical steps:

Build the application.
Upload the built artifact to an Azure Storage Account.
Build image and upload to Azure Container Registry.
Use the ARM template behind the Azure Marketplace offer to update the cluster with the latest image.
Verify all pods are updated.
Verify the application is running at the latest version using Playwright.

This pipeline takes many inputs because it requires all the Azure resources are created & configured before running it. We also have another pipeline Azure-Samples/cargotracker-azure#setupWlsAks.yml to setup the required environment, these two pipelines combine together to provide a more complete DevOps experience.

A brief introduction to our work

Oracle WebLogic Server is a scalable, enterprise-ready Java application server. We are a team from Microsoft that works on bringing the Oracle WebLogic Server experience on Azure which includes:

WebLogic Server on AKS: The WebLogic Server on AKS offer automates provisioning an AKS cluster, the WebLogic Kubernetes Operator, WLS Docker images and the Azure Container Registry (ACR). The offer also supports configuring load balancing with Azure App Gateway or the Azure Load Balancer, easing database connectivity, publishing metrics to Azure Monitor as well as mounting Azure Files as Kubernetes Persistent Volumes. For more on this offer, please visit < https://aka.ms/wlsaks >.
WebLogic Server on Virtual Machines: The WebLogic Server on virtual machines offers automate provisioning virtual network, storage, and Linux resources, installing WLS, setting up security with a network security group, easing database connectivity, configuring load-balancing with App Gateway or Oracle HTTP Server, connecting to Azure Active Directory, enabling centralized logging via ELK as well as integrating distributed caching with Oracle Coherence. For more on this offer, please visit < https://aka.ms/wlscluster >.

If you want to learn more about our offers or work closely on your migration scenarios with us, just go to this CONTACT ME page and hit the button! Program managers, architects and engineers will reach back out to you shortly and initiate collaboration!

Reference

GitHub Actions makes it easy to develop a lightweight but powerful CI/CD experience for your code from GitHub.

GitHub Actions for Azure are developed by Microsoft and designed to be used with Azure.

Eclipse Cargo Tracker is a project demonstrates how you can develop applications with Jakarta EE using widely adopted architectural best practices like Domain-Driven Design (DDD).

Playwright is built to enable cross-browser web automation. And it can be easily introduced into a Java project using Maven.

Using Playwright in GitHub Actions

zhengchang907 — Thu, 18 Nov 2021 03:29:15 +0000

Story

A few months ago, we started working on a project which demos a path of modernizing traditional Java application(WebLogic + PostgreSQL). And we implemented a pipeline that builds and deploys the Eclipse Cargo Tracker application to a WebLogic on Azure Kubernetes Service (AKS) environment as part of the CI/CD experience.

For the sake of completeness, in the pipeline, a final step of validating the deployed application is the latest version is necessary.

Our approach

After researching around, we decided to add an invisible stamp in the index page of the Cargo Tracker. Every time we build the app, this stamp will be updated with an unique value. And then at the end of the pipeline, we add a validation step to run a Java Playwright application, which fetches the version string from the deployed Cargo Tracker app, and compares it with the valued we pre-stored in earlier steps(Where new version string is generated and the app is not deployed).

The steps are as follow:

Create the Playwright application

package com.microsoft.azure.javaee;

import com.microsoft.playwright.*;

public class FetchBuildVersion {
  public static void main(String[] args) {
    try (Playwright playwright = Playwright.create()) {
      BrowserType webkit = playwright.webkit();
      Browser browser = webkit.launch(new BrowserType.LaunchOptions().setHeadless(true));
      Page page = browser.newPage();
      // take first parameter as Cargo Tracker url
      page.navigate(args[0]);

      ElementHandle p = page.querySelector("xpath=/html/body/div[1]/div/div[2]/p");

      // take second parameter as pre-stored version string
      if (!p.innerText().equals(args[1])) {
        throw new RuntimeException("Build Version is not updated!");
      }
    }
  }
}

Add property to Cargo Track called version string, which is a combined string of Maven project version and Maven project build time. And every time the app is built, a new string will be generated.

# src/main/resources/org/eclipse/cargotracker/messages.properties
versionString=${project.version} ${project.build.time}

Embed the version string into the index page

<!-- src/main/webapp/index.xhtml -->
<div class="container text-muted">
    <p><h:outputText value="#{messages.versionString}" /></p>
</div>

In the GitHub workflow, add step to query build version and store it as an environment variable.

- name: Build the app
  run: |
    echo "build the Cargo Tracker web app"
    mvn clean install -PweblogicOnAks --file cargotracker/pom.xml
- name: Query version string for deployment verification
  run: |
    PROPERTY_FILE="cargotracker/target/cargo-tracker/WEB-INF/classes/org/eclipse/cargotracker/messages.properties"
    PROP_KEY=versionString
    deployVersion=$(cat $PROPERTY_FILE | grep "$PROP_KEY" | cut -d '=' -f 2)
    echo "deployVersion=${deployVersion}" >> $GITHUB_ENV

Add the step to call the Playwright application

- name: Verify that the app is update
  run: |
    # install dependencies
    sudo apt-get install libegl1\
                      libopus0\
                      libwoff1\
                      libharfbuzz-icu0\
                      libgstreamer-plugins-base1.0-0\
                      libgstreamer-gl1.0-0\
                      libgstreamer-plugins-bad1.0-0\
                      libopenjp2-7\
                      libwebpdemux2\
                      libenchant1c2a\
                      libhyphen0\
                      libgles2\
                      gstreamer1.0-libav -y
    appURL=http://${{ env.appGatewayURL }}/cargo-tracker/
    cd cargotracker/src/test/aks/playwright-ui-test
    mvn clean install
    mvn exec:java -e -Dexec.mainClass=com.microsoft.azure.javaee.FetchBuildVersion -Dexec.args="'${appURL}' '${{ env.deployVersion }}'"

A brief introduction to our work

Oracle WebLogic Server is a scalable, enterprise-ready Java application server. We are a team from Microsoft works on bringing the Oracle WebLogic Server experience on Azure which includes:

WebLogic Server on AKS: The WebLogic Server on AKS offer automates provisioning an AKS cluster, the WebLogic Kubernetes Operator, WLS Docker images and the Azure Container Registry (ACR). The offer also supports configuring load balancing with Azure App Gateway or the Azure Load Balancer, easing database connectivity, publishing metrics to Azure Monitor as well as mounting Azure Files as Kubernetes Persistent Volumes.
WebLogic Server on Virtual Machines: The WebLogic Server on virtual machines offers automate provisioning virtual network, storage, and Linux resources, installing WLS, setting up security with a network security group, easing database connectivity, configuring load-balancing with App Gateway or Oracle HTTP Server, connecting to Azure Active Directory, enabling centralized logging via ELK as well as integrating distributed caching with Oracle Coherence.

Reference

Playwright is built to enable cross-browser web automation. And it can be easily introduced into a Java project using Maven.

GitHub Actions makes it easy to develop a lightweight but powerful CI/CD experience for your code from GitHub.

Eclipse Cargo Tracker is a project demonstrates how you can develop applications with Jakarta EE using widely adopted architectural best practices like Domain-Driven Design (DDD). This is the repo contains the pipeline described above