Load Balancer

Load Balancer

The Load Balancer Pattern allows you to delegate to one of a number of endpoints using a variety of different load balancing policies.

Build in load balancing policies

Camel has out of the box the following policies:

Round Robin

Camel 1.x behavior
The round robin load balancer can actually be used to failover with Camel 1.x. This is no longer possible in Camel 2.x as the underlying Error Handler foundation has been significantly overhauled in Camel 2.x. Frankly the round robin load balancer in Camel 1.x was not thought to be used in a failover scenario.

Camel 2.x behavior
The round robin load balancer is not meant to work with failover, for that you should use the dedicated failover load balancer. The round robin load balancer will only change to next endpoint per message.

The round robin load balancer is statefull as it keeps state which endpoint to use next time.

Using the Fluent Builders

Using the Spring configuration

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="direct:start"/>
    <loadBalance>        
        <roundRobin/>
        <to uri="mock:x"/>        
        <to uri="mock:y"/>       
        <to uri="mock:z"/>                 
    </loadBalance>
  </route>
</camelContext>

So the above example will load balance requests from direct:start to one of the available mock endpoint instances, in this case using a round robbin policy.
For further examples of this pattern in use you could look at the junit test case

Failover

Available as of Camel 2.0
The failover load balancer is capable of trying the next processor in case an Exchange failed with an exception during processing.
You can configure the failover with a list of specific exception to only failover. If you do not specify any exceptions it will failover over any exceptions. It uses the same strategy for matching exceptions as the Exception Clause does for the onException.

It has the following options:

Camel 2.2 or older behavior
The current implement of failover load balancer is a simple logic which always tries the first endpoint, and in case of an exception being thrown it tries the next in the list, and so forth. It has no state, and the next message will thus always start with the first endpoint.

Camel 2.3 onwards behavior
The failover load balancer now supports round robin mode, which allows you to failover in a round robin fashion. See the roundRobin option.

Here is a sample to failover only if a IOException related exception was thrown:

You can specify multiple exceptions to failover as the option is varargs, for instance:

// enable redelivery so failover can react
errorHandler(defaultErrorHandler().maximumRedeliveries(5));

from("direct:foo").
    loadBalance().failover(IOException.class, MyOtherException.class)
        .to("direct:a", "direct:b");

Using failover in Spring DSL

Failover can also be used from Spring DSL and you configure it as:

   <route errorHandlerRef="myErrorHandler">
      <from uri="direct:foo"/>
      <loadBalance>
          <failover>
              <exception>java.io.IOException</exception>
              <exception>com.mycompany.MyOtherException</exception>
          </failover>
          <to uri="direct:a"/>
          <to uri="direct:b"/>
      </loadBalance>
    </route>

Using failover in round robin mode

An example using Java DSL:

And the same example using Spring XML:

Weighted Round-Robin and Random Load Balancing

Available as of Camel 2.5

In many enterprise environments where server nodes of unequal processing power & performance characteristics are utilized to host services and processing endpoints, it is frequently necessary to distribute processing load based on their individual server capabilities so that some endpoints are not unfairly burdened with requests. Obviously simple round-robin or random load balancing do not alleviate problems of this nature. A Weighted Round-Robin and/or Weighted Random load balancer can be used to address this problem.

The weighted load balancing policy allows you to specify a processing load distribution ratio for each server with respect to others. You can specify this as a positive processing weight for each server. A larger number indicates that the server can handle a larger load. The weight is utilized to determine the payload distribution ratio to different processing endpoints with respect to others.

The parameters that can be used are
In Camel 2.5

Available In Camel 2.6

Using Weighted round-robin & random load balancing

• In Camel 2.5
  An example using Java DSL:

  ArrayList<integer> distributionRatio = new ArrayList<integer>();
  distributionRatio.add(4);
  distributionRatio.add(2);
  distributionRatio.add(1);
  
  // round-robin
  from("direct:start")
      .loadBalance().weighted(true, distributionRatio)
      .to("mock:x", "mock:y", "mock:z");
  
  //random
  from("direct:start")
      .loadBalance().weighted(false, distributionRatio)
      .to("mock:x", "mock:y", "mock:z");
  

And the same example using Spring XML:

    <route>
      <from uri="direct:start"/>
      <loadBalance>
        <weighted roundRobin="false" distributionRatio="4 2 1"/>
          <to uri="mock:x"/>
          <to uri="mock:y"/>
          <to uri="mock:z"/>
      </loadBalance>
    </route>

• As of Camel 2.6
  An example using Java DSL:

  // round-robin
  from("direct:start")
      .loadBalance().weighted(true, "4:2:1")
      .to("mock:x", "mock:y", "mock:z");
  
  //random
  from("direct:start")
      .loadBalance().weighted(false, "4,2,1", ",")
      .to("mock:x", "mock:y", "mock:z");
  

And the same example using Spring XML:

    <route>
      <from uri="direct:start"/>
      <loadBalance>
        <weighted roundRobin="false" distributionRatio="4,2,1" distributionRatioDelimiter="," />
          <to uri="mock:x"/>
          <to uri="mock:y"/>
          <to uri="mock:z"/>
      </loadBalance>
    </route>

Using this Pattern