Mainframe Modernization – AWS Cloud Migration Using COBOL – Part #2
Part #2 of the mainframe modernization case study focuses on further optimizing the existing IT infrastructure and ensuring the large-scale transformation takes place seamlessly.
Introduction
- After the initial success of migrating our client’s legacy applications to AWS, our team moved on to subsequent phases to further modernize and optimize the client’s IT infrastructure.
- While the first part of the project achieved notable milestones, the ongoing nature of such a large-scale transformation revealed additional challenges that required innovative solutions.
- Part two of the previous COBOL case study extension delves into the complexities encountered during the 9th wave of the project, showcasing our continued commitment to ensuring a seamless transition and enhanced operational efficiency for our client.
Project Expansion and Discovery
- As we moved into the 9th phase of the project, we encountered new challenges when migrating legacy applications from an outdated system at a manufacturing plant to Amazon Web Services (AWS).
- These applications, which were around three to four decades old, posed unique obstacles due to their outdated architecture and lack of features for integration with other systems. This called for innovative solutions.
- Therefore, we opted to use Raincode as the primary technology for compiling and executing the applications.
Migration Blueprint for the Manufacturing Plant’s Legacy System
Below is the plan for the short-term migration option that the team implemented to reduce project duration and achieve a faster return on investment.
Legacy System
Business functions
100%
Application Code 33%
Utilities 33%
Data Formats 33%
Middleware and Database
100%
Legacy OS
100%
Legacy Hardware
100%
Modern Re-platforming
Business functions
100%
Application Code 33%
Utilities 33%
Data Formats 33%
Middleware and Database
90%
Hardware Emulation and Linux OS
100%
AWS
100%
Challenges and Pain Points
Here are the primary challenges that the team encountered during the AWS migration:
Legacy Knowledge and Documentation Deficits
- Knowledge Gaps – The legacy applications, developed over three to four decades, had limited documentation, with only a few senior members in the client organization possessing deep functional knowledge.
- Component Decommissioning –Identifying obsolete components was difficult due to the lack of comprehensive documentation, complicating the decommissioning process.
Initial AWS Deployment Complexities
- Behavior Prediction – Migrating these applications to AWS for the first time introduced unpredictability in how they would perform in the new environment.
- Testing and Debugging –Extensive testing and triage were required to manage and rectify unexpected behaviors and performance issues.
Concurrent User Access Limitations
- User Load Management – The original mainframe environment supported numerous simultaneous users, but the initial AWS configuration allowed limited concurrent logins, impacting operational efficiency.
- Licensing Requirements –The team needed to acquire and configure Client Access Licenses (CALs) to expand user access and meet operational demands
Raincode Compatibility Issues
- Legacy Functionality – Raincode, while a powerful tool, lacked support for many older COBOL functionalities, necessitating significant code refactoring.
- Code Refactoring –The legacy code required extensive rewriting and restructuring to align with Raincode capabilities, involving detailed analysis and numerous test cases.
AWS Infrastructure Setup
- Base Instance Configuration – Establishing base instances and setting up pipelines on AWS was time-consuming, requiring a robust configuration to support future migrations.
- Scalability and Reliability –Ensuring the infrastructure could scale and remain reliable for subsequent application migrations was a critical and challenging task.
Underestimated Project Complexity
- Initial Assumptions – The project was initially perceived as a straightforward lift-and-shift operation, but deeper analysis revealed significant inherent issues in the source code.
- Source Code Refactoring –The legacy application source code had to be extensively refactored to resolve underlying issues before it could be successfully migrated to AWS.
The Solution
Once our team identified the problem, we utilized various tools from AWS and other third-party providers to overcome significant challenges.
Legacy Knowledge and Documentation Deficits
- Knowledge Transfer and Analysis – Conducted detailed knowledge transfer sessions and implemented a knowledge management system[5] with the few remaining experts familiar with the legacy systems to capture their insights and document the functional flow of the applications.
- Automated Documentation Tools – Employed automated tools to analyze the legacy codebase and generate comprehensive documentation, aiding in the identification of components for decommissioning.
Initial AWS Deployment Complexities
- Behavioral Analysis and Simulation – Utilized AWS CloudFormation and AWS CodePipeline to create staging environments that mimicked production, allowing extensive testing and debugging before full deployment.
- Automated Testing Frameworks – Implemented automated testing frameworks such as Selenium (functional testing) and JUnit to execute a wide array of test cases, ensuring thorough validation and addressing unexpected behaviors.
Concurrent User Access Limitations
- User Load Testing and Optimization – Leveraged AWS Elastic Load Balancer and Auto Scaling groups to optimize the system for concurrent user access, ensuring that performance remained stable under increased loads.
- License Management – Procured and configured the necessary Client Access Licenses (CALs) to support a higher number of simultaneous users, using AWS IAM to manage user permissions and access control efficiently.
Raincode Compatibility Issues
- Code Refactoring and Modernization – Engaged COBOL experts to refactor legacy code, ensuring compatibility with Raincode by breaking down complex legacy functions into smaller, manageable units.
- Custom Adapters and Middleware –Developed custom adapters and middleware solutions to bridge gaps where Raincode lacked support for older functionalities, ensuring seamless integration and performance.
AWS Infrastructure Setup
- Robust Infrastructure Design – Partnered with AWS solution architects to design a scalable, reliable infrastructure using AWS EC2 instances, S3 for storage, and RDS for database management.
- CI/CD Pipeline Configuration –Configured continuous integration and continuous deployment (CI/CD) pipelines using AWS CodePipeline and Jenkins, streamlining the setup of base instances and pipelines for ongoing and future migrations.
Misjudged Project Complexity
- Comprehensive Code Review and Refactoring – Conducted an in-depth review of the legacy code to identify and resolve inherent issues, employing static code analysis tools and manual code inspections.
- Agile Project Management –Adopted agile methodologies to manage the refactoring process, ensuring iterative development, continuous feedback, and regular client updates to handle the evolving complexities of the project.
Custom Development Debugger
The Outcome
This short-term migration option that our team chose did provide substantial results which are as follows:
- Successfully migrated the initial legacy applications to AWS, ensuring efficient operation in the new environment.
- Overcame user access limitations, enabling a larger number of concurrent users.
- Established a comprehensive and scalable infrastructure on AWS, streamlining future migrations.
- Enhanced the client’s ability to maintain and update their applications with the new, flexible environment.
- Improved the efficiency and functionality of the applications, exceeding client expectations and resulting in high satisfaction levels.
From Legacy to Leading – Revolutionize Your Operations with KMTEQ
Expert Mainframe Modernization.
Ready to modernize your legacy systems and propel your business into the future? With KMTEQ, you can achieve your vision of data migration