Apache Camel 2016 Numbers

Its been 5 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 2016.

Number of releases in 2016: 12
Number of posts on Camel user forum in 2016: 5423
Number of commits in 2016: 4325 (git shortlog -ns --since 2016-01-01 | cut -c1-7 | awk '{ SUM += $1} END { print SUM }')

Total number of tickets created at end of 2016: 10663
Number of tickets created in 2016: 1192
Number of tickets resolved in 2016: 1256

Total number of commits at end of 2016: 26390
Number of stars on github at end of 2016: 1149
Total number of contributors on github at end of 2016: 267
Number of closed pull requests at end of 2016: 1363
Number of closed pull requests in 2016: 615
Number of committers doing commits in 2016: 192 (git shortlog --after 2015-12-31 --before 2017-01-01 -ns | wc -l).

You can find more statistics at github and Open Hub.

Happy New Year and 2017 is going to be a special year for Apache Camel.


Work started on Apache Camel Intellij IDEA plugin

Just because its Christmas does not mean the Camel stands still.

On the even of the 23rd I took the evening to do a bit of research and start hack on a little prototype for an Apache Camel plugin for IDEA. Its something that has been on my radar for a longer time. 

The reason is that Apache Camel provides a catalog with has a ton of great information for tooling. The catalog includes every little detail about every Camel component, EIPs, data formats, languages, and much more.

I have long wanted to have a little plugin for IDEA (and also Eclipse if possible) for code assistance to setup Camel endpoints - in other words, having ctrl + space to show a list of Camel options you can use on any given Camel endpoint.

Sidestory begins ...
So in the darkness of the night I found myself back in Intellij IDEA plugin land. It was a long long time since last time I hacked on a IDEA plugin. It was so many years ago I cannot remember exactly, but it was around 2002. I created a little plugin called Generate toString which would generate nice toString methods for your POJO classes, like you can generte equals/hashCode etc. Over the years that followed I maintained the plugin and upgraded it for newer IDEA versions which would often break the plugin, or they have moved/changed their APIs. Back then the plugin API was hardly documented, and there was no source code of the editor itself, so it was no fun to try to figure out how to get it to work again, or how to use some of  the existing IDEA dialogs etc. But in the end it was possible, and for a few dialogs I actually had to build it myself using Java Swing etc. The plugin later found a new home at Jetbrains where they took over and provides the plugin out of the box in IDEA. Thanks Jetbrains. You make the best editor on the planet. 
You can read more about this story in the following blog posts: Fast forward to 2016 and I was back in somewhat familiar waters, the AST model is still named PsiSomething.
... sidestory ends.

However doing a plugin that hooks into the Java language of IDEA took a while to find out, because I was walking down the wrong path, trying to find an extension-point about smart completion. 

So instead I looked at some of the out of the box plugins as you can find their source code, and eventually found a plugin that hook into the Java language which took me down the right path.

So after a while I got something working, which was marvelous to see that the smart completion suggestion list included the Camel endpoint options for the given component.

On christmas morning I hacked some more, and posted a tweet with the first screenshot

Today on the 25th December I do have a bit more time as well to polish up the code and to publish it on github. 

I have created a new project on github where we can hack on the code to make the plugin awesome and great. The intention is that the code eventually will be donated to Apache Camel. But for now we can keep it separated so its easier because there is only the plugin code, and not all the other Camel source as well.

You can find more details on the github page, where there is instructions how to try / run and build the plugin. There is also a issue tracker with tickets for stuff we need to work on.

Anyone is welcome to help with the plugin.

Sadly I don't have so much time currently to justify spending days hacking on the plugin, even thought it would be really fun. I have to focus on completing the Camel in Action 2nd edition book. I am 85% complete with the microservices chapter, and then have another chapter to complete as soon as possible in the start of 2017. However I am also a human whom want to have a bit fun hacking so I will hack a bit from time to time on the plugin.

A shameless plug for the book, there is a 40% discount code during the holidays.

The discount code is camiach(40% off Camel in Action, Second Edition, all formats, expiration: January 7, 2017)

To finish this blog post here are the latest screenshot of the Camel IDEA plugin in action:
Smart completion to present possible Camel options

The plugin also supports smart completion for the values, for example an enum based option shows which choices there are (and which one is the default if there is a default value)

Smart completion for enum values


Status of Camel in Action 2nd edition book

Jonathan and I just wanted to give an update on the status of the book, now that we are entering 2017 which will be the year the book is finished. Before summer 2017 we all have the final book in our hands.

Manning have told us the book is doing well, and they have granted us with a special x-mas holiday promotion code.

The discount code is camiach (40% off Camel in Action, Second Edition, all formats, expiration: January 7, 2017)

Yesterday we send out the following letter to our readers of the Camel in Action 2nd edition book.

Dear Reader,

2016 is coming to an end and we are well aware that we need to hurry up and complete the remaining chapters.

Claus has been busy of late with personal "stuff" which has taken away time and energy that he would otherwise have put toward the book. However the "stuff" is clearing up and he has free time to get back in the saddle and into the writing zone. He is on track with the popular microservices chapter that will be ready in the beginning of 2017.

Jonathan is closing in on having chapter 15 ready as well for the beginning of 2017 where a new MEAP update can be expected.

Then there are two more chapters scheduled. Claus will work on a container chapter that covers all the exciting new technologies with containers, Docker, Kubernetes, cloud, and so on.

We are very pleased that Henryk Konsek has agreed to be our guest author on a chapter about Camel and IoT.

We are revising the TOC and have decided to fold chapter 17 and 18 together into a single chapter about Camel, containers, and cloud where clustering is natural. This also means there is one less chapter and the book will be finished sooner.

After all the chapters are complete, we will revise every single chapter with all the feedback from the reviews and from our technical editors. So expect the material to sharpen up, and be much more fluent and pleasant to read when the proof editors have done their magic.

Kind regards,

Jonathan and Claus


Camel Live Reload of XML routes

Its been a while since I last did a Camel video. So today I recorded a video of the upcoming live reload functionality in Camel 2.19.

You can now enable live reload of your Camel XML routes which will trigger a reload on-the-fly whenever you save the XML file from your editor.

This is demonstrated in the short 5 minute video.

You can use the Camel live reload easily when using:

  • Camel standalone with Camel Main class
  • Camel Spring Boot
  • From the camel:run maven plugin

And for other use-cases you can enable this manually be setting a ReloadStrategy on the CamelContext. We provide the FileWatcherReloadStrategy out of the box, which is what is used above as well. However the idea is that end users can provide their own custom strategies as well.

We ship two examples out of the box which you can look at and try for yourself


Camel Maven Plugin can now parse your source code and report invalid endpoints

I have previously blogged about the fabric8 Camel Maven Plugin which is able to parse your source code and parse all the Java RouteBuilder and XML routes and report invalid Camel endpoints.

That was in the start of 2016. Now at the end of 2016, the code has stabilized and the fabric8 team has gracefully donated the source to to ASF so it will be included out of the box from Apache Camel 2.19.0 onwards.

To see the plugin in action you can watch the video from my previous blog. The plugin would work the same when its from Apache Camel.

To give a demonstration of the plugin, I have modified the camel-example-twitter-websocket example from Apache Camel to make some invalid configurations:

- Renamed the polling to poling in the twitter endpoint
- Added foo=bar as option to the log endpoint
- Spelt the sendToAll option with a lower case a.

And when I run the plugin I see

mvn camel:validate

Then Maven outputs:

[INFO] --- camel-maven-plugin:2.19.0-SNAPSHOT:validate (default-cli) @ camel-example-twitter-websocket ---
[INFO] Using Camel version: 2.19.0-SNAPSHOT
[WARNING] Endpoint validation error at: org.apache.camel.example.websocket.TwitterWebSocketRoute.configure(TwitterWebSocketRoute.java:109)


                   type    Invalid enum value: poling. Possible values: [polling, direct, event]. Did you mean: [polling]. Default value: direct

[WARNING] Endpoint validation error at: org.apache.camel.example.websocket.TwitterWebSocketRoute.configure(TwitterWebSocketRoute.java:110)


                    foo    Unknown option

[WARNING] Endpoint validation error at: org.apache.camel.example.websocket.TwitterWebSocketRoute.configure(TwitterWebSocketRoute.java:112)


              sendToall    Unknown option. Did you mean: [sendToAll]

[WARNING] Endpoint validation error: (0 = passed, 3 = invalid, 0 = incapable, 0 = unknown components)
[INFO] Simple validation success: (0 = passed, 0 = invalid)
[INFO] ------------------------------------------------------------------------
[INFO] ------------------------------------------------------------------------

As you can see it discovered 3 invalid endpoints, and reported suggestions what is the error.

By default the maven goal does not fail maven itself, and hence why you see BUILD SUCCESS. The plugin has a number of options you can configure.

For more information see the Camel Maven Plugin documentation.

PS: The plugin also parses your Simple expressions and report invalid configurations as well.

We may in the future add parsers for other languages so we can parse XPath, XQuery, Groovy and others.


Back from ApacheCon Sevilla 2016

This week I attended my first (but not my last) ApacheCon in Sevilla Spain. The event is co-hosted with Apache Big Data that runs monday and Tuesday and then ApacheCon from Wednesday till friday. I had the opportunity to travel to Sevilla on monday, and therefore had Tuesday as full day for sight seeing and attending a few talks at Apache Big Data.

Fellow Camel rider Jean Baptiste co-presented Apache Beam which seems like a really interesting project. It provides an unified API and DSL on top of various big data implementations such as Apache Flink, Hadoop, Storm, and what else is out there. I talked to Jean about a potential integration between Beam and Camel. It would open up the number of systems that Beam could ingest data from using the many Camel components.

In the hallway I meet Krzysztof Sobkowiak from the Apache ServiceMix project, so we took the opportunity to take a selfie. Kudos to Krzysztof for getting involved with ServiceMix so this project can get some releases out the door from time to time.

In the afternoon I went for sightseeing and I must say Seville is a beautiful city with parks, historical buildings, big cathedral and a bull fighter arena. All within walking distance in the city center.

The Plaza de Espana is particular impressive (see link on wikipedia for more impressive photos). Supposedly some footage of Star Wars and Game of Thromes was filmed there.

A friend of mine had be in Sevilla before and he told me about the many citrus trees in the streets, which was not so hard to find.

Citrus trees in the streets of Sevilla

On thursday I kicked off a series of Apache Camel talk. My talk was an introiuctinary talk as there is still many people who are not aware of Apache Camel - even at ApacheCon. However my first thought was that everybody knew Camel and people wanted to sleep in, as 10 minutes before my talk the room was empty.

Spanish way of life with siesta - 10 minutes before my talk

However people turned up and the room was half full and about 1/3 already knew Camel, so I was a on a mission to spread the word about Apache Camel.

Thanks Bilgin for the photo of me during my presentation
You can find slides to my talk at my slideshare account.

The following speaker Dzmitry Pletnikau talked about how his company are using Camel since 2013 in the real world as a non Java shop. It was interesting to hear how much they can do with Camel XML and a ServiceMix container running in docker so developers dont need any Java installed locally and just drop/edit an XML file.

Dzmitry Pletnikau speaking about Camel

Then Colm from Talend talked about the Apache Syncope (identity management) project and how they have integrated with Apache Camel that adds a lot of power to what you can do.

Colm about to start his presentation (sorry the photo is a little blurred)
The last Camel talk of the day was Bilgin Ibryam whom talked about cloud native Camel design patterns.

Bilgin about to start his presentation

Bilgin whom authored the awesome book Camel Design Patterns gave an excellent presentation where he talked about the implications and also new possibilities that the container world brings to the table. One of his slides had a great summary of integration patterns evolving.

How are integration patterns evolving?

You can find the slides for Bilgins talk at his slideshare account.

In the evenings Bilgin, myself and Krzysztof had the pleasure of accompanying some of our Apache friends from Talend and go out for tapas and a few beers. The highlight was the first evening on Wednesday where we found an excellent tapas bar with great food. I took a photo but unfortunately it was blurry.

Blurry photo but the food was excellent

I had to return back on friday morning as I have been attending two birthday parties with my friends in Sweden. So I could not attend the last day where Yahoo Japan gave a talk about Apache Camel and how they are using Camel in their production systems in Japan. I had the pleasure of meeting the speakers the day before and talk about Camel and what they are doing.

I also had many other hallway talks with attendees and fellow speakers about Open Source, Apache, and Apache Camel. It was great meeting so many and hearing about what is happening.

ApacheCon EU 2016 was great, and the location in Sevilla is awesome. I hope to be back in 2017 if Camel still sparks interrest and my talk is accepted.


Apache Camel now with 1000+ stars

Apache Camel was created before github existed. The project is hosted at ASF on their infrastructure.

ASF integrated with github 4-5 years ago and all their projects are mirrored to github. For example the first PR at github to Apache Camel is from November 2012.

In those 4 years at github we have seen more involvement from the community. Its much easier for users to provide code changes as github PRs and as such we have merged/closed 1246 as of today. A rough estimate is 95% of those PRs are from outside contributors, and 5% from Camel team itself.

At github projects can be starred by users whom seems to like the project. I personally do star other projects there whom I am using or have been used in the past which has benefited me.

Yesterday at the 9th November 2016 which is going to be a date that the world remembers as the day that Apache Camel reached 1000 stars at github. (* there was also another event on 8th/9th November that many people will remember)

As of now Apache Camel has 1030 stars. Thank you for showing the support for the project. 


I am going to ApacheCon EU 2016 - All day track on Apache Camel

I just booked my hotel and flight tickets for ApacheCon EU 2016 which is hosted in Sevilla Spain. Its a city I have never visited so I am looking forward to the trip. I will fly in on Monday so I have a full day before ApacheCon starts, where I plan to walk the streets and soak in some of the local atmosphere, food, coffee and maybe a beer ;).

ApacheCon EU starts on Wednesday 16h November and ends on Friday 18th. On the day between Thursday there is an entire full day track about Apache Camel.

I have the honor of kick off the track with my talk about Apache Camel - The integration library.

Of the other talks on the day I want to point out Bilgin's talk Cloud Native Camel Design Patterns. Biligin whom is a senior Camel architect/consultant has many years of experience in the field, and based on his knowledge he catalog a book Camel Design Patterns that has the modern patterns about microservices and cloud technologies. I really enjoy his book, which is highly recommended.

As a long term Camel user I am looking forward to attend and see all the other Camel talks to see how other users fare with Camel.

If you have interest in Apache Camel, then I hope you can attend ApacheCon EU. I love the hallway conversations at the conferences and events I attend. 


Apache Camel - Time for a new logo

At the Apache Camel project we have a current logo as shown

It was a great initial effort of a logo for the project when it was created 9 years ago. However we have discussed in the community to come up with a new logo.

We got in touch with some designers from opensourcedesign whom does volunteer work, and they have come up with a first design of a logo.

They work is posted at github where we encourage Camel users to participate and share your thoughts. We are an open community and very much want to hear and see your ideas for a new logo.

The logo is also discussed at the Apache Camel @dev mailing list where you also can participate.

Github ticket: https://github.com/opensourcedesign/jobs/issues/108


Apache Camel 2.18 Released - Whats included

This week Apache Camel 2.18.0 was released. This release is a significant release which I will highlight in this blog post.

Java 8
Camel 2.18 is the first release that requires Java 1.8 (eg easy to remember Camel 2.18 = Java 1.8. Camel 2.17 = Java 1.7). We have taken a cautious approach and kept the Camel API backwards compatible in the sense as an end user you can take your existing Camel application source code and re-compile them with Java 1.8 and Camel 2.18 and you should be all good.

Internally in the Camel source code we have started using Java 8 APIs for new functionality. Existing functionality is still using Java 7 APIs so we can easily backport bug fixes to the older versions.

We have also gently introduced a few Java 8 lambda/functional APIs into the Java RouteBuilder you can use in predicates and message transformations. You can view a little example at github.

Spring Boot Starters
We had support for Spring Boot since Camel 2.15, but in this release we have curated all the Camel components to align and make them work as first class Spring Boot starter components. This means you should use -starter as your dependencies, such as camel-kafka-starter.

Spring Boot Auto Configuration
All the Camel components now generate Spring Boot auto configuration source code which means you can configure components, data formats, languages etc using Spring Boot configuration. For example in the application.properties file. And on top of that tooling such as IDEA, Eclipse etc which has support for Spring Boot will have code completions when editing the application.properties file.

Nicola Ferraro whom help implement posted a blog entry with more details.

Spring Boot Health Check
Apache Camel comes with health check integrated with Spring Boot if you are using actuators. The health check does a coarse grain check that Camel did start up properly. We plan to implement a deeper Health Check API in Camel to allow individual components to participate in the check. For example to check if the component can connect to a remote system and so on.

WildFly-Swarm Camel
The WildFly Swarm project also has great support for Apache Camel. However this development happens at the wildfly-camel project. WildFly-Camel released version 4.3.0 that supports Camel 2.18.0.

Automatic Documentation
I have previously blogged about that we are working on keeping and generating the Camel documentation from the source code. This means that every Camel component, eip, language, data format etc. all have their options documented in the source code, which we then extract during build and keep the accompanying documentation up to date. We have migrated almost all the documentation from the old wiki system to .adoc files in the source code. We will continue this work to complete this for the next release, and will work on build a new website.

As a Camel developer you may think its not a big deal but really it is. This ensures that all options are always 100% up to date in the documentation. It also allows tooling to access this information at both design and runtime. hawtio can at runtime display deep level information about all your endpoints and include the documentation for each option as shown:

We also have a Maven plugin that can scan all your source code and report invalid configuring Camel endpoints. This plugin is currently hosted at fabric8 where we can foster innovation faster. However when the plugin matures then we plan to donate the source code to Apache Camel project to be included out of the box.

XML XSD fully documented
The XML XSD for Spring and Blueprint now also includes documentation for the configuration you can do outside routes, such as on and other global configurations.

One of the smaller but really lovely new additions is the FluentProducerTemplate which is using a fluent style API as a client API for sending a message to a Camel endpoint. Now you can do this nicely with

template().withBody("Hello World).withHeader("foo", 123").withHeader("bar", 456).to("jms:queue:beer").send();

Rest Producer
The Rest component allows to call REST services now (as a client), where you can pick one of the following Camel components for the HTTP transport: http, http4, netty4-http, jetty, restlet, undertow. You can also refer to a existing swagger api doc and include camel-swagger-java on the classpath, for automatic validation of rest endpoint is configured to use a valid rest operation/parameters.

Circuit Break using Hystrix
We added native support for using Netflixx Hystrix as circuit break in your Camel routes. There is an example included.

Below is another example from an example with Spring Boot calling a service running on WildFly Swarm that runs on Kubernetes cluster (or local) which I have been giving talks about recently.

    public void configure() throws Exception {
                .setBody().constant("Nobody want to talk to me")

Zipkin message tracing
The release also includes camel-zipkin which allows to use zipkin for distributed message tracing. You can find more details with the provided example.

The Service Call EIP allows to call remote services with service discovery from a pluggable service registry. For example you can use etdc, consul, ribbon, kubernetes and others are coming.

New Components
As usual each release comes with a number of new components:

  • camel-asterisk - For interacting with Asterisk PBX Servers
  • camel-cm-sms - For sending SMS messages using SM SMS Gateway.
  • camel-consul - For integrating your application with Consul.
  • camel-ehcache - For interacting with Ehcache 3 cache.
  • camel-flink - Bridges Camel connectors with Apache Flink tasks.
  • camel-lumberjack - For receiving logs over the lumberjack protocol (used by Filebeat for instance)
  • camel-ribbon - To use Netflixx Ribbon with the Service Call EIP.
  • camel-servicenow - For cloud management with ServiceNow.
  • camel-telegram - For messaging with Telegram.
  • camel-zipkin - For tracking Camel message flows/timings using zipkin.
  • camel-chronicle - For interacting with OpenHFT's Chronicle-Engine.
New Data Formats
And we also have a single new data format:
  • camel-johnzon - Apache Johnzon is an implementation of JSR-353 (JavaTM API for JSON Processing).
Important information when upgrading
Older versions of Spring such as 3.x and 4.0.x has been dropped.

OSGi users on ServiceMix/Karaf should also be using Karaf 4.x. However it may work on some older Karaf versions, but its not officially supported. The next release will drop support for older releases for sure.

OSGi users with Spring-DM should install camel-spring-dm module as Spring DM has been removed from camel-spring.

Spring Boot 1.4.x is now required.

You can find more details in the Camel release notes.

What's Next
We will work on a Camel 2.19 release where we can further improve on the trajectory the Camel 2.18 release brings us with the new path on Java 8. We also want to finish migrating the documentation and work on a new website. Hopefully we can also get a nice logo. 

Followed by Camel 2.19, we will get started on Camel 3.x. But this will be discussed in the Camel community first. However for the remainder of this year, we will focus on Camel 2.19 which is planned for start of / Q1 2017.


Installing Kubernetes from Copenhagen Airport in one command (while having a drink)

Yesterday I was on my way to USA to attend and speak at two events in Atlanta and Minneapolis that Red Hat is hosting.

My flight was delayed 3.5 hours and I was given a voucher with the value of 79 DKK which I could only spend in certain shops and restaurants. So I asked myself - Is it to early for a beer because the time was 10:30 am? 

... No never when you are in an Airport.

I worked a bit on my slides and when I was done with that, I though - Could I install Kubernetes using a single command, while I was drinking my 2nd order which was a Whiskey Sour?

So I deleted Kubernetes, fabric8 and what else I had on my laptop and got myself prepared and pressed the video record button. 

After 18 minutes of recording .. I can answer that Yes you can. 

Now I have arrived in Atlanta and have uploaded the full video recording, which you can take a look at. You may want to fast forward after 4-5 minutes where binaries and docker are downloading the internet from dockerhub. Yeah I guess I was pushing the boundaries what a public free to use wifi can be used for in an airport. I would assume they had some rate limiting or something. But nevertheless it works, and you are free to enjoy a beverage. That is a pretty good deal ;)

In case you wonder. The maven command:

   mvn io.fabric8:fabric8-maven-plugin:3.1.62:cluster-start

... can be run in any directory. There is no pom.xml file in the directory where I run the command.

You can find more information in the fabric8 maven documentation. And also if you haven't read James Strachan recent excellent blog about the busy Java developer, then I highly recommend to take a look at that too.

PS: I did make another spelling mistake. Did you spot it? .. It was in the text box in the beginning where I typed Kuberentes instead of Kubernetes.


James Strachan - A busy Java developers guide to developing microservices on Kubernetes and docker

James Strachan blogged a few days ago about all the great work that has happened recently at the fabric8 project in terms of improving the developer experience with "kicking the tires" as I say it.

As a Java developer he shows how you can get started with a Kubernetes cluster with a single Maven command, that downloads and install the binaries. While its doing that you can go fetch a cup of coffee and relax.

And don't worry the installation is local and installing in your home directory under .fabric8. So at the end of the day, you can just delete it all, and its gone - no uninstall procedure or something like that.

It has never been that easy to just from Maven run

    mvn fabric8:run

And it will build, deploy your application in the cluster, and then tailing the log. And when you are done, just press ctrl + c to break and the app is un deployed.

Oh bugger there is a bug in the code somewhere. How do I debug this, when the application runs in the cluster and my Java IDE is running on my computer/laptop? Well behold just run:

    mvn fabric8:debug

And you can attach a remote debugger from your Java IDE.

Okay I don't want to steal more of James thunder. Now head over and read his blog piece and make sure also to watch the video at the end. Christian Posta demonstrates all this.

PS: Next week we are traveling and presenting in USA. So if you have the opportunity to attend then James Strachan, Christian Posta, Rob Davies, James Rawling and myself will be there to give talks and demos about this stuff and other cool things as well.

PPS: The next thing we are working on is a fabric8:watch so you can do live code changes in your running containers without a full redeploy. There is still a few things to iron out to make it work well, but we are getting very close.


Videos from my two latest talks about Apache Camel and Developing Java based microservices

Last week I gave two talks at JDKIO 2016 in Copenhagen. I want to thank Javagruppen for organizing this conference and having my come to my home country and spread the love about Apache Camel and fabric8.

We had a group photo of all the speaks and organizers taken at the lovely waterfront in front of the Royal Library.

(its me with the orange bag-pack in the front center left) 

The talks was video recorded and just published to youtube today.

Apache Camel - The Integration Library

Links for video and slides.

Developing Java based microservices ready for the world of containers

Links for video slides and source code.


fabric8 going to America - Microservices day in Atlanta and Minneapolis

I have just got all my flight tickets and hotel bookings confirmed and are set for going to America in early October.

Red Hat is hosting two Microservices days in Atlanta and Minneapolis. They have titled the event:

... which is a title I really like ;)

The event is a full day event, where fabric8 and friends are speaking about the technologies and projects we work on.

James, Claus, and other speakers will discuss topics including: Kubernetes for Java developers, microservices with Apache Camel, microservices workflow, Integrated Platform-as-a-Service (iPaaS), and API-centric architectures.

I will bring along some of my fellow fabric8 colleagues: James Strachan, James Rawlings and Rob Davies from the EU, and we are joined by Christian Posta from the states. And I am sure Christian bring along a number of copies of his recent book: Microservices for Java Developers. And if you ask him I am sure he will also sign the book. I am still waiting for a chance myself to get hand on a hardcopy of the book.

We will be in Atlanta first, where the event take place on Tuesday 4th of October followed by the event in Minneapolis hosted on Thursday 6th of October.

I am glad to be visiting the state of Georgia again, where I spoke at the DevNexus conference five years ago. Minneapolis will be my first visit to the state of Minnesota. Minneapolis got my attention recently when I learned that Metallica played a rock concert there in what I assume is a new/rebuild stadium - feel free to correct me.

I have previously blogged about these kind of events such as last time we went to New York.

Hope to see you at either of the events, and we love to chat, and also share a beer.
You can find more details about the event, venue, and time at the event page.

PS: Yes you would need to register if you are going. The event page has more details.

PPS: If you need accommodation, then we are staying in the Hotel Indigo in Atlanta, and Hilton Garden Inn in Minneapolis. I am not aware of any discount code for hotels.


Giving two talks at the JDK.IO conference in Copenhagen

I am going to the JDK.IO conference next month, to give two presentations. The conference is located in Copenhagen, Denmark, so its a great chance for me to visit my home country. Well it's actually just 1 hour away with public transports from my door.

I am presenting the following two talks, on Tuesday 13th September:
The first talk is spreading the word about the lovely integration library called Apache Camel - readers of my blog may have heard about it before, or know that I have a "little" role in this project.

The second talk is about "the new world of containers" and how Java developers can get onboard developing Java applications (using Spring Boot, WildFly-Swarm, Camel, etc in the examples) in a microservice style that can run on container technology such as docker and kubernetes, all made easier using the fabric8 microservices platform. The abstract of this talk hasn't been updated on the website, but I assume they will publish that in due time.

For my talks I will have some giveaways, such as the lovely EIP playing cards, so that surely alone is worth a ticket ;)


New Book - Microservices for Java Developers by Christian Posta

One of our Camel riders, Christian Posta, recently had his first book published.

Microservices for Java Developers

The book is free of charge if you obtain it from the Red Hat Developer website (registration is maybe needed).

I recently finish reading the book which is the magic number of 128 pages. Luckily Christian mentions the promise of a 2nd edition of the book, so we can get the other half of 128 pages to make it a total of 256.

I really enjoyed reading the book as its very well written and the flow of the book takes you to the content you expect. I really like Christian did take the time to set the scene of microservices not being a magic technical one-stop silverbullet solution. The first chapter is really excellent at setting the scene what to expect from the book, what "microservices" is. Make sure to read this chapter, not only once but maybe a second time as well.

The technical content of the book shows you how to get started with building a Java based microservice using three well known Java frameworks with Spring Boot, WildFly Swarm, and DropWizard. So if you do not have hands on experience with all three of them, then there is something to learn for "old guys" like myself. I also loved that JBoss Forge was used as developer tool to quickly create the REST service for the WildFly Swarm example. This tool is a hidden gem. 

The last two chapters covers distributed microservices on a clustered platform such as Kubernetes. This is a new world to many, and this book has great content how to approach and get started. This world moves very fast and since the book was published, then I would suggest to use minikube or minishift to run a clustered kubernetes as that is much easier than the Red Hat OpenShift CDK. Also the fabric8 Maven plugin to build the docker image is currently being much improved (version 3.x) so it requires a lot less configuration. 

Is there anything less good about the book? Yes Apache Camel was not mentioned or covered in the book. We can only cross our fingeres for the 2nd edition to include our beloved Camel ;)

Christian - congratulation on the book. You surely know how to write, we have already seen this in your great blog posts in last couple of years covering the Microservices topics. Looking forward to the 2nd edition.


Video of Panel Discussion about Java Past, Present and Future with great experts in the Java world

In March 2016 I was speaking at Riga Dev Day 2016 about fabric8 Camel microservices for Docker & Kubernetes.

Later that day there was a Panel Discussion with some of the speakers talking about Java Past, Present and Future. Somehow I got myself into that panel (they may had a cancellation or something, and just grab the Camel guy for the empty seat). Thank you Riga Dev Day for having me on the seat along side great minds like Anton Archipov.

The video of that panel is now posted online on youtube.

It was great fun to be on the panel, and if I remember then I am pushing for Java to be smaller, slimmer and has less footprint so its more ready for tomorrows/todays world of container based platforms.


Apache Camel 2.18 - Highlights of what is coming

The Camel riders are busy working on the upcoming Apache Camel 2.18 release. As we update the release notes on the fly, its a way of quickly looking at what is coming.

I just wanted to do a quick update here in the summer what we have done so far with the highlights in short form. More elaborate details to come when a release is getting closer and the documentation improves.

Java 8
Apache Camel 2.18 is the first release that is requiring Java 8 as the runtime. I have previously blogged about that. So all the build and source code has been changed to compile as Java 8, and we have started using Java 8 code style with lambdas in new code (not in existing code as we backport fixes to older versions).

Netflixx OSS
We have new components that integrate Camel with the Netflixx OSS stack such as Hysterix and Ribbon.

which is integrated with the Hystrix dashboard.

And there is also a Zipkin component for distributed message tracing.

Service Call
We have introduced a service call EIP to abstract and making calling external services from Camel easy. The idea is that you can call a remote services the same way regardless where the service is hosted. Camel will lookup the service from a service registry of choice, such as from kubernetes, openshift, cloud foundry, zuul, consul, zookeeper or whatever.

Spring Boot
Running Camel on Spring Boot has been improved.

Camel is now available in the Spring starter website.

.. and Camel is now also on the WildFly Swarm website as well.

Camel now exposes a health indicator if spring boot health actuator is enabled

All Camel components and data formats now provide auto configuration options (with documentation) you can configure from tooling (we are pondering how to do similar for endpoint options).

And its all auto generated from the source code, so when a new option is added its automatic included in the next release.

Component documentation
We are in the process of migrating the Camel documentation from wiki to ascii docs files that are included in the source code, so we can generate a new website and documentation. This also allows us to keep the documentation automatic up to date from the source code. Huge thanks to Andrea Cosentino who has patiently done most of the migration, which is a labor intensive process.

New components
And as usual there is a number of new components. Currently we have 8 new for you.

Apache Camel 2.18 is targeted to be released after the summer vacation, around September timeframe.


Video presentation — fabric8 Camel microservices for Docker & Kubernetes

I gave a presentation at Riga Dev Day 2016 which was recorded and posted online on youtube today.

Title: fabric8 Camel microservices for Docker & Kubernetes

The slides for the talk is available on slideshare here.

The abstract of the talk is as follows:

The so-called experts are saying microservices and containers will change the way we build, maintain, operate, and integrate applications. This talk is intended for Java developers who wants to hear and see how you can develop Java microservices that runs in containers.

This talk uses Apache Camel as the Java library to build microservice architectured applications. At first we introduce you to Apache Camel and show how you can easily get started with Camel on your computer, and build a microservice application that runs on CDI and Spring-Boot.

The second part of this talk is about running Camel (or any Java project) on Docker and Kubernetes.

We start covering the basic concepts you as a Java developer must understand about Kubernetes. Then we show how to migrate Java projects to build as Docker images and deployable on Kubernetes, with help from fabric8 Maven tooling.

You will also hear about how to make your microservices scalable and distributed by leveraging the facilities that Kubernetes provides for truly distributed services with load balancing and location independence.

You will also see how to manage your container using the Kubernetes CLI and the fabric8 web console.

At the end we have a bit of fun with scaling up and down your Camel application to see how resilient the application is, when we kill containers.

This talk is a 50/50 mix between slides and demo.


Camel in Action 2 - One year later since we started

Its been a while since my last blog post or video.

I wanted to say some words about the progress of the work we do on the Camel in Action 2nd edition book.

I have noted in my calendar that I started writing the first words on Saturday March 7h 2015. Today one year later we are close to having 13 chapters done. Jonathan is finishing up the final touches on chapter 2. And yesterday I handed up my updates to the testing chapter to include a section covering Citrus Integration Testing with Camel.

All together on page counts, we have now surpassed the 1st edition which was 550 pages, and I estimate we are closing in on 600 pages. My last two chapters was rather long with about 70 pages each.

We are up for 2/3 round review where we will receive very valuable feedback from our readers. Thanks a lot. It really helps us steer the book in the right directions, and also help us focus on covering topics that are of the most interest.

There is still a many miles until we get to the finish line. But we are about to pass 66% and I am preparing for writing the chapter about microservices with Camel. I believe its a chapter that readers are looking forward to have in their hands.

Just a few words about writing a computer tech book. Its a lot of work besides the words on paper. At the same time we are building examples and providing source code for the book. And that do also take up a lot of time to do these code bits correct and of interest. We also spend time adding code comments and organizing the source code so you can browse the code on github, and quickly refer to where the code is being covered in detail in the book.

And you do this on a moving target. Apache Camel keeps marching on as usual, and we are very active working on the next release. At the same time Jonathan and I have to take notes about which of these changes/new features/etc are impacting the book. And then from time to time we have to circle back in past chapters and make updates accordingly.

So when you see that 10 out of 19 chapters are done in the Manning website. Then they are not done done. We are only done done when Manning tells us we are so, and that the book is heading into print. Well even so we are not done done, because after the book has been published, we keep updating the accompanying source code with future Camel releases. We have done that for 5 years since the 1st edition was published. Besides updates the source code we unfortunately may have mistakes slipping into the book, so with thanks from our readers, we have an errata to track those mistakes.

With the roads ahead of us I anticipate that Jonathan and I will have all the material ready in fall 2016, and the book enters type setting phase which is a process that Manning handles and that takes its time. That means the book will not be published in 2016, but in start of 2017.

Maybe at this time next year I can post a blog with the physical book in hand. That's gonna be a big big book. I estimate its going to be about 50% bigger than the 1st edition, so that is 800 pages.


Help tell Pivotal to accept Apache Camel as a choice on start.spring.io

With the Apache Camel 2.17.0 release we have a camel-spring-boot-starter module that has the naming and convention that Spring Boot advises.

What would be good is to get Pivotal to add Apache Camel to the list of choices in the http://start.spring.io web application.

I have created a github PR with a screenshot of the web app showing Apache Camel.

Now to raise the voice of the community. The Camel users who would like to see this happen, should go to this PR


And then notice that thumbs up yellow icon that is just below the description (you may need to scroll a little bit down). Currently it has 27 votes.

To cast a vote then hover the mouse just next to the icon, and there should be a "add your reaction" showing you can click and select thumbs up.

In the PR there is also a screenshot you can look at what that would be like, which is also shown here below:

We want Apache Camel as a choice in start.spring.io !!!


Apache Camel 2.17 Released

Apache Camel 2.17 has just been released.

This is the last release to support Java 1.7 which we have previously announced.

Here is a breakdown of the top noteworthy changes in this release (in random order).

For OSGi users.

Reworked the Apache Karaf feature to not install camel-spring by default. The problem is camel-spring is using spring-dm which is only supports Spring 3.x, and therefore Spring 3.x was installed and used. All the Camel features that uses Spring JARs are now using Spring 4.x.

SQL component can now load the SQL queries from external resources so you can use comments and format the queries using multi lines and indents.

In addition to that the SQL component now supports SQL IN queries where the IN values are dynamic calculated from the message body.

And there is also support for calling stored procedures using the sqlstored component.

There is a new camel-spring-boot-starter module that works like any other Spring Boot starter module.

The setHeader and setExchangeProperty allows to use a dynamic header key using the Simple language if the name of the key is a Simple language expression.

Many improvements and fixes to Rest DSL among others

Rest DSL is Swagger API 2.0 compliant.

The Rest DSL now supports default values for query parameters

The Rest DSL now only binds from POJO to JSon/XML if the content-type is for json or xml. This allows you to specify a custom content-type and omit the binding, such as when having binary payloads.

Using CORS has been improved and fixed.

Swagger API can now generate YAML output as well as JSon.

Avoid logging sensitive message body details.

Exchange and Message now only prints their id when their toString is called. Likewise the Camel Error Handler no longer log message body/header details when logging the Message History. There is an option you can turn this on again if wanted.

Complete overhaul and rewrite of the camel-cdi module. Thanks to our new Camel rider Antonin Stefanuti.

The Camel CDI component has been improved to better fit into the CDI programming model, cover a larger set of containers, and provide these new features:

  • The Camel events from the org.apache.camel.management.event package (like CamelContextStartedEvent) can be observed as CDI events
  • The new CDI event Camel endpoint enable CDI events to be seamlessly consumed from (respectively produced by) Camel consumers (respectively Camel producers)
  • CDI beans annotated with the @Converter annotation are automatically registered as type converters
  • The CDI Camel contexts can be properly customized programmatically in bean constructor or @PostConstruct lifecycle callback
  • Camel routes configured in RouteBuilder beans are added before the corresponding Camel contexts get started
  • CDI Camel contexts are now properly adapted when deployed in OSGi containers and are registered as OSGi services
  • Proper support of multiple Camel contexts across all the features
  • A new Camel CDI Test module is available to ease testing of Camel CDI applications

The camel-kafka module has migrated from using the Kafka Scala library to Kafka Java.

The Loop EIP now allows to run in a while loop mode, so it loops until the predicate returns false.

And as usual a bunch of new components. This time there is 12 new components and 4 new data formats.

For more details see the detailed release notes.

And any users who are upgrading then always read the bottom of the release notes about important changes to consider when upgrading.

You can download the release from Apache Camel website or from Maven Central if using Maven.


Roadmap for Apache Camel 2.18 and towards Camel 3

The Camel team recently announced that Camel 2.17 would be the last release to support Java 1.7. And that the following release Camel 2.18 will require Java 1.8.

The numbers in the versions aligns very well to make it easy to remember:

  • Camel 2.17 = Java 1.7
  • Camel 2.18 = Java 1.8

So with Java 1.8 being the minimum Java version and that the code is compiled as 1.8 source brings in all the glory of Java 1.8 with aspects from functional programming with lambdas and whatnot.

Apache Camel has a huge community of existing Camel users, and we do not want to throw you guys under the bus, with massive Java 1.8 API changes in Apache Camel 2.18. Instead we see this release as a stepping stone towards more Java 1.8 readiness and the next major release Camel 3.0.

We have put up an open discussion in the Camel community on the developer mailing list, where you can read and participate. We love to hear feedback from the community.

You can read online using nabble where you can also post to the list. Or you can signup using old fashioned mailing list and write emails.

But what if you want to provide feedback elsewhere. Well I am sorry but Apache Software Foundation mandates openness and transparency. The discussions about the Apache Camel project must take place using ASF infrastructure such as the mailing list. However you are welcome to post a short comment on this blog, and I can post your comments on the mailing list on your behalf, if you are not arsed to signup on a mailing list, or register using nabble. However you do yourself a favor of signing up the Camel mailing list as there is a ton of information you can learn from other Camel users.

Just a word about Camel 3.0. The big goal for Camel 3.0 is less technical but more a new website and new documentation. And we would love to see a new project logo as well. The technical parts are sure there too, but its overdue for a modern website with documentation we maintain from the source code so its much easier and faster to keep it up to date. Also all the EIP and Component options is slurped from the source code to ensure the documentation is 100% in sync.


Camel tools to add or edit endpoints from current cursor position

This is a continuation of the video blogs I have done about our development on the fabric8 Camel tools.

Today is friday so it was a chance to grab a beer and do a one take video recording. This time demonstrating how the Camel tools is able to from the cursor position in your Java editor such as IDEA or Eclipse to add or edit Camel endpoints in a type-safe way using a wizard. What is cool about the command is that you just put the cursor on the line with the endpoint to edit, or place the cursor where you want to add the endpoint.

The video is 7 minutes long and shows Eclipse and IDEA where I edit two different Camel projects. One project is using XML for declaring the Camel routes, and the other is using Java. The tools work with both kind.

So sit back and grab a beer and watch, or if you are in the office then maybe grab a coffee or tea.

We are working on doing the same for the EIP patterns and got that working for XML, but the Java bits is still pending. But down the road what you see in this video would be possible to across the board in Camel.


Cheers - fabric8 Camel Maven Plugin to validate Camel endpoints from source code

Today I recorded a 12 minute video to demonstrate the new fabric8 camel-maven-plugin that is able to validate all your Camel endpoints from the source code. This allows to ensure your endpoints are valid before you run your Camel applications or unit tests. And it helps you catch those type errors or if you use invalid values for the options and so on.

video of fabric8 camel-maven-plugin in action
The fabric8 camel-maven-plugin can be run from within your Java editor as I demonstrate in the video, and of course from the command line. The plugin is able to parse both XML and Java code (the latter uses Eclipse JDT). So should be useful for all schools of Camel users.

We hope to improve on the plugin to have tighter integration in the editors such as IDEA and Eclipse, so you can have in-place Camel endpoint validation and code assistance while typing your Camel endpoints. We are working together with the JBoss Forge team to add the necessary hooks and apis that allows this plugin and the Camel forge commands to tie into that. 

Cheers and have a beer its the weekend soon, and yesterday Apache Camel 2.16.2 and hawtio 1.4.60 was released. That is a good excuse for grabbing a beer or a glass of wine.


Apache Camel and other ESB products (Camel vs Mule) - 5 years later

Yesterday Raul Kripalani (a fellow Camel rider) posted a tweet:
Shoutout to @davsclaus & #Camel riders! Just added a reflection upon the last 5y on this SO question: https://stackoverflow.com/questions/3792519/apache-camel-and-other-esb-products/34818263#34818263 …. Have a look!
The tweet refers to an old question on stackoverflow about the Apache Camel versus other ESB, and this question is in particular about Camel vs Mule.

The question was asked in September 2010, and now fast forward 5+ years Raul took a look at the situation today. I think his detailed answer is worth attention for users of Camel, and others who are doing assessment on integration software.

Rauls answer starts out as shown below. I suggest to go read his post - after you have finished reading this blog ;). And you are welcome to use the upvote ;)

I think Raul has some major points to point out about the difference between Camel and Mule.

The key differentiator I see is, the non technical aspects, Apache Camel is:
  • 100% truly open source
  • Open community
  • Everything is discussed and happening in the open
  • Anyone can participate (and become a committer)
  • No control of a single vendor
  • All branding and marks belongs to ASF
  • ASF is a non-profit foundation where companies cannot control it
  • All code is open source and ASL licensed (no open-core/community vs enterprise model)
  • No vendor lock-in

An maybe overlocked fact is that the branding and marks of Apache Camel belongs to the ASF foundation. So no commercial company can "take the brand" and run with it. Neither Red Hat or Talend etc. can create a product called Red Hat Camel, Talend Camel ESB etc or some variation of the project name. Apache Camel is the authentic project.

Other projects may encounter such a problem. For example docker is very famous brand today, and there is no neutral foundation that owns that brand, the brand is owned by docker.inc (the company). So IMHO there is an interest of conflict with the brand name and docker.com the commercial company.

Another important aspect of Apache Camel (and ASF projects) is that there is no open-core/community vs enterprise model. At Apache Camel we would never deceive the community, for example by learning which Camel components that are the most popular and remove the source code from the community version and put that under a different license in a closed-source enterprise only product.

We from the Apache Camel project do neither spread/post FUD and eschewed marketing stunts on the Apache Camel website, unlike Mulesoft, where they are doing that by posting their controversial Mule vs Camel post on their commercial website. The piece of material smells of corporate bullshit, and no true honest developer would write such a piece of ...  (excuse my english)

And a final note Its also worth referring people to the previous blog, which also spun from a tweet where you can easily compare projects on blackduck, such as Camel vs Mule.

With Apache Camel it is all about the community, for the community, and all work is done in the open. Anyone can participate and we love contributions.

Roll on 2016 its going to be another great year for the Camels.