Fellow Red Hat associates Cesar Saavedra, Pavol Loffay, Jeff Mesnil, Antoine Sabot-Durand, Scott Stark, and I have written a book on Eclipse MicroProfile, called Hands-On Enterprise Java Microservices with Eclipse MicroProfile.
This 256-page book provides an introduction to microservices and why they are important, and it showcases Eclipse MicroProfile as a way to implement so-called 12-factor apps.
Now through December 15, you can use the following link and discount code to receive a 20% discount when purchasing this ebook through the Packt website.
Hands-On Enterprise Java Microservices with Eclipse MicroProfile
Discount code: eclipse20
Continue reading “New Eclipse MicroProfile book provides introduction to enterprise Java microservices”
Eclipse MicroProfile and Spring Boot are often thought of as separate and distinct APIs when developing Java microservices. Developers default to their mental muscle memory by leveraging the APIs that they use on a daily basis. Learning new frameworks and runtimes can be a significant time investment. This article aims to ease the introduction to some popular MicroProfile APIs for Spring developers by enabling them to utilize the Spring APIs they already know while benefiting from significant new capabilities offered by Quarkus.
More specifically, this article covers the scope and details of the Spring APIs supported by Quarkus so Spring developers have a grasp of the foundation they can build on with MicroProfile APIs. The article then covers MicroProfile APIs that Spring developers will find helpful in the development of microservices. Only a subset of MicroProfile is covered.
Continue reading “Autowire MicroProfile into Spring with Quarkus”
Microservices provide a modern approach to development, which is compliant with the cloud environment and gives us the ability to create cloud-native applications. With microservices, we promote resilience, fault tolerance, and scale; however, a microservice approach also presents different challenges than monolithic applications because of its distributed nature.
One of these challenges involves monitoring and logging, which naturally brings us to the concept of observability. In this article, we’ll look at how Eclipse MicroProfile can help you implement observability in microservices.
Continue reading “Introduction to microservices observability with Eclipse MicroProfile”
In this article, I’ll give you a quick tour of how to use the new MicroProfile Starter (Beta) site to generate, download, and build a Maven-based MicroProfile project with just a few clicks. Using this online project generator, you choose the MicroProfile version and server (such as Thorntail) that you want your project to be based on. Then you’ll be able to choose what example code to include in your project to see how to use the APIs that are part of the MicroProfile specifications such as Config, Health Check, Metrics, CDI, and more.
Continue reading “Jumpstart your microservices development with MicroProfile Starter (Beta)”
A Java runtime environment should be able to run compiled source code, whereas a development kit, for example, OpenJDK, would include all the libraries/binaries to compile and run the source code. Essentially the latter is a superset of the runtime environment. More details on OpenJDK support and lifecycle can be found here.
Red Hat ships and supports container images with OpenJDK for both Java 8 and 11. More details are here. If you are using Red Hat Middleware, the s2i images shipped are also useful to deploy, for example, on Red Hat Openshift Container Platform.
Note that Red Hat only provides OpenJDK-based Java 8 and 11 images. With that said, there will certainly be situations where developers would like to create their own Java runtime images. For example, there could be reasons such as minimizing storage to run a runtime image. On the other hand, a lot of manual work around libraries such as Jolokio or Hawkular and even security parameters would need to be set up as well. If you’d prefer not to get into those details, I would recommend using the container images for OpenJDK shipped by Red Hat.
In this article we will:
- Build an image with Docker as well as Buildah.
- We will run that image with Docker as well as Podman on localhost.
- We will push our image to Quay.
- Finally, we will run our app by importing a stream into OpenShift.
This article was written for both OpenShift 3.11 and 4.0 beta. Let’s jump right into it.
Continue reading “Creating and deploying a Java 8 runtime container image”
This is the finale of a series on whether Kubernetes is the new Application Server. In this part I discuss the choice between Kubernetes, a traditional application server, and alternatives. Such alternatives can be referred to as “Just enough Application Server”, like Thorntail. There are several articles on Thorntail (previously known as Wildfly Swarm) on the Red Hat Developer blog. A good introduction to Thorntail is in the 2.2 product announcement.
Continue reading Curse you choices! Kubernetes or Application Servers? (Part 3)
By now you have probably heard of Eclipse MicroProfile (MP). It is a community-driven initiative to define specifications for enterprise Java microservices. MicroProfile is only two years old, yet it has delivered eight innovative specifications and is evolving fast. It provides metrics, API documentation, health checks, fault tolerance, distributed tracing, and more. With it, you can take full advantage of cutting-edge cloud-native technologies and do it in a vendor-neutral fashion!
For developers familiar with Spring Boot, we have prepared this article, which compares the basics of developing applications with Spring Boot and with MicroProfile. We wrote two applications, one with each solution. In this article, we will go through the differences between them. You can find the source code for both projects on GitHub.
For the MicroProfile application, we use Thorntail (formerly know as Wildfly Swarm), but except for the setting up part, Open Liberty, Payara, TomEE, or any other implementation would look exactly the same.
Throughout this article, we assume you know Spring Boot and we focus on what is different in MicroProfile.
Continue reading “Eclipse MicroProfile for Spring Boot developers”
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”
Welcome to the second in a series of posts on Kubernetes, application servers, and the future. Part 1, Kubernetes is the new application operating environment, discussed Kubernetes and its place in application development. In this part, we explore application servers and their role in relation to Kubernetes.
You may recall from Part 1 that we were exploring the views put forth in Why Kubernetes is The New Application Server and thinking about what those views mean for Java EE, Jakarta EE, Eclipse MicroProfile, and application servers. Is it a curtain call for application servers? Are we seeing the start of an imminent decline in their favor and usage?
Before answering that, we need to discuss the use case for application servers. Then can we decide whether it’s still a valid use case.
Continue reading “Are App Servers Dead in the Age of Kubernetes? (Part 2)”