Apache Camel 3 - Whats New Top 10

Apache Camel 3 was released last thursday November 28th 2019, which also happens to be the day of the US Thanksgiving. This was not intentionally but we can say its a big thanks from us to the community with a brand new major version of Camel - this does not come by often. In fact it's 10 years since Camel 2 hit the streets. So this 3rd generation is long overdue.

This blog post highlights the noteworthy new features and improvements in Camel v3.

Apache Camel, is now a family of projects (3 at this time of writing):

  • Camel 3: Integration Framework Swiss knife of integration
  • Camel K: Lightweight Serverless Integration Platform Camel on Kubernetes & Knative
  • Camel Quarkus: Camel extensions for Quarkus Optimised JVM & Native compiled Java (GraalVM)

The Camel code-base is very large, and we have setup sub-projects for new innovative projects using Camel. The first sub-project was to run Camel as cloud-native on Kubernetes in a serverless manner which became Camel K. Then Camel Quarkus came to make Java and Camel with very fast startup and very small memory footprint primary for container based deployments.

A major goal for Camel 3 was to finally revamp the old aging website to use modern technologies and be able to auto-generate content from the source code. This has taken years to get to this point as we have built tools over the last many Camel 2.x releases that could take us closer. At end of 2019 then the Camel community and others stepped up and provided the new art-work, logo, and look and feel for the new website - thank you very much!.

For Camel 3.x we will continue to improve the website and the documentation. This is much easier for us to do, and also for people to contribute changes as its just a regular github PR to provide updates. We love contributions.

Zoran had some fun with the new look and feel and he added a little gem; if you stare at the front page, then you should see a little animation of the curved bezel ;)

3) JAVA 11
Camel 3 is the first official release that supports Java 11. Java 8 will still be supported for the first number of 3.x releases, but is expected to be dropped later in 2020. However we wanted to provide Java 8 support to help migrate Camel 2.x users whom may be restricted to Java 8 for some time to come.

The camel-core has been modularized from 1 JAR to 33 JARs. The core functionality has been splitup into:


For Camel end users then only a few JARs is relevant.

camel-api contains the public API for Camel (eg interfaces such as CamelContext, Endpoint, Exchange, Message, and so on).

camel-support contains the base classes and RouteBuilder which you would use to build Camel routes and applications. This JAR is also contains necessary base classes for building custom Camel components, and other kinds of plugins.

The components that resided in camel-core has also be externalized into individual components:


Camel end users can then pick and choose exactly only what they need, or keep using everything.

Therefore we have camel-core and camel-core-engine as two starting dependencies. You can use camel-core which gives you all the JARs which is similar to Camel 2.x. When you use camel-core-engine you get the minimum set of JARs that makes a functional Camel.

camel-core contains 33 JARs and camel-core-engine contains 12 JARs.

We have reduced the size of core Camel and the number of classes loaded. For example in Camel 2 about 5200 classes was loaded, which has been reduced to about 4300 loaded classes in Camel 3.

We have also done many smaller optimizations in the core, to reduce the number of allocated Java objects, and speeup initialization and other means. We have used JVM profiling tools to assist and find the bottlenecks.

Another area of improvement is to reduce Java reflections. In Camel 2 then all the configuration of Camel components, endpoints, and routes are reflection based. In Camel 3 we have source code generated Java code for configuration that allows us to use direct Java calls instead of reflections.

Another similar area is Camel’s type converters which in Camel 2 are Java reflection based (you could build custom type converts that were not reflection based). In Camel 3 we also generate Java source code which means that type converting is direct Java calls at runtime.

We have also moved initialization logic to earlier phases when it was possible. For example there is a new build phase which allows Camel to do special initialization during building your project (this requires Camel Quarkus).

All this optimization improves the startup performance of Camel and reduces the memory overhead. With Camel Quarkus you can natively compile your Camel application and make it startup in 30 milli seconds and consume only 10mb of memory (RSS) with a full blown HTTP REST server and health-checks and metrics.

There are still a few items on the agenda that we want to work on in Camel 3.x to further optimize Camel core.

Camel end users whom has configured endpoints using URI strings, would all have experienced the problem when you make a configuration mistake in the endpoint, which then makes Camel fail on startup.

In Camel 3, we have a new type-safe DSL for endpoints which you can use in Java routes. You can continue to use the classic URI strings, but if you want to try the endpoint DSL, then you need to add camel-endpointdsl to your classpath. Then you should extend EndpointRouteBuilder instead of RouteBuilder to access the endpoint DSL.

Here is a basic example without and with the endpoint DSL:



You can also find a little example in the source code.

The routing engine in Camel has internally been reactive’fied and all EIPs has been retrofitted to work in a reactive manner. However this is internal only, and the Camel API for both end users and component developers are based on existing callback behavior.

We will later introduce and work on a client-side facing reactive API after we have jumped to Java 11 as minimum version (then we can support Java 9 flowable API).

Camel already have integration with reactive frameworks such as Vert.X, RxJava and Reactor Core in the dedicated Camel components.

We have introduced camel-main as a standalone JAR that makes it easier to run just Camel. There are a couple of examples with the source code that demonstrates how to do that.

We also use camel-main to have common code to configure and bootstrap Camel for standalone, Spring Boot, Camel K, and Camel Quarkus. This allows us to share the same code, and configuration options.

Camel 3 now integrates better with Eclipse Microprofile and we have Camel components for Microprofile configuration, metrics, health checks, and fault tolerance (on the way).

More components to come in upcoming Camel releases. These microprofile components are also used by Camel Quarkus.

Camel 3 now supports JUnit 5 for unit tests, with the test components that have -junit5 as suffix.

The Camel Registry is now also writeable, so you can add beans to the registry at runtime, or from unit tests etc.

You can also configure endpoints (producer) to lazy start. By default Camel works in a fail-fast mode, which means that Camel components that fails to connect to external systems during startup may cause the route to fail on startup. For Camel 3 you can now configure these endpoints to lazy start, which means the route will startup and they will first fail when a message is routed to the endpoint.

Camel also allows to configure your routes to be supervised during startup, which allows Camel to more intelligently start routes in a more safe manner, by restarting routes that failed.

We have of course cleaned up the code base, such as removing all deprecated APIs and components. We have also adjusted some APIs to make them easier to use from end users, and more Java 8 lambda friendly.

Internally we have also adjusted the route model, to make it easier to extend into new DSLs; and there is a YAML DSL on the way which was initiated in Camel K.

In terms of backwards compatibility then Camel 3 is mostly compatibility for regular Camel applications. However if you are using some of the more advanced features and other plugins in Camel then migration is needed. Also custom components must be migrated and recompiled. There are other adjustments such as Spring Boot users must use org.apache.camel.springboot as groupId instead of org.apache.camel etc. All details can be seen in the migration guide.

Good luck with your migration if you decide to continue your Camel journey. And for new users to Camel then good luck getting onboard.

There are 30 net new components in Camel 3, such as more stuff for Amazon AWS, and with GraphQL, and also worthwhile to mention is integration with Debezium, which is a change data capture project to grab change events from databases. 


Upcoming Tech Event in Copenhagen - What does the system integration toolbox anno 2019 looks like

On October 24th 2019, I am presenting at a full day tech event in Copenhagen.

My session is the first of the day, with a total of 90 minutes covering all the latest about Apache Camel 3, Camel K, and Camel Quarkus. I will have up to date slides, and demos ready for the talk.

The event also hosts other speakers such as Jeppe Cramon whom will talk about EDA and microservices. And I have been told that we should look forward to Syed Shaaf's session where he has a big tech demo with many moving parts.

In the afternoon you can choose to listen to breakout sessions or attend a full 2,5 hours hands-on workshop. The breakout sessions will among others cover use-cases with Apache Camel and Apache Kafka from the real world.

You can find more details about the event, the location, and how to register here.

Hope to see you there.

Cloud-native integration with Apache Camel on Kubernetes

Cloud-native applications of the future will consist of hybrid workloads: stateful applications, batch jobs, microservices, and functions, wrapped as Linux containers and deployed via Kubernetes on any cloud.

In this session, we will explore key challenges with function interactions and coordination, addressing these problems using Enterprise Integration Patterns (EIP) and modern approaches with the latest innovations from the Apache Camel community:

  • Apache Camel 3
  • Camel K
  • Camel Quarkus

Apache Camel is the Swiss army knife of integration, and the most powerful integration framework. In this session you will hear about the latest features in the brand new 3rd generation.

Camel K, is a lightweight integration platform that enables Enterprise Integration Patterns to be used natively on any Kubernetes cluster. When used in combination with Knative, a framework that adds serverless building blocks to Kubernetes, and the subatomic execution environment of Quarkus, Camel K can mix serverless features such as auto-scaling, scaling to zero, and event-based communication with the outstanding integration capabilities of Apache Camel.

We will show how Camel K works. We'll also use examples to demonstrate how Camel K makes it easier to connect to cloud services or enterprise applications using some of the 300 components that Camel provides.


Upcoming Webinar - Integration Patterns in a Serverless World

Next Thursday, October 10th, I am giving a 35 minutes webinar about Serverless Integration (yeah it covers Apache Camel, Camel K, Knative and Quarkus).

The webinar is part of a full day event (virtual event) where there are keynotes and a parallel tracks with 12 breakout sessions. 

My talk is focused purely on the upstream work we do at Apache Camel with the next generation Camel 3.

The abstract for my talk 

Cloud-native applications of the future will consist of hybrid workloads: stateful applications, batch jobs, microservices, and functions, wrapped as Linux containers and deployed via Kubernetes on any cloud.

In this session, we'll explore the key challenges with function interactions and coordination, addressing these problems using classic integration patterns and modern approaches with the latest innovation from the Apache Camel community: Camel K, a lightweight integration platform that enables enterprise integration patterns to be used natively on any Kubernetes cluster.

When used in combination with Knative, a framework that adds serverless building blocks to Kubernetes, and the subatomic execution environment of Quarkus, Camel K can mix serverless features such as auto-scaling, scaling to zero, and event-based communication with the outstanding integration capabilities of Apache Camel.

We will show how Camel K works. We'll also use examples to demonstrate how Camel K makes it easier to connect cloud services or enterprise applications using some of the 250+ components that Camel provides.


The event is free to attend, and you can signup using this link.

Date: October 10th 2019
Time: 5 pm CEST (event starts with keynotes)


Apache Camel 3 is only 2 months away

The Camel team is busy working on the last set of work for Apache Camel 3. Today the 2nd release candidate was built and published on a staging repository for early adapters to give it a try.

As I am busy myself then I just wanted to write a short blog post to keep the community posted that Apache Camel 3 is on the way, and that we expect it to be released by end of this year (sometime in November or December).

The latest deadline is to release Camel 3.0 before December 19th 2019 as it was exactly on that day 1 year ago, we switched the master branch to become the work branch for Apache Camel 3. That means the total development time for Camel 3 would be 1 year.

Here is a illustration that highlights the timeline of Camel 3:

That is not all Apache Camel, is now a family of 3 projects (at this moment). So working on Camel 3 is not all we do. Camel K and Camel Quarkus are very promising for cloud-native integration (microservices and serverless).

These projects have their own lifecycle. Will will post more details about these projects, and what's new in Camel 3 in the following months leading up to the final release of Camel 3.  So stay tuned.

PS: If you are migrating Camel 2.x applications to Camel 3, then read the migration guide.


New website for Apache Camel

Yesterday we published the new website for Apache Camel.

It's really fantastic to finally see a new website. And now with a modern tech for the website we can much easier update and keep it more modern for the future, and also it should help encourage users to contribute to its content to help build a better user guide.

Huge thanks to all involved.


Apache Camel 3 - camel-core vs camel-core-engine (smaller core)

The Camel team is very busy currently working on Apache Camel 3. A lot of work has already been implemented and we have released 3 milestone releases so far. The next milestone release number 4 has some great new innovative features which I will blog about in the following months.

The topic of this blog is the work we have been doing on splitting up camel-core into smaller modules which you can now easily pick exactly only what you need.

If we take a look at the dependency tree of the camel-core JAR you can see that it's been split up into many modules as shown below:

[INFO] +- org.apache.camel:camel-core:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-api:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-base:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-jaxp:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-management-api:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-support:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-util:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-util-json:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-bean:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-browse:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-caffeine-lrucache:jar:3.0.0-SNAPSHOT:compile
[INFO] |  |  \- com.github.ben-manes.caffeine:caffeine:jar:2.7.0:compile
[INFO] |  |     +- org.checkerframework:checker-qual:jar:2.6.0:compile
[INFO] |  |     \- com.google.errorprone:error_prone_annotations:jar:2.3.3:compile
[INFO] |  +- org.apache.camel:camel-controlbus:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-dataformat:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-dataset:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-direct:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-directvm:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-file:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-language:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-log:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-mock:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-properties:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-ref:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-rest:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-saga:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-scheduler:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-seda:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-stub:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-timer:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-validator:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-vm:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-xpath:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-xslt:jar:3.0.0-SNAPSHOT:compile
[INFO] |  \- org.slf4j:slf4j-api:jar:1.7.25:compile

In Camel 2.x all those modules were included in the same camel-core JAR.

To make the migration from Camel 2.x to 3.0 and also the ease of use, we will keep camel-core as the same set of JAR dependencies as in Camel 2.x. So the output above is from just declaring a dependency on camel-core, in your Maven pom.xml file or gradle build file.

However what is coming in Camel 3 milestone 4, is to make it easy as well to just pick what you need. For example the following shows a the dependency tree where we are only using as little as possible (using the new camel-core-engine JAR as dependency):

+- org.apache.camel:camel-core-engine:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-api:jar:3.0.0-SNAPSHOT:compile
[INFO] |  |  \- org.apache.camel:camel-util:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-management-api:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-support:jar:3.0.0-SNAPSHOT:compile
[INFO] |  \- org.apache.camel:camel-core:jar:3.0.0-SNAPSHOT:compile
[INFO] |     +- org.apache.camel:camel-base:jar:3.0.0-SNAPSHOT:compile
[INFO] |     \- org.apache.camel:camel-properties:jar:3.0.0-SNAPSHOT:compile

To illustrate this we have provided 2 set of examples

The former uses the camel-core as dependency which includes all the core components etc. The latter is the tiny dependency set, which only includes what is needed. The example only uses the bean and quartz2 component and therefore you would need to add them as dependency:

The dependency tree is as follows (mind that JAXB is excluded as test scope)

[INFO] --- maven-dependency-plugin:3.1.1:tree (default-cli) @ camel-example-main-tiny ---
[INFO] org.apache.camel.example:camel-example-main-tiny:jar:3.0.0-SNAPSHOT
[INFO] +- org.apache.camel:camel-core-engine:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-api:jar:3.0.0-SNAPSHOT:compile
[INFO] |  |  \- org.apache.camel:camel-util:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-management-api:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.apache.camel:camel-support:jar:3.0.0-SNAPSHOT:compile
[INFO] |  \- org.apache.camel:camel-core:jar:3.0.0-SNAPSHOT:compile
[INFO] |     +- org.apache.camel:camel-base:jar:3.0.0-SNAPSHOT:compile
[INFO] |     \- org.apache.camel:camel-properties:jar:3.0.0-SNAPSHOT:compile
[INFO] +- org.apache.camel:camel-main:jar:3.0.0-SNAPSHOT:compile
[INFO] +- org.apache.camel:camel-bean:jar:3.0.0-SNAPSHOT:compile
[INFO] +- org.apache.camel:camel-quartz2:jar:3.0.0-SNAPSHOT:compile
[INFO] |  +- org.quartz-scheduler:quartz:jar:2.3.1:compile
[INFO] |  |  +- com.mchange:mchange-commons-java:jar:0.2.15:compile
[INFO] |  |  \- com.zaxxer:HikariCP-java7:jar:2.4.13:compile
[INFO] |  \- com.mchange:c3p0:jar:
[INFO] +- com.sun.xml.bind:jaxb-core:jar:2.3.0:test
[INFO] +- com.sun.xml.bind:jaxb-impl:jar:2.3.0:test
[INFO] +- org.apache.logging.log4j:log4j-api:jar:2.11.2:runtime
[INFO] +- ch.qos.logback:logback-core:jar:1.2.3:compile
[INFO] \- ch.qos.logback:logback-classic:jar:1.2.3:compile
[INFO]    \- org.slf4j:slf4j-api:jar:1.7.25:compile

If we compare the size of the JARs between the two examples (incl logger etc), then we have:

  • camel-example-main (camel-core): 48 JAR files with total of 9.3 MB
  • camel-example-main-tiny (camel-core-engine): 21 JAR files with total of 7.4 MB

If we run the two examples then you can also see the number of classes loaded into the JVM is a bit smaller when using camel-core-engine:
  • camel-example-main (camel-core): 3666 classes loaded
  • camel-example-main-tiny (camel-core-engine): 3430 classes loaded
Okay the reduction here is not as significant, but it is expected as Camel will lazy load components in use, and the example only uses the bean and quartz component. However the classpath scanning would be a bit faster as there are roughly 25% less disk-size and 50% less JAR files.

There are many other great things coming in Apache Camel 3 which I will start writing blogs about during this summer leading up to the release (expected in September/October 2019).


What is Apache Camel K - Awesome 30 minute video

Last year we created the Apache Camel K sub-project of Apache Camel. Since we have been busy working on Camel K and also the upcoming Apache Camel v3.

What is Apache Camel K ?

A lightweight integration platform born on #Kubernetes, with serverless superpowers 🐫🚀💪

Last week Nicola and Luca gave a fantastic overview and demo of Apache Camel K. They talk was recorded and its posted online on youtube. If you have the time I highly recommend to watch the video and see where we are going with serverless integration with Camel K.


Long 2h Apache Camel video (sorry it's in danish)

A couple of days ago I was back in Copenhagen, at the capital region IT division for health care, where my Apache Camel journey started in 2008. So it was great being back at that magical place ;)

The event was hosted by Javagruppen and they had video equipment so they streamed the event live on youtube.

The agenda of my 2 hour session was:

  • What is Apache Camel?
  • Apache Camel v3
  • Apache Camel K
  • Knative & Camel
  • Quarkus & Camel

The main topic of the session was the new Apache Camel K project, but I gave a good extended coverage of what's coming in the upcoming Apache Camel v3.

For anyone curious a bit what is coming in Apache Camel v3, then you can take a look at the slides as they are in english.

The slides of the talk is here:

... and the video is online at youtube (danish):


Short Apache Camel K video

You may have seen the work we are doing in the Apache Camel community around Camel K.
Nicola introduced Camel K on his blog a half year ago, with the words
Just few months ago, we were discussing about a new project that we could start as part of Apache Camel. A project with the potential to change the way people deal with integration. That project is now here and it’s called “Apache Camel K”.
The Apache Camel K is in active development and its progressing nicely. Yesterday I gave a talk at the KMD Steam conference in Copenhagen, Denmark about Serverless Integration with Knative and Camel K on Kubernetes. As the talk was only 30 minutes I decided not to do any live demos and quickly recorded a 45 second short video of a quick Camel K demo.

In the top left corner you have a Camel route in a single Sample.java source file. On the top right corner we have an openshift web console, as I am running a local minishift cluster (Camel K also runs nicely on vanilla Kubernetes, but their web console is not as great as the one from openshift).
In the bottom we have the terminal where I run the Camel K integration with the Camel K CLI tool and the output of the integration is logged in the console. Notice how quickly the rolling upgrade is when I edit and save the Java source code.


I am now a Java Champion

At the end of November last year I was officially welcomed as a new JavaChampion on twitter.

I was among 30 new champions in 2018 and I am very humble to be among all these great champions. As you most likely know my work with Java is heavily focused on the Apache Camel project, and its good to know that other influencers in the Java eco-system that are not invested in general Java, can be recognized for their hard work and be nominated as a champion.

You can find a list of the champions on the official list (updated yearly) and on github (updated frequently).

This weekend I received a welcome gift, which is the official JavaChampion t-shirt and jacket.


Camel in Action / Apache Camel is not for everyone

Writing books is really hard, and you may think that when the book is finally published, you are all done. Well that is not the case for technical books, where our industry and the software stack the book covers is evolving.

For the Camel in Action books where we cover Apache Camel (no shit sherlock) is the same. We are from time to time, updating the source code examples to use newer version of Camel. This is curtesy to our readers so they have examples that runs on the latest Camel version at the time, and also used as a test-bed for the Apache Camel project, when we are testing/voting on new release candidates.

As an author you are also contacted from time to time by readers, whom have question to the book, its examples, and about Apache Camel in general. Thank you for the feedback and we love to get in touch with our readers, but sometimes we have to point people to use the general upstream community for the general Camel questions, when the subject is not specific about our book. And I would also like to thank the readers whom take the time to say thank you to us, that the book helped them get onboard Apache Camel, and other stories they can tell that made a difference.

We also get reports from the observable readers whom have found small mistakes in the book. We are very grateful for getting these to our attention so we can update the errata.

Then finally we have people doing book reviews (awesome, thank you for doing this, we appreciate all honest reviews). Most often we get positive feedback, and that the book has a lot to offer the readers. However we occasionally get the reviews from readers whom very likely have the book for the wrong reason.

For our second edition, we have two such examples from Amazon US and Germany. I have to the best of my ability responded to those reviews, with our point of view, and trying to explain/address their critique. All we want is for potential new readers to have the fact at their hands, and can make a better decision whether to purchase the book or not.

And I want to end this blog with me officially saying

Apache Camel is not for everyone

( but its still the most used open source integration framework in the universe )

Amazon.com review - Not very useful

Amazon.de review - Nahezu nutzlos..


Webinar - Develop Cloud Native Microservices using Apache Camel

On next thursday 31st January 2019 I am presenting a live webinar about developing cloud native microservices with Apache Camel.

The session is scheduled for a full hour including QA. The talk with be a mix of slides and live demos. It will be my first talk with revealing details about Apache Camel 3 and a peak and demo of Camel K (next-gen serverless Camel on Kubernetes).

The abstract of the talk is as follows

Apache Camel has fundamentally changed the way enterprise Java developers think about system-to-system integration by making enterprise integration patterns (EIP) a simple declaration in a lightweight application—wrapped and delivered as a single JAR.

In this webinar, we’ll show you how to bring EIP best practices to containers running on top of Kubernetes and deployed as Spring Boot microservices, which are both cloud-native and cloud-portable.

We'll discuss:

  • How building and designing cloud-native microservices impacts the way we develop.
  • How to build distributed and fault-tolerant microservices.
  • The upcoming Camel 3.0 release, which includes serverless capabilities via Camel K.


The webinar is scheduled on thursday 31st of January at 11am ET (5pm CET) and is of course free to attend. All you need to do is to register at the provided link.

More webinars

We have talked about continuing the webinar with a series of Camel and agile integration talks. So if you are interested to hear more webinars and have requests for topics to be covered then we are open for feedback.


Apache Camel explained to Luke Skywalker

A long time ago in a galaxy far,
far away ...
there was a a young boy,
whom went to

What a story. So Mark Hamill is addressed as Mr Camel. What an honour to have him in our Camel family and to be known as the first Mr Camel. The 2nd Mr Camel is our spirit animal for the Apache Camel project.

Okay back to Luke Skywalker, so his tweet lead to people talking about Camel's and I was then brought into the conversation whether Mark's audition story was my inspiration for Apache Camel, which again lead to Mark Hamill (Luke Skywalker) asking what Apache Camel is:

I must say I have never seen the day, where Luke Skywalker would ask me what Apache Camel is 😃 - I am a great fan of Star Wars and yes I am so old that I favour the first 3 classic movies.

Explaining what Apache Camel is to Luke Skywalker

At first though you may think that Apache Camel is a new model of the 4-legged walker with or without humps 🙃 ... but it is NOT

Instead let us ask the most wise man in the universe, Yoda, for the answer:

"Software that enables you to do integrations between other softwares, it is." - Yoda

And in my humble words ...

"What the force telekinesis does for universal Jedi connection ... the Apache Camel does for universal computer integration .... mindblow powers they are" - DavsClaus

And here is another great explanation from Matthew what Apache Camel is:

Has Luke Skywalker used Apache Camel?

Yes Mark you would unknowingly have used Apache Camel. Here is why. 

Apache Camel is a software project that has been around for over a decade. And its a very succesfull project and are thus widespread in use across all industries, enterprises, government institutions, and used in all parts of our planet.

In the US, for example, the FAA uses Camel in their services for air-traffic control. So anyone whom has been traveling by plane in the US airspace (covers 15% of the planet) would have used Camel.

Camel is also ubiquitous used among banking and finance enterprises, so any US citizen whom has done bank transfers, credit card transactions etc would at one point have the banking systems exchange data via software with Camel included.

If you are a Netflix subscriber then their payment system is using Camel as well. If you have a parcel delivery by brown-trucks (UPS) then Camel is helping with the track and trace.


Thank you Mark Hamill for asking me what Apache Camel is. I have been working on Apache Camel for more than 10 years and I still not able to explain it to the common man in a few words. Even trying to explain it to my peers in the IT industry is failing, evident by my last book is a staggering 900 page monster 🙃

May the force be with you


Apache Camel 2018 Numbers

Its been 2 years since I last did a blog post about the Camel numbers.

Just to do a quick post on some of the numbers for the Apache Camel project in year 2018.

Number of releases in 2018: 12
Number of posts on Camel user forum in 2018: 1266
Number of gitter chat users at end of 2018: 428
Number of commits in 2018: 3600 (git shortlog -ns --since 2018-01-01 --until 2019-01-01 | cut -c1-7 | awk '{ SUM += $1} END { print SUM }')

Total number of JIRA tickets created at end of 2018: 13033
Number of JIRA tickets created in 2018: 924
Number of JIRA tickets resolved in 2018: 766

Stackoverflow number of questions at end of 2018: 8375
Stackoverflow number of watchers at end of 2018: 1.8k

Number of stars on github at end of 2018: 2303
Total number of commits at end of 2018: 34431
Total number of contributors on github at end of 2018: 447
Number of closed pull requests at end of 2018: 2674
Number of closed pull requests in 2018: 280 (is:pr is:closed merged:>=2018-01-01)
Number of committers doing commits in 2018: 184 (git shortlog --since 2018-01-01 --until 2019-01-01 -ns | wc -l).

The Apache Software Foundation recently posted a summary of the most active projects in 2018 and Apache Camel was ranked 4th by commits.

You can find more statistics for example at GitHub and OpenHub.

Happy New Year and 2019 is going to be a special year for Apache Camel, with Camel 3 in the works.