2016-08-22

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


2016-08-08

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.


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