Building an Elastic SIP Server with WebSphere, XAP and Cloudify
WebSphere and XAP are sometimes considered competing products, when in reality, XAP can be fairly complementary to WebSphere in various areas.
In this post I will share a specific customer use case which required the integration between the two products. I’ll start with the motivation and end with the technical details that describe the actual integration.
There are basically two parts to the integration process
1. Integration with In Memory Computing based on XAP
2. Integrating WebSphere with Cloudify to automate the deployment of both WebSphere and XAP on a bare-metal environment and on private or public cloud.
I’ll start first with the motivation that led the customer in search of such an integration in the first place.
WebSphere is considered one of the more widely adopted JEE containers in many enterprises. WebSphere has a rich set of applications and services that are bundled with the product.
In this specific case, the product of interest was the SIP server, which is basically a web container that supports the SIP protocol. SIP (Session Initiation Protocol) is a signaling protocol used to create, manage and terminate sessions in an IP-based network. A session could be a simple two-way telephone call or it could be a collaborative multi-media conference session.
As the customer was interested in managing the state of the calls and storing the session information in a latency sensitive environment, they were interested in moving towards In Memory Computing.
XAP was able to fill the customer’s needs with transaction support, data persistency and event processing using features such as – event containers and remote services.
Putting the two together basically creates a more scalable and performant SIP server.
Having said that one of the area’s of complexity associated with integrating any separate product is related to the number of moving parts and lack of consistent management.
This is where Cloudify comes in, making the deployment and installation of all system parts easy to control and maintain. Cloudify provides control over all parts of the system, enabling scalability and fail over capabilities.
A by product of this integration (which proved to be valuable for future versions of this product) was the cloud support, provided by simply using Cloudify which can install any app on any cloud.
And now to the technical side of how all this fits together:
Integrating XAP with WebSphere
* XAP is packaged as processing units. Processing units are basically an extension of SpringContainer coupled with logic that makes the injection of XAP In Memory Data Grid simpler. In this case, we did not use the XAP extension of the Spring containers, but the out of the box Spring container. To do that we follow these steps:
# Set up WebSphere to use Spring
# Set up our Spring container in a way that it could inject and reference XAP In Memory Data Grid as part of its Beans.
* XAP runs as a separate cluster that may or may not share the same machines as the WebSphere servers. XAP consists of two main parts:
# A Clustered Proxy – this is the client side library that maps the the calls from the WebSphere Sip server to the relevant XAP In Memory partition.
# XAP Cluster – the actual memory containers that manages our data.
* Each WebSphere service becomes a stateless service as the entire session state is now stored in an external memory cluster managed by XAP. In this way, we can bring WebSphere instances up or down without losing our call session information. XAP itself is set to be elastic; we can add more XAP nodes elastically and XAP will rebalance itself to make use of the readily available memory resources.
* Cloudify automates the installation and scaling of applications on various environments. Cloudify uses a DevOps/Recipe – based model as the interface for managing each application. To integrate WebSphere with Cloudify, we needed to create a Websphere recipe. The minimal step for creating a WebSphere recipe involves wrapping our life-cycle scripts i.e. start, stop with a Cloudify Service Recipe :
To view the full recipes click “here”:https://github.com/aharonmoll/cloudify-recipes/tree/master/services/wlp.
* For more advanced use of Cloudify, it is recommended to also add custom metrics. Custom metrics allows us to monitor some of the key performance indicators through the Cloudify management console. Beyond monitoring, we can use those metrics to take actions. For example, we can monitor the number of active calls and scale the number of WebSphere instances dynamically to meet the scaling demand.
* In the same way, we can build a “LoadBalancer”:https://github.com/aharonmoll/cloudify-recipes/tree/master/services/apacheLB or XAP recipe, as both XAP and Apache are already pre-integrated with Cloudify.
The benefits of this integration:
# Continuous availability
# Full automation
# Cloud ready