Jakarta EE / EclipseCon 2020

[This recording contains some minor technical issues.]
Transactions are one of the most complex and yet very important areas of computing. They can get particularly hard when the system moves to the distributed environments as almost every component in the distributed system is liable to failures. Traditional locking protocols, used in transaction solutions today, are then very prone to holding locks on resources for unnecessarily long periods. The saga pattern provides an alternative non-blocking solution with the design that allows individual parts of the transaction to be committed immediately and independently. This design is specifically suitable for long running transactions and distributed systems. In this session, we will present a newly created MicroProfile specification called Long Running Actions (LRA) which provides a definition of the transactional protocol and a simple API for the distributed transactions in the Java microservices environment based on the saga pattern. We will show you why the saga pattern is a very suitable transactional solution for many distributed microservices applications and demonstrate the usage of the LRA specification with the live coded demo.


Speaker(s):
Martin Štefanko (Red Hat, Inc.)

We have been hearing a lot about the benefits of using the reactive approach to solving concurrency problems in distributed systems. While reactive programming refers to the implementation techniques being used on the coding level, on the systems deployment and runtime level, we can leverage on a robust yet very flexible and lightweight framework such as Vert.x to deliver. In this session, we will first learn about what the missions of a reactive system are, which, among many things, include handling multiple concurrent data stream flows and being able to control back pressure as well as managing errors in an elegant manner. We will also discuss the special polyglot nature of Vert.x and its use of the Vertical model. Live coding will accompany this session to illustrate how to program a simple use case using multiple JVM languages such as Java and Kotlin, and then we will build and dockerize it to be deployed as a serverless container to the Knative cluster in a delightful manner.


Speaker(s):
Mary Grygleski (IBM)

The session will describe how to migrate an existing Java EE/Jakarta EE application to run in Kubernetes, how that application can be extended using Java microservices supporting MicroProfile. I will show how a "hybrid" application comprising Java EE/Jakarta EE components, microservices, and a shared distributed cache can be modeled and managed as a single logical application in Kubernetes to support ongoing application modernization. The session will demonstrate technologies that make such a migration possible, giving developers pragmatic approaches for evolving existing enterprise applications to modern cloud native architectures and innovative technologies such as GraalVM.

Attendees should be generally familiar with Java EE/Jakarta EE technologies, MicroProfile and containers and Kubernetes/CNCF technologies. The session focuses on how these technologies can be integrated and used together to support evolution of cloud native enterprise applications in Java.


Speaker(s):
Will Lyons (Oracle)

One of the most important things when building microservices for the enterprise mission critical systems is high reliability. Even if a new deployed service has a bug, it is required that the other services should not be affected by this bad service.

This session will provide how to build such a robust system with MicroProfile functions such as Fault Tolerance, Metrics, and OpenTracing. Although there are a lot of tuning knobs in Fault Tolerance (timeout, circuitbreaker, retry, fallback, and so on), it is very difficult to find the best values for each parameter of each microservice.

This session will provide a demonstration to show how to tune these parameters in cooperation with Istio, and various other tools, such as Grafana and Kiali, to monitor microservices, and the attendees will learn how to find the best parameter values.

Speaker(s):
Kenji Kazumura (Fujitsu Limited)

In this presentation you'll learn how to quickly and easily build and deploy your Java application on the cloud using Eclipse JKube.

The presentation will show how standard Java applications using a variety of Frameworks can be easily deployed into Kubernetes and OpenShift clusters with very little configuration and a very smooth and seamless user experience.

We will also show how to make a plain old webapp ready to be deployed in the cloud and how can the development process and experience be greatly improved by using Eclipse JKube's developer features.

A beginner level of Java and Maven is recommended.


Speaker(s):
Marc Nuri (Red Hat, Inc.)

When it comes to API, REST is king. Its simplicity and pragmatism have seduced the greatest number of people. Even if the good practices and recommendations of Roy Fielding, its founder, are not always well implemented…

In 2012, FaceBook developped GraphQL which is an alternative API technology based on a query language and an execution engine. Since then, GraphQL has become Open Source and is now managed under the umbrella of the Linux foundation. This presentation will allow you to understand the characteristics of GraphQL and how it relates to REST: complement or replacement? Is it just for unicorn or open to enterprise applications?

It will also be the opportunity to showcase a concrete implementation with MicroProfile GraphQL.

So, ready to boost your APIs?

Speaker(s):
Jean-François James (Worldline)

Jakarta EE 9 is out! This is the second release of Jakarta EE since the transition from the Java Community Process (JCP) to Eclipse Foundation. In this session, we will go through every aspect of Jakarta EE 9 and how this release lowers the barriers of entry, eases the migration and lays the foundation for a platform for future innovation.
We will also look ahead towards what future releases may bring.

Speaker(s):
Ivar Grimstad (Eclipse Foundation)

Are you wondering how to secure microservices? Eclipse MicroProfile JWT (https://microprofile.io/) is the answer. MicroProfile JWT designs a token based authentication and authorization mechanism, which enables authorized access from clients to services or from services to services by using JWT token. This session will give you a quick overview on the MicroProfile JWT design, followed by a live demo of 2 microservices communication by passing on the JSON web token, running on Open Liberty (https://openliberty.io/) and Quarkus (https://quarkus.io/). Come to this session to understand the technology and learn how to use it.


Speaker(s):
Emily Jiang (IBM)

For the last few years the terms cloud-native and microservice architecture have been used interchangeably. However recently people have ceased to view microservices as the go-to solution for all problems, reflecting a growing maturity in our understanding of how to best take advantage of the benefits of cloud computing.

While microservices have many benefits, they also bring their own challenges and better understanding (and some failed microservices projects) have led to a more critical evaluation of suitability of microservices to all problems. This evolved understanding has resulted in a new interest in the place for monoliths in the cloud. Whether referred to as macroservices, or cloud-native monoliths there is a gap forming between the terms cloud-native and microservices that wasn’t there before.

What does this gap mean? How are cloud architectures evolving? How does Eclipse, through Jakarta EE and Eclipse MicroProfile, fit into this new world? Join me as I look at microservices and monoliths in the context of cloud-native architectures.


Speaker(s):
Alasdair Nottingham (IBM)

For most enterprise projects, testing is not really fun. It’s boring, cumbersome, and takes time and effort — especially for distributed applications or when changes in existing functionality forces test scenarios to adapt. Still, software tests are crucial; so, how can we tackle them in an effective and productive way?

This session shows what is necessary to effectively test Java microservices in an automated way. We’ll see which approaches work well, how to keep a fast feedback loop and constant velocity, how to manage complex test scenarios that involve multiple services, and how to verify our API contracts. One of the key aspects will be how to write maintainable test code with high quality that embraces principles of software craftsmanship. I’ll be live-coding test cases using Enterprise Java, Quarkus, Docker, and Kubernetes. Join us to improve your testing flow experience.

Speaker(s):
Sebastian Daschner (IBM)

Dive into the next generation cloud native framework for running Java in microservice oriented cloud platforms. Quarkus focuses on developers and ease of use in modern serverless environments.
It is a Kubernetes Native Java framework tailored for GraalVM and HotSpot, crafted from best-of-breed Java libraries and standards.
A hands on overview of the Quarkus cloud native framework, what it brings to the Java ecosystem and what new concepts and design guidelines it introduces.

Demo presenting Quarkus with focus on:
- Developer joy
- Memory footprint and performance
- Reactive and imperative paradigms
- Libraries and standards

The attendances should have programming experiences with Java and some knowledge around Enterprise Java runtimes and frameworks.


The attendances will get an overview of Enterprise Java challenges in Serverless and Cloud environments and how Quarkus rises up to those challenges. The developer experience that Quarkus provides and various run modes.


Speaker(s):
Anamarija Talijanac (IBM)

In this session we will compare some of the most popular Microservice frameworks in the Java ecosystem like SpringBoot, Quarkus, Eclipse MicroProfile, and more. We will give an overview and jumpstart for each framework. Next to this we will answer questions like:
Which features do provide all of them, what are their unique selling points?
How do I start writing microservices with the different frameworks?
Which technology stack do the different frameworks use?
How do they perform in regards to startup time, and responding with different response sizes?
How large are the resulting application containers in Docker?

Slides (External URL):
https://speakerdeck.com/hendrikebbers/a-comparative-review-of-microservice-frameworks


Speaker(s):
Karsten Thoms (Karakun AG)
Hendrik Ebbers (Karakun AG)

Writing micro-services within Jakarta EE is technically possible, but you miss a few goodies for the distributed environment you are running in. MicroProfile wants to optimize your Enterprise Java application by creating Java standards which link to some well known CloudNative standards like etcd for Configuration, OpenTracing and Jaeger for Distributed Tracing and Prometheus for Metrics. In this talk, we go over some basic concepts of the MicroProfile specifications and show you through various demos how the integration with those tools can be done easily. Examples of configuration, tracing, metrics and fault tolerance will be shown. After this introduction, you will know all the basics to write your next micro-service with Enterprise Java and MicroProfile.

This session shows the attendees various examples of how the MicroProfile implementations can be integrated with products from the CloudNative standards. It will give them insight how microservices defined with Java and MicroProfile can use those products to make the operations of their micro services easier.

Attendees should have a basic understanding of microservices and the challenges which come with them.


Speaker(s):
Rudy De Busscher (Payara Services Limited)