2016-06-30

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.


2016-06-14

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.

2016-05-31

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.

2016-05-01

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.

2016-03-30

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

https://github.com/spring-io/initializr/issues/207

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 !!!

2016-03-27

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).

1)
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.

2)
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.

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

4)
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.

5)
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.

6)
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.

7)
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

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

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

10)
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.



2016-03-24

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.