Companies are increasingly using hosted and managed services to deliver on application modernization efforts and reduce the burden of managing cloud infrastructure. The recent release of Red Hat OpenShift API Management makes it easier than ever to get your own dedicated instance of Red Hat 3scale API Management running on Red Hat OpenShift Dedicated.
Continue reading 5 steps to manage your first API using Red Hat OpenShift API Management
This article illustrates how to configure a browser authentication flow using X.509 user-signed certificates. Once you have set up authentication using X.509 user-signed certificates, your users will not be required to enter a username and password when authenticating against Red Hat’s single sign-on technology (SSO). Instead, they will present an X.509 certificate to the SSO instance.
Continue reading X.509 user certificate authentication with Red Hat’s single sign-on technology
Most of the new cloud-native applications and microservices designs are based on event-driven architecture (EDA), responding to real-time information by sending and receiving information about individual events. This kind of architecture relies on asynchronous, non-blocking communication between event producers and consumers through an event streaming backbone such as Red Hat AMQ Streams running on top of Red Hat OpenShift. In scenarios where many different events are being managed, defining a governance model where each event is defined as an API is critical. That way, producers and consumers can produce and consume checked and validated events. We can use a service registry as a datastore for events defined as APIs.
From my field experience working with many clients, I’ve found the most typical architecture consists of the following components:
In this article, you will learn how to easily integrate your Spring Boot applications with Red Hat Integration Service Registry, which is based on the open source Apicurio Registry.
Continue reading “Integrating Spring Boot with Red Hat Integration Service Registry”
Odo 2.0 introduces a configuration file named
devfile.yaml. Odo uses this configuration file to set up cloud-native projects and determine the actions required for events such as building, running, and debugging a project. If you are an Eclipse Che user,
devfile.yaml should sound familiar: Eclipse Che uses devfiles to express developer workspaces, and they have proven to be flexible to accommodate a variety of needs.
Continue reading Developing your own custom devfiles for odo 2.0
Kubernetes is an established foundation layer for cloud-native microservices and serverless architectures. By automating application deployment, scaling, and management, Kubernetes changes the developer’s daily workflow in terms of inner loop development (local coding, building, running, and testing the application) and outer loop development (integration testing, continuous deployment, and security). Developers using Kubernetes also must plan for containerization, debugging code inside pods, and automating test cases.
Continue reading Enhancing the development loop with Quarkus remote development
Quarkus is a Java stack tailored for OpenJDK HotSpot (or OpenJ9 on zSeries) and GraalVM, crafted from optimized Java libraries and standards. It is a good choice for building highly-scalable applications while using lower amounts of CPU and memory resources than other Java frameworks. These applications can be traditional web applications, serverless applications, or even functions as a service.
Continue reading Spring Boot on Quarkus: Magic or madness?
It has been quite a year for Arm Ltd., the firm that designs reduced instruction set computing (RISC) architectures for computer processors. The news that Arm-based computers will be important for the foreseeable future has even reached the mainstream media. At the end of 2019, Amazon Web Services announced Arm-based Graviton2 servers. In June 2020, Apple announced its plans to move Macintosh computers over to Apple silicon—which means Arm.
Continue reading How Red Hat ported OpenJDK to 64-bit Arm: A community history
Serverless functions are driving the fast adoption of DevApps development and deployment practices today. To successfully adopt serverless functions, developers must understand how serverless capabilities are specified using a combination of cloud computing, data infrastructure, and function-oriented programming. We also need to consider resource optimization (memory and CPU) and high-performance boot and first-response times in both development and production environments. What if we didn’t have to worry about all of that?
Continue reading Write a Quarkus function in two steps on Red Hat OpenShift Serverless
OpenJDK has long been a top pick for real-world applications and workloads, chosen for its blend of performance, compatibility, reliability, and observability. For many years, JDK Flight Recorder (JFR) and JDK Mission Control (JMC) have contributed to OpenJDK’s success. Until recently, both were commercial features, however, available only for certain users and workloads.
Continue reading Introduction to ContainerJFR: JDK Flight Recorder for containers
Red Hat Decision Manager helps organizations introduce the benefits of artificial intelligence to their daily operations. It is based on Drools, a popular open source project known for its powerful rules engine.
Continue reading Knowledge meets machine learning for smarter decisions, Part 2