mLogica Thought Leaders: How DevOps Drives Better Mainframe Modernization Outcomes

In a previous mainframe modernization blog we described a basic scenario for replatforming a mainframe workload to AWS using the mLogica LIBER*M Mainframe Modernization Suite of automated software modules. In this article, we’ll dive deeper into how early engagement of DevOps practices accelerates innovation and reduces risk in mainframe modernization projects.

DevOps (development operations) is the set of tools, practices and methodologies that allow organizations to accelerate and automate aspects of developing, testing, releasing and updating software. According to a Statista survey of over 30,000 developers, DevOps has become so integral to software development that 80% of respondents see it as vital to their operations.

While it’s not impossible to integrate a mainframe with DevOps, it is difficult and expensive, requiring significant ongoing investment of resources. By contrast, modernization approaches like replatforming and refactoring naturally enable DevOps integration for the modernized system. For strictly regulated enterprises, modernization and DevOps can also be critical to fulfilling compliance requirements around configuration management, coding standards and security controls.

There are two main modernization approaches: replatforming, also known as rehosting, which entails moving a mainframe workload to the cloud while staying on COBOL, and refactoring—translating COBOL and other legacy languages to Java or C#. In both methodologies the resulting code base will require change control, compilation, building and deployment, testing and infrastructure.

A proper DevOps strategy for mainframe modernization should address the following requirements:

1. Continuous integration and delivery (CI/CD)
2. Automated testing
3. Infrastructure as code
4. Monitoring and logging

If your current system has DevOps implementation for distributed applications, this is typically the logical starting point, although modifications may be required to align your existing DevOps environment to the needs of a mainframe modernization project. These can include:

• Building new CI/CD pipelines to incorporate new compilers, e.g., for COBOL, code scanners and deployment tasks
• Enhancing automated testing to cover batch processing or terminal mode tests
• Extending monitoring and logging to cover platforms introduced by modernization

If there is no existing DevOps facility to align to, then it is critical to engage internal technical leadership in building a strategy that will work for the long term. Key considerations should include:

• Is the DevOps implementation only for modernized mainframe workloads, or are there other distributed applications to cover? Where are they deployed?
• Is there a need to continue to operate mainframes or IBM systems, and do these need to be brought under the DevOps umbrella?
• What are the compliance requirements?

One option is an open-source approach managed by in-house resources. This requires a substantial ongoing financial and human resources investment to ensure availability of staff who are expert in both integrating emerging technologies and combating continuous security threats. A DIY approach also limits options for cost-saving on-demand scalability aligned to fluctuating demand.

Another option is a commercial platform with on-demand cloud computing and automated scalability like Amazon Web Services (AWS). Their ready-to-use stack provides integrated DevOps solutions suitable for both refactored and replatformed systems, including:

• AWS CodeCommit
• AWS CodePipeline
• AWS CodeBuild
• AWS CodeDeploy
• AWS CloudFormation (for provisioning infrastructure as code)
• AWS X-Ray (for visibility and monitoring)
• AWS Elastic Container Registry (ECR)

Since IT teams have been developing mainframe software for decades without DevOps or continuous integration/continuous deployment (CI/CD), why are they now so important when mainframe applications are migrated to cloud platforms like AWS?

After refactoring to Java or C#, many organizations enhance their new modern code by breaking down large mainframe-style functions into microservices that allow them to build single applications comprised of multiple autonomous small services that operate independently.

This offers a host of benefits, including:

• Easier defect detection and isolation
• Greater ease of deployment
• Replication across multiple business units
• Accelerated time to market
• Enhanced security and more

Automated testing accelerates this process while reducing the risk of compromising the integrity of the underlying business logic. With automated tests in place, developers can change the flow of control and data “behind the tests,” ensuring changes to the application architecture don’t introduce functional changes. For planned functional changes, developers can follow a test-driven development (TDD) approach in which they design tests that reflect the functional changes and then manually refactor the code until it passes these tests.

DevOps, especially when integrated with CI/CD, can dramatically speed up the deployment process and enhance the reliability of software updates. This is particularly useful when transitioning from a monolithic, tightly coupled codebase to a microservices architecture.

With CI/CD, every code change made in the application is automatically tested and prepared for release to production. This means developers can deploy updates more frequently and with less risk, as any security vulnerabilities and other issues are automatically identified so they can be fixed promptly.

DevOps promotes a culture of collaboration between development and operations teams, breaking down the traditional silos that can delay the software development process. This collaborative approach is crucial when transitioning to a microservices architecture, as it requires careful coordination between different parts of the application.

By working together, development and operations teams can ensure each microservice is properly integrated and functioning within the larger application ecosystem. This increased collaboration leads to greater efficiency, faster problem-solving and a more robust final product.

This is particularly valuable in replatformed environments where legacy development teams make the shift from ISPF green screen code editing to working in an integrated development environment (IDE) with source control and DevOps tools. Even if the application is maintained as a monolithic architecture, teams benefit from this process.

Using DevOps practices to manage infrastructure as code (IaC) and containerization can further increase flexibility by making it easy to manage and replicate environments, including facilitating rapid scaling when needed. IaC, using tools like AWS CloudFormation, dramatically simplifies the processes of provisioning and deploying temporary test or sandbox environments and automating high availability and disaster recovery failover and restoration.

Integrating DevOps practices into mainframe modernization projects is not just an optional convenience, but a key driver for successful, efficient transformations. The benefits of such an integration are manifold, accelerating the transition to microservices and enhancing deployment speed and reliability, particularly when paired with CI/CD methodologies.

Leveraging DevOps also fosters improved collaboration and efficiency among teams, breaking down traditional silos that can delay the development process. Furthermore, by managing infrastructure as code, DevOps offers flexibility and ease of environment replication, which is crucial for rapid scaling and high availability.

Whether you're replatforming or refactoring , adopting a DevOps strategy tailored to your organization's needs can significantly streamline your mainframe modernization journey, leading to increased agility, expanded talent pools and a robust final product that meets today's dynamic business needs.