Oct
15
4:30pm
Kafka and Kubernetes on OpenShift World Tour
By IBM Developer
In this workshop in the Build Smart on Kubernetes World Tour series, you will work with Java, Reactive Messaging APIs, Apache Kafka, and Red Hat OpenShift. You will learn how to build reactive Java microservices using the Eclipse MicroProfile Reactive Messaging API and Open Liberty.
You will learn how to build reactive microservices that can send requests to other microservices, and asynchronously receive and process the responses. You will use an external messaging system to handle the asynchronous messages that are sent and received between the microservices as streams of events. MicroProfile Reactive Messaging makes it easy to write and configure your application to send, receive, and process the events efficiently.
Asynchronous communication between microservices can be used to build reactive and responsive applications. By decoupling the requests sent by a microservice from the responses that it receives, the microservice is not blocked from performing other tasks while waiting for the requested data to become available. Imagine asynchronous communication as a restaurant. A waiter might come to your table and take your order. While you are waiting for your food to be prepared, that waiter serves other tables and takes their orders too. When your food is ready, the waiter brings your food to the table and then continues to serve the other tables. If the waiter were to operate synchronously, they must take your order and then wait until they deliver your food before serving any other tables. In microservices, a request call from a REST client to another microservice can be time-consuming because the network might be slow, or the other service might be overwhelmed with requests and can’t respond quickly. But in an asynchronous system, the microservice sends a request to another microservice and continues to send other calls and to receive and process other responses until it receives a response to the original request.
MicroProfile Reactive Messaging provides an easy way to asynchronously send, receive, and process messages that are received as continuous streams of events. You simply annotate application beans' methods and Open Liberty converts the annotated methods to reactive streams-compatible publishers, subscribers, and processors and connects them up to each other. MicroProfile Reactive Messaging provides a Connector API so that your methods can be connected to external messaging systems that produce and consume the streams of events, such as Apache Kafka.
🖥 What you will learn
During this webinar you will learn the following skills:
- running reactive microservices in containers
- consuming Apache Kafka messaging in IBM Cloud from containers
- running containers with Kubernetes on Red Hat OpenShift
🎙 Speakers
Marek Sadowski is the published author on Serverless Swift (preorder today: https://www.apress.com/gp/book/9781484258354) - connect with Marek via Twitter: @blumareks
hosted by
IBM Developer
share