JavaOne 2015 Diary – Day 5 “The Final Chapter”
JavaOne is happening as we speak and we’ve got Lars Röwekamp reporting on what you want to know from the biggest Java event of the year. His final diary entry for the conference focuses squarely on microservices and Java EE.
So today was the last day of the JavaOne conference, sad! Today’s agenda involved the traditional JavaOne Community (Comedy) Keynote and another session on Microservices.
Although the hype around the topic of microservices certainly isn’t as high as it would be at specially aligned conferences, you can just feel that there is so much need for discussion around it now – especially in the Java community. What better place than JavaOne?
Microservices and Java EE
My first event dedicated to microservices was Reza Rahman (Oracle) and Steve Millidge’s (Payara) session, appropriately titled “Down-to-Earth Microservices with Java EE”. You could see that Rahman is a 100% advocate of Java EE, and it was obvious very quickly that he wasn’t the biggest fan of microservices:
I’m not here to CHEERLEAD microservices. I’m here to give you a realistic view on it.
I really liked Rahman’s definition, too:
The problem is, microservcies are not necessarily micro and are not necessarily services. For me, building a microservice-based system means taking a large system and separating it into smaller, separately deployable parts.
From a purely technological point of view, Java EE has everything it needs to develop microservices, says Rahman – and I absolutely agree. For many years, in addition to the necessary APIs for implementing RESTful services, tools have also existed for management and monitoring. Anything else would frankly be surprising, since Java EE is not just a collection of APIs but an enterprise computing platform.
After Rahman chatted about microservices in general and the possibility of implementation using Java EE, Steve Millidge referenced the Cargo Tracker Application – a kind of blueprint for combining Java EE and DDD – which makes a monolith into a microservice-based application that can then be migrated. To this end, he extracted a service from the monolithic Cargo Tracker Application and deployed it several times separately in connection with access from the original application. This was carried out on the server’s various instances via a load balancer. Sources from the demo can be found on GitHub and are definitely worth a closer look.
SEE ALSO: JavaOne 2015 Diary – Day 3 (a.k.a Day 4)
Millidge’s demo was really well done. Above all, this example shows how the complexity (and with it the risk) of development decreases with the gradual migration of a monolith to a microservice-based architecture, while the areas of deployment, management and monitoring take on even more meaning (DevOps, here’s your cue). And to prove that this requires a large degree of discipline, one need look no further than the microservice role model that is Netflix.
Of course, Rahman is right when he claims that Java EE brings all essential elements along for the implementation and operation of microservices. However, I personally can’t imagine that Netflix would be able to operate successfully if several hundred services were deployed via a Java EE server, a hundreds times a day. This certainly works for some, but beyond that there must be an alternative. There are now a number of server manufacturers and suppliers recognising the Java EE environment and offering appropriate solutions, such as TomEE Shades, Wildfly Swarm, Payara Micro, GlassFish and KumuluzEE. All of these solutions are capable of bundling Java EE components together with their own (micro) service as a separate bootable JAR, then operate as a standalone service. Alternatively, even a glance at Drop Wizard or SpringBoot wouldn’t hurt.
Microservices and the other stuff you need
My impression is that microservices don’t eliminate the existing complexity of an enterprise application, but shift it from development into the area of operations. To this end, the session “Building a Microservice Ecosystem: Some Assembly (still) Required” by Daniel Bryant (Open Credo) confirmed my thoughts. Apart from the fact that I have never heard a speaker talk so fast in my life, the session was really informative and gave a good overview of possible tools one could use for a successful microservice ecosystem (Build, Test, Deploy, Operate and Observe). A look at Bryant’s slides would be worthwhile for those interested – even if they only reflect a fraction of what Bryant dished out advice-wise in 60 minutes of audio.
SEE ALSO: JavaOne 2015 Diary – Day 2
Also of interest would be the blog post “Anatomy of a Modern Production Stack” by Joe Bedas, which Bryant referred to in his talk. Bedas describes how a modern production stack with quality characteristics should look to him: Debuggable, self healing, self managing, supporting and efficient.
From this talk I’ve taken in a lot of information, but two quotations were especially poignant:
“A Microservice is an application that fits in your head.”
James Lewis, ThoughtWorks
“Monitoiring is all about the people!”
Daniel Bryant, Open Credo
… So true!
One conference ends, another begins
Slowly, but surely, the JavaOne has come to an end. It’s now time for me to pack my bags and return to good ol’ Germany. There, the WJAX in Munich awaits me. I’m looking forward to sharing the positive impressions of JavaOne, which I hope will pique the interests of other attendees. Feel free to speak to me if we bump into each other!