DevNation tech talks are hosted by the Red Hat technologists who create our products. These sessions include real solutions and code and sample projects to help you get started. In this talk, you’ll learn about future-proofing applications from Eric Murphy and Ales Nosek, Architects with Red Hat Consulting.
When building an MVP software application, you may immediately jump to a microservices architecture because it’s the new norm for building cloud-native applications. You may also be skeptical about starting off with a monolith because of the perception of such applications as relics of the past.
In this talk, we will show how to evolve a monolithic application in a highly controlled way using modular design principles. We will also demonstrate a future-proofed Quarkus + Vert.x application that is both a monolith and microservices while using the same code and modular design.
Continue reading “Future-proof monolithic applications with modular design”
The latest update to Red Hat Runtimes has arrived and now supports Eclipse Vert.x 3.8.1.
Red Hat Runtimes provides application developers with a variety of application runtimes and enables them to run on the Red Hat OpenShift Container Platform.
With this update, some of the new additions and updates include:
Continue reading “Eclipse Vert.x 3.8.1 update for Red Hat Runtimes”
Red Hat Application Runtimes recently added extended support for the Spring Boot 2.1.6 runtime for Red Hat customers building Spring apps. Red Hat Application Runtimes provides application developers with a variety of application runtimes running on the Red Hat OpenShift Container Platform.
Introduction to Spring Boot
Spring Boot lets you create opinionated Spring-based standalone applications. The Spring Boot runtime also integrates with the OpenShift platform, allowing your services to externalize their configuration, implement health checks, provide resiliency and failover, and much more.
Continue reading “Extending support for Spring Boot 2.1.6 and Spring Reactive”
Our connected world is full of events that are triggered or received by different software services. One of the big issues is that event publishers tend to describe events differently and in ways that are mostly incompatible with each other.
To address this, the Serverless Working Group from the Cloud Native Computing Foundation (CNCF) recently announced version 0.2 of the CloudEvents specification. The specification aims to describe event data in a common, standardized way. To some degree, a CloudEvent is an abstract envelope with some specified attributes that describe a concrete event and its data.
Working with CloudEvents is simple. This article shows how to use the powerful JVM toolkit provided by Vert.x to either generate or receive and process CloudEvents.
Continue reading “Processing CloudEvents with Eclipse Vert.x”
If you saw or heard about the multi-cloud demo at Red Hat Summit 2018, this article details how we ran Red Hat Data Grid in active-active-active mode across three cloud providers. This set up enabled us to show a fail over between cloud providers in real time with no loss of data. In addition to Red Hat Data Grid, we used Vert.x (reactive programming), OpenWhisk (serverless), and Red Hat Gluster Storage (software-defined storage.)
This year’s Red Hat Summit was quite an adventure for all of us. A trip to San Francisco is probably on the bucket list of IT geeks from all over the world. Also, we were able to meet many other Red Hatters, who work remotely for Red Hat as we do. However, the best part was that we had something important to say: “we believe in the hybrid/multi cloud” and we got to prove that live on stage.
Photo credit: Bolesław Dawidowicz
Continue reading “Red Hat Data Grid on Three Clouds (the details behind the demo)”
This post is the fifth post of my Introduction to Eclipse Vert.x series. In the last post, we saw how Vert.x can interact with a database. To tame the asynchronous nature of Vert.x, we used
Future objects. In this post, we are going to see another way to manage asynchronous code: reactive programming. We will see how Vert.x combined with Reactive eXtensions gives you superpowers.
Let’s start by refreshing our memory with the previous posts:
- The first post described how to build a Vert.x application with Apache Maven and execute unit tests.
- The second post described how this application became configurable.
- The third post introduced
- In the fourth post, we replaced the in-memory back end with a database and introduced
Future to orchestrate our asynchronous operations.
In this post, we are not going to add a new feature. Instead, we’ll explore another programming paradigm: reactive programming.
Continue reading “When Vert.x Meets Reactive eXtensions (Part 5 of Introduction to Vert.x)”
This post is the third in a series on the Introduction to Eclipse Vert.x. So, let’s have a quick look back at the content of the previous posts. In the first post, we developed a very simple Eclipse Vert.x application and saw how this application can be tested, packaged, and executed. In the second post, we saw how this application became configurable and how we can use a random port in a test.
Well, nothing fancy… Let’s go a bit further this time and develop a CRUD-ish / REST-ish application. So an application exposing an HTML page interacting with the backend using a REST API. The level of RESTfulness of the API is not the topic of this post; I leave it you to decide as it’s a very slippery topic.
So, in other words, we are going to see:
- Vert.x Web – a framework to let you create web applications easily using Vert.x.
- How to expose static resources.
- How to develop a REST API.
Continue reading “Some REST with Vert.x (Part 3 of Introduction to Vert.x)”
In my previous post, Introduction to Eclipse Vert.x, we developed a very simple Vert.x application and saw how this application can be tested, packaged, and executed. That was nice, wasn’t it? Well, that was only the beginning. In this post, we are going to enhance our application to support external configuration, and learn how to deal with different configuration sources.
Continue reading “Eclipse Vert.x Application Configuration (Part 2 of Introduction to Vert.x)”
Let’s say, you heard someone saying that Eclipse Vert.x is awesome. Ok great, but you may want to try it yourself. The next logical question is “where do I start?”. This article is a good starting point. It shows: how to build a very simple Vert.x application (nothing fancy), how it is tested, and how it is packaged and executed. Basically everything you need to know before building your own groundbreaking application.
The code developed in this article is available on GitHub. This is part of the “Introduction to Vert.x Series”. The code for this post is located in the https://github.com/redhat-developer/introduction-to-eclipse-vertx repository in the
Continue reading “Introduction to Eclipse Vert.x – My First Vert.x Application”
JUnit 5 is a rewrite of the famous Java testing framework that brings new interesting features, including:
- nested tests,
- the ability to give a human-readable description of tests and test cases,
- a modular extension mechanism that is more powerful than the JUnit 4 runner mechanism (@RunWith annotation),
- conditional test execution,
- parameterized tests, including from sources such as CSV data,
- the support of Java 8 lambda expressions in the reworked built-in assertions API,
- support for running tests previously written for JUnit 4.
Testing asynchronous operations is not straightforward
Continue reading “JUnit 5 support lands in Eclipse Vert.x for testing asynchronous operations”