Apache Camel, as usual, is a step backward in comparison with the Spring framework and there is no difference in the case of microservices architecture. However, Camel have introduced new set of components for building microservices some months ago. In its newest version 2.18 there is a support for load balancing with Netflix Ribbon, circuit breaking with Netflix Hystrix, distributed tracing with Zipkin and service registration and discovery with Consul. The new key component for microservices support on Camel is ServiceCall EIP which allows to call a remote service in a distributed system where the service is looked up from a service registry. There are four tools which can be used as service registry for Apache Camel microservices: etcd, Kubernetes, Ribbon, and Consul. Release 2.18 also comes with a much-improved Spring Boot support.

In this articale I’m going to show you how to develop Apache Camel microservices with its support for Spring Boot, REST DSL and Consul. Sample application is available on GitHub. Below you see a picture with our application architecture.

To enable Spring Boot support in Camel application we need to add following dependency to pom.xml. After that we have to annotate our main class with @SpringBootApplication and set property camel.springboot.main-run-controller=true in application configuration file (application.properties or application.yml).

<dependency>
   <groupId>org.apache.camel</groupId>
   <artifactId>camel-spring-boot-starter</artifactId>
   <version>${camel.version}</version>
</dependency>

Then we just have to create Spring @Component extending Camel’s RouteBuilder. Inside route builder configuration we declare REST endpoint using Camel REST DSL. It’s really simple and intuitive. In the code visible below I exposed four REST endpoints: three for GET method and an single one for POST. We are using netty4-http component as a web container for exposing REST endpoints and JSON binding. We also have to add to dependencies to pom.xml: camel-netty4-http for Netty framework and camel-jackson library for enabling consuming and producing JSON data. All routes are forwarding input requests to different methods inside Spring service @Component.

@Component
public class AccountRoute extends RouteBuilder {

   @Value("${port}")
   private int port;

   @Override
   public void configure() throws Exception {
      restConfiguration()
         .component("netty4-http")
         .bindingMode(RestBindingMode.json)
         .port(port);

      rest("/account")
         .get("/{id}")
         .to("bean:accountService?method=findById(${header.id})")
         .get("/customer/{customerId}")
         .to("bean:accountService?method=findByCustomerId(${header.customerId})")
         .get("/")
         .to("bean:accountService?method=findAll")
         .post("/").consumes("application/json").type(Account.class)
         .to("bean:accountService?method=add(${body})");
   }

}

Next element in our architecture is service registry component. We decided to use Consul. The simplest way to run it locally is to pull its docker image and run using docker command below. Consul provides UI management console and REST API for registering and searching services and key/value objects. REST API is available under v1 path and is well documented here.

$ docker run -d --name consul -p 8500:8500 -p 8600:8600 consul

Well, we have account microservice implemented and running Consul instance, so we would like to register our service there. And here we’ve got a problem. There is no mechanisms out of the box in Camel for service registration, there is only component for searching service. To be more precise I didn’t find any description about such a mechanism in Camel documentation… However, it may exists… somewhere. Maybe, you know how to find it? Here’s interesting solution for Camel Consul registry, but I didn’t check it out. I decided to rather simpler solution implemented by myself. I added two next routes to AccountRoute class.

from("direct:start").marshal().json(JsonLibrary.Jackson)
   .setHeader(Exchange.HTTP_METHOD, constant("PUT"))
   .setHeader(Exchange.CONTENT_TYPE, constant("application/json"))
   .to("http://192.168.99.100:8500/v1/agent/service/register");
from("direct:stop").shutdownRunningTask(ShutdownRunningTask.CompleteAllTasks)
   .toD("http://192.168.99.100:8500/v1/agent/service/deregister/${header.id}");

Route direct:start is running after Camel context startup and direct:stop before shutdown. Here’s EventNotifierSupport implementation for calling routes during startup and shutdown process. You can also try with camel-consul component, but in my opinion it is not well described in Camel documentation. List of services registered on Consul is available here: http://192.168.99.100:8500/v1/agent/services. I launch my account service with VM argument -Dport and it should be registered on Consul with account${port} ID.

@Component
public class EventNotifier extends EventNotifierSupport {

   @Value("${port}")
   private int port;

   @Override
   public void notify(EventObject event) throws Exception {
      if (event instanceof CamelContextStartedEvent) {
         CamelContext context = ((CamelContextStartedEvent) event).getContext();
         ProducerTemplate t = context.createProducerTemplate();
         t.sendBody("direct:start", new Register("account" + port, "account", "127.0.0.1", port));
      }
      if (event instanceof CamelContextStoppingEvent) {
         CamelContext context = ((CamelContextStoppingEvent) event).getContext();
         ProducerTemplate t = context.createProducerTemplate();
         t.sendBodyAndHeader("direct:stop", null, "id", "account" + port);
      }
   }

   @Override
   public boolean isEnabled(EventObject event) {
      return (event instanceof CamelContextStartedEvent || event instanceof CamelContextStoppingEvent);
   }

}

The last (but not least) element of our architecture is gateway. We also use netty for exposing REST services on port 8000.

restConfiguration()
   .component("netty4-http")
   .bindingMode(RestBindingMode.json)
   .port(8000);

We also have to provide configuration for connection with Consul registry and set it on CamelContext calling setServiceCallConfiguration method.

ConsulConfigurationDefinition config = new ConsulConfigurationDefinition();
config.setComponent("netty4-http");
config.setUrl("https://192.168.99.100:8500");
context.setServiceCallConfiguration(config);

Finally, we are defining routes which are mapping paths set on gateway to services registered on Consul using ServiceCall EIP. Now you call in your web browser one of those URLs, for example http://localhost:8000/account/1. If you would like to map path also while serviceCall EIP you need to put ‘//‘ instead of sinle slash ‘/‘ described in the Camel documentation. For example from(“rest:get:account”).serviceCall(“account//all”), not serviceCall(“account/all”).

from("rest:get:account:/{id}").serviceCall("account");
from("rest:get:account:/customer/{customerId}").serviceCall("account");
from("rest:get:account:/").serviceCall("account");
from("rest:post:account:/").serviceCall("account");

Conclusion

I was positively surprised by Camel. Before I started working on the sample described in this post I didn’t expect that Camel has such many features for building microservice solutions and working with them will be simple and fast. Of course, I can also find some disadvantages like inaccuracies or errors in documentation, only a short description of some new components in the developer guide, or no registration process in discovery server like Consul. In these areas, I see an advantage of the Spring Framework. But on the other hand, Camel has support for some useful tools like etcd, or Kubernetes which is not available in Spring. In conclusion, I’m looking forward to the further improvements in Camel components for building microservices.