There are some things with WebSphere PortalServer that work well and are well documented. There are other things that are well-documented and work well in theory. There are still other things that have okay documentation and will work well when all of the WebSphere stars are aligned. Depending on your implementation, Portal Clustering can fit into all three categories.

De-Mystification
Given the broad range of configurations open to an infrastructure planner when dealing with WebSphere software, it's no wonder that there's often a good deal of confusion when it comes to making a complex product like Portal highly available. Naturally, there can be no single "Learn Clustering in 20 Minutes" manual that conveys all knowledge. But there are some general steps to follow and some to avoid.

Let's start with a very basic explanation of the WebSphere Cell and how the Portal fits into it (see Figure 1).

A basic install of WebSphere AppServer is often on a single machine, typically referred to as a node. A simple enterprise infrastructure might include several AppServer nodes each performing their own tasks. As the infrastructure evolves and grows more complex, the need arises to simplify operational management of the multiple nodes. The Network Deployment incarnation of WebSphere Application Server lets you centrally manage and control multiple Application Servers. The configuration of the security parameters, user directories, JNDI resources, etc. is greatly simplified by this centralized operational management. Instead of deploying code to three different WebSphere machines, I can now deploy once and have the Network Deployment services distribute the code for me. The combination of the Network Deployment Manager and the Application Servers it manages represent the WebSphere Cell (see Figure 2).

The process of adding Application Server nodes to the cell is called federation. Its opposite, unfederation, describes removing a node from a cell and returning it to standalone status.

The Deployment Manager communicates with cell members via a small JVM called the nodeagent located on each of the managed nodes. The Deployment Manager will keep track of all configuration changes occurring and utilize the nodeagents on the federated nodes to "synchronize" the configurations so that they all represent what is defined in the master configuration on the Deployment Manager itself.

In many respects Portal is no different than any other Web application that would be configured to run in a WebSphere Cell. Just like a regular Web app, I could choose to run Portal on a single node in the cell or on multiple nodes or even have multiple instances running on a single node (see Figure 3).

Unlike a regular Web application, Portal utilizes several other services that aren't part of the regular WebSphere Application Server product set. As such, there's a completely separate installation that must exist on each node that you want to run Portal.

A Network Deployment infrastructure consisting of several WebSphere AppServer nodes gives you tremendous advantages that could (and do) fill entire Red Books. For purposes of the Portal, there are four that are of primary importance:

• Simplification of operational management
• Central management of Portal configurations
• Highly available environment
• Session and cache data replicated between all Portal nodes

Which Way to Cluster?
Starting with Portal 5.1, there are two ways to establish a cluster of Portals. The first way is to build a WebSphere Cell of multiple federated nodes and then install Portal onto each node in the existing cell. The second way is to take a set of standalone nodes with Portal already installed on them and federate them into a cell. Which way is better? Well, that depends.

Using an existing cell of AppServers and simply installing Portal into that topology is easiest, but has its drawbacks. When an Application Server node is federated into a cell, it loses its default configuration and assumes the configuration dictated by the Network Deployment Manager. If the node is ever unfederated, the original configuration is loaded from a backup copy and the node reverts to its standalone state. So, if I have a node that's already been federated and I install an application on it, if that node ever gets unfederated it will revert to its default state and the application I installed on it will go away. You can see the limitation here. I couldn't unfederate a Portal node and still have it be a Portal node.

Conversely, if I have a standalone node on which I install Portal and then I federate it, the Portal is part of the node's original pre-federated configuration and will always be present on the node, even if it gets unfederated. Unfortunately, doing it this way is more complicated and prone to error and endless frustration. Historically this has been the only way to cluster the Portal and it has led to many late nights and high consulting fees.

A real-world recommendation, one that recognizes impossible deadlines, unrealistic demands, and the constant need to document procedures, would be to go the first route. Build your cell of federated WebSphere nodes, verify that they function, then add Portal to the mix. It's less flexible, but I think you'll find yourself going home at 5pm more often.

Federation
Naturally you first have to install WebSphere Application Server. Let's assume you can get this far and that you have two WAS nodes (WAS1 and WAS2) installed and ready to go at version 5.1.x. There are no Web applications installed other than the default ones. You have also installed and configured a Network Deployment Manager (DM1) at version 5.1.x. For argument's sake, let's say each component is installed on a separate Windows machine.

In our scenario, WebSphere Global Security isn't enabled (yet). This makes the process of federation very easy. On each of the two WAS nodes you'd execute the following:

WAS_HOME\bin\addNode.bat DM1_HostName DM1_SOAP_Port

By default, the SOAP port of the Deployment Manager out-of-the-box is 8879.

Once executed, you'll see the console output describing the process of federation. When it's complete on both nodes, you'll have a cell. See? So easy. Now let's put Portal into the mix.