Apache Tomcat Development
Clustering/Session Replication HOW-TO
|For the impatient|
<Engine> or your
<Host> element to enable clustering.
Using the above configuration will enable all-to-all session replication
DeltaManager to replicate session deltas. By all-to-all we mean that the session gets replicated to all the other
nodes in the cluster. This works great for smaller cluster but we don't recommend it for larger clusters(a lot of Tomcat nodes).
Also when using the delta manager it will replicate to all nodes, even nodes that don't have the application deployed.
To get around this problem, you'll want to use the BackupManager. This manager only replicates the session data to one backup
node, and only to nodes that have the application deployed. Downside of the BackupManager: not quite as battle tested as the delta manager.
Here are some of the important default values:
- Multicast address is 184.108.40.206
- Multicast port is 45564 (the port and the address together determine cluster membership.
- The IP broadcasted is
java.net.InetAddress.getLocalHost().getHostAddress() (make sure you don't broadcast 127.0.0.1, this is a common error)
- The TCP port listening for replication messages is the first available server socket in range
- Two listeners are configured
- Two interceptors are configured
The following is the default cluster configuration:
Will cover this section in more detail later in this document.
To run session replication in your Tomcat 7.0 container, the following steps
should be completed:
- All your session attributes must implement
- Uncomment the
Cluster element in server.xml
- If you have defined custom cluster valves, make sure you have the
ReplicationValve defined as well under the Cluster element in server.xml
- If your Tomcat instances are running on the same machine, make sure the
attribute is unique for each instance, in most cases Tomcat is smart enough to resolve this on it's own by autodetecting available ports in the range 4000-4100
- Make sure your
web.xml has the
- If you are using mod_jk, make sure that jvmRoute attribute is set at your Engine
<Engine name="Catalina" jvmRoute="node01" >
and that the jvmRoute attribute value matches your worker name in workers.properties
- Make sure that all nodes have the same time and sync with NTP service!
- Make sure that your loadbalancer is configured for sticky session mode.
Load balancing can be achieved through many techniques, as seen in the
Load Balancing chapter.
Note: Remember that your session state is tracked by a cookie, so your URL must look the same from the out
side otherwise, a new session will be created.
Note: Clustering support currently requires the JDK version 1.5 or later.
The Cluster module uses the Tomcat JULI logging framework, so you can configure logging
through the regular logging.properties file. To track messages, you can enable logging on the key:
To enable session replication in Tomcat, three different paths can be followed to achieve the exact same thing:
- Using session persistence, and saving the session to a shared file system (PersistenceManager + FileStore)
- Using session persistence, and saving the session to a shared database (PersistenceManager + JDBCStore)
- Using in-memory-replication, using the SimpleTcpCluster that ships with Tomcat (lib/catalina-tribes.jar + lib/catalina-ha.jar)
In this release of session replication, Tomcat can perform an all-to-all replication of session state using the
perform backup replication to only one node using the
The all-to-all replication is an algorithm that is only efficient when the clusters are small. For larger clusters, to use
a primary-secondary session replication where the session will only be stored at one backup server simply setup the BackupManager.
Currently you can use the domain worker attribute (mod_jk > 1.2.8) to build cluster partitions
with the potential of having a more scalable cluster solution with the DeltaManager(you'll need to configure the domain interceptor for this).
In order to keep the network traffic down in an all-to-all environment, you can split your cluster
into smaller groups. This can be easily achieved by using different multicast addresses for the different groups.
A very simple setup would look like this:
DNS Round Robin
/ \ / \
Tomcat1 Tomcat2 Tomcat3 Tomcat4
What is important to mention here, is that session replication is only the beginning of clustering.
Another popular concept used to implement clusters is farming, i.e., you deploy your apps only to one
server, and the cluster will distribute the deployments across the entire cluster.
This is all capabilities that can go into with the FarmWarDeployer (s. cluster example at
In the next section will go deeper into how session replication works and how to configure it.
Membership is established using multicast heartbeats.
Hence, if you wish to subdivide your clusters, you can do this by
changing the multicast IP address or port in the
The heartbeat contains the IP address of the Tomcat node and the TCP port that
Tomcat listens to for replication traffic. All data communication happens over TCP.
ReplicationValve is used to find out when the request has been completed and initiate the
replication, if any. Data is only replicated if the session has changed (by calling setAttribute or removeAttribute
on the session).
One of the most important performance considerations is the synchronous versus asynchronous replication.
In a synchronous replication mode the request doesn't return until the replicated session has been
sent over the wire and reinstantiated on all the other cluster nodes.
Synchronous vs. asynchronous is configured using the
flag and is an integer value. The default value for the
SimpleTcpCluster/DeltaManager combo is
8, which is asynchronous. You can read more on the send flag(overview) or the
During async replication, the request is returned before the data has been replicated. async replication yields shorter
request times, and synchronous replication guarantees the session to be replicated before the request returns.
|Bind session after crash to failover node|
If you are using mod_jk and not using sticky sessions or for some reasons sticky session don't
work, or you are simply failing over, the session id will need to be modified as it previously contained
the worker id of the previous tomcat (as defined by jvmRoute in the Engine element).
To solve this, we will use the JvmRouteBinderValve.
The JvmRouteBinderValve rewrites the session id to ensure that the next request will remain sticky
(and not fall back to go to random nodes since the worker is no longer available) after a fail over.
The valve rewrites the JSESSIONID value in the cookie with the same name.
Not having this valve in place, will make it harder to ensure stickiness in case of a failure for the mod_jk module.
By default, if no valves are configured, the JvmRouteBinderValve is added on.
The cluster message listener called JvmRouteSessionIDBinderListener is also defined by default and is used to actually rewrite the
session id on the other nodes in the cluster once a fail over has occurred.
Remember, if you are adding your own valves or cluster listeners in server.xml then the defaults are no longer valid,
make sure that you add in all the appropriate valves and listeners as defined by the default.
With attribute sessionIdAttribute you can change the request attribute name that included the old session id.
Default attribute name is org.apache.catalina.ha.session.JvmRouteOrignalSessionID.
You can enable this mod_jk turnover mode via JMX before you drop a node to all backup nodes!
Set enable true on all JvmRouteBinderValve backups, disable worker at mod_jk
and then drop node and restart it! Then enable mod_jk Worker and disable JvmRouteBinderValves again.
This use case means that only requested session are migrated.