Introducing Technical Reports

RHAMT 4.1.0 Is Released!

The 4.1.0 version of the Red Hat Application Migration Toolkit has recently been released, and with it is a new report that I’d like to highlight.

If you’re not familiar with RHAMT, check out my previous article introducing the product.

Technology Reports

One of the RHAMT features mentioned at this year’s summit were the Technology Reports.

This report provides an aggregate listing of the technologies used, grouped by function, for the analyzed applications. It shows how the technologies are distributed, and hundreds of applications can be simultaneously compared after analysis has been performed. In addition, the size, number of libraries, and story point totals of each application are displayed, allowing you to quickly determine each application’s type from a single report.

Examining application_13 in the above list, we can see that this is likely a secured frontend application with a cache for performance. It contains several libraries, most of which pertain to security in some form.

Each application can be further examined to identify the technologies in use. For instance, drilling down into application_13 shows:

Here we can see that the precise libraries in use within each category. As previously noted, this application uses a large number of security libraries, and we can precisely identify the technologies in use.

Regardless of how you use the technology reports, I’m certain it will be useful in your migration and modernization efforts.

An Introduction to Red Hat Application Migration Toolkit

Application migration and modernization can be a daunting task. Not only do you have to update legacy applications with newer libraries and APIs, but often must also address new frameworks, infrastructures, and architectures all while simultaneously keeping resources dedicated to new features and versions.

Red Hat Application Migration Toolkit (RHAMT), formerly known as Windup, provides a set of utilities for easing this process. Applications can be analyzed through a command-line interface (CLI), a web-based interface, or directly inside Eclipse, allowing immediate modification of the source code.

These utilities allow you to quickly gain insights into thousands of your applications simultaneously. They identify migration challenges, code or dependencies shared between applications, and accelerate making the necessary code changes to have your applications run in the latest middleware platforms.

Choosing the Right Distribution

You’ve read the introduction, possibly seen a video, and are eager to run your first application through the process. Where do you begin?

RHAMT provides a number of different distributions to meet your needs, and all include detailed reports that highlight migration issues with effort estimation. Each of these is summarized below.

CLI

CLI DownloadProduct Documentation

The CLI is a command-line tool that provides access to the reports without the overhead of the other tools. It includes a wide array of customization options, and allows you to finely tune the RHAMT analysis options or integrate with external automation tools.

Web Console

Web Console DownloadProduct Documentation

The web console is a web-based system that allows a team of users to assess and prioritize migration and modernization efforts. In addition, applications can be grouped into projects for analysis.

Eclipse Plug-in

Eclipse Plug-in DownloadProduct Documentation

The Eclipse plug-in provides assistance directly in Eclipse and Red Hat JBoss Developer Studio (JBDS) and allows developers to see migration issues directly in the source code. The Eclipse plug-in also provides guidance on resolving issues and offers automatic code replacement where possible.

Start by Choosing a Distribution

  • If you’re working on a team that needs concurrent access to the reports, or have a large number of applications to analyze, then choose the web console.
  • If you’re a developer familiar with Eclipse or JBDS and want live feedback, then start with the Eclipse plug-in.
  • Otherwise, we recommend starting with the CLI.

Follow the download link for the chosen distribution, and then examine the first few chapters in the appropriate guide to install and run the tool.

Analyzing an Application

You have a local installation of RHAMT, located at RHAMT_HOME, and an application you want to analyze. For the purposes of this blog, we’ll assume that you chose the CLI. With that out of the way, let’s get started.

The analysis is performed by calling `rhamt-cli` and passing it in the application along with any desired options, as seen in the following example.

$ bin/rhamt-cli --sourceMode --input /path/to/source_folder/ --output /path/to/output_folder/ --target eap7

The options are straightforward:

  • –sourceMode – indicates the input files are source files instead of compiled binaries
  • –input – path to the file or directory containing the files to be analyzed
  • –output – path to the directory to contain the reports
  • –target – technology to migrate to; used to determine the rules for the analysis

Once the analysis finishes, a message will be seen in the console indicating the path to the report.

Report created: /path/to/output_folder/index.html
Access it at this URL: file:///path/to/output_folder/index.html

Rules

All of RHAMT’s distributions utilize the same rules engine to analyze the APIs, technologies, and architectures used by the application you plan to migrate. This engine extracts files from archives, decompiles classes, scans and classifies file types, analyzes XML and other file content, analyzes application code, and then generates the reports.

Each of these actions is handled by defined rules, which consist of a set of actions to perform once conditions are met. We’ll look more in-depth at how rules work, and creating your own custom rules, in a subsequent post, but for now know that RHAMT includes a comprehensive set of standard migration rules to get you started.

Just Lifting and Shifting?

Lifting and shifting, or rehosting, an application is one possible first step in migrating it. This process involves moving the application onto a different target runtime or infrastructure. A common end goal of this stage is to make the smallest number of changes to have the application running successfully in a cloud environment.

Once the application is successfully running in the cloud, the next step is to modernize the application so that it’s natively designed for a cloud environment. Instead of simply rehosting the application, this step involves redesigning it, moving unnecessary dependencies and libraries outside the application.

Regardless of which step you’re at, RHAMT assists with both of these steps by providing a set of cloud-ready rules. Once executed against the application, a detailed report is created that indicates what changes should be made. For anyone familiar with using RHAMT to migrate middleware platforms, the process is similar – examine the report and adjust your application based on the feedback.

It’s that simple.

Summary

Wherever you are in the migration process, I’d recommend looking at RHAMT. It’s extremely simple to set up, and comes with a number of default rules to assist in any part of the migration and modernization process. In addition, RHAMT facilitates solving unique problems once – after a given solution has been identified a custom rule can be created to capture that solution, vastly simplifying the migration process.

Stay tuned for our next update, where we discuss how to create custom rules to better utilize RHAMT in your environment.

References

https://developers.redhat.com/products/rhamt/overview/

https://access.redhat.com/documentation/en-us/red_hat_application_migration_toolkit/