Introduction

This article explains how to migrate existing on-prem code and run it on webMethods.io Integrations.

Audience

It is assumed that readers of this article know how to create integrations on Webmethods.io Integration.

Pre-requisite

• webMethods.io Integration tenant with DADA capabilities enabled.
• On premise Integration server package
• Any external git like Azure Git, GitLab, GitHub. In our case, we are using GitHub repository account.
• Service designer.

Link: https://community.ibm.com/community/user/integration/viewdocument/ibm-webmethods-serv[…]ey=82b75916-ed06-4a13-8eb6-0190da9f1bfa&tab=librarydocuments

  What is DADA?

      The Develop anywhere and deploy anywhere (DADA) provides the flexibility to use      webMethods  on prem existing code and run the same in a runtime deployed in cloud or onpremise.  This allows customers to deploy their code into runtimes in cloud or on their on premise/network and monitor them.

Please refer below link for more : 

https://community.ibm.com/community/user/integration/blogs/john-carter/2023/10/20/what-is-develop-anywhere-deploy-anywhere

Use Case         

• Imagine a banking customer say BANAB bank has been leveraging the on-Premise setup of webMethods Integration server.
• BANAB Bank is responsible for issuing credit cards to its customers.
• The credit card issuance process involves invoking multiple third-party backend services to gather the necessary details for generating the credit card.
• These services include salesforce, co-branding service, security data service, delivery partner service and many more services like this
• To achieve above business usecase client has developed the application using Integration server running on self-hosted environment.

•  Please refer the above image for overview architecture of their existing setup

         Target Architecture

• We are deploying the code to the nearest location where the third-party services running to reduce the latency.
• Removing the pain of maintaining infra as the new code will be deployed on iPaas platform. So, all the infra related upgrades will be taken care by IBM team.

    Migration path

• Create the project in webMethods.io Integration cloud and Let us name it as “DigitalCardIssuance”.
• Analyze the assets developed on Integration server using cloudAnalyzer.
• Create an external git account
• Create the personal access token    
• Push the code to the external repository.
• Configure the version control using personal access token on webMethods.io Integration
• Pull the assets on your project.
• Create the Integration runtimes
• Create the flow service to orchestrate the flow.
• Run the flow service.

Run Cloud Analyzer :

• Install cloud analyzer package on your self-hosted setup Integration server.
• Run the tool to generate the report.
• Then the generated report can be analyzed to see what all assets are available on Integration server and we can also see if there are any assets which are not compatible with cloud.

• In our case we have all the assets compatible, therefore no refactoring of code required before we push the code to GitHub.

  Note:

Github link: https://github.com/SoftwareAG/WxCloudReadinessAnalyzer.git

Bring on prem Assets to cloud

• We will push all the packages to the GitHub.
• Each package refers to each git hub repository.
• Make sure the package name and git hub repository name are same.
• To import packages to the cloud we need to get the github token .
•  Generate the GitHub classic token and configure the version control on your IBM webmethods tenant under setting section.

Create GitHub token:

• To import the packages we need to get the PAT from the our external repo.
• In our case we are using GitHub as an external repo.
• Login to GitHub and navigate to setting sections.

• Under setting section click on Developer setting.

• Click on token classic

• And then generate the classic token with proper expiry date.

Push the on prem assets to external REPO

• Create the repo for each package and then push the package from on prem to GitHub.

Note:

• The package we want to push should be first analyzed using cloud analyzer.
• If there are any dependencies on the package then it should be added under the package dependencies explicitly.
• In our case we using the Salesforce, and WmJDBCAdapter package in our package implementation. Then these dependencies should be added.
• Refer the screenshot for same.

Setup version controls and imports external packages in webMethods.io Integration

• Under the user icon click on settings.

• Click on version control tab.

• Provide the details to add the external repo.

• Once you provide the details click Validate.
• If the token and other details will be added to the you tenant. 
• For more details refer the below documentation link: https://docs.webmethods.io/saas/webmethods-integration/11.0.10/develop_anywhere_deploy_anywhere/git_account/

Pull the packages from the external repository

• Navigate to the project where you want to pull the assets.
• Under project go to the packages tab and click Add package.
• Select the GIT as source. 

• Provide the github repo url for which you need to pull the assets.
• Select the branch and click pull.

Now we can see the list of external packages 

• In the above screenshot DigitalCardIssuanceStageProject is my webMethods.io Project
• And rest all our third packages pulled from GitHub version control
• When we have imported the package then the dependent package will also get pulled in the backend.
• For example in our case we have added the WmJDBCAdapter and WmSalesforceRESTProvider package as dependent package, then it got automatically pulled.
• We can verify under the package information.

Note:

•  The way we need to place the jar file to work with WmJDBCAdapter on our self-hosted setup. In similar fashion we need to upload same on cloud iPaas platform.
• In our case we are using the jar file for JDBC adapter on our on prem setup therefore we will now upload the same file in our cloud project “DigitalCardIssuanceProject ” under the library section.

• Now when we have imported the assets on webMethods.io Integration.
• We need to decide on which runtimes we want to run.

What is Integration Runtimes?

• IBM’s webMethods Integration platform provides a modern, innovative approach to integration architecture through its unique “Develop Anywhere, Deploy Anywhere” approach. This architectural approach allows you to run integrations that can be distributed throughout the extended enterprise, with centralized management and monitoring.

• Please refer to the link below for more details.

https://community.ibm.com/community/user/integration/blogs/theo-ezell/2025/03/07/develop-anywhere-deploy-anywhere-what-are-integrat

https://docs.webmethods.io/saas/webmethods-integration/11.0.10/develop_anywhere_deploy_anywhere/deployanywhere_integrations/#co-additional_options

• In our case we have requirements to have both cloud runtimes and well as edge runtimes.

Steps to setup the edge runtime

• Click on Integration runtimes
• Click on Add + button
• Select the webMethods Edge Runtime

•  Pull the edge runtime image from the container registry

• Click on start pairing.

• Copy the command and execute it where you want to run your edge runtime.

• In our case I am executing it on my local machine where my Integration server is running. 

• Now when we have the on prem assets available on cloud lets orchestrate it on cloud and configure where to run the assets.

Orchestration

• Create a flow service and name it as “cardIssuancepublicServices”.
• Invoke the package service inside the flow service and select the runtime where you need to execute it.

• In our case we are going to invoke the salesforce service on CRT (cloud runtime).
• JAVA service. Card security service and SQL DB service on ERT (edge runtime).

Configure the Connectors

• Inside the project navigate to connector tab.
• Click on Deploy Anywhere tab.
• In our case we are using Salesforce cloudstream connector and JDBC connector.

• We should be able to see both of them under this tab.
• In our case we have to run the salesforce connector on CRT, Therefore select the salesforce connector and Add CRT runtime.
• Click on manage runtimes.
• Provide the secret details like ClientID, client secret, access token and refresh token.

• Click on save
• Now sync the connector details to the CRT by clicking in the gear icon.
• Follow the similar steps for JDBC adapter but in this case select the edge runtime instead of CRT.
• Note: When we do sync these connector details are saved to manifest file in the backend.

Test

• Now run the flow service.
• In the screenshot below we can see the service is invoked and different services ran on different runtimes as configured during design time.
• We can see the invocation details for these services on their respective runtimes.

Note: Attached the sample package used for this use case.