An Introduction to Thorntail
Today Red Hat is making Thorntail 2.2 generally available to Red Hat customers through a subscription to Red Hat OpenShift Application Runtimes (RHOAR). RHOAR provides application developers with a variety of application runtimes running on the OpenShift Container Platform.
Thorntail is the new name for WildFly Swarm, and bundles everything you need to develop and run Thorntail and MicroProfile applications by packaging server runtime libraries with your application code and running it with
java -jar. It speeds up the transition from monoliths to microservices and takes advantage of your existing industry standard Java EE technology experience.
Continue reading “Announcing: Thorntail 2.2 General Availability”
At the recently concluded Microsoft Ignite 2018 conference in Orlando, I had the honor of presenting to a crowd of Java developers and Azure professionals eager to learn how to put their Java skills to work building next-gen apps on Azure. Of course, that meant showcasing the technology coming out of the popular MicroProfile community, in which Red Hat plays a big part (and makes a fully supported, productized MicroProfile implementation through Thorntail, part of Red Hat OpenShift Application Runtimes).
We did a demo too, which is the main topic of this blog post, showing how easy it is to link your Java MicroProfile apps to Azure services through the Open Service Broker for Azure (the open source, Open Service Broker-compatible API server that provisions managed services in the Microsoft Azure public cloud) and OpenShift’s Service Catalog.
Here’s how to reproduce the demo.
Continue reading “Deploying MicroProfile apps on Microsoft Azure using the Azure Open Service Broker”
During the last three months, there have been some changes regarding Eclipse MicroProfile at Red Hat. If you haven’t been following the details, this post recaps what’s changed and introduces Thorntail and SmallRye.
Bye-bye WildFly Swarm! Hello Thorntail!
You may have missed this important news. Our MicroProfile implementation changed its name two months ago.
After a lot of feedback from the community, we decided to rename “WildFly Swarm” to Thorntail. While the former name was nice, we found that the “Swarm” term was a bit overloaded in the IT industry and could be confusing. It’s the same for the “WildFly” part; sharing this name with our Java EE application server was a source of confusion for some users, making them think it was a subproject of WildFly.
Continue reading “Eclipse MicroProfile and Red Hat Update: Thorntail and SmallRye”
Launched nearly two years ago, the Eclipse MicroProfile project is moving fast with four releases and eight subspecs having at least two implementations each. Because it’s a fast moving target, this post tries to give an overview of MicroProfile 1.3, which was released on September 30th, and helps you to get started with the specification.
Continue reading “MicroProfile Status in Version 1.3”
Every developer has the goal of building the most resilient application possible. Due to the distributed nature of microservices, resiliency and handling failures gracefully is mandatory. The Java ecosystem has some nice frameworks for fault tolerance, such as Hystrix or Failsafe. However, none of these provide a standard API, so using them means your application will be tightly coupled to that framework. The primary motivation for the MicroProfile specifications is to provide standard APIs that eliminates the tight coupling and improves deployment flexibility. This article will describe the main features of the MicroProfile Fault Tolerance specification, and then demonstrate how it was implemented in WildFly Swarm, the Red Hat MicroProfile implementation.
Continue reading “MicroProfile Fault Tolerance in WildFly Swarm”
A previous article described the specifications in the Eclipse MicroProfile 1.2 release and the benefits for Java-based cloud-native applications. This article shows how software developers writing Java-based microservices can leverage those specifications to take advantage of the management capabilities provided by Red Hat OpenShift.
Continue reading Develop Cloud-native Applications with MicroProfile (Config & Health Check) and OpenShift
This article will show how to use a custom version of Hibernate (Hibernate ORM and Hibernate Search) on a WildFly Swarm Java application. I won’t give details about the WildFly Swarm configuration, if you need more information you can take a look at the WildFly Swarm User’s Guide.
WildFly Swarm includes fractions for Hibernate ORM and Hibernate Search.
You can add those fractions using:
Continue reading “Custom Hibernate ORM and Hibernate Search on WildFly Swarm”
The purpose of this blog post is to provide an overview of the APIs and specifications in the Eclipse Microprofile 1.2 release. In particular, I’ll try to connect these specifications and APIs with their architectural purpose. Where do they fit and why? If you’re thinking of moving your Java application to the cloud, then this post might be for you.
Continue reading “Cloud-native development with Microprofile 1.2”
At the beginning of October, I attended JavaOne in San Francisco to present on WildFly Swarm and Apache Kafka. For those of you that weren’t able to attend the session, or for those that did and saw first hand the issues with the demo, I will be covering all the details of how the demo should work!
Continue reading Data Streaming with WildFly Swarm and Apache Kafka
“I used WildFly Swarm to shrink my app from 45 megabytes to only 2243 bytes.”
I was recently playing around with various techniques for packaging Java microservices and running on OpenShift using various runtimes and frameworks to illustrate their differences (WildFly Swarm vs. WildFly, Spring Boot vs. the world, etc). Around the same time as I was doing this an internal email list thread ignited discussing some of the differences and using terms like Uber JARs, Thin WARs, Skinny WARs, and a few others. Some folks were highlighting the pros and cons of each, especially the benefits of the thin WAR approach when combined with docker image layers.
Continue reading “The Skinny on Fat, Thin, Hollow, and Uber”