Monolith to Hybrid Architecture in 1 Hour.

Application Modernization

Transformation from Monolith to Hybrid Architecture is challenging and may take days and weeks for realizing first Microservice within A Hybrid Architecture.

In this Blog, I am going to discuss an option which can quickly and safely land you on a Hybrid Architecture from Java Monolith within no time! The name of the Tool is Open Transform available on https://github.com/miracleatwork/opentransform.

This tool automates transformation of Monolith to Hybrid Application.

I have been part of several Application Modernization exercises and I have faced several technical challenges. While Hybrid Architecture allows you to use Monolith Application and one of the component within Modernization, arriving to that state has its own challenges, which can be listed as follows:

1. Manual modification of Monolith App code is time consuming.
2. Executing modified code of Monolith App involves more than trivial efforts.
3. Realization of benefits of Hybrid Architecture is realized only after substantial effort and time is invested over the transition of the Monolith Application. 
4. Inter-Service communication and Monolith communication channels can add complexity to the Architecture.
5. We need to save our Architecture from implementing Anti-patterns.

Unique Approach to Transformation

We want to break a Monolith Application into A Hybrid Architecture. This approach can be as complex as the Application itself, while very simple at Microlevel.

Monolith Application is primarily complex with respect to Architecture for:

1. Monolith Application has huge code base.
2. Individual Classes( DAO, VO, Service, etc) are tightly coupled
3. The VM for their execution is generally shared.
4. Analysis & Mapping of dependencies takes huge efforts.
5. Vertical Slicing becomes very complex and iterative due to coupling.

Strategy to minimize the risk and quickly realize Hybrid Architecture

1. Take Bottom-To-Top Approach

   Here we focus on individual classes which are candidate of Microservice Functions. This classes will obviously have public & protected methods and there will be other classes, which are dependent on it. If we change the structure of this class, the application will start breaking due to this coupling.
   
   

   

   Fig 1: We have Class A, B &C within our Monolith Application. For Vertical slicing, if we process Class B, keeping its structure intact, Monolith Application can still function with modified class.

2. No Change in Efferent Coupling of the Class

   Efferent Coupling is termed as The number of classes in other packages that the classes in the package depend upon is an indicator of the package's dependence on externalities. If we don't change this Coupling for the Dependent Classes, our complexity of slicing is highly reduced. This also saves lot of time & efforts!
   
   
   

   

    Fig 2: We Modify Class B to enable it as a service, keeping its structure intact, Monolith Application can still function with modified class.
   
   

3. Add Webclient to Dependee Class

   We will replace the internal functionality of the Dependee Class B with a webclient which can perform a HTTP request for the state of the Class B.
   The local JVM method call within Class B is now replaced with a HTTP request call but Dependent Class A is Agnostic of this change.
   
   

   

    Fig 3: We Modify internal method definition of Class B and add WebClient to it.
   
   
   
   

4. Expose Dependee Class over REST

   Once we modify Dependee Class to expose its state over REST endpoint, it can service the Monolith Dependee classes over the REST Endpoints through HTTP Request. This way we readily get Hybrid Architecture.
   
   
   

   

   
    Fig 4: We add Controller Wrapper for Class B and make it accessible over REST endpoint.
   
   
   

5. Use Stripped Monolith Application with MVC Wrapper Application

   After we modify the Dependee Class, our Monolith Application will still function in the same way as it did earlier because we have not changed the structure of Dependee Classes. Hence we don't put any extra efforts due to stripping of the Dependee Class in Monolith Application.
   
   We wrap Dependee Class in a MVC Application and make it available as REST Service, hence it qualifies for Microservice Application.
   
   

   

   
   Fig 5: We transform Monolith Application to Hybrid Architecture
   
   You can also check Package Diagram, Component Diagram and Deployment Diagram of this hybrid application from its Presentation available at https://github.com/miracleatwork/opentransform/blob/master/docs/OpenTransform.pdf
   Open Transform automates this entire process for you and hence you can start your Application Modernization instantly using Open Transform. How to execute Guide is also available on https://github.com/miracleatwork/opentransform/blob/master/docs/HowToExecute.pdf
   
   

   About Open Transform

   Open Transform allows you to quickly transform your Monolith into Microservices. Its an automation of various manual activities that developer does in order to transform Monolith Application.
   
   Open Transform adheres to many best practices like Java Conventions, Test Driven Development, Open Software Stack like Microprofile, Thorntail etc.
   
   

   "Transform" tool from Miracle Software Solution can help you in automating many of these activities and get a Microservice Hybrid Application instantly, in less than 5 Hours. You can also evaluate it within free workshop. You can request the same through an email on support@codageeks.com .
   
   
   
   
   
   
   

Transformation Experts

Application Modernization

 

Transformation Experts is a team of IT Professionals who have master the space of Application Modernization. Your best bet is the  expertise and experience of the team who will drive the Application Development for you. Here I will mention about important aspects of Technical Qualification, Skills and Roles of the Developers & Architects.

This blog is for Software Professionals & Enterprise IT Managers who are aware of Application Modernization concepts.

Technical Skills & Roles

Application Developer Team should have varied Technical Expertise

1. Certified Professionals
2. Cloud Architects
3. Microservice Developers
4. Application Developers
5. Architects
6. Multi-Cloud Experts

 

Certified Professionals

Certification is assessment of demonstration of skills. Prominent Certifications are available for IT Professional in the field of Distributed Application Development & Management. Having certified professionals in your team will increase your chances of lowering the mistakes and adhering to your planned delivery timelines. Prominent certifications are as follows:

• Microservice Developer Certification from RedHat.
• Solution Architect & Developer Certification from AWS.
• Developer Associate Certification from Azure.

Cloud Architects

Cloud Architects help your services to be compatible and make best use of Cloud Native features. Cloud native applications are best suite for your Modern Applications. While each Cloud vendor has specific features unique to their offerings, A generalized expertise is organized by adhering to the use of industry practices like using Kubernetes.

Cloud Architects contribute to unique features for the desired cloud platform, hence your applications can take advantage of available options. Eg. Lambda services in AWS is similar to Azure functions. Complexity in working with similar and distinctive features of Cloud is solved by Cloud Architects.

Microservice Developers

Microservices can be of various types and they can adopt to various Inter Service communication channels. There are many technology stacks which are best for few types of requirements while they are good for almost any microservice.

• Microprofile & Spring are used for Java based Microservice Developement.
• Node.js, React Js, Vue.Js are for Javascript based Microservice Development.

Microservice Developers use their expertise for Microservice Development.

Application Developers

Application Developers have skills for developing in Java, .Net, Node.js etc languages.  Their contribution is important to meet the business functionality within the Modernized Application. The business functions are implemented by these developers and they become part of Microservices.

Architects

Architects are involved from initial state of Application Modernization where they come up with Compliance requirements like Enterprise Architecture, Devops, Delivery Guidelines etc. They decide on the execution platforms, communication channels, scaling, resiliency etc features of the application

Multi-Cloud Experts

In the time of Infrastructure As A Service, where Enterprises have to select best option from Public to Private Clouds and combination of On-Premises and On-Cloud Infrastructure, Multi-Cloud Expertize should always be handy for smooth execution of Modernized Applications.

Knowledge of Orchestration tools like Kubernetes & Openshift along with unique offerings of each vendor will influence the Architecture decision for your Modernize application.

While this are just high level activities, things can go very dizzy as you move ahead. "Transform" tool from Miracle Software Solution can help you in automating many of these activities and get a Microservice Hybrid Application instantly, in less than 5 Hours. You can also evaluate it within free workshop. You can request the same on their website's Contact Us section.

New Patterns Introduced for Digital Transformation

Wrapper Controller: It adds Rest Controller which wraps the Java Class. All methods are exposed through matching endpoints.
 

Class Bridge: It bridges the conversion of datatype of request payload and response body to the datatypes matching to the method parameters and return type
 

Controller Client: It replaces the method body with the call to rest client. It uses Json convertors to transform the Datatypes into Json which can be sent as payload to the rest client and also to convert the response into the Java class types of the response.
 

Architecture & Best Practices

Application Modernization

 

Architecture know how is a very important aspect while you evolve in your Application Transformation phase. Monolith Applications have huge code base to manage while you strive to package the self executing code into a business function and encapsulate the similar functions into a Microservice. It is very important to address the best Architecture Practices while you evolve your Application Architectures.

This blog is for Software Professionals & Enterprise IT Managers who are aware of Application Modernization concepts.

Major considerations for Architecture & Best Practices

Lets us go through important phases of Architecture & Best Practices:

1. Best Architectures
2. DevOps
3. Cloud Native
4. Containerization
5. Container Orchestration
6. Multi-Cloud Platform

Best Architecture

Not All of the Best Architectures are good for your Application. It requires clarity of the aim behind the Modernization to select the best Architecture.

• You can always start with Hybrid Architecture to start Modernization
• You should than select Microservice based Architectures for Web enabled functions.
• You should select Event based Architectures for Domain Driven Functions.
• You should select off-the shelf tools like opentransform, Elastic-Logstash-Kibana etc which already has good Architecture implemented.

Modernization will involve multiple Architectures for unique business requirements.

DevOps

DevOps allows you to focus on the last mile stone of your delivery life cycle. It takes Continuous Integration, Continuous Delivery & Continuous Release.

• CI covers your development environment and automation of Builds.
• CD covers Infrastructure required to execute various Builds.
• CR covers quick and multiple releases of your applications.

DevOps has been a major factor in quickly identifying the bugs and shortening the Build and Release time, hence you can now deliver more!
DevOps involves containerization techniques like Docker, Orchestration and Repostitories.

 

Cloud Native

Cloud Native applications are de-facto standards for Application Modernization. 

Making applications Cloud Ready allows you to leverage Infrastructure As A Service for executing your Applications. It brings advantages like Scaling, Security, Resiliency, Manageability etc for your applications.

You always have option to select from Private Cloud or Public Cloud.

Containerization

Containerization is a light weight Virtualization for your applications. Containers are execution of Application Images. You can automate the scaling of your Application very easily.

Docker is the most widely used technology for Containerization. The produced Image can be shared using a Private Repository or Public Repositories like Github.com, etc.

Container Orchestration

Within no time, you will have to start dealing with high number of containers spawned from your application images. It is evident to have Orchestration tools to manage the life cycle of Containers.

Docker Swarm, Kubernetes, Openshift are prominent Orchestration Platforms which provides you ease of management for containers.

Multi-Cloud

Multi-Cloud comes in the option for Public, Private and combination of both the clouds. Enterprises tend to secure the important applications within their         On-premises Infrastructure and publish supporting applications with less risk on public clouds.

Many vendors provide On-premises Deployment of Infrastructure tools like VMware, IBM, etc, many Enterprises may not have any On-premises Infrastructure.

Multi-Cloud strategy provides you better option for managing Infrastructure cost with trade-offs with concerns like security & privacy.

Architecture Best Practices are essential part of your Modernization activity. "Transform" tool from Miracle Software Solution can help you in automating many of these activities and get a Microservice Hybrid Application instantly, in less than 5 Hours. You can also evaluate it within free workshop. You can request the same on their website's Contact Us section.