Software is complex, but we can't seem to stop creating it. That's because the complexity we build into our software is also the part that solves our users' interesting problems. We can't eliminate complexity but, good news, we can organize it.
MicroServices, MicroProfile, EE4J, & Java EE
Eclipse MicroProfile Metrics provides a unified way for MicroProfile servers to share monitoring data with performance management systems. Metrics also provides a common Java API for exposing their telemetry data including unified and mutually understandable metadata. In this talk you will learn how MicroProfile Metrics gathers telemetry data about the JVM and underlying system from collectors like Performance Co-Pilot (PCP) and Parfait.
With the right tools, building scalable applications can be much easier than it seems. Eclipse MicroProfile allows you to build such applications easily and you get a variety of options to scale them if you add distributed data grids. These can become a backbone for building horizontally scalable services, while at the same time providing flexible caching to scale up their performance vertically.
On my right : Java 9 and its modular approach with JPMS (also known as Jigsaw).
On my left : the Micrroprofile platrform which targets very small deployment to perform small feature in the most resilient and lightest way possible.
Can we marry both ?
In this session we'll explore all the challenges to solve to use JPMS on microservice and explore some solution to get started with modularity and Microprofile.
In a second part we'll try to creaate a full modular standalone runtime image with Jlink, and, who knows, perhaps we'll succeed?
Microprofile is a great standard to build vendor neutral micro services. One of the nicest feature of the platform is probably the fact that it is CDI centric.
Having CDI as a core requirement for Microprofile allow users to add features to their micro services in a standard portable way.
In this session we'll see how we can use CDI to add extra features to a microservice in a natural and portable way. We'll start with an existing extension and then we'll create our own CDI feature by using protable extensions to show how easy it is to extend the Microprofile platform
Lifting and shifting existing applications to the Cloud is a common task for many deveopers these days. This session will explain 3 common scenarios for moving Java EE standards based applications to Azure using concepts applicable to other cloud environments as well. One is of course using Containers and Kubernetes; Second is by using a platform runtime such as Azure AppService. And the third is by using Service Fabric. In the end, we will see the differences, pros/cons, and also open for Q&A.
On March 2018, Microsoft released the source code of one of its core Azure services: Service Fabric is now open sourced on GitHub - https://github.com/Microsoft/service-fabric/. This talk will introduce Java developers to the platform: how to download and install Service Fabric on Linux, and how to run an application designed for it.
Java EE, cloud native and service meshes — this doesn’t really sound like a good fit. Or does it? Is it possible to develop modern, cloud native Java Enterprise applications that fulfill concerns such as scalability, monitoring, tracing, or routing — without implementing everything ourselves? And if so, how to do this?
Testing is still a topic that most developers would like to avoid. Even though it is crucial for working software, developing and maintaining tests takes certain time and effort — especially when changes in existing functionality forces test scenarios to adapt or distribution needs to be taken into account. Omitting software tests can’t be the solution; therefore, how can we tackle enterprise tests in an effective and productive way?
This session is the perfect starting point for entering the world of microservices. First, play my game, a minimalistic microservice application built using the latest technologies that Jakarta EE and MicroProfile have to offer. You only need your phone (and nimble fingers). Next, see how it works. Learn the core concepts and basic architecture for developing and deploying microservice applications. Stay engaged long after the session by extending the game with your own AI service. Plug it in and watch it compete against other AI services.