RESTEasy Reactive: Why should you care? | DevNation Tech Talk

•

0 likes•3,924 views

RESTEasy Reactive is a JAX-RS implementation built for Quarkus that is async by default using Vert.x. It provides reactive support with Mutiny and has an ultra-fast architecture using code generation and endpoint pipelining. RESTEasy Reactive makes REST endpoints non-blocking and faster by default while also supporting blocking use cases. The presentation demonstrates how to make endpoints faster using RESTEasy Reactive and encourages feedback on the framework.

Technology

RESTEasy Reactive : why should I care?
Stéphane Épardaud, Red Hat. @UnFroMage

We always need a plan, even if we don’t follow it
● A brief glimpse at why you should care about async, reactive, blocking
○ And all those event-loop, IO Thread, Worker Thread terms that hipsters and C programmers
use
● How can I turn my REST endpoints from rusted, slow, old-style to golden
buzzword-enabled syrup?
○ DEMO!!!
● This item was placed here just to check if anybody is reading this, but it
doesn’t matter we won’t have time to cover it anyway
● Recap and Questions

Traditional architecture: IO and worker threads

More efficient architecture: non-blocking by default

So what is RESTEasy Reactive?
● JAX-RS implementation redone from scratch (client and server)
● Built for Quarkus
○ Async by default, using Vert.x
○ Reactive support with Mutiny
○ Ultra-fast architecture
■ Code generation, no reflection
■ Endpoint pipelining
■ Dead steps elimination
○ Better APIs
○ Better defaults
○ Small footprint
○ Dev UI support
● Great in conjunction with Mutiny, the Vert.x reactive SQL clients and
Hibernate Reactive!

But is it hard to make my endpoint faster-than-light?

Recap
● Import quarkus-resteasy-reactive*
● Non-blocking by default
○ Also supports blocking use-cases: use @Blocking
● Faster by default
○ If you don’t need more speed, perhaps you need the usability improvements?
● We’re looking for feedback, so don’t hesitate to throw some our way!
● Get quarkus-resteasy-reactive for free today with the #RROSS
coupon
○ Offer good forever
■ There’s no fine print
● Well there is but it’s just a joke

Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/2PeX3wC. Steve Klabnik gives an overview of Rust’s history, diving into the technical details of how the design has changed, and talks about the difficulties of adding a major new feature to a programming language. Filmed at qconnewyork.com. Steve Klabnik is on the core team of Rust, leads the documentation team, and is an author of "The Rust Programming Language”. He is a frequent speaker at conferences and is a prolific open source contributor, previously working on projects such as Ruby and Ruby on Rails.

Event machinealmeidaricardo

rsyslog meets docker

Rainer Gerhards

Building your own NSQL store

Edward Capriolo

Unikraft: Fast, Specialized Unikernels the Easy Way

ScyllaDB

P99 CONF Unikernels are famous for providing excellent performance in terms of boot times, throughput and memory consumption, to name a few metrics. However, they are infamous for making it hard and extremely time consuming to extract such performance, and for needing significant engineering effort in order to port applications to them. We introduce Unikraft, a novel micro-library OS that (1) fully modularizes OS primitives so that it is easy to customize the unikernel and include only relevant components and (2) exposes a set of composable, performance-oriented APIs in order to make it easy for developers to obtain high performance. Our evaluation using off-the-shelf applications such as nginx, SQLite, and Redis shows that running them on Unikraft results in a 1.7x-2.7x performance improvement compared to Linux guests. In addition, Unikraft images for these apps are around 1MB, require less than 10MB of RAM to run, and boot in around 1ms on top of the VMM time (total boot time 3ms-40ms). Unikraft is a Linux Foundation open source project and can be found at www.unikraft.org.

Rust kafka-5-2019-unskip

Gerard Klijs

Rust is a relatively new programming language promising performance, reliability and productivity. In order to learn Rust Gerard converted a micro service he already wrote in Clojure and Kotlin, both JVM languages, to Rust. The microservice processes two kinds of events, and uses PostgreSQL to keep state. As part of the conversion he wrote a library to use the Confluent Schema Registry with Rust. What can be said about the promises of Rust compared to the JVM? Gerard will tell about his experiences in using Rust with Kafka, and presenting some benchmarks comparing the different languages. The focus of the benchmarks will be the end to end latency and resource usage. He will conclude with some remarks why it may or may not be a good idea to add some Rust to your Kafka.

Whoops! I Rewrote It in Rust

ScyllaDB

Three engineers, at various points, each take their own approach adding Rust to a C codebase, each being more and more ambitious. I initially just wanted to replace the server’s networking and event loop with an equally fast Rust implementation. We’d reuse many core components that were in C and just call into them from Rust. Surely it wouldn’t be that much code… Pelikan is Twitter’s open source and modular framework for in-memory caching, allowing us to replace Memcached and Redis forks with a single codebase and achieve better performance. At Twitter, we operate hundreds of cache clusters storing hundreds of terabytes of small objects in memory. In-memory caching is critical, and demands performance, reliability, and efficiency. In this talk, I’ll share my adventures in working on Pelikan and how rewriting it in Rust can be more than just a meme.

Rust Is Safe. But Is It Fast?

ScyllaDB

Rust promises developers the execution speed of non-managed languages like C++, with the safety guarantees of managed languages like Go. Its fast rise in popularity shows this promise has been largely upheld. However, the situation is a bit muddier for the newer asynchronous extensions. This talk will explore some of the pitfalls that users may face while developing asynchronous Rust applications that have direct consequences in their ability to hit that sweet low p99. We will see how the Glommio asynchronous executor tries to deal with some of those problems, and what the future holds.

By Katerina Barone-Adesi. Driven by the needs of scientific computing, rapid rises in memory bandwidth have made it possible to implement high-performance network functions in a radically simpler way. Snabb Switch rides this wave, bypassing the kernel to process network packets in terse Lua, leaving the programmer free to focus on the essence of their problem. This talk presents our experiences delivering a carrier-grade implementation of "lightweight 4 over 6", an IPv4-as-a-service architecture that tunnels access to the IPv4 internet through specialized Snabb appliances. We report on our recent experience implementing a carrier-grade virtualized network function, with observations on what it is like to build real-world, high-performance Snabb applications. (and kernel bypass). Each instance runs at essentially line speed on two ten-gigabit Ethernet cards. Lightweight 4-over-6 (lw4o6) defines an IPv4-as-a-service architecture that allows ISPs to internally operate an IPv6-only network, tunneling IPv4 connections between lw4o6-aware endpoints installed at the customer's site (e.g. in OpenWRT) and an internet-facing "lwAFTR". Lw4o6 was specified in 2015 as RFC 7596 and has the architectural advantage that the carrier-side lwAFTR only needs per-customer state, not per-flow state. An lw4o6 system can also be configured to share IPv4 addresses between multiple customers as part of an IPv4 exhaustion strategy. It allows IPv4 networks to interoperate smoothly, while a carrier between them runs a pure-IPv6 network. Igalia has built an open source "lwAFTR" implementation that is ready to deploy in production. We describe the joys of hacking with Snabb, giving a quick intro to Snabb, modern x86, and lw4o6 along the way. (c) 2016 FOSDEM VZW CC BY 2.0 BE https://archive.fosdem.org/2016/

High Availability for OpenStack

Kamesh Pemmaraju

The primary requirements for OpenStack based clouds (public, private or hybrid) is that they must be massively scalable and highly available. There are a number of interrelated concepts which make the understanding and implementation of HA complex. The potential for not implementing HA correctly would be disastrous. This session was presented at the OpenStack Meetup in Boston Feb 2014. We discussed interrelated concepts as a basis for implementing HA and examples of HA for MySQL, Rabbit MQ and the OpenStack APIs primarily using Keepalived, VRRP and HAProxy which will reinforce the concepts and show how to connect the dots.

Scylla Summit 2018: Rebuilding the Ceph Distributed Storage Solution with Sea...

ScyllaDB

RedHat built a distributed object storage solution named Ceph which first debuted ten years ago. Now we are seeing rapid developments in the industry and we want to take advantage of them. In this talk, we will briefly introduce Ceph, revisit the problems we are seeing when profiling its I/O performance with flash device, and explain why we want to embrace the future by switching to Seastar. We’ll share our experiences with the audience of how and when we are porting our software to this framework.

Object Compaction in Cloud for High Yield

ScyllaDB

In file systems, large sequential writes are more beneficial than small random writes, and hence many storage systems implement a log structured file system. In the same way, the cloud favors large objects more than small objects. Cloud providers place throttling limits on PUTs and GETs, and so it takes significantly longer time to upload a bunch of small objects than a large object of the aggregate size. Moreover, there are per-PUT calls associated with uploading smaller objects. In Netflix, a lot of media assets and their relevant metadata is generated and pushed to cloud. We would like to propose a strategy to compact these small objects into larger blobs before uploading them to Cloud. We will discuss how to select relevant smaller objects, and manage the indexing of these objects within the blob along with modification in reads, overwrites and deletes. Finally, we would showcase the potential impact of such a strategy on Netflix assets in terms of cost and performance.

Spring Boot to Quarkus: A real app migration experience | DevNation Tech Talk

Red Hat Developers

Running a Spring Boot application but still want to benefit from Quarkus and its supersonic, subatomic Java capabilities? Me too! With a “hello world” everything looks simple, but what about a real app? Will it be easy? Or fun? In this session we’ll show our experience migrating a Spring Boot app to Quarkus. Technologies involved in the app include Hibernate, Prometheus, REST endpoints, and more. Be prepared to listen to a journey of reality, failure, and wins in the Quarkus universe.

Rust with-kafka-07-02-2019

Gerard Klijs

Cassandra To Infinity And Beyond

Romain Hardouin

Netflix Open Source Meetup Season 4 Episode 2

aspyker

In this episode, we will take a close look at 2 different approaches to high-throughput/low-latency data stores, developed by Netflix. The first, EVCache, is a battle-tested distributed memcached-backed data store, optimized for the cloud. You will also hear about the road ahead for EVCache it evolves into an L1/L2 cache over RAM and SSDs. The second, Dynomite, is a framework to make any non-distributed data-store, distributed. Netflix's first implementation of Dynomite is based on Redis. Come learn about the products' features and hear from Thomson and Reuters, Diego Pacheco from Ilegra and other third party speakers, internal and external to Netflix, on how these products fit in their stack and roadmap.

Apache Kafka – (Pattern and) Anti-Pattern

confluent

High Performance Systems in Go - GopherCon 2014

Derek Collison

Build Low-Latency Applications in Rust on ScyllaDB

ScyllaDB

Deployment topologies for high availability (ha)

Deepak Mane

Netty training

Marcelo Serpa

Ruby eventmachine pres at rubybdx

Mathieu Elie

Building event streaming pipelines using Apache Pulsar

StreamNative

FluentD for end to end monitoring

Phil Wilkins

Fluentd and Distributed Logging at Kubecon

N Masahiro

Stacking up with OpenStack: Building for High AvailabilityOpenStack Foundation

RISC-V on Edge: Porting EVE and Alpine Linux to RISC-V

ScyllaDB

What is special about community-industry collaboration around an open architecture like RISC-V is that the community can join development around key kernel subsystems in parallel with the semiconductor companies and manufacturers as they are producing the new chipsets and boards. Open silicon design, open board design, and open kernel software speeds bring-up of new boards and fosters greater innovation due to the diversity of talent contributing to the technology. For many kernel developers, tackling RISC-V is becoming harder to resist now that commercially viable and scalable hardware has begun to enter the market. A private beta program launched by the BeagleBoard Foundation in March 2021 placed an affordable, yet powerful prototype RISC-V board into the hands of Roman Shaposhnik. What did Roman do? He joined a diverse team of software and hardware hackers to tackle bringing up Linux on the new board. In this talk, Roman will tell you about his experience porting Alpine Linux and LF Edge EVE-OS to the new RISC-V architecture.

Scylla Summit 2022: Learning Rust the Hard Way for a Production Kafka+ScyllaD...

ScyllaDB

Numberly operates business-critical data pipelines and applications where failure and latency means "lost money" in the best-case scenario. Most of those data pipelines and applications are deployed on Kubernetes and rely on Kafka and ScyllaDB, where Kafka acts as the message bus and ScyllaDB as the source of some data enrichment. The availability and latency of both systems are thus very important because they mix and match data in the early stage of their pipelines to be consumed by their platforms. Most of their applications are developed using Python. But they always felt that they could benefit from a lower-level programming language to squeeze the performance of their hardware even further for some of the most demanding applications. So, when an important part of their data pipeline was to be adjusted to reflect some important changes in their platforms, they thought it was a great opportunity to rewrite it in Rust! Moving to Rust was hard, not only because of the language itself, but because being at a lower level allowed them to see, test, and demonstrate things that they could not pinpoint or explain that well using Python. They spent a lot of time analyzing the latency impacts of code patterns and client driver settings and ended up contributing to Apache Avro as they went down the rabbit hole. This session will share their experience transitioning from Python to Rust while meeting the expectations of a business-critical application mixing data from Confluent Kafka and ScyllaDB. There will be code snippets, graphs, numbers, tears, pull requests, grins, latency results, smiles, rants of frustration, and a lot of fun! To watch all of the recordings hosted during Scylla Summit 2022 visit our website here: https://www.scylladb.com/summit.

Asynchronous job queues with python-rq

Ashish Acharya

Reasoning about data and consistency in systems

Daniel Norman

What's hot

Snabb Switch: Riding the HPC wave to simpler, better network appliances (FOSD...

Igalia

High Availability for OpenStack

Kamesh Pemmaraju

Scylla Summit 2018: Rebuilding the Ceph Distributed Storage Solution with Sea...

ScyllaDB

Object Compaction in Cloud for High Yield

ScyllaDB

Spring Boot to Quarkus: A real app migration experience | DevNation Tech Talk

Red Hat Developers

Rust with-kafka-07-02-2019

Gerard Klijs

Cassandra To Infinity And Beyond

Romain Hardouin

Netflix Open Source Meetup Season 4 Episode 2

aspyker

Apache Kafka – (Pattern and) Anti-Pattern

confluent

High Performance Systems in Go - GopherCon 2014

Derek Collison

Build Low-Latency Applications in Rust on ScyllaDB

ScyllaDB

Deployment topologies for high availability (ha)

Deepak Mane

Netty training

Marcelo Serpa

Ruby eventmachine pres at rubybdx

Mathieu Elie

Building event streaming pipelines using Apache Pulsar

StreamNative

FluentD for end to end monitoring

Phil Wilkins

Fluentd and Distributed Logging at Kubecon

N Masahiro

Stacking up with OpenStack: Building for High AvailabilityOpenStack Foundation

RISC-V on Edge: Porting EVE and Alpine Linux to RISC-V

ScyllaDB

Scylla Summit 2022: Learning Rust the Hard Way for a Production Kafka+ScyllaD...

ScyllaDB

What's hot (20)

Snabb Switch: Riding the HPC wave to simpler, better network appliances (FOSD...

High Availability for OpenStack

Scylla Summit 2018: Rebuilding the Ceph Distributed Storage Solution with Sea...

Object Compaction in Cloud for High Yield

Spring Boot to Quarkus: A real app migration experience | DevNation Tech Talk

Rust with-kafka-07-02-2019

Cassandra To Infinity And Beyond

Netflix Open Source Meetup Season 4 Episode 2

Apache Kafka – (Pattern and) Anti-Pattern

High Performance Systems in Go - GopherCon 2014

Build Low-Latency Applications in Rust on ScyllaDB

Deployment topologies for high availability (ha)

Netty training

Ruby eventmachine pres at rubybdx

Building event streaming pipelines using Apache Pulsar

FluentD for end to end monitoring

Fluentd and Distributed Logging at Kubecon

Stacking up with OpenStack: Building for High Availability

RISC-V on Edge: Porting EVE and Alpine Linux to RISC-V

Scylla Summit 2022: Learning Rust the Hard Way for a Production Kafka+ScyllaD...

Similar to RESTEasy Reactive: Why should you care? | DevNation Tech Talk

Asynchronous job queues with python-rq

Ashish Acharya

Reasoning about data and consistency in systems

Daniel Norman

Kernel Recipes 2014 - Performance Does Matter

Anne Nicolas

Deploying clouds is in everybody’s mind but how to make an efficient deployment ? After setting up the hardware, it’s mandatory to make a deep inspection of server’s performance. In a farm of supposed identical servers, many miss-{installation|configuration} could seriously degrade performance. If you want to discovery such counter-performance before users complains of their VMs, you have to be detect them before installing any software. Another performance metric to know is “how many VMs could I load on top of my servers ?”. By using the same methodology it is possible the compare how a set of VMs performs regarding the bare metal capabilities. The challenge is here: How do detect automatically servers that under perform ? How to insure that a new server entering a farm will not degrade it ? How to measure the overhead of all the virtualization layers from the VM point of view ? Erwan Velu – Performance Engineer @eNovance

How To Maintain Million Lines Of Open Source Code And Remain Sane or The Stor...

Radovan Semancik

PyCon Canada 2019 - Introduction to Asynchronous Programming

Juti Noppornpitak

Since Python 3.5 and PEP 492, we have been able to write asynchronous programs in an easy and Pythonic way without external libraries. Even so, it is still difficult to understand what asynchronous programming is all about and when we, Python developers, should consider using it. This talk will give you a gentle introduction to the world of asynchronous programming, focusing mostly on the core concept of async programming, how it works, and what its applications are, in order to provide a good foundation to Python developers on the topic. On top of that, we will explore a small code example (mostly involving the built-in asyncio) and briefly exam the source code of CPython to find out how it works. This talk will also give you some brief comparison of threading.Thread and ThreadPoolExecutor.

A first look into the Project Loom in Java

Lukas Steinbrecher

The async/await syntax has arrived in JavaScript, Kotlin and Rust as a pattern for asynchronous programming - but the Project Loom of the JDK team chooses another way. This talk deals with the approaches of asynchronous programming in different programming languages and shows what Java and Project Loom want to do differently with their concept. https://lukstei.com/2020-07-25-a-first-look-into-the-project-loom-in-java/

Understanding concurrency

Anshul Sharma

Rundown of Async/Await in Rust

Knoldus Inc.

Asynchronous programming is a method of programming that can allow multiple different things to be run concurrently (or in parallel). In Rust, it is accomplished using a high-level idea called a Future. Asynchronous programming is used a lot for IO because there are many times where you have to wait for something to happen (such as reading from a socket or a file) during which no progress can be made. This is a perfect moment to hand over control to something else so that it can start to make progress. This allows our program to always be making progress, which is the name of the game. Go through this slides, where Pawan Bisht will be talking about the asynchronous concept in Rust Programming like what operations performed by the Rust compiler that actually makes our code asynchronous and what's the role of waker, poll, etc. With this, you can increase your software/application's performance and responsiveness.

Kubernetes Native Java and Eclipse MicroProfile | EclipseCon Europe 2019

Jakarta_EE

Kubernetes Native Java and Eclipse MicroProfile | EclipseCon Europe 2019

The Eclipse Foundation

Voxxed Athens 2018 - Methods and Practices for Guaranteed Failure in Big Data

Voxxed Athens

The art of concurrent programming

Iskren Chernev

Enterprise Frameworks: Java & .NET

Anant Corporation

Montreal OpenStack Q2 MeetUp - May 30th 2017

Stacy Véronneau

Node.js streams talk

zladuric

OutSystems Tips and Tricks

OutSystems

reverse.ppt.pptx

VijayaPratapReddyM

Node.js Presentation

Exist

OpenStack Toronto Q2 MeetUp - June 1st 2017

Stacy Véronneau

Os Lamotheoscon2007

Similar to RESTEasy Reactive: Why should you care? | DevNation Tech Talk (20)

Asynchronous job queues with python-rq

Reasoning about data and consistency in systems

Kernel Recipes 2014 - Performance Does Matter

How To Maintain Million Lines Of Open Source Code And Remain Sane or The Stor...

PyCon Canada 2019 - Introduction to Asynchronous Programming

A first look into the Project Loom in Java

Understanding concurrency

Rundown of Async/Await in Rust

Kubernetes Native Java and Eclipse MicroProfile | EclipseCon Europe 2019

Voxxed Athens 2018 - Methods and Practices for Guaranteed Failure in Big Data

The art of concurrent programming

Enterprise Frameworks: Java & .NET

Montreal OpenStack Q2 MeetUp - May 30th 2017

Node.js streams talk

OutSystems Tips and Tricks

reverse.ppt.pptx

Node.js Presentation

OpenStack Toronto Q2 MeetUp - June 1st 2017

Os Lamothe

More from Red Hat Developers

DevNation Tech Talk: Getting GitOps

Red Hat Developers

In 2022 we heard your GitOps questions at meetups and gatherings, big stages and local panels and one question was often top of mind: how do I get started? The benefits of GitOps are calling your name, but getting started isn’t that straightforward. Red Hat is excited to kick off 2023 with a DevNation TechTalk, focused on GitOps to help you sift through your questions. At DevNation you’ll hear from passionate GitOps practitioners about the pitfalls to avoid and hurdles to jump while kicking off or evolving your GitOps practices. This event is aimed at audiences that are new to GitOps or early in their practice development within a cloud native environment. During this live session you’ll learn: Upcoming updates and key milestones in the ArgoCD roadmap and how Red Hat will support them How to simplify the delivery GitOps across multi-cloud environments GitOps best practices from experts at: PostNord Strålfors: Filip Jansson Arbetsförmedlingen: Misho Kmetovski & Richard Hermansson Swiss Railways (SBB): Manuel Wallrapp & Thomas Bruederli Plus stick around for an “Ask me Anything” segment to ask any outstanding questions live.

Exploring the power of OpenTelemetry on Kubernetes

Red Hat Developers

Modern cloud-native applications are incredibly complex systems. Keeping the systems healthy and meeting SLAs for our customers is crucial for long-term success. In this session, we will dive into the three pillars of observability - metrics, logs, tracing - the foundation of successful troubleshooting in distributed systems. You'll learn the gotchas and pitfalls of rolling out the OpenTelemetry stack on Kubernetes to effectively collect all your signals without worrying about a vendor lock in. Additionally we will replace parts of the Prometheus stack to scrape metrics with OpenTelemetry collector and operator.

GitHub Makeover | DevNation Tech Talk

Red Hat Developers

GitHub plays a key role in the everyday work of thousands of developers and is a central piece of the open-source software ecosystem. Even though it is getting better and better every day, it still misses some key features that we need. If you want a better way of reviewing PRs, navigating through the code or better yet - writing the code without leaving the browser - this talk is for you! This talk will be demo driven, and as the title suggests, we will start with the aesthetic revamp. But we definitely won’t stop there! You will also learn a few cool things about interacting with GitHub through the command line. So not only your UI will be officially revamped, but you will also gain a productivity boost.

Quinoa: A modern Quarkus UI with no hassles | DevNation tech Talk

Red Hat Developers

Extra micrometer practices with Quarkus | DevNation Tech Talk

Red Hat Developers

How do you know you have improved the performance of your portfolio of applications? By measuring it, of course! The ultimate goal of gathering application metrics is to have a standardized practice that is applicable across multiple microservices and that adds minimal runtime overhead. Join this session to discuss what metrics are available out of the box with the Quarkus micrometer extensions, what (and, more importantly, why) you should customize, and how those pieces of information will impact your development outcomes.

Event-driven autoscaling through KEDA and Knative Integration | DevNation Tec...

Red Hat Developers

This talk will teach you how to redesign an event-driven autoscaling architecture for cloud-native microservices by utilizing Apache Kafka, Knative, and KEDA infrastructure. You will also learn how to deploy serverless applications (Quarkus) using a Knative service. Finally, KEDA will enable you to autoscale Knative Eventing components (KafkaSource) through events consumption over standard resources (CPU, memory).

Integrating Loom in Quarkus | DevNation Tech Talk

Red Hat Developers

Loom is among the most highly anticipated projects in the Java world. It promises to address concurrency and Java execution model issues by providing virtual threads. Thus, there is no need to write concurrent programs using asynchronous or reactive APIs; it will be possible to use the traditional imperative model and let Loom handle the rest. The JVM will execute the program and leverage non-blocking APIs automatically! Sounds good, doesn't it? How does it work, though? Are there any hidden costs? What is Loom going to change in modern Java frameworks? We will answer these questions in this talk. Starting with the integration of Loom in Quarkus, we will compare the different approaches we considered, discuss their respective pros and cons, and show how Loom might change the Java world.

Quarkus Renarde 🦊♥: an old-school Web framework with today's touch | DevNatio...

Red Hat Developers

Quarkus Renarde 🦊♥ is a new Web framework based on Quarkus. This framework focuses not on microservices but web applications and makes Quarkus even easier to use for web apps: - Endpoints based on convention, even easier than RESTEasy Reactive and JAX-RS - Server-side templating with Qute - Validation with Hibernate Validation - Data with Hibernate ORM or Reactive with Panache - Simple authentication with OpenID Connect or WebAuthn Quarkus Renarde 🦊♥ can deliver all this while still providing the joy of developing with Quarkus, with live reload, continuous testing, the Dev, and more.

Containers without docker | DevNation Tech Talk

Red Hat Developers

Recent changes in one desktop product generated many doubts in developer communities regarding containers. Can we still use or create them? Do we have alternatives to docker? We have some answers! Join us in this session to learn more about some popular docker alternatives. You can create containers without docker, and you can also run and publish them. There's life after docker, and containers are here to stay.

Distributed deployment of microservices across multiple OpenShift clusters | ...

Red Hat Developers

Hybrid-cloud and multi-cloud patterns are the next application deployment architectures, and Kubernetes is the de facto container orchestration engine. 50% of production Kubernetes workloads involve some form of microservices applications. How can we manage this inter-cluster application connectivity? Meet Skupper: an open-source project that solves multi-cloud communication for Kubernetes. In this Tech Talk, you will briefly learn about Skupper and watch a live demo of an e-commerce application with 10 microservices spanning three OpenShift clusters running on three different public cloud providers.

DevNation Workshop: Object detection with Red Hat OpenShift Data Science [Mar...

Red Hat Developers

In this workshop, you’ll learn an easy way to incorporate data science and AI/ML into an OpenShift development workflow. As an example, you’ll use an object detection model to detect ‘dog(s)’ in an image. You will: Use Jupyter Notebooks and TensorFlow to explore a pre-trained object detection model Serve the model in a REST API as a Flask App Use Source-to-Image (S2I) to build and deploy the Flask app Explore Kafka streams from Notebooks Deploy a Kafka consumer with the same object detection model You’ll be able to do all of this without having to install anything on your own computer, thanks to Red Hat OpenShift Data Science and Red Hat OpenShift Streams for Apache Kafka. Note: Beginner data handling and Python skills are required for this workshop.

Dear security, compliance, and auditing: We’re sorry. Love, DevOps | DevNatio...

Red Hat Developers

DevOps solved the conflict between development and operations, but other essential aspects of the delivery lifecycle—security, compliance, and audit—were left out. DevSecOps is an excellent reminder that security must be DevOps’d, but compliance and audit are still missing. There’s no need for a new DevSecAuditComplianceOps buzzword; instead, let’s talk about continuous authorization, which applies Zero Trust principles to continuous monitoring. In this tech talk, Bill Bensing will discuss practical ways to start with continuous authorization for the software delivery lifecycle using Ploigos.

11 CLI tools every developer should know | DevNation Tech Talk

Red Hat Developers

A Microservices approach with Cassandra and Quarkus | DevNation Tech Talk

Red Hat Developers

We will dissect the world famous todo app that provides a REST API (which is the foundation of microservices) with data backed by Apache Cassandra. We will leverage the TODO MVC and the TODO backend projects with the back end that we will build with Quarkus and Cassandra. Attendees will get an overview of Cassandra, including the driver for Quarkus. Through live coding (that attendees can try out later) in a cloud-based environment, primarily in Quarkus and Cassandra, attendees will understand how to implement and connect the APIs to the backend and leverage the generic client(s)provided. After attending this session attendees will walk away with a good understanding of implementing microservices using Cassandra and Quarkus. They will also get a working knowledge of how Astra (Cassandra as a service) can be leveraged in other solutions.

GitHub Actions and OpenShift: Supercharging your software development loops...

Red Hat Developers

Every software developer wants more productivity. What if the only commands you needed to deploy were "git commit" and "git push"? Join us as we walk you through a live demonstration of how you can ship your lovely application code from your local machine to a free OpenShift cluster, fully automated through GitHub Actions. By the end of this session, you'll have a sound understanding of building a GitHub Action workflow for your codebase that leverages OpenShift to deploy your application.

To the moon and beyond with Java 17 APIs! | DevNation Tech Talk

Red Hat Developers

Since moving to a 6 monthly release cadence, the Java platform is evolving more dynamically than ever before. It can be quite a challenge to stay on top of all the changes and new features. In this talk we're going to explore the most important developments in the Java API: which classes have been added, and what has been removed? Join Duke, the Java mascot, for a trip to space and learn which exciting new APIs provided by the Java platform can help him with his journey: The Java Vector API for utilizing the SIMD capabilities of modern CPU architectures The Foreign Linker API for integrating with native code The JFR Event Streaming API for publishing JDK Flight Recorder Events We'll also take a look at some useful changes to the Java runtime, such as CDS archives for a faster spaceship..., uhm, application launch!

Profile your Java apps in production on Red Hat OpenShift with Cryostat | Dev...

Red Hat Developers

Kafka at the Edge: an IoT scenario with OpenShift Streams for Apache Kafka | ...

Red Hat Developers

Apache Kafka is taking the world by storm and is rapidly becoming the de-facto event bus for event-driven and streaming applications that respond to events and data in real time. OpenShift Streams for Apache Kafka is Red Hat's fully hosted and managed Apache Kafka service targeting development teams that want to incorporate streaming data and scalable messaging in their applications, without the burden of setting up and maintaining a Kafka cluster infrastructure. In this session you will discover how Apache Kafka can be used in an IoT scenario to ingest data from devices and make them available in real-time to other applications. More specifically you will learn how to: Simulate devices that send MQTT messages to a MQTT broker Use Apache Camel and Camel-K to bridge MQTT with Apache Kafka Use Kafka Streams in a Quarkus application to process the device messages Query the state of the devices using GraphQ

Kubernetes configuration and security policies with KubeLinter | DevNation Te...

Red Hat Developers

With Kubernetes, implementing security policies can be challenging. First, developers, administrators, and security teams need to understand security policies in collaboration to have the best chance of successful adoption. Next, policy enforcement needs to integrate with developer workflows. Lastly, policies need to contain corrective action that is as close to the developer as possible. KubeLinter solves these problems by linting Kubernetes YAML files and Helm charts at the source: the developer. In this session, we will evaluate KubeLinter by moving through a hands-on demo of the application, showing a use case for local machines and CI pipeline integration, and chatting about how best to integrate it into your organization: KubeLinter, and its default checks How you can leverage the application in your day-to-day operations The open source StackRox community

Level-up your gaming telemetry using Kafka Streams | DevNation Tech Talk

Red Hat Developers

Many modern video games are constantly evolving post-release. New maps, game modes, and game balancing adjustments are rolled out, often on a weekly basis. This continuous iteration to improve player engagement and satisfaction requires data-driven decision making based on events and telemetry captured during gameplay, and from community forums and discussions. In this session you will learn how OpenShift Streams for Apache Kafka and Kafka Streams can be used to analyze real-time events and telemetry reported by a game server, using a practical example that encourages audience participation. Specifically you’ll learn how to: Provision Kafka clusters on OpenShift Streams for Apache Kafka. Develop a Java application that uses Kafka Streams and Quarkus to process event data. Deploy the application locally, or on OpenShift and connect it to your OpenShift Streams for Apache Kafka Cluster.

More from Red Hat Developers (20)