Serverless

Guru Night at Red Hat Summit: Hands-on experience with serverless computing

Guru Night at Red Hat Summit: Hands-on experience with serverless computing

Millions of developers worldwide want to learn more about serverless computing. If you’re one of the lucky thousands attending Red Hat Summit in Boston May 7-9, you can gain hands-on experience with the help of Burr Sutter and the Red Hat Developer team.

Guru Night is a BYOL (bring your own laptop) event taking place Wednesday, May 8 from 5:00 p.m. to 8:00 p.m. at the Boston Convention and Event Center in ML2 East-258AB. (Doubtless there will be a map to show you where or what ML2 East etc. is; we have no idea.) Head to the signup page and fill out your details now.

TL;DR: Beer and pizza will be served.

We felt compelled to point that out. But read on.

Continue reading “Guru Night at Red Hat Summit: Hands-on experience with serverless computing”

Share
Build and deploy an API with Camel K on Red Hat OpenShift

Build and deploy an API with Camel K on Red Hat OpenShift

With the growing number of APIs and microservices, the time given to creating and integrating them has become shorter and shorter. That’s why we need an integration framework with tooling to quickly build an API and include capabilities for a full API life cycle. Camel K lets you build and deploy your API on Kubernetes or Red Hat OpenShift in less than a second. Unbelievable, isn’t it?

For those who are not familiar with it, Camel K is a subproject of Apache Camel with the target of building a lightweight runtime for running integration code directly on cloud platforms like Kubernetes and Red Hat OpenShift. It was inspired by serverless principles, and it will also target Knative shortly. The article by Nicola Ferraro will give you a good introduction.

In this article, I’ll show how to build an API with Camel K. For that, we will start first by designing our API using Apicurio Studio, which is based on the OpenAPI standard, and then we will provide the OpenAPI standard document to Camel K in order to implement the API and deploy it to Red Hat OpenShift.

Continue reading “Build and deploy an API with Camel K on Red Hat OpenShift”

Share
From zero to Quarkus and Knative: The easy way

From zero to Quarkus and Knative: The easy way

You’ve probably already read about Quarkus, but you may not know that the superfast startup speed of Quarkus makes it the best candidate for working with Knative and serverless for your Function-as-a-Service (FaaS) projects.

Quarkus, also known as Supersonic, Subatomic Java, is a Kubernetes native Java stack tailored for GraalVM and OpenJDK HotSpot, crafted from the best-of-breed Java libraries and standards. Knative is a Kubernetes-based platform to build, deploy, and manage modern serverless workloads. You can learn more in this article series.

This article does not provide a full deep dive on Knative or Quarkus. Instead, I aim to give you a quick and easy way to start playing with both technologies so you can further explore on your own.

Continue reading “From zero to Quarkus and Knative: The easy way”

Share
The evolution of serverless and FaaS: Knative brings change

The evolution of serverless and FaaS: Knative brings change

Are serverless and Function as a Service (FaaS) the same thing?

No, they’re not.

Wait. Yes, they are.

Frustrating, right? With terms being thrown about at conferences, in articles (I’m looking at myself right now), conversations, etc., things can be confusing (or, sadly, sometimes misleading). Let’s take a look at some aspects of serverless and FaaS to see where things stand.

Continue reading “The evolution of serverless and FaaS: Knative brings change”

Share
Containers, Kubernetes, and microservices: Start here

Containers, Kubernetes, and microservices: Start here

Although containers and Kubernetes and microservices seem to come up in every conversation, there’s a big chasm between talking about, demonstrating, and actually using a technology in production. Anyone can discuss containers, many people can demo them, but far fewer are successfully using containers and Kubernetes in a microservices architecture.

Why? There are likely many reasons, but a simple one may be that developers don’t know where to start.

Consider this series of articles your starting point. Relax, read on, and get ready to enter the exciting world of containers, Kubernetes, and microservices.

Continue reading “Containers, Kubernetes, and microservices: Start here”

Share
Quarkus 0.12.0 released

Quarkus 0.12.0 released

Quarkus, a next-generation Kubernetes native Java framework, was announced in early March, and now Quarkus 0.12.0 has been released and is available from the Maven repository. The quickstarts, guides, and website also have been updated, and 213 issues and PRs are included in this release. That’s quite a few updates, but in particular check out the new metrics, health check, and Kafka guides. Also, this release requires GraalVM 1.0.0-RC13 for Building a Native Executable.

Continue reading “Quarkus 0.12.0 released”

Share
Quarking Drools: How we turned a 13-year-old Java project into a first-class serverless component

Quarking Drools: How we turned a 13-year-old Java project into a first-class serverless component

“The question of whether a computer can think is no more interesting than the question of whether a submarine can swim.” (Edsger W. Dijkstra)

Rule-based artificial intelligence (AI) is often overlooked, possibly because people think it’s only useful in heavyweight enterprise software products. However, that’s not necessarily true. Simply put, a rule engine is just a piece of software that allows you to separate domain and business-specific constraint from the main application flow. We are part of the team developing and maintaining Drools—the world’s most popular open source rule engine and part of Red Hat—and, in this article, we will describe how we are changing Drools to make it part of the cloud and serverless revolution.

Continue reading “Quarking Drools: How we turned a 13-year-old Java project into a first-class serverless component”

Share
Introducing Quarkus: a next-generation Kubernetes native Java framework

Introducing Quarkus: a next-generation Kubernetes native Java framework

Java was introduced to the open-source community more than 20 years ago and it still remains popular among developers. In fact, Java has never ranked lower than #2 on the TIOBE Index. Java was born in the mid-1990s and has nearly 20 years of optimizations for running highly dynamic monolithic applications that assumed sole ownership of (virtualized) host CPU and memory. However, we now live in a world dominated by the cloud, mobile, IoT, and open source, where containers, Kubernetes, microservices, reactive, Function-as-a-Service (FaaS), 12-factor, and cloud-native application development can deliver higher levels of productivity and efficiency. As an industry, we need to rethink how Java can be best utilized to address these new deployment environments and application architectures.

We’d like to introduce you to Quarkus and Supersonic Subatomic Java!

Quarkus is a Kubernetes Native Java framework tailored for GraalVM and HotSpot, crafted from best-of-breed Java libraries and standards. The goal of Quarkus is to make Java a leading platform in Kubernetes and serverless environments while offering developers a unified reactive and imperative programming model to optimally address a wider range of distributed application architectures.

Continue reading “Introducing Quarkus: a next-generation Kubernetes native Java framework”

Share