<?xml version="1.0"?>
<!DOCTYPE document [
  <!ENTITY project SYSTEM "project.xml">
]>
<document url="cluster-howto.html">

    &project;

    <properties>
        <author email="fhanik@apache.org">Filip Hanik</author>
        <author email="pero@apache.org">Peter Rossbach</author>
        <title>Clustering/Session Replication HOW-TO</title>
    </properties>

<body>


<section name="Important Note">
<p><b>This document is pending an update to the latest implementation.<br/>
   You can also check the <a href="config/cluster.html">configuration reference documentation.</a></b>
</p>
</section>

<section name="For the impatient">
  <p>
    Simply add <source>&lt;Cluster className=&quot;org.apache.catalina.ha.tcp.SimpleTcpCluster&quot;/&gt;</source>
    to your <code>&lt;Engine&gt;</code> or your <code>&lt;Host&gt;</code> element to enable clustering.
  </p>
  <p>
    Using the above configuration will enable all to all session replication
    using the <code>DeltaManager</code> to replicate session deltas.<br/>
    Here are some of the important default values:<br/>
    1. Multicast address is 228.0.0.4<br/>
    2. Multicast port is 45564<br/>
    3. The IP broadcasted is <code>java.net.InetAddress.getLocalHost().getHostAddress()</code><br/>
    4. The TCP port listening for replication messages is the first available server socket in range <code>4000-4100</code><br/>
    5. Two listeners are configured <code>ClusterSessionListener</code> and <code>JvmRouteSessionIDBinderListener</code><br/>
    6. Two interceptors are configured <code>TcpFailureDetector</code> and <code>MessageDispatch15Interceptor</code><br/>
    The following is the default cluster configuration:<br/>
    <source>
        &lt;Cluster className=&quot;org.apache.catalina.ha.tcp.SimpleTcpCluster&quot;
                 channelSendOptions=&quot;8&quot;&gt;

          &lt;Manager className=&quot;org.apache.catalina.ha.session.DeltaManager&quot;
                   expireSessionsOnShutdown=&quot;false&quot;
                   notifyListenersOnReplication=&quot;true&quot;/&gt;

          &lt;Channel className=&quot;org.apache.catalina.tribes.group.GroupChannel&quot;&gt;
            &lt;Membership className=&quot;org.apache.catalina.tribes.membership.McastService&quot;
                        address=&quot;228.0.0.4&quot;
                        port=&quot;45564&quot;
                        frequency=&quot;500&quot;
                        dropTime=&quot;3000&quot;/&gt;
            &lt;Receiver className=&quot;org.apache.catalina.tribes.transport.nio.NioReceiver&quot;
                      address=&quot;auto&quot;
                      port=&quot;4000&quot;
                      autoBind=&quot;100&quot;
                      selectorTimeout=&quot;5000&quot;
                      maxThreads=&quot;6&quot;/&gt;

            &lt;Sender className=&quot;org.apache.catalina.tribes.transport.ReplicationTransmitter&quot;&gt;
              &lt;Transport className=&quot;org.apache.catalina.tribes.transport.nio.PooledParallelSender&quot;/&gt;
            &lt;/Sender&gt;
            &lt;Interceptor className=&quot;org.apache.catalina.tribes.group.interceptors.TcpFailureDetector&quot;/&gt;
            &lt;Interceptor className=&quot;org.apache.catalina.tribes.group.interceptors.MessageDispatch15Interceptor&quot;/&gt;
          &lt;/Channel&gt;

          &lt;Valve className=&quot;org.apache.catalina.ha.tcp.ReplicationValve&quot;
                 filter=&quot;&quot;/&gt;

          &lt;Deployer className=&quot;org.apache.catalina.ha.deploy.FarmWarDeployer&quot;
                    tempDir=&quot;/tmp/war-temp/&quot;
                    deployDir=&quot;/tmp/war-deploy/&quot;
                    watchDir=&quot;/tmp/war-listen/&quot;
                    watchEnabled=&quot;false&quot;/&gt;

          &lt;ClusterListener className=&quot;org.apache.catalina.ha.session.JvmRouteSessionIDBinderListener&quot;/&gt;
          &lt;ClusterListener className=&quot;org.apache.catalina.ha.session.ClusterSessionListener&quot;/&gt;
        &lt;/Cluster&gt;    
    </source>
  </p>
</section>

<section name="Cluster Basics">

<p>To run session replication in your Tomcat 6.0 container, the following steps
should be completed:</p>
<ul>
<li>All your session attributes must implement <code>java.io.Serializable</code></li>
<li>Uncomment the <code>Cluster</code> element in server.xml</li>
<li>Uncomment the <code>Valve(ReplicationValve)</code> element in server.xml</li>
<li>If your Tomcat instances are running on the same machine, make sure the <code>tcpListenPort</code>
    attribute is unique for each instance.</li>
<li>Make sure your <code>web.xml</code> has the <code>&lt;distributable/&gt;</code> element 
    or set at your <code>&lt;Context distributable="true" /&gt;</code></li>
<li>If you are using mod_jk, make sure that jvmRoute attribute is set at your Engine <code>&lt;Engine name="Catalina" jvmRoute="node01" &gt;</code>
    and that the jvmRoute attribute value matches your worker name in workers.properties</li>
<li>Make sure that all nodes have the same time and sync with NTP service!</li>
<li>Make sure that your loadbalancer is configured for sticky session mode.</li>
</ul>
<p>Load balancing can be achieved through many techniques, as seen in the
<a href="balancer-howto.html">Load Balancing</a> chapter.</p>
<p>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.</p>
<p>Note: Clustering support currently requires the JDK version 1.5 or later.</p>
</section>


<section name="Overview">

<p>To enable session replication in Tomcat, three different paths can be followed to achieve the exact same thing:</p>
<ol>
  <li>Using session persistence, and saving the session to a shared file system (PersistenceManager + FileStore)</li>
  <li>Using session persistence, and saving the session to a shared database (PersistenceManager + JDBCStore)</li>
  <li>Using in-memory-replication, using the SimpleTcpCluster that ships with Tomcat 5 (server/lib/catalina-cluster.jar)</li>
</ol>

<p>In this release of session replication, Tomcat performs an all-to-all replication of session state.

   This is an algorithm that is only efficient when the clusters are small. For large clusters, the next
   release will support a primary-secondary session replication where the session will only be stored at one
   or maybe two backup servers. 
   Currently you can use the domain worker attribute (mod_jk &gt; 1.2.8) to build cluster partitions
   with the potential of very scaleable cluster solution.
   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:
   </p>

<source>
        DNS Round Robin
               |
         Load Balancer
          /           \
      Cluster1      Cluster2
      /     \        /     \
  Tomcat1 Tomcat2  Tomcat3 Tomcat4
</source>

<p>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, ie, 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 <code>server.xml</code>)</p>
<p>In the next section will go deeper into how session replication works and how to configure it.</p>

</section>

<section name="Cluster Information">
<p>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 <code>&lt;Membership&gt;</code> element.
</p>
<p>
   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.
</p>
<p>
    The <code>ReplicationValve</code> 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).
</p>
<p>
    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 <code>channelSendOptions</code>
    flag and is an integer value. The default value for the <code>SimpleTcpCluster/DeltaManager</code> combo is
    8, which is asynchronous. You can read more on the <a href="#pointer-to-Tribes-Channel-Javadoc-here">send flag</a>.
    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.
</p>


<section name="Bind session after crash to failover node">
<p>
  As you configure more then two nodes at same cluster for backup, most loadbalancer
  send don't all your requests after failover to the same node.
</p>
<p> 
    The JvmRouteBinderValve handle tomcat jvmRoute takeover using mod_jk module after node
    failure. After a node crashed the next request going to other cluster node. The JvmRouteBinderValve 
    now detect the takeover and rewrite the jsessionid
    information to the backup cluster node. After the next response all client
    request goes direct to the backup node. The change sessionid send also to all
    other cluster nodes. Well, now the session stickyness work directly to the
    backup node, but traffic don't go back too restarted cluster nodes!<br/>
    As jsessionid was created by cookie, the change JSESSIONID cookie resend with next response.
</p>
<p>
    You must add JvmRouteBinderValve and the corresponding cluster message listener JvmRouteSessionIDBinderListener.
    As you add the new listener you must also add the default ClusterSessionListener that receiver the normal cluster messages.

<source>
&lt;Cluster className="org.apache.catalina.tcp.SimpleTcpCluster" &gt;
...
     &lt;Valve className="org.apache.catalina.cluster.session.JvmRouteBinderValve"
               enabled="true" sessionIdAttribute="takeoverSessionid"/&gt;	
     &lt;ClusterListener className="org.apache.catalina.cluster.session.JvmRouteSessionIDBinderListener" /&gt;
     &lt;ClusterListener className="org.apache.catalina.cluster.session.ClusterSessionListener" /&gt;
...
&lt;Cluster&gt;
</source>
</p>
<p>
    <b>Hint:</b><br/>
    With attribute <i>sessionIdAttribute</i> you can change the request attribute name that included the old session id.
    Default attribuite name is <i>org.apache.catalina.cluster.session.JvmRouteOrignalSessionID</i>.
</p>
<p>
    <b>Trick:</b><br/>
    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.
</p>

</section>

</section>

<section name="Configuration Example">
<source>
        &lt;Cluster className=&quot;org.apache.catalina.ha.tcp.SimpleTcpCluster&quot;
                 channelSendOptions=&quot;6&quot;&gt;

          &lt;Manager className=&quot;org.apache.catalina.ha.session.BackupManager&quot;
                   expireSessionsOnShutdown=&quot;false&quot;
                   notifyListenersOnReplication=&quot;true&quot;
                   mapSendOptions=&quot;6&quot;/&gt;
          &lt;!--
          &lt;Manager className=&quot;org.apache.catalina.ha.session.DeltaManager&quot;
                   expireSessionsOnShutdown=&quot;false&quot;
                   notifyListenersOnReplication=&quot;true&quot;/&gt;
          --&gt;        
          &lt;Channel className=&quot;org.apache.catalina.tribes.group.GroupChannel&quot;&gt;
            &lt;Membership className=&quot;org.apache.catalina.tribes.membership.McastService&quot;
                        address=&quot;228.0.0.4&quot;
                        port=&quot;45564&quot;
                        frequency=&quot;500&quot;
                        dropTime=&quot;3000&quot;/&gt;
            &lt;Receiver className=&quot;org.apache.catalina.tribes.transport.nio.NioReceiver&quot;
                      address=&quot;auto&quot;
                      port=&quot;5000&quot;
                      selectorTimeout=&quot;100&quot;
                      maxThreads=&quot;6&quot;/&gt;

            &lt;Sender className=&quot;org.apache.catalina.tribes.transport.ReplicationTransmitter&quot;&gt;
              &lt;Transport className=&quot;org.apache.catalina.tribes.transport.nio.PooledParallelSender&quot;/&gt;
            &lt;/Sender&gt;
            &lt;Interceptor className=&quot;org.apache.catalina.tribes.group.interceptors.TcpFailureDetector&quot;/&gt;
            &lt;Interceptor className=&quot;org.apache.catalina.tribes.group.interceptors.MessageDispatch15Interceptor&quot;/&gt;
            &lt;Interceptor className=&quot;org.apache.catalina.tribes.group.interceptors.ThroughputInterceptor&quot;/&gt;
          &lt;/Channel&gt;

          &lt;Valve className=&quot;org.apache.catalina.ha.tcp.ReplicationValve&quot;
                 filter=&quot;.*\.gif;.*\.js;.*\.jpg;.*\.png;.*\.htm;.*\.html;.*\.css;.*\.txt;&quot;/&gt;

          &lt;Deployer className=&quot;org.apache.catalina.ha.deploy.FarmWarDeployer&quot;
                    tempDir=&quot;/tmp/war-temp/&quot;
                    deployDir=&quot;/tmp/war-deploy/&quot;
                    watchDir=&quot;/tmp/war-listen/&quot;
                    watchEnabled=&quot;false&quot;/&gt;

          &lt;ClusterListener className=&quot;org.apache.catalina.ha.session.ClusterSessionListener&quot;/&gt;
        &lt;/Cluster&gt;
</source>
</section>

<section name="Cluster Architecture">

<p><b>Component Levels:</b>
<source>
         Server
           |
         Service
           |
         Engine
           |  \ 
           |  --- Cluster --*
           |
         Host
           |
         ------
        /      \
     Cluster    Context(1-N)                 
        |             \
        |             -- Manager
        |                   \
        |                   -- DeltaManager
        |
     ---------------------------
        |                       \
      Channel                    \
    ----------------------------- \
     |          |         |        \
   Receiver    Sender   Membership  \
                                     -- Valve
                                     |      \
                                     |       -- ReplicationValve
                                     |       -- JvmRouteBinderValve 
                                     |
                                     -- LifecycleListener 
                                     |
                                     -- ClusterListener 
                                     |      \
                                     |       -- ClusterSessionListener
                                     |       -- JvmRouteSessionIDBinderListener
                                     |
                                     -- Deployer 
                                            \
                                             -- FarmWarDeployer
      
      
</source>
</p>

</section>
<section name="How it Works">
<p>To make it easy to understand how clustering works, We are gonna take you through a series of scenarios.
   In the scenario we only plan to use two tomcat instances <code>TomcatA</code> and <code>TomcatB</code>.
   We will cover the following sequence of events:</p>

<ol>
<li><code>TomcatA</code> starts up</li>
<li><code>TomcatB</code> starts up (Wait that TomcatA start is complete)</li>
<li><code>TomcatA</code> receives a request, a session <code>S1</code> is created.</li>
<li><code>TomcatA</code> crashes</li>
<li><code>TomcatB</code> receives a request for session <code>S1</code></li>
<li><code>TomcatA</code> starts up</li>
<li><code>TomcatA</code> receives a request, invalidate is called on the session (<code>S1</code>)</li>
<li><code>TomcatB</code> receives a request, for a new session (<code>S2</code>)</li>
<li><code>TomcatA</code> The session <code>S2</code> expires due to inactivity.</li>
</ol>

<p>Ok, now that we have a good sequence, we will take you through exactly what happens in the session repliction code</p>

<ol>
<li><b><code>TomcatA</code> starts up</b>
    <p>
        Tomcat starts up using the standard start up sequence. When the Host object is created, a cluster object is associated with it.
        When the contexts are parsed, if the distributable element is in place in web.xml
        Tomcat asks the Cluster class (in this case <code>SimpleTcpCluster</code>) to create a manager
        for the replicated context. So with clustering enabled, distributable set in web.xml
        Tomcat will create a <code>DeltaManager</code> for that context instead of a <code>StandardManager</code>.
        The cluster class will start up a membership service (multicast) and a replication service (tcp unicast).
        More on the architecture further down in this document.
    </p><p></p>
</li>
<li><b><code>TomcatB</code> starts up</b>
    <p>
        When TomcatB starts up, it follows the same sequence as TomcatA did with one exception.
        The cluster is started and will establish a membership (TomcatA,TomcatB).
        TomcatB will now request the session state from a server that already exists in the cluster,
        in this case TomcatA. TomcatA responds to the request, and before TomcatB starts listening
        for HTTP requests, the state has been transferred from TomcatA to TomcatB.
        In case TomcatA doesn't respond, TomcatB will time out after 60 seconds, and issue a log
        entry. The session state gets transferred for each web application that has distributable in
        its web.xml. Note: To use session replication efficiently, all your tomcat instances should be
        configured the same.
    </p><p></p>
</li>
<li><B><code>TomcatA</code> receives a request, a session <code>S1</code> is created.</B>
    <p>
        The request coming in to TomcatA is treated exactly the same way as without session replication.
        The action happens when the request is completed, the <code>ReplicationValve</code> will intercept
        the request before the response is returned to the user.
        At this point it finds that the session has been modified, and it uses TCP to replicata the
        session to TomcatB. Once the serialized data has been handed off to the operating systems TCP logic,
        the request returns to the user, back through the valve pipeline.
        For each request the entire session is replicated, this allows code that modifies attributes
        in the session without calling setAttribute or removeAttribute to be replicated.
        a useDirtyFlag configuration parameter can be used to optimize the number of times
        a session is replicated.
    </p><p></p>

</li>
<li><b><code>TomcatA</code> crashes</b>
    <p>
        When TomcatA crashes, TomcatB receives a notification that TomcatA has dropped out
        of the cluster. TomcatB removes TomcatA from its membership list, and TomcatA will no longer
        be notified of any changes that occurs in TomcatB.
        The load balancer will redirect the requests from TomcatA to TomcatB and all the sessions
        are current.
    </p><p></p>
</li>
<li><b><code>TomcatB</code> receives a request for session <code>S1</code></b>
    <p>Nothing exciting, TomcatB will process the request as any other request.
    </p><p></p>
</li>
<li><b><code>TomcatA</code> starts up</b>
    <p>Upon start up, before TomcatA starts taking new request and making itself
    available to it will follow the start up sequence described above 1) 2).
    It will join the cluster, contact TomcatB for the current state of all the sessions.
    And once it receives the session state, it finishes loading and opens its HTTP/mod_jk ports.
    So no requests will make it to TomcatA until it has received the session state from TomcatB.
    </p><p></p>
</li>
<li><b><code>TomcatA</code> receives a request, invalidate is called on the session (<code>S1</code>)</b>
    <p>The invalidate is call is intercepted, and the session is queued with invalidated sessions.
        When the request is complete, instead of sending out the session that has changed, it sends out
        an "expire" message to TomcatB and TomcatB will invalidate the session as well.
    </p><p></p>

</li>
<li><b><code>TomcatB</code> receives a request, for a new session (<code>S2</code>)</b>
    <p>Same scenario as in step 3)
    </p><p></p>


</li>
<li><code>TomcatA</code> The session <code>S2</code> expires due to inactivity.
    <p>The invalidate is call is intercepted the same was as when a session is invalidated by the user,
       and the session is queued with invalidated sessions.
       At this point, the invalidet session will not be replicated across until
       another request comes through the system and checks the invalid queue.
    </p><p></p>
</li>
</ol>

<p>Phuuuhh! :)</p>

<p><b>Membership</b>
    Clustering membership is established using very simple multicast pings.
    Each Tomcat instance will periodically send out a multicast ping,
    in the ping message the instance will broad cast its IP and TCP listen port
    for replication.
    If an instance has not received such a ping within a given timeframe, the
    member is considered dead. Very simple, and very effective!
    Of course, you need to enable multicasting on your system.
</p>

<p><b>TCP Replication</b>
    Once a multicast ping has been received, the member is added to the cluster
    Upon the next replication request, the sending instance will use the host and
    port info and establish a TCP socket. Using this socket it sends over the serialized data.
    The reason I choose TCP sockets is because it has built in flow control and guaranteed delivery.
    So I know, when I send some data, it will make it there :)
</p>

<p><b>Distributed locking and pages using frames</b>
    Tomcat does not keep session instances in sync across the cluster.
    The implementation of such logic would be to much overhead and cause all
    kinds of problems. If your client accesses the same session
    simultanously using multiple requests, then the last request
    will override the other sessions in the cluster.
</p>

</section>






<section name="Monitoring your Cluster with JMX">
<p>Monitoring is a very important question when you use a cluster. Some of the cluster objects are JMX MBeans </p>
<p>Add the following parameter to your startup script with Java 5:
<source>
set CATALINA_OPTS=\
-Dcom.sun.management.jmxremote \
-Dcom.sun.management.jmxremote.port=%my.jmx.port% \
-Dcom.sun.management.jmxremote.ssl=false \
-Dcom.sun.management.jmxremote.authenticate=false
</source>
</p>
<p>Activate JMX with JDK 1.4:
<ol>
<li>Install the compat package</li>
<li>Install the mx4j-tools.jar at common/lib (use the same mx4j version as your tomcat release)</li>
<li>Configure a MX4J JMX HTTP Adaptor at your AJP Connector<p></p>
<source>
&lt;Connector port="${AJP.PORT}" 
   handler.list="mx"
   mx.enabled="true" 
   mx.httpHost="${JMX.HOST}" 
   mx.httpPort="${JMX.PORT}" 
   protocol="AJP/1.3" /&gt;
</source>
</li>
<li>Start your tomcat and look with your browser to http://${JMX.HOST}:${JMX.PORT}</li>
<li>With the connector parameter <code>mx.authMode="basic" mx.authUser="tomcat" mx.authPassword="strange"</code> you can control the access!</li>
</ol>
</p>
<p>
List of Cluster Mbeans<br/>
<table border="1" cellpadding="5">

  <tr>
    <th align="center" bgcolor="aqua">Name</th>
    <th align="center" bgcolor="aqua">Description</th>
    <th align="center" bgcolor="aqua">MBean ObjectName - Engine</th>
    <th align="center" bgcolor="aqua">MBean ObjectName - Host</th>
  </tr>

  <tr>
    <td>Cluster</td>
    <td>The complete cluster element</td>
    <td><code>type=Cluster</code></td>
    <td><code>type=Cluster,host=${HOST}</code></td>
  </tr>
 
  <tr>
    <td>ClusterSender</td>
    <td>Configuration and stats of the sender infrastructure</td>
    <td><code>type=ClusterSender</code></td>
    <td><code>type=ClusterSender,host=${HOST}</code></td>
  </tr>
 
  <tr>
    <td>ClusterReceiver</td>
    <td>Configuration and stats of the recevier infrastructure</td>
    <td><code>type=ClusterReceiver</code></td>
    <td><code>type=ClusterReceiver,host=${HOST}</code></td>
  </tr>

  <tr>
    <td>ClusterMembership</td>
    <td>Configuration and stats of the membership infrastructure</td>
    <td><code>type=ClusterMembership</code></td>
    <td><code>type=ClusterMembership,host=${HOST}</code></td>
  </tr>

  <tr>
    <td>IDataSender</td>
    <td>For every cluster member it exist a sender mbeans. 
    It exists speziall MBeans to all replication modes</td>
    <td><code>type=IDataSender,
        senderAddress=${MEMBER.SENDER.IP},
        senderPort=${MEMBER.SENDER.PORT}</code></td>
    <td><code>type=IDataSender,host=${HOST},
        senderAddress=${MEMBER.SENDER.IP},
        senderPort=${MEMBER.SENDER.PORT}</code></td>
  </tr>
 
  <tr>
    <td>DeltaManager</td>
    <td>This manager control the sessions and handle session replication </td>
    <td><code>type=Manager,path=${APP.CONTEXT.PATH}, host=${HOST}</code></td>
    <td><code>type=Manager,path=${APP.CONTEXT.PATH}, host=${HOST}</code></td>
  </tr>

  <tr>
    <td>ReplicationValve</td>
    <td>This valve control the replication to the backup nodes</td>
    <td><code>type=Valve,name=ReplicationValve</code></td>
    <td><code>type=Valve,name=ReplicationValve,host=${HOST}</code></td>
  </tr>

  <tr>
    <td>JvmRouteBinderValve</td>
    <td>This is a cluster fallback valve to change the Session ID to the current tomcat jvmroute.</td>
    <td><code>type=Valve,name=JvmRouteBinderValve,
              path=${APP.CONTEXT.PATH}</code></td>
    <td><code>type=Valve,name=JvmRouteBinderValve,host=${HOST},
              path=${APP.CONTEXT.PATH}</code></td>
  </tr>

</table>
</p>
</section>

<section name="FAQ">
<p>Please see <a href="http://tomcat.apache.org/faq/cluster.html">the clustering section of the FAQ</a>.</p>
</section>

</body>

</document>
