Integration Lifecycle Management: Best practices for integration deployment

Managing integration deployment efficiently is crucial in today’s dynamic digital landscape. Celigo’s Integration Lifecycle Management simplifies the deployment process, offering tools that ensure integrations are developed, tested, and deployed with minimal risk.

This guide covers best practices for deployment using ILM, focusing on sandbox testing, cloning integrations to production, and the pull/merge process, which includes the ability to ignore specific resource fields when necessary.

Intro to Integration Lifecycle Management

Integration Lifecycle Management (ILM) within Celigo’s integrator.io provides a powerful toolkit for managing the entire lifecycle of custom integrations. From creating backups to testing in sandbox environments and seamlessly deploying to production, ILM helps ensure smooth transitions between development and live environments.

For example, say you want to integrate Salesforce and NetSuite to sync “Accounts” and “Opportunities.” With ILM, you can build, test, and deploy this integration without risking disruption to your current production systems.

ILM in under 5 minutes

1. Snapshot management: Creating and reverting versions

Snapshot management is a key feature of ILM. It allows you to capture the state of your integration at any point in time.

Snapshots preserve configurations, field mappings, and other important settings, giving you a fallback option if something goes wrong during the update process.

Best practices:

• Create snapshots before major updates: Always create a snapshot before making significant changes to your integration. For example, save a snapshot titled “Backup v1.0” before modifying or updating the configuration.
• Revert easily when needed: If new changes lead to errors, reverting to a previous version is simple. Use the three-dot menu in the revisions tab to select and revert to a previous snapshot, ensuring continuity in your integration.

Snapshots are critical for maintaining the stability of your integrations, especially during larger-scale updates.

2. Developing and testing in a sandbox environment

In an ideal workflow, create and test integrations in a sandbox environment to fully vet updates before introducing them to production.

Best practices:

• Build in sandbox first: Begin by developing your integration in a sandbox. This allows you to safely configure and test new features, such as a Salesforce integration with NetSuite to send “Account” and “Opportunity” information, without impacting your live environment.
• Test extensively before production: Test the integration thoroughly, including all workflows and edge cases, before considering deployment. Ensure that your data flows and error handling work as expected. The sandbox should be a fully isolated environment where you can experiment freely.

This approach ensures that all changes are vetted and tested before they affect the live production environment, minimizing potential disruptions.

3. Cloning and deploying to production

After successfully testing your integration in the sandbox, the next step is to clone and deploy the tested integration to the production environment. ILM makes this process straightforward and reliable.

Best practices:

• Clone your tested integration to production: Once your integration has passed sandbox testing, clone it directly into your production environment. This ensures that all the tested configurations are carried over without needing to rebuild the integration from scratch.
• Double-check environment-specific settings: After cloning, review any environment-specific configurations or production-specific settings to ensure they are correct for the live system.

Cloning from sandbox to production streamlines the deployment process, reducing errors and ensuring consistency between the two environments.

4. Pull and merge: Creating a pull and reviewing changes

One of ILM’s key features is the pull and merge process, which allows you to transfer changes from your sandbox into the production environment. This process ensures that only the desired changes are moved, with the ability to review and control the updates before finalizing them.

To make further changes or enhancements to an integration, it’s best practice to implement and test modifications in a sandbox environment before deploying them to production. This approach allows thorough validation, helping identify and resolve potential issues without affecting live data or workflows.

Create a pull:

After you’ve completed testing in the sandbox and are ready to deploy to production, use ILM’s “create pull” feature to bring changes from the sandbox into your live system.

Steps to create a pull:

1. Navigate to the revisions tab: In your production environment, go to the revisions tab to view all recent changes.
2. Initiate a pull: Select the option to create a pull from the sandbox environment. This action starts the process of importing all updates that were made and tested in the sandbox.

Review changes:

Before merging the changes into production, ILM allows you to review every change brought over from the sandbox. This step ensures you know exactly what will be modified.

Best practices for reviewing changes:

• Examine differences: Review a detailed comparison of the current production version and the sandbox version. Check field mappings, flow changes, and other updates that may impact the production environment.
• Leverage selective merging: During the review, you may come across fields such as relativeURI, savedSearchId, or other environment-specific configurations that should remain unchanged in production. The “ignore resource” fields in a pull feature allows you to exclude these fields from being updated during the merge process, ensuring sensitive data and configurations remain intact.

Merge changes:

Once you’re satisfied with the review and have made any necessary adjustments, you can merge the changes into production.

Steps for merging:

1. Finalize your review: Confirm the pull after reviewing the changes and ensuring all critical fields are handled appropriately (including ignoring any necessary fields).
2. Complete the merge: The changes are now merged into your live production environment. Ensure that everything functions as expected after the merge is completed.

Following this structured pull and merge process, you will maintain full control over which changes are deployed to production and can prevent unintended overwrites of sensitive fields.

5. Rollback strategies: Quick and efficient reversions

If an issue arises post-deployment, it’s essential to have the ability to quickly revert to a previous version. ILM makes this rollback process fast and efficient by automatically creating snapshots of before and after merge

Best practices:

• Maintain up-to-date snapshots: Ensure that you have recent snapshots available so that you can revert to the last known stable configuration if issues arise.
• Use the revert option: Access the three-dot menu in the revisions tab and revert to a previous version. This allows you to immediately restore the integration to a stable state.

A rollback plan ensures you can quickly respond to any deployment issues and minimize downtime.

Optimizing your deployment with ILM

Celigo’s ILM provides a comprehensive framework for managing integrations throughout their lifecycle. By adhering to these best practices, you can streamline your deployment process and maintain system stability.

ILM allows teams to innovate quickly while reducing the risk of errors and disruptions in production. For additional guidance on optimizing your deployment processes or leveraging ILM’s advanced features, contact your Celigo account team.

Additional ILM resources

• Integration Lifecycle Management (ILM) overview – This document provides a comprehensive overview of ILM, including version control, release management, and git-style features for building and managing integrations.
• Practicing lifecycle management – This guide offers insights into using ILM to manage integration lifecycles, covering scenarios for stable state rollbacks, testing, and managing integration development across teams.
• Integration Lifecycle terminology – A glossary of terms commonly used in ILM, including key concepts like clones, conflicts, snapshots, and revisions.