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.
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.
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.
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
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.
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.