OpenDevHour

MicroProfile Reactive Messaging proposes an efficient way to build event-driven microservices and streaming applications. Reactive Messaging is used in various use cases ranging from IoT gateway to data analytics. Its protocol-agnostic approach and CDI development model enables asynchronous, message-based exchanges between your microservices.

In this show, we will cover:

• What is reactive messaging, and briefly talk about other reactive terms;
• How it supports multiple protocols such as Apache Kafka, AMQP, MQTT, and the integration with Apache Camel;
• The novelties introduced in 2.0 related to bridge reactive and imperative programming model, message processing, acknowledgment, metrics...

After this talk, you should be able to understand Reactive concepts and be able to use MicroProfile Reactive Messaging 2.0 to build a reactive microservice.

Java has evolved significantly in the past two decades, and with that comes new use cases. Some users still want to run highly scalable monolithic applications; but others demand fast start-up and small footprints for cloud computing.

Checkpointing in Java can help both legacy and cloud users. In this session we will show you how to checkpoint a simple application and then restore it to one or several different machines. An application that might take minutes to start up can load classes, initialize its state, be garbage collected, and then checkpoint itself for easy distribution in its warmed-up state. Such applications can be restored and ready to provide services in milliseconds.

What you will learn:

• An overview of Checkpoint-Restore In Userspace (CRUI), a Linux utility that Java checkpointing is based on.
• The proposed Java API.
• Interesting use cases including how to precisely checkpoint legacy applications via byteman without modifying the code.

AQAvit (Adoptium Quality Assurance) is an initiative to make the verification of OpenJDK binaries more open, transparent and robust. It is also an approach at continuous improvement. With over a quarter billion downloads, a rapid release cadence, an ever-growing set of supported platforms and running upwards of 100,000,000 tests per OpenJDK release, our work needs to be highly automated and evolve quickly.

In this session we will focus on some design choices for portability, extendability and continual innovation, and talk about specific decisions that we made to support various CI systems (Jenkins/Github actions/Azure Devops), running external application tests (including Quarkus/Scala/Microprofile TCKs) and prototyping and research (in the areas of Machine Learning/Change-based testing).

What you will learn:

• What is Eclipse Adoptium (AdoptOpenJDK) and Eclipse AQAvit, and why you should care.
• How AQAvit delivers massive-scale open-source DevOps solutions.
• Design choices and innovations that help our open-source projects stay vital.

Without data, software is nothing. The more sophisticated the software, the more data sources flow through it. The temptation can be to automate these flows with scriptish code that connects databases, web services, stream and other components. But microservices work best when components remain decoupled. They are easier to optimize and the whole environment becomes more scalable.

In this session we will look at how Apache Camel provides the integration framework and methodology to support microservices DevOps.

What you will learn:

• The basics of an integration framework and what’s important.
• Apache Camel’s toolbox in action, including recommendations for integration patterns and data flows.
• Other open source integration platforms and tools, such as Syndesis and Fuse.
• Real-life use-cases.

Observability is a critical concept for developers to understand and utilize to the fullest. It’s not just about the APIs that developers use to register metrics, create traces, and log messages. Developers must know how the telemetry they produce is used for observability by SREs and operations. Without that knowledge, developers are only creating telemetry that creates a problem of too much data for operations.

This session will highlight key aspects of Observability for developers, walking through the various pieces of telemetry that can be created with Quarkus. Utilizing Micrometer for metrics and OpenTelemetry for tracing, attendees will learn how they can work together to provide a detailed view of an applications’ behavior with monitoring tools.

What you will learn:

• What is Observability? Hint, it's not monitoring!

• Why is Observability key to application success?

• The OOTB metrics with Micrometer and Quarkus

• Tracing execution with OpenTelemetry and Quarkus

Building Manageable Cross Cluster Microservices Architectures

Artificial intelligence (AI) is becoming increasingly popular and helps to support automation within daily life. With this change how do we ensure this can easily be trusted by a user?

Regulation changes such as the GDPR mean that users have a right to understand how their data has been processed as well as saved. Therefore if, for example, you are denied a loan you have the right to ask why. This can be hard if the method for working this out uses “black box” machine learning techniques such as neural networks. TrustyAI is a new initiative in Red Hat which aims to explain decisions like this and help to trace the decision-making process for auditing.

What you will learn:

• Methods of how to trust your AI

• A new initiative at Red Hat which aims to do this

• How to look at black-box models and explain them

Building Manageable Cross Cluster Microservices Architectures

When breaking down your monoliths and moving to a microservices architecture, interesting new opportunities arise. Microservices can be deployed and hosted on different cloud providers, deployed to different runtime container platforms, use best of breed managed services, and can utilize new programming paradigms like event-driven architecture and reactive programming. All this is done to make these systems more agile, scalable, and available in a fast-moving online industry.

However, this decoupling also introduces a lot of complexity in terms of monitoring, tracing, debugging, security, etc. In this session, we’ll cover:

• How OpenShift enables architecting microservices for the hybrid cloud.

• Adding tracing capabilities to your architecture to enable cross-cluster application insights.

• Debugging techniques for applications running in container platforms.

We’ll discuss and demo some of the OSS tools and techniques that Red Hat consulting uses to help developers build/package applications into containers and deploy them onto a container platform. We’ll discuss how Red Hat does it at scale during customer engagement and Labs residencies and discuss the lessons learned.

• We’ll explore the concept of an “Application Chassis” for all containerised applications.
• Discuss and demo the Open Innovation Labs “ubiquitous-journey” GitOps CI/DC approach.
• Run through a demo of PathFinder, a tool we use to assess existing applications for containerisation.
• And if there’s time left discuss a book we’re currently writing.

So you have built-in no time your Quarkus application and it's supersonic subatomic fast but have you thought about security? Usually, this is the thing we implement at the end even if it's a crucial part of our application we often ignore it. The good news it's that with Quarkus, adding security and identity management is a breeze. Join us for an almost slideless hack session walking you through security concepts in Quarkus.

Join us for the live coding session where we

• explore the different options that Quarkus offers you to secure your applications.
• talk about best practices and single sign on
• learn what it takes to think about security from top to bottom.

This session was canceled due to illness.

Come and join us for an (almost) no-slides session around the terrific trio of Debezium, Apache Kafka Streams, and Knative Eventing!

Leveraging Apache Kafka as the de-facto standard for event-driven data pipelines, these open-source technologies allow you to ingest data changes from relational and NoSQL databases, process and enrich them, and consume them serverless-style.

In a live demo, you’ll see:

• How Debezium, Apache Kafka, Quarkus, and Knative are the dream-team for building serverless, cloud-native stream processing pipelines.
• How to stream change events out of your database using Debezium
• How to use Kafka Streams and Quarkus to build cloud-native stream processing applications, running either on the JVM or as native binaries via GraalVM
• How to consume and distribute Kafka messages with Knative Eventing, allowing you to manage modern serverless workloads on Kubernetes

Speed: faster feature delivery, faster startup, faster peak performance. The downside to speed is that it doesn’t matter how fast something works if it gets the wrong answer If the code security can hurt you then faster is not better — it just means you will be harmed faster. Fortunately, native tooling integrates into this stack, letting people code with tools they know while finding problems they otherwise would not know. Learn how a new framework, RedHat’s Quarkus, picks up where JavaEE and Spring left off, to enable more rapid delivery of features while staying secure.

In this interactive 60-minute webinar we will cover the following topics:

• What makes code secure
• What the common pitfalls are while programming in Java
• How to secure your code with Quarkus

Managing the lifecycle of applications in Kubernetes and OpenShift can be complex. Developers not only need to manage multiple manifest files but have an intimate understanding of each of these resources. Learn how Helm improves productivity, reduces complexity and speeds up cloud-native adoption. 

In this interactive 60-minute webinar we covered the following topics:

• What Helm is and does
• How Helm simplifies the development of cloud-native applications
• How packaging changed 
• Effectively using Helm as Developer

Quarkus flips your assumption about how fast and small Java can be. It gives you super-fast start-up times and small memory and disk footprint. Perfect fit for usage in Cloud Native and Serverless applications.

In this interactive 60-minute webinar we will cover the following topics:

• An introduction to Quarkus 
• How it was made,
• What it does and
• Why it makes Java relevant again.
• The brand new features of Quarkus 1.4 and 1.5 that makes Quarkus go beyond just containers and microservices.

Slides    More resources