As organizations evolve their development practices, integrating robust Continuous Integration/Continuous Deployment (CI/CD) solutions for mainframe environments is becoming essential. IBM’s strategic push encourages mainframe users to adopt modern development tools like Git, IBM Dependency-Based Build (DBB), and IBM Wazi aaS, providing a more efficient, automated, and scalable workflow for z/OS.
Kobee plays a critical role as the orchestrator, bringing these tools together to ensure seamless DevOps integration for mainframes.
To cater to IBM customers who prefer to retain their existing orchestrator, we offer the core functionalities of IBM tools automation through specialized integration options.
What is Kobee?
Kobee is a powerful orchestration tool designed specifically for mainframe CI/CD pipelines. It ensures that modern DevOps practices—such as automation, version control, and continuous delivery—are seamlessly applied to mainframe environments. Acting as the backbone for your pipeline, Kobee integrates multiple tools and processes, streamlining the development lifecycle from code commit to deployment, ensuring your mainframe remains aligned with contemporary development standards.
Kobee Key Offerings
We provide two primary offerings:
- Kobee Orchestrator:
The core tool that manages and automates the CI/CD pipeline for z/OS environments.
- Kobee Phases:
Modular components that facilitate actions throughout the entire development and deployment lifecycle are available for popular CI/CD orchestrators, such as Jenkins (Plugins).
In the future, they will also be accessible for GitLab (Templates) and GitHub (Actions)
Figure one: Kobee's DevOps process, for rapid and flexible CI/CD for legacy and modern environments.
How Does It Work?
Kobee as orchestrator serves as the essential glue that brings together a variety of tools and processes in your CI/CD pipeline. While traditional mainframe environments relied heavily on manual steps, Kobee automates and orchestrates the entire workflow.
Additionally, the brilliance of the Kobee Phases concept lies in its simplicity and flexibility. Each Kobee Phase is designed to support essential functions, whether you’re sticking with classic JCL for compilation or utilizing modern IBM tools (DBB, Wazi Deploy,…) or others. And as mentioned before also available for other orchestrators.
Classic Approach
In the classic approach, developers can reuse their compile and promote JCL scripts by importing them into Kobee as models and configuring them through properties. Kobee then ensures the correct scripts are executed, providing autmation for the build and deployment process.
Modern Toolset Approach: The Power of Integration
As organizations shift towards more modernized workflows, the Modern Toolset approach leverages dedicated IBM tools for z/OS to streamline mainframe development, testing, and deployment processes. Kobee acts as the orchestrator that binds these tools together, providing a cohesive and automated experience leveraging its Phases to handle the specific actions for each stage.
Both approaches use the same Phase architecture.
Figure 2: Phases with classic JCL Models or Models for IBM state of the art tooling and the Resources (parameters)
Figure 2a: Sample generated script for a CICS PreCompile JCL based on the CICS Precompile Model and resource file
Figure 2b: Sample generated script for DBB based on a DBB Model and resource file
Key Tools in the Modern Approach
IBM Wazi as a Service (Wazi aaS) for Isolated Development
IBM Wazi aaS allows developers to create isolated z/OS environments in the cloud, making development and testing faster and safer. By virtualizing mainframe environments, Wazi aaS eliminates resource constraints and allows for parallel work.
Git for Distributed Version Control
Using Git allows mainframe developers to collaborate in a distributed manner, leveraging parallel development through branching and merging. Git’s powerful version control mechanisms help developers track changes, roll back when necessary, and ensure that everyone works on the latest code version.
Kobee’s Role:
Kobee integrates Git into the pipeline, automating the handoff between code commits and builds. It monitors Git repositories for changes and triggers build processes as soon as new code is pushed, ensuring continuous integration across distributed teams.
IBM Dependency-Based Build (DBB) for Automated Builds
IBM DBB brings build automation to z/OS by tracking dependencies and generating the necessary Groovy script to build only the changed components, reducing manual intervention and build times.
Kobee’s Role:
Kobee integrates with DBB, orchestrating the build process. Once a developer pushes code to Git, Kobee generates the necessary properties and scripts for DBB and then triggers it to automatically generate and submit the correct script for the build. With this integration, the entire process—from code commit to execution—is automated, ensuring accuracy and efficiency in the build process.
IBM Wazi Deploy for Simplified Deployment
IBM Wazi Deploy automates z/OS deployments, handling the complexities of deploying across CICS, Db2, and IMS environments. It integrates with artifact repositories like JFrog Artifactory to manage deployment artifacts, ensuring that the right versions are deployed at the right time.
Kobee’s Role:
Kobee coordinates the deployment pipeline, working with Wazi Deploy to manage and deploy the correct build artifacts generated by DBB. By automating this process, Kobee eliminates the need for manual intervention, ensuring consistent and traceable deployments across environments.
Figure 3: The IBM Wazi based setup for classic and state-of-the-art CI/CD for z/OS
Why Kobee is Essential for Mainframe DevOps
Kobee transforms how modern tools work together by acting as the central orchestrator in the pipeline. Without a tool like Kobee, each component—whether it’s Git, DBB, Wazi aaS, or Wazi Deploy—would function in isolation, requiring manual coordination between steps. Kobee connects these tools, providing:
- Smooth Integration Across Tools: Kobee ensures that tools like Git, DBB, and Wazi Deploy work in harmony. For example, a code commit in Git automatically triggers a DBB build, and once successful, initiates deployment through Wazi Deploy.
- Centralized Control and Automation: Kobee provides a single interface for managing complex workflows across multiple tools. It automates the entire process, from build to deployment, ensuring each tool performs its role efficiently without manual input.
- Seamless CI/CD Orchestration: By orchestrating the entire lifecycle, Kobee ensures that developers can focus on writing and improving code, rather than managing the intricacies of builds and deployments.
- Error Reduction and Speed: Kobee removes manual steps, reducing errors and speeding up the development process. Automated testing and deployment eliminate bottlenecks, making continuous integration and continuous deployment (CI/CD) a reality for mainframe environments.
Figure 4: Kobee offers you a free choice of CI/CD engine: Kobee, Jenkins or other
Conclusion
Kobee is indispensable for orchestrating the modern mainframe DevOps pipeline. By integrating key tools like IBM Wazi aaS, Git, IBM DBB, and IBM Wazi Deploy, Kobee enables automation, reduces complexity, and ensures seamless collaboration across teams. As mainframe environments continue to modernize, Kobee’s ability to bring these tools together makes it an essential component of any organization’s DevOps strategy.
René DE VLEESCHAUWER
CEO Ikan Development
red@ikan.be
Website: https://kobee.io/
Kobee is a TechXchange Finalist for the Mainframe Innovation Award and won the Award!
Excellence in Mainframe Innovation
This award recognizes organizations that have demonstrated exceptional creativity and forward-thinking in leveraging IBM mainframe technology to drive innovation and growth and have successfully implemented groundbreaking solutions that have significantly advanced the capabilities and efficiency of mainframe systems, creating a path for future innovations.
This award goes to Rene De Vleeschauwer from Kobee who provides out-of-the box DevOps (CI/CD) and Toolchain Orchestration for z/OS, monitors the VCR (GIT) and will upon codebase change initiate compile and promote processes according to the life cycle of the project. The DevOps processes may run on IBM Wazi and production on the on-premise mainframe, integrating modern IDE’s with JIRA, GIT and IBM DBB, IBM Wazi Deploy and much more, with a plug and play implementation.