In our earlier DevOps and IMS: Getting Started blogpost, we described how Agile and DevOps practices can help teams deliver higher quality code in less time and reduce the cost of development.

In this follow-up blogpost, we will show how easy it is to use open source DevOps tools like Jenkins to drive a fully-automated end-to-end deployment process, one that requires no manual hand-offs between development and the system teams.

Consider the following scenario:

Dillon is a Build Engineer responsible for the enterprise DevOps pipeline, which automates the continuous build and deployment of applications.

Over the years, the company at which Dillon works has developed many types of applications: some applications run on distributed platforms, some run in the cloud, but their core business applications are all running in z/OS.

Dillon finds it difficult to integrate z/OS application deployment into his DevOps pipeline; the mainframe application tools his company uses do not support newer technologies, which are supported by DevOps tools that run on other platforms. This means Dillon has to resort to a manual hand-off between the distributed and mainframe application delivery.

Dillon’s goal is an end-to-end enterprise DevOps pipeline capable of building and deploying both mainframe and distributed assets in a continuous and automated fashion.

Edward is an application architect working at the same company as Dillon. He oversees the adoption and implementation of new technologies and tooling to support applications required by the business.

One of Edward’s biggest challenges is to find resources and skills (such as COBOL and IMS DLI) to maintain IMS and other z/OS-hosted applications. The lack of skills and resources often causes delays in application development and increases development and maintenance costs.

Edward’s goal is to leverage new technologies and implement application solutions that can respond to business requirements more quickly, with minimally required training and low development costs.

Edward recently learned from the IMS Dev Center page that IMS supports Java. Java applications can run in IMS as easily as they can run on other platforms. And more so, existing IMS COBOL or PL/I applications can also be extended to call Java methods while still running inside of IMS.

By using Java with IMS, not only can Edward leverage existing Java skills in his company, he can also potentially lower the running cost, as Java workload can be offloaded to specialty engines on Z, such as zIIP. Also, by keeping applications and the data co-located on the mainframe, network latency is minimized, and performance is potentially enhanced.

Dillon heard that Edward wants to modernize existing IMS applications with Java on the mainframe. Dillon loves that idea, because many DevOps tools support Java applications today out of the box. This means that he can easily integrate mainframe applications into a DevOps pipeline without much work.

Dillon is very excited, and he tells Sanjay, the z/OS System Programmer, that he is building a DevOps pipeline that would eliminate the existing manual hand-off processes. Sanjay told Dillon that not only does IMS support z/OS Management Facility (zOSMF) workflows, it provides several IMS samples in the IMS Github repository that can be used to provision IMS instances or create and start IMS regions for applications to run. This mean that Dillon’s DevOp pipeline can be fully automated end-to-end from build to deployment, as well as provision mainframe applications and environments.

This makes Sue, the application developer, super happy, because she no longer has to ask Sanjay to update the IMS application environment in order for her to do the testing. She can kick off a build and provision an IMS application environment instantly from her laptop in the blink of an eye.

As you can see in this scenario with modernized application assets and a DevOps pipeline:

  • IMS application assets can easily integrate into a DevOps pipeline without mainframe or IMS skills
  • Applications can be stored in an SCM on or off the mainframe platform (for example, on Git or in RTC)
  • Open source DevOps tool like Jenkins can be used to both pull source from the SCM as well as build the application (using Maven)
  • Application environments can be configured and provisioned automatically
  • The agility and ROI of IMS assets are extended with lowered development and running costs

A working sample of a DevOps pipeline is available to you in the IMS Github. It uses the Open source tool Jenkins to deploy and provision an IMS Java application as follows:

Detailed step-by-step instructions are available here – Deliver a Java application to IMS using open source tools.

The DevOps process can be driven by the click of a button on the Jenkins interface from a web browser on any platform; alternatively, triggers can be set up to automatically start the build/deployment process after the code is committed.

With the help of the DevOp process, a developer can drive code changes to the mainframe without any mainframe skills, or without requiring a manual hand-off to an IMS System Programmer. Modernizing IMS with Java and DevOps helps you to extend the agility and ROI of your IMS assets and lower your development costs.

For more information about IMS and Java, including how to write a Java application that runs inside IMS, see the IMS Java page on our IMS Dev Center.

For more IMS applications and DevOps sample, see IMS Github.

Join The Discussion

Your email address will not be published. Required fields are marked *