Skip to main content

How to streamline application portfolio modernization with Tackle

Tackle is an open source tool that helps organizations migrate and modernize their application portfolio to leverage Kubernetes without risk of vendor lock-in.
Gold gears on a black background

Photo by Miguel Á. Padriñán from Pexels

One of the key challenges for application modernization is providing organizations with open tools to transform their applications to leverage cloud-native technologies, especially in the Kubernetes space.

Most existing tools are proprietary and introduce some form of vendor lock-in, preventing organizations from achieving the level of flexibility that hybrid cloud aims for. Tackle is a new open source tool from the Konveyor community that aims to solve this.

Before you can use a tool to gain time and cost efficiency, you need a good modernization approach. Most migration and adoption methodologies sit within organizations and are not generic enough to be broadly transferable and applicable in common scenarios. This negatively impacts the speed that a group can implement application modernization. Organizations often have to reinvent the wheel and define their own tooling and methodology or make tradeoffs, such as accepting vendor lock-in.

You can watch my presentation to the Konveyor community (embedded at the end of this article) to learn more about approaching large-scale Kubernetes adoption projects.

Modernize and migrate your application portfolio with Tackle

Tackle's vision is simple yet ambitious. We want it to become the ultimate open source toolkit to help organizations safely migrate and modernize their application portfolio to leverage Kubernetes, providing differential value on each stage of the adoption process.

Tackle is not so much about performing the actual migration in an automated fashion (like the other Konveyor projects). Instead, it's about providing insight to the teams in charge of adoption and enabling them to make informed decisions. There is also some degree of automation involved. We envision some of its tools assisting in some parts of the process, such as functional validation or configuration and code adaptations.

I want to stress the words safely migrate. As an architect in charge of an adoption initiative, you must gather as much information as possible to identify risks early so that you can develop a mitigation plan that makes the project measurable and predictable. That way, you can keep it on track, allowing the organization to build its business strategy on top of its IT landscape with confidence.

But you may have a massive amount of information to consider when designing the adoption plan, and it can quickly become overwhelming. Tackle is designed to obtain valuable insight out of raw information, enabling adoption initiative leaders to dramatically reduce risks so that they can make the right decisions.

[ You might also be interested in reading An introduction to enterprise Kubernetes. ]

Tackle is not only about helping architects and others make high-level decisions. Tackle provides tools to help developers perform required changes on the source code and configure applications they migrate, ideally automating this as much as possible.

One of the trickiest parts of migrating applications is ensuring they behave the same once the changes are applied and running on the target platform. In most cases, those doing the migration aren't part of the development team maintaining the application, so they lack the knowledge to validate that the migrated application is functioning correctly. To address this, Tackle includes a differential testing tool that automatically generates a set of test cases and creates a functional profile of how the application behaves before and after the migration to certify that everything remains the same.

To sum things up, Tackle aims at making adoption teams' lives easier. It helps tech leads make well-founded decisions while providing guidance and assistance to developers and migrators on adapting applications to leverage Kubernetes.

Install Tackle

We released the first Tackle Operator version in July 2021 on both for upstream Kubernetes distributions and the OperatorHub flavor available in OpenShift. That included two tools: Application Inventory and Pathfinder. Tackle 1.1.0, released in November 2021, includes user-experience enhancements.

Tackle's installation is fully automated and managed by an Operator, making it easy to consume. The only requirement is to have the Operator Lifecycle Manager available in the Kubernetes cluster where you want to install Tackle. This requires almost no effort on upstream Kubernetes distributions, and it comes out of the box with OpenShift 4. Once the Operator is available, it provides a Tackle Custom Resource Definition (CRD) that can instantiate all the components of a typical Tackle installation. As of this writing, this Operator reaches Capability Level I, although we are planning enhancements.

Application Inventory and Pathfinder

Application Inventory main view
(Ramon Nissen, CC BY-SA 4.0)

The Application Inventory is the entry point and natural integration interface for all tools within the Tackle toolkit. The idea is to allow organizations to manage their portfolio in a centralized fashion and, from there, classify applications and launch any actions that might be related to them, such as analysis and assessments.

Application details
(Ramon Nissen, CC BY-SA 4.0)

On its own, the Application Inventory provides a way to rationalize an organization's application portfolio through an extensible tagging model that allows the classification of applications in multiple dimensions. The tool comes with a series of curated tags related to typical aspects of application development, such as programming languages, operating systems, or databases it consumes. Users can extend it however they want to accommodate concepts like the custom corporate framework used to develop an application. Aside from the tagging model, the Application Inventory also allows users to group applications by the business service they belong to and provides a way to manage dependencies between applications.

Pathfinder application assessment view
(Ramon Nissen, CC BY-SA 4.0)

The rest of the information that the Application Inventory displays comes from the assessment data provided by the Pathfinder tool. Born as an open source tool for Red Hat Consulting customer engagements, Pathfinder was contributed to the Tackle project and rebuilt from scratch to have it fully integrated with the Application Inventory.

[ Get access to the O'Reilly eBook Kubernetes patterns for designing cloud-native apps at no charge. ]

The tool aims to assist organizations in assessing their application portfolio to determine the suitability of containerization and enable adoption leads to make informed decisions on the migration strategy for each application or application type. This is achieved in a questionnaire-driven approach covering all essential topics related to technology and application lifecycle management.

Application review
(Ramon Nissen, CC BY-SA 4.0)

Based on the answers, the tool can detect any potential risks that might prevent an application from running in containers, providing insight to help the adoption lead select the best migration strategy for each case.

Reports view
(Ramon Nissen, CC BY-SA 4.0)

The adoption team can also add information about the estimated effort to migrate the application and assign priority based on the business criticality using the Pathfinder application.

Pathfinder is now fully integrated with the Application Inventory to provide a seamless user experience when launching assessments and reviewing results from its main view. This integration is especially useful in the Reports view, in which the adoption leads can see an aggregated view of the risks detected on the application portfolio during the assessment and drill down into the dependencies between applications to start defining a migration plan.

A taste of things to come

These combined tools provide a powerful way for an organization to manage and assess its application portfolio. We already have reports of architects in the field successfully using this first version of Tackle on Kubernetes adoption engagements. But this is only the beginning, as many other features and tools will become available and integrated into the user experience in the upcoming months.

We're working on multiple initiatives to widen Tackle's scope, allowing it to go beyond the assessment stage and fulfill our vision of providing value at every stage of the adoption process. These include:

  • Windup, the upstream project behind the current Migration Toolkit for Applications by Red Hat, is an automated analysis tool that you can use with application source code and binaries to determine the gap to migrate to a given target platform. It provides guidelines and assistance on the required adaptations at the source-code level. In our case, it will be especially useful to detect the changes needed for application containerization.
  • Tackle Container Advisor uses artificial intelligence (AI) to understand a description of an application using natural language and suggest the most suitable container image to containerize the application.
  • Tackle Configuration Discovery locates and transforms configuration files to adapt them to a target runtime. For example, when migrating Spring Boot applications to Quarkus.
  • The Data Intensive Validity Advisor (DiVA) analyzes the data layer of applications and detects dependencies to different data stores and distributed transactions.
  • Tackle Test Generator is a test-driven modernization tool that certifies that an application behaves the same way after migration by creating a functional application profile using automatically generated unit tests.

Most of these projects are already available as standalone tools. Still, we aim to have a seamless user experience, with the Application Inventory becoming the entry point for all these tools. To achieve this, we are working on defining overarching user stories that serve the adoption process as a whole and designing the required integration layers to get the most out of all projects working together on a joint purpose.

Tackle Kubernetes

Tackle is one of several tools found in Konveyor, a community created to fill a void in the Kubernetes adoption space. The platform is becoming the standard for application deployment. Tackle plays an essential role in various adoption scenarios, as it helps organizations leverage Kubernetes to its full potential. It offers tools that go from the high-level considerations related to application lifecycle management to the last details of the application's source code. This approach helps architects design adoption strategies and plans that are measurable, predictable, and ultimately safe.

We are an open community looking to cover all adoption scenarios, so everyone is welcome to contribute, from any tools that could enhance our projects' capabilities to use cases that might broaden the scope of what we already have. We want to meet the needs of everyone out there looking to get the most out of their Kubernetes clusters.

Join the Konyeyor community by subscribing to our mail list on the Konyeyor website or get in touch with us in the Kubernetes Slack channel (#konveyor).

For more information, watch my presentation about Tackle to the Konveyor community:

Author’s photo

Ramón Román Nissen

Ramón Román is the Product Manager for the Migration Toolkit for Applications within the Modernization and Migration Solutions team in Red Hat. More about me

Navigate the shifting technology landscape. Read An architect's guide to multicloud infrastructure.


Privacy Statement