In the dynamic field of software development, integrating DevOps practices such as continuous integration (CI) is crucial, especially for enterprises utilizing iPaaS solutions like the Celigo platform (integrator.io).

For builders working with the Celigo platform, integrating with external source code versioning solutions like GitHub serves as a robust framework for storing integration code in a centralized repository. This setup not only facilitates seamless collaboration across various teams, including development and QA, but also aligns with the company’s broader DevOps best practices.

By using various tools provided by Celigo, such as different platform APIs to interact with components, organizations can manage their integration processes more effectively. These tools enable an automated workflow where code can be consistently managed and updated, enhancing both transparency and efficiency in development processes.

This article will cover several key areas to provide a comprehensive understanding of effective integration management using Celigo. 

We will discuss:

• An overview of the integration lifecycle management features within Celigo. 
• The critical role of external code versioning systems and why they are essential for maintaining code integrity and facilitating team collaboration.
• A detailed example of a CI/CD pipeline, demonstrating how to use Celigo’s API for downloading integration packages, using a GitHub repository for code storage, and employing GitHub Actions to automate workflows.
• Specific workflows include the repository dispatch event workflow, which triggers actions based on external events, and the release workflow, which handles the building of the deployable package after a merge operation with the base code.

This guide will provide you with a practical example to help you improve your integration processes by effectively following the best DevOps practices.

Overview of Celigo’s integration lifecycle management 

Integration lifecycle management (ILM) is a crucial feature on the Celigo platform, providing users with a Git-style method for managing the software development lifecycle of integrations through operations such as push, merge, and commit.

Many Celigo users are already familiar with the “revisions” section, where you can create “snapshots” that act as backups. Builders can pull a specific revision, revert to a particular revision, and more.

Why use external code versioning?

Adopting an external code versioning system such as Git offers several distinct advantages for developers working with integration components in the Celigo platform.

Let’s uncover some of them:

Centralized code storage

It serves as a single source of truth for all integration code. This repository can be version controlled and audited, ensuring that changes are tracked and managed systematically. Such centralization is particularly beneficial for companies that include highly technical teams. Those less familiar with source control might prefer to use only the out-of-the-box ILM feature mentioned previously.

Multi-environment / multi-accounts deployment

Using a versioning system facilitates consistent deployment across various environments—including sandbox and production—and multiple accounts. This ensures that every team member, regardless of their environment, works with the same code version, which enhances the reliability and predictability of deployments.

Collaboration and testing

External versioning systems significantly boost collaboration among cross-functional teams, such as development and QA. They act as a staging area where these teams can efficiently share, review, and test code. However, it is advisable to avoid making substantial changes to the integration components outside of Celigo. This is because any changes made externally cannot be tested within the platform, posing risks to the integrity and functionality of the code. Despite this, such systems still play a crucial role in enabling seamless teamwork and improving overall project transparency.

This approach not only aligns with DevOps best practices but also reinforces the robustness of the integration management process.

CI/CD pipeline example using Github and Github actions

2. Next, the dispatcher event workflow will launch the tasks configured in job:

3. The merge of the pull-request will then trigger the second flow that will build the release.

This workflow has 2 Jobs {Prepare and Release}:

4. Our base code will be then updated in the repo:

5. And as a result of the second workflow, we will have a release with as assets, the zip of our integration, ready for deployment:

Celigo offers robust, developer-friendly features that enhance your code’s integrity and bolster collaboration within your teams. By integrating with external code versioning systems and leveraging comprehensive CI/CD pipelines, Celigo empowers you to streamline your integration processes effectively.

Following the practical guide and examples provided, such as utilizing Celigo’s API with GitHub for code storage and automating workflows with GitHub Actions, you can significantly improve your operations and adhere to best DevOps practices.

This approach ensures your projects are scalable, maintainable, and aligned with the latest industry standards for continuous integration and deployment.