Originally posted June 23 2014 | Visits (10965)

IBM UrbanCode Deploy orchestrates and automates the deployment of applications, middleware configurations, and database changes into development, test, and production environments. You can use IBM UrbanCode Deploy with IBM Integration Bus to automate the deployment of integration applications and configure the resources they depend on. You can also use IBM UrbanCode Deploy to automate the installation and configuration of the IBM Integration Bus runtime.

In previous articles, Imran and I have shown how to deploy IBM integration Bus to SoftLayer servers, and how to automate that deployment by using Chef and Chef Solo. In this article, I describe how to use IBM UrbanCode Deploy (UCD) to define environments, components and processes which use the IBM Integration Bus Chef cookbook to create an IBM Integration Bus runtime environment, and deploy an integration application to that environment as part of a continuous delivery approach. You can read more about reasons for using UrbanCode Deploy with Chef.

IBM UrbanCode Deploy describes what needs to be done to set up a set of systems using a model which includes the following elements:

  • agents which are software components installed on the target systems that allow remote deployment to those systems
  • components that contain the software that needs to be installed and processes that install and configure the software
  • applications which are collections of components along with a process that defines how the components are combined
  • environments which define for an application which components are installed on which systems, identified by their agents

In this article, I describe a procedure to provide continuous delivery for an integration application in three parts:

Part 1 prepare prerequisites:

  • Set up a UCD server with the Chef plug-in installed.
    To use the IBM Integration Bus cookbook with UCD, you must install the Chef plug-ins, as these are not there by default. This article does not cover the set up of UCD itself. To learn more about setting up UCD, review the UCD documentation.
  • Set up the target system ready for the UCD agent.
    This system will have the UCD agent and the IBM Integration Bus runtime and BAR file deployed to it. The UCD agent will also be used to download the Chef cookbook, and copy the product installation files into the UCD storage. This article describes the setup for a target machine which has the RedHat Enterprise Linux operating system.
  • Create an IIB_Chef_Test_Node agent, and install it on the target system.

Part 2 use UCD to automate the installation of the IBM Integration Bus runtime by using the IBM Integration Bus Chef cookbook:

  • Create an IIB_Chef_Cookbook component, which contains a clone of the IIB Chef cookbook from GitHub.
  • Create an IIB_Runtime_Using_Chef component, which contains the product install files, and a process that installs the IBM Integration Bus runtime by using the Chef cookbook.
  • Create an IIB_Chef_Test_App application, which combines the above components.
  • Create an IIB_Chef_Test_Env environment, which associates the IIB_Chef_Test_App application components with the IIB_Chef_Test_Node agent. When the above prerequisites are complete, the IBM Integration Bus runtime can be deployed automatically from UCD.

Part 3 use UCD to automate the deployment of the application BAR file by using IBM Integration Bus commands:

  • Create an IIB_Test_BAR component, which contains a BAR file, and a process that deploys the BAR file.
  • Update the IIB_Chef_Test_App application to include the IIB_Test_BAR component, and add its process to the application process.
  • Update the IIB_Chef_Test_Env environment to add the IIB_Test_BAR component to the IIB_Chef_Test_Node agent.
  • When the above prerequisites are complete, the IBM Integration Bus runtime and BAR file can be deployed automatically from UCD

Part 1: Prerequisites

In this part, I describe how to set up the UCD server to enable the use of Chef cookbooks, and set up a system on which software can be installed using Chef. These steps are required for any UCD automation that uses Chef, and are not specific to IBM Integration Bus.

Install Chef plug-in on the UrbanCode Deploy server

The procedure for installing plug-ins can be found in the UCD product documentation.  The available plug-ins, including the Chef plug-in can be found on the UrbanCode developerWorks page.

  1. Download the Chef plug-in from https://developer.ibm.com/urbancode/plugin/chef/. Click the Download button, and save the .zip file.
  2. In the UCD web console, select the Settings tab, on the right of the page.
    Tip: the IBM UrbanCode Deploy username which you use to log in to the web console needs to have administrative privileges in order to see the “Settings” tab.
  3. Click Automation Plugins in the first Settings section titled “Automation”.
  4. Click the Load Plugin button, then in the dialog box, click Browse… and locate the .zip file you just downloaded.
  5. Once this is complete you will see Chef in the list of automation plug-ins.  Clicking the Chef entry will show these details:
Set up the target system ready for the UCD agent

The target system is the machine on which we will install IBM Integration Bus and the example BAR file, using the UCD agent. The UCD agent requires Java to be installed on the target system. In this article we will also use this system to clone the IBM Integration Bus Chef cookbook, so it must have git installed on it. The target system described in this article has the RedHat Enterprise Linux operating system.

A quick and easy way to provision such a system is to create a Cloud Computing Instance on SoftLayer, by taking advantage of their 30-day free trial, although that server must have network addressability to your UCD server in both directions.

  1. Log in to the target system as root.
  2. Install Java and Git:
yum install java
yum install git

TIP: run yum update –y and deal with any conflicting packages on the target system before proceeding with the IBM Integration Bus install.

  1. Create a user, under which the UCD agent will run. I chose to call it “udeploy”:
useradd udeploy
passwd udeploy
  1. Use the visudo command to permit the udeploy user to run commands as root, and enable those commands to run without a terminal (explained in this link [http://pic.dhe.ibm.com/infocenter/ucdeploy/v6r0/topic/com.ibm.udeploy.doc/topics/arch_appx_sudo_using.html ]), by adding the following lines to the sudoers file.
udeploy (ALL)=ALL NOPASSWD: ALL
Defaults !requiretty

TIP: ensure that /tmp has enough free space. You can see how much space /tmp has by using the command: “df –h /tmp”. Mine was initially set to 1GB, which is not big enough for the IBM Integration Bus installation.  The df command shows the name of the volume group that contains /tmp, which in my case was /dev/mapper/basevg-tmp. To increase the size of /tmp by 5GB, I used the commands “lvextend –L +5g /dev/mapper/basevg-tmp” and then “resize2fs /dev/mapper/basevg-tmp”.

Create an IIB_Chef_Test_Node agent installed on the target system

The UCD agent is a software service that runs on the target machine, so that commands can be run on that machine remotely from the UCD web console.  The UCD agent itself can be remotely installed on the target machine. This procedure is described in the UCD product documentation.

  1. Log into the UCD web console, and create the new agent by navigating to the Resources tab, then the Agents sub-tab, and click Install New Agent:

  2. Enter the appropriate details for the target system:
  • the SSH username must be “udeploy” (as we defined earlier)
  • the host names of your target host and UCD server host
    TIP: Assign a Team, of which your UCD user is a member, to the agent so that you will have permission to view the agent once it is created.
  1. Add the agent as a resource.  Navigate to the Resources tab, and click Create Top-Level Group. Enter the name “IIB_Chef” and ensure that your team is identified as one of the teams:
  2. On the IIB_Chef resource group line, click Actions…, and then Add agent.
  3. Select the IIB_Chef_Test_Node agent, and click Save.

Part 2: Automating the IBM Integration Bus runtime installation

In this part I will use UCD to automate the installation of the IBM Integration Bus runtime by using the IBM Integration Bus Chef cookbook:

Create an IIB_Chef_Cookbook component

A UCD component represents a software dependency, something that must be copied or installed on the system where an application will run.

Integration applications are dependent on the IBM Integration Bus Chef cookbook, because it is used to install the IBM Integration Bus runtime. We therefore represent the IBM Integration Chef cookbook as a component called IIB_Chef_Cookbook, and use UCD to define and install that component wherever it is required.

The IIB_Chef_Cookbook component holds a clone of the IBM Integration Bus Chef cookbook on GitHub.  By having a local copy, you can control when the cookbook contents are updated. Alternatively, you could clone the cookbook on the target system as a component process step, but that might be less predictable, and dependent on an external system.

To create the IIB_Chef_Cookbook component:

  1. In the UCD web console, navigate to the Components tab and click Create New Component.
  2. Enter the details as shown in this screen capture, and click Save.  Note that the IIB_Chef_Test_Node agent is used to do the git clone; it is not done on the UCD server itself.

Once the component has been created, we need load the cookbook files into it.  This is done by importing a new version of the component files:

  1. Navigate to the Components tab.
  2. Select the IIB_Chef_Cookbook component.
  3. Navigate to the Versions tab
  4. Click the Import New Versions button.
  5. Enter “1.0” for Name to create the version with. Leave Specific Version/Tag empty.
  6. Click Save. This will run the git clone on the IIB_Chef_Test_Node agent. The files will be stored in the UCD server and you will see a “1.0” version in the list.  Click that link to see the files. If an error occurs, the import log should identify the issue.
Create a component process to install the cookbook

A component process describes the steps necessary to copy component files to a target system, and perform any actions on that system to complete the deployment. An example of creating a component process is described in the UCD product documentation.

For the IBM Integration Bus Chef cookbook, the process needs to download the cookbook files into an appropriate directory on the target system. For this example, the cookbook is downloaded to the agent work directory in a “chef/cookbooks/ibm_integration_bus” subdirectory.

  1. Select the IIB_Chef_Cookbook component.
  2. Click Create New Process.
  3. Name the process “IIB_Cookbook_Copy”
  4. Accept the other default values.
  5. Click Save.

Click the IIB_Cookbook_Copy process link in the list to open the process editor.

To create this process:

  1. Locate the Download Artifacts plug-in step in the Repositories/IBM UrbanCode Deploy folder and drag it on to the canvas between the Start and Finish steps.
  2. In the Edit Properties dialog, leave all default values; set the value for the working directory to:
    ${p:resource/work.dir}/chef/cookbooks/ibm_integration_bus
    then click Save.
  3. Wire the “Start” step to the “Download Artifacts” step by moving the mouse cursor over the “Start” step and then dragging the blue arrow to the “Download Artifacts” step.  This creates an arrow between the steps.
  4. Do the same to wire the “Download Artifacts” step to the “Finish” step.
  5. Click the blue diskette icon item under Tools to save the component process.
Create an IBM Integration Bus_runtime component

The IBM Integration Bus BAR files are dependent on the IBM Integration Bus runtime, so we must represent the IBM Integration Bus runtime as a component, and use UCD to define and install that component where it is required.

The files that are needed for the IBM Integration Bus runtime component are:

  • The IBM Integration Bus install image.
    The Chef cookbook can download the image from a supplied URL, but if it already exists in the correct place on the file system, it can use the image directly. For this example, the install image is stored in the component, and downloaded to the target system before the Chef recipes are run.  The product install image used in this example is the IBM Integration Bus v9 for developer’s Runtime install package.  Choose the “Multi package” download, and then download the “IBM Integration Bus (Runtime) for Linux on x86-64”. The file is called “9.0.0-IIB-LINUXX64-DEVELOPER-RUNTIME.tar.gz.
  • A Chef node file, “nodes/iib_node.json”.  This is used to provide properties to the Chef recipes to define how the IBM Integration Bus runtime is installed and configured.
    In this article, the node file uses the default IBM Integration Bus names and topology.
    The package_site_url property is mandatory and has to be an absolute URL. The value will not be used by the recipe because the file will already be present in the expected location. Set the property to “http://unused”.
    The account_username property defines the user name under which IBM Integration Bus will be installed.  This must be different from the agent username, so in this article I use “iibuser”.
    The iib_node.json file must contain the following information:
{
  "run_list": [ "recipe[ibm_integration_bus::runtime]" ],
  "ibm_integration_bus": {
    "package_site_url": "http://unused",
    "package_name": "9.0.0-IIB-LINUXX64-DEVELOPER-RUNTIME.tar.gz",
    "account_username": "iibuser"
  }
}

TIP: If you want the IBM Integration Bus integration node or WebSphere MQ queue manager created with different names, you can specify a node data item which provides those details, as described in Creating a custom integration node setup on a virtual machine using Chef.  These details could be hard-coded in the data item file, or the component process could generate the file based on environment variables.

  • A Chef solo.rb file. This contains properties for Chef to define the cookbook and working directory locations. Define the cache directory as the working directory and cookbooks located in the “cookbooks” subdirectory, by adding the following information to the solo.rb file:
root = File.absolute_path(File.dirname(__FILE__))
file_cache_path root
cookbook_path root + '/cookbooks'

Import the files by putting them in a location visible to an agent. For simplicity, I’ve chosen to use the same IIB_Chef_Test_Node agent that I created earlier, and put the files in a shared directory that’s accessible from the target system on which the agent is installed.

Create a “components/iib/9.0” directory on the shared directory (or a local directory on the target system).  Copy the IBM Integration Bus install image (9.0.0-IIB-LINUXX64-DEVELOPER-RUNTIME.tar.gz) to that directory. Create the solo.rb file in that directory, and the iib_node.json file in a “nodes” subdirectory. You should have:

components\iib\9.0\solo.rb
components\iib\9.0\9.0.0-IIB-LINUXX64-DEVELOPER-RUNTIME.tar.gz
components\iib\9.0\nodes\iib_node.json

Create the “IIB_Runtime_Using_Chef” component (Components -> Create New Component), with the properties shown in the screen capture.  For the Base Path value, substitute the full path of the “9.0” directory (as written above).  Don’t include the “9.0” in the directory name, because this is the version number and is automatically added by UCD when you import the component files.

After you create the component, import the files by navigating to the Versions tab and selecting Import New Versions.  When complete (it may take a while to upload the 1.1GB file), click on the “9.0” version. You will see the following files:

TIP: if you made any errors in the iib_nodes.json or solo.rb files,, you can delete the version and re-import it if you’ve not used this component in an application. However once a component is used in an application, you must create a new version for any changes. Rename the “9.0” directory to “9.1”, and make your changes to the file, then click Import New Versions.

Create a component process to install IBM Integration Bus using the Chef cookbook
For the IIB_Runtime_Using_Chef component, the process for performing the installation consists of three steps, as shown in the screen capture.

Here we will perform similar actions as for the previous component process, adding a couple of extra steps using the Chef plug-in installed earlier.  To create the component process:

  1. Select the IIB_Runtime_Using_Chef component by clicking its name on the Components tab.
  2. Click Create New Process.
  3. Name the process “IIB_Install Runtime”.
  4. Accept the other default values.
  5. Click Save.

Next, click the IIB_Install_Runtime process link in the list.  This opens the process editor. To create the process:

  1. Locate the Download Artifacts plug-in step in the Repositories/IBM UrbanCode Deploy folder, and drag it on to the canvas.
  2. In the Edit Properties window, leave all default values and set the working directory to: ${p:resource/work.dir}/chef then click Save.
  3. Locate the “Install Chef” plug-in step in the Automation/Chef folder, and drag it on to the canvas.
  4. In the Edit Properties window, select Use Impersation, enter “root” for the user, and select Use Sudo. This will ensure that required permissions are available to perform the install of the Chef software. Leave all other values as the default.
  5. Locate the “Install Chef Node” plug-in step in the Automation/Chef folder, and drag it on to the canvas.
  6. In the Edit Properties window, enter the values as shown in the screen capture:
  7. Wire the “Start” step to the “Download Artifacts” step by moving the mouse cursor over the “Start” step, and then dragging the blue arrow to the “Download Artifacts” step.  This creates an arrow between the steps.
  8. Similarly wire the “Download Artifacts” step to the “Install Chef” step, that to the “Install Chef Node” step and that to the “Finish” step.
  9. Click the blue diskette icon item under Tools to save the component process.

TIP: You can have steps execute in parallel by wiring them both to a previous step. In this component process, you could wire both the “Download Artifacts” step and “Install Chef” step to the “Start” step, because they do not depend on each other. The “Install Chef Node” step has to run after both of these steps, so would need to be wired from both previous steps.

Create an IIB_Chef_Test_App application that combines the IIB Chef_Cookbook and IIB_Runtime components

An application represents a collection of components with a process that describes how to install each component.  An application also has one or more environments, which describe the relationship between the components and the systems to deploy to, identified by their agents. For a multi-system deployment, it is possible to create an environment with multiple agents and associate appropriate components with each agent. For this example, we have a single agent with both components.

To install IBM Integration Bus by using the Chef cookbook, we must create an application which combines these components and associates them with the IIB_Chef_Test_Node agent in an environment.

To create the application and add the components to it:

  1. Click the Applications tab.
  2. Click Create New Application.
  3. Name the application “IIB_Chef_Test_App”
  4. Add your team to the list of teams that have access to the application. Your team might already be listed by default.
  5. Click Save.
  6. Click “IIB_Chef_Test_App” in the list of applications.
  7. Select the Components tab for the application.
  8. Click Add component.
  9. Select the IIB_Chef_Cookbook component, and click Save.
  10. Repeat the previous two steps for the IIB_Runtime_Using_Chef component.

Now create an environment that associates these components with the IIB_Chef_Test_Node agent:

  1. Select the Environments tab for the application.
  2. Click Create New Environment.
  3. Name the environment “IIB_Chef_Test_Env”
  4. If your team is not listed, add your team to the list.
  5. Click Save.
  6. Click the “IIB_Chef_Test_Env” environment name in the list.
  7. Click Add Base Resources.
  8. Locate the “IIB_Chef_Test_Node” agent inside the “IIB_Chef” resource group, and select the check box next to the agent. Click OK.
  9. On the agent row in the resources table, click on Actions… and Add component. Select the IIB_Chef_Cookbook component.
  10. Repeat the previous step for the IIB_Runtime_Using_Chef component.

You now have an environment definition for the IIB_Chef_Test_App application which identifies that both components will be deployed to the IIB_Chef_Test_Node agent.

Create an application process that installs the IBM Integration Bus runtime using Chef

To deploy multiple components within an application, you must define the process. The process for the IIB_Chef_Test_App simply runs the component processes in the correct order.  To create the application process:

  1. In the IIB_Chef_Test_App application view, select the Processes tab.
  2. Click Create New Process.
  3. Name the process “IIB_Chef_Install”, and click Save.
  4. Click the “IIB_Chef_Install” process link in the table.
  5. Drag the “Install component” step onto the process canvas.
  6. In the Edit Properties window, select the “IIB_Chef_Cookbook” component. Leave everything else as the default values.
  7. Repeat the previous two steps for the IIB_Runtime_Using_Chef component.
  8. Connect the steps, as shown in the screen capture.
  9. Click Save.
Test Deploying the application

You can now test everything that has been configured so far, to deploy an IBM Integration Bus runtime to your target system. To deploy the application:

  1. Navigate to the main Applications tab
  2. Click the “IIB_Chef_Test_App” link in the table.
    You should now see the Environments tab:

  1. Click the grey arrow icon, highlighted in the above screen capture. This requests that the application process is run for the given environment.
  2. In the Run Process window,  clear Only Changed Versions, then click the “Choose Versions” link.
  3. Click Select for All…, and select Latest Available.
  4. Click OK to accept the selected versions.
  5. Click Submit to start the deployment.

You will now see the process steps running.  For each step, you can expand the list and see the console to see progress and identify any issues.

TIP: if you see errors installing 32-bit libraries, this is likely to be a multilib issue. The usual cause is that the target system has two versions of a 64-bit package, which prevents the installation of the 32-bit package. To resolve this, you must uninstall one of (usually the older of) the 64-bit packages.

If the deployment is successful, you’ll see the following by expanding all the steps:

You can verify the deployment by connecting to the IBM Integration Bus Web Administration console on the target system, by pointing your browser to http://<target system host>:4414/

Part 3: Automating deployment of a BAR file

The components and processes defined in Part 2 can be reused for every target system on which you need the IBM Integration Bus runtime installed, and typically will not change often. This part of the article makes use of these components to extent the deployment to include an integration application, packaged as a BAR file, which is the unit used to deploy workload for IBM Integration Bus.  For this article, I used a simple BAR file which contained an “echo” Integration Service implemented as a web service which just returns the message sent to it.  I’ll verify its deployment by requesting the WSDL document from the integration service’s URL.

TIP: The approach taken here is to add the BAR file as a component to the existing “IIB_Chef_Test_App” application.  An alternative approach would be to create a separate application for each BAR file, so that the deployment can be managed separately from the IBM Integration Bus runtime.

Create an IIB_Test_BAR component for a BAR file

The example BAR file must be represented as a component in UCD. This component will hold the BAR file, and define the component process which will deploy the BAR file in a system which has the IBM Integration Bus runtime installed.

As with the previous part, for simplicity the BAR file is imported into the UCD server using the IIB_Chef_Test_Node agent, placing the BAR file in a shared directory that is visible to the Sgent.  I put the BAR file into a subdirectory called “apps/echo/1.0”.

Create the IIB_Test_BAR component as before from the Components tab with Create New Component, and enter the following information, setting Base Path to the full path of the “apps/echo/1.0” directory, but not including the “1.0”:

Import the BAR file. Click on the Versions tab and Import New Versions, which should result in the creation of a “1.0” version of the component.

Next create a component process to install the BAR file into an existing IBM Integration Bus runtime. Some of the steps here will be common to all BAR files, but there usually are additional steps, such as creating queues and databases, that are required for a specific BAR file.

Note that there is a “WebSphere Message Broker” plug-in for UCD which includes a process step to deploy a BAR file.  I’ve chosen here to use the IBM Integration Bus commands directly to illustrate their use from a Shell script.

The component process consists of three steps:

  1. Download the component artifacts, i.e. the BAR file, into the agent’s working directory
  2. Run a shell script that moves the BAR file into the “iibuser” user’s home directory, and makes it visible to “iibuser” (remember that the IBM Integration Bus runtime was installed under this username).
  3. Run a shell script which checks that the IBM Integration Bus integration node is running, and then deploys the BAR file by using the “mqsideploy” command.  These commands must run as user “iibuser”. However, the agent has no visibility of that user’s files, and vice-versa, so run the step as root, and then in the shell script, use the “runuser” command to run the commands as “iibuser”.

Create the component process as follows:

  1. In the IIB_Test_BAR component view, select the Processes tab
  2. Click Create New Process.
  3. Name the process IIB_Deploy_Test_BAR and click Save.
  4. Click the “IIB_Deploy_Test_BAR” process link in the table.
  5. Drag the “Download Artefacts” plug-in step from the Repositories/IBM UrbanCode Deploy folder onto the process canvas.
  6. In the Edit Properties window, click Save to use the default values.
  7. Drag the “Shell” plug-in step from the Scripting/Shell folder onto the process canvas.
  8. In the Edit Properties window, name the step “Move BAR file”.
  9. Enter the following commands into the “Shell Script” field:
cp echo.bar /home/iibuser
chown iibuser:iibuser /home/iibuser/echo.bar
  1. Select Use Impersonation.
  2. Enter “root” as User, select Use Sudo, then click Save.
  3. Repeat steps 7 to 11 for the “Deploy BAR file” step, using the following commands in the “Shell Script” field:
runuser -l iibuser -c 'mqsistart IB9NODE'
runuser -l iibuser -c 'mqsideploy IB9NODE -e default -a echo.bar'
  1. Connect the steps as shown in the screen capture.
  2. Save the component process.
Add the example BAR file component to the application

To deploy the BAR file, the IIB_Test_BAR component must be added to the IIB_Chef_Test_App application and its environment:

  1. Navigate to the Applications top-level tab
  2. Select the “IIB_Chef_Test_App” application by clicking its name.
  3. Navigate to the Components sub-tab, click Add Component.
  4. Select the “IIB_Test_BAR” component, and click Save.
  5. Navigate to the Environments sub-tab of the IIB_Chef_Test_App application.
  6. Select the “IIB_Chef_Test_Env” environment by clicking its name.
  7. On the IIB_Chef/IIB_Chef_Test_Node line in the table, click Actions… -> Add Component.
  8. Select the IIB_Test_BAR component, and click Save.  The Resources tab for the environment should now look like this:

Next, update the IIB_Chef_Test_App application process to include the BAR file deployment step:

  1. Navigate to the Applications top-level tab
  2. Select the “IIB_Chef_Test_App” application.
  3. Navigate to the Processes tab.
  4. Select the “IIB_Chef_Install” application process by clicking its name.
  5. Drag the “Install Component” step on to the process canvas.
  6. In the Edit Properties window, select the “IIB_Test_BAR” component then click Save.
  7. Connect the new “Install Component” step between the “Install IIB_Runtime_Using_Chef” step and the “Finish” step.
  8. Save the updated application process.

The IIB_Chef_Test_App application is now fully configured and ready to deploy.

Deploy the BAR file using the environment

Now that all configuration is complete, you can test the deployment of the “IIB_Chef_Test_App” application as in part 2.  This time the additional step will run, and the BAR file will be deployed to the IBM Integration Bus runtime.  For my example “echo” BAR file, I can point my browser at http://<target system host:7800/Echo/Echo?wsdl and see the WSDL document for the service to verify that it did install.

Conclusion

This series of articles has shown how the IBM Integration Bus Chef cookbook can be used in a variety of ways to simplify and automate the installation of the IBM Integration Bus runtime.  In this article, we’ve taken this one step further, by combining the cookbook with IBM UrbanCode Deploy to define an environment that includes the IBM Integration Bus runtime as well as an IBM Integration Bus integration application with automated deployment. Additional capabilities of IBM UrbanCode Deploy such as versioning, variables, and multi-system environments, build on this simple case to provide a powerful continuous delivery environment for applications running on IBM Integration Bus and other run time components.

Tags:  installation cloud broker chef ibm-integration-bus continuous-delivery integration iib ibm-integration

Join The Discussion

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