'maak serverless java supersonisch met lambda en quarkus'

[ENGLISH BELOW]

Weinig developers staan te springen als ze Java serverless moeten gebruiken. Het heeft de reputatie traag te zijn. Solution architects Michael Strydom en Julian Exenberger vertellen je hier dat dit oud nieuws is. Met de juiste optimalisaties werkt Java ook serverless weer soepel – bijvoorbeeld op Lambda. En als kers op de taart bouw je met Quarkus in een mum van tijd de snelste serverless Java-apps.

Waar denk je aan als je Alfa Romeo hoort? Waarschijnlijk aan roest. Een vervelend stigma dat op het automerk rust sinds de jaren zeventig toen het inderdaad kort met roestproblemen kampte. Met zo’n stigma kampt ook Java. En het is waar, wil je serverless werken met Java dan houdt het nieuwere talen als JavaScript en Python niet bij. Een echte beperking voor Java developers in de serverless space. Jammer dat dit beeld nu overheerst, want Java is in de kern ontzettend stabiel, flexibel en in staat zich te evolueren. Als je het maar een beetje liefde geeft.

Kies serverless

Dat Java het minder goed doet op serverless platforms heeft vooral te maken met de langzame start-up. Ideaal voor traditionele client/server computing, waarbij een enkel Java Server-programma duizenden verzoeken voor gebruikers uitvoerde en de start-up zo veel mogelijk werd geoptimaliseerd. Hierdoor komt Java traag op gang, maar draait het daarna extreem snel. Serverless daarentegen draait potentieel duizenden standalone Java-programma’s met elk een eigen gebruikersverzoek. Daar merk je bij elk verzoek aan het serverless platform de trage opstarttijd van Java.

Benut de lifecycle

Die traagheid van Java binnen een serverless platform kan je met wat aandacht gelukkig prima oplossen. Hoe precies, vertellen we je aan de hand van AWS Lambda. Op dat platform lopen de verschillende fasen van de lifecycle op verschillende snelheden. Door te veranderen hoe Java samenwerkt met de serverless lifecycle, realiseer je – in sommige gevallen – een dramatische prestatieboost. Hoe? Door de verschillende snelheden van de lifecycle te benutten om de algemene prestaties te verbeteren.

Stop met Spring

En je kan verder optimaliseren door Java-apps anders te schrijven. We hebben serverless namelijk niet altijd de overhead nodig van populaire ontwikkelingsframeworks, zoals Spring. Die helpen bij het beheer van complexe programma’s, maar verhogen ook het resourceverbruik en de start-upsnelheid van Java-programma’s. En de vele Spring-alternatieven die er dankzij Android zijn, maken efficiëntere en eenvoudigere programma’s mogelijk. Denk aan het Dagger framework van Google, dat conceptueel vergelijkbaar is met Spring, maar veel beter werkt voor kleinere applicaties en stukken sneller is.

Blijf trouw aan Java

Quarkus is zo’n geschikt framework om snel serverless Java-apps te bouwen. Iets waar Java tot voor kort het onderspit in dolf. Waarom? Java kon Kubernetes en de opkomst van clusterbeheer met lichtgewicht applicaties niet bijhouden. Nieuwe scripttalen boden bovendien meer mogelijkheden voor server- en clientside ontwikkelingen. En single threaded apps zoals Node.JS waren geen probleem meer, omdat Kubernetes meerdere van deze single threaded toepassingen beheert. Multi-threaded applicaties zoals Java kregen hierdoor een klap.

Java ondervond nog meer problemen op Kubernetes. Vooral de grootte van de artefacten na het bouwen en de tijd die het kostte om apps uit te rollen. En vergeet niet het beroemde garbage collection-probleem, waarbij het onmogelijk was om een garbage collection uit te voeren op het moment van jouw voorkeur. En wanneer dat toch lukte, hielp het weinig. Als gevolg verdween Java bijna van het toneel. Pas bij de latere patchversie van Java 8 (na patch 153) werden de meeste problemen met de Java-Kubernetes-integratie opgelost. Op één ding na: de grootte van deployment artefacten bleef groot.

Herontdek Java met Quarkus

Daar vond Red Hat in 2019 een antwoord op met hun opensourceplatform Quarkus. Red Hat wilde Java klein en licht maken en zorgen dat Java-development van serverless apps leuk en gemakkelijk werd. Daarom heeft Quarkus uitgebreide libraries en standaarden en combineert het imperatief en reactief coderen. Zo lost Red Hat onder meer het probleem van Java’s grootte op.

Quarkus maak je je ook makkelijk eigen. Zo configureer je het – zonder te overdrijven – in een dag. Ik, Michael, gebruik Quarkus nu voor integraties en rapportages om mijn team te ontlasten. Ik bouw met Quarkus in een mum van tijd Springboot-API’s, Apache Camel-integraties en OpenTelemetry. Helemaal sterk is dat je geen keuzestress hebt bij Quarkus; in plaats van duizend manieren om code te schrijven is gekozen voor de meest nuttige manier.

En dan is Quarkus ook nog eens open source, en wordt het platform continu verbeterd door haar gemeenschap.

We kunnen dus officieel zeggen: de roestproblemen van Java zijn verleden tijd. Java is nu ook serverless keihard uit de startblokken. Spread the word.

Over Julian

Julian is software architect bij Capgemini met een passie voor technologie. Naast Java heeft hij in alles gewerkt van VB tot Objective-C tot Ruby-on-Rails. De laatste tijd is hij uitgegroeid tot een behoorlijk Kotlin-afficiando, cloud-native ontwikkelingsveteraan en Lean-enthousiasteling. Als hij niet achter een computer zit, kan je hem zien lezen, schrijven of houtbewerken of gewoon tijd doorbrengen met zijn gezin.

Over Michael

Ook Michael is software architect bij Capgemini. Het grootste deel van zijn ervaring ligt in systeemintegratie, SOA-patronen en natuurlijk Java. In zijn vrije tijd experimenteert hij onder andere met de cloud, IOT, automatisering, robotica en Raspberry Pi. Hij heeft een voorliefde voor alles wat met back-end te maken heeft en laat het front-end werk over aan degenen die van selfies en man-buns houden.

---

‘Make serverless Java go supersonic with Lambda and Quarkus’

Not many developers are eager to go serversless with Java. It’s earned a reputation for being too slow. But as solution architects Michael Strydom and Julian Exenberger explain, that’s all old news. With the right optimizations Java can run just fine serverless, for example on Lambda. And as icing on the cake, you can use Quarkus to build the fastest serverless Java apps in no time.

What’s the first thing you think of when you hear the name Alfa Romeo? There’s a good chance it’s ‘rust’. Alfa Romeo earned that reputation back in the 1970s, when the cars did have a bit of a rust problem. Java suffers from a similar stigma. And it’s not entirely unjustified: Java can’t keep up with newer languages like JavaScript or Python for serverless applications. That’s a serious limitation for developers in the serverless space. But it’s unfortunate that so many people are still hesitant to use it, because at its core Java is stable, flexible and constantly evolving. You just have to give it a little TLC.

Choose serverless

The reason Java doesn’t work as well on serverless platforms is mainly because of the slow start-up time. It’s ideal for traditional client/server computing, where a single Java Server program performs thousands of user requests and optimizes the start-up as much as possible. That makes it start up slow, but then everything goes extremely fast. Serverless applications on the other hand may need to run thousands of stand-alone Java programs, each with its own user request. That’s when you notice Java’s slow start-up time for each request for the serverless platform.

Utilize the life cycle

Fortunately, you can solve Java’s speed problem on serverless platforms with just a few simple changes. We’ll explain how using the example of AWS Lambda. On that platform, the various phases of the life cycle run at different speeds. By changing how Java collaborates with the serverless life cycle, you can potentially achieve a dramatic boost in performance. How? By utilizing the various speeds of the life cycle to improve overall performance.

Stop using Spring

You can also continue to optimize by changing how you write Java apps. That’s because with serverless, we don’t always need the overhead for popular development frameworks, like Spring. They can help with managing complex programs, but they also increase the resource requirements and the start-up speeds of Java programs. And the many alternatives to Spring now available thanks to Android make more efficient and simpler programs possible. Take Google’s Dagger framework, for example, which is conceptually comparable to Spring but works much better for smaller applications, and is much faster.

Stay true to Java

Quarkus is another framework that’s suitable for building fast serverless Java apps, which is an area where Java had been losing until recently. Why? Java wasn’t able to keep up with Kubernetes and the rise of cluster management with lightweight applications. Newer script languages also offered more options for server-side and client-side developments. And single-threaded apps like Node.JS were no longer a problem, because Kubernetes can manage multiple single-threaded applications. That was a big setback for multi-threaded applications like Java.

Java also experienced other problems on Kubernetes; especially the size of the artifacts after build and the time it took to roll out apps. And don’t forget the infamous garbage collection problem, which made it impossible to conduct a garbage collection at the moment of your choosing. And if you did manage to do one, it didn’t help very much. So Java virtually disappeared from the scene. Only with the later patch version of Java 8 (after patch 153) were most of the problems solved with the integration of Java and Kubernetes. All but one, in fact: the deployment artefacts were still too large.

Rediscover Java with Quarkus

In 2019, Red Hat found an answer with their open-source platform Quarkus. Red Hat wanted to make Java small and light, and ensure that Java development of serverless apps was fun and easy. To that end, Quarkus offers expansive libraries and standards, and combines imperative and reactive coding. That’s how Red Hat solved problems like Java’s cumbersome size.

Quarkus is also easy to master. You can quite literally configure it in just one day. I (Michael) use Quarkus now for integrations and reports, to take work out of my team’s hands. With Quarkus, I can build Springboot APIs, Apache Camel integrations and OpenTelemetry in no time. And one great benefit is that you don’t have too much to choose from with Quarkus; instead of having thousands of ways to write code, they’ve chosen the most useful method. Quarkus is also open source, and the community is constantly improving the platform.

So we can now officially announce: Java’s rusty reputation is a thing of the past! Java is now revving its engines to get started with serverless. Spread the word.

About Julian

Julian is a software architect at Capgemini with a passion for technology. He’s worked in everything, from Java and VB to Objective-C and Ruby-on-Rails. Recently he’s grown to become a serious Kotlin afficionado, a cloud-native development veteran and a Lean groupie. When he’s not working at his computer, you can find him reading, writing, doing woodwork or simply spending time with his family.

About Michael

Michael is also a software architect at Capgemini. He has a wealth of experience with system integration, SOA patterns, and of course Java. In his free time, he also experiments with the cloud, IoT, automation, robotics and Raspberry Pi. He has a soft spot for anything related to back-end, and leaves the front-end work to those who like selfies and man-buns.