Using Knative to build event-driven applications on Kubernetes

Are you tired of manually scaling your applications based on user demand? Do you want to build applications that can respond dynamically to changes in the environment? If so, then you need to check out Knative, the event-driven platform for Kubernetes.

Knative allows developers to build serverless applications in a Kubernetes environment, leveraging the power of Kubernetes and Istio to create a seamless experience for developers. In this article, we will explore how to use Knative to build event-driven applications on Kubernetes.

Introduction

Knative is a Kubernetes-based platform that provides a set of components for building serverless applications. These components include serving, eventing, and build, which are designed to automate the process of deploying and scaling applications.

Serving allows developers to deploy and manage serverless applications on Kubernetes. Eventing provides a powerful mechanism for handling asynchronous events, while Build provides a seamless CI/CD pipeline for building and deploying applications.

In this article, we will primarily focus on Eventing, which is the core component that enables developers to build event-driven applications on Kubernetes.

Event-driven architectures

Before we dive into how to build event-driven applications with Knative, let's understand what an event-driven architecture is.

In an event-driven architecture, the application reacts to events that occur in the environment. These events could be user actions, network events, system events, or even business events.

For example, consider an e-commerce application that sends users an email when their order is shipped. In a traditional architecture, the application would periodically check the status of the order and send the email. However, in an event-driven architecture, the application would react to an event that is triggered when the order is shipped, and send the email automatically.

Event-driven architectures provide several benefits such as improved scalability, reduced processing time, and increased reliability.

Knative Eventing

Knative Eventing provides a powerful mechanism for building event-driven applications on Kubernetes. It enables developers to react to events from different sources such as webhooks, message brokers, and Kubernetes events.

Concepts

Knative Eventing is built upon a few key concepts that developers need to understand before building event-driven applications.

Event sources

Event sources are the originators of events. They could be Kubernetes events, message brokers, or even external systems. Event sources emit events in a structured format, which can be consumed by Eventing components.

Channels

Channels are where events are sent to and from. They are essentially named pipes that connect event sources to event consumers. Channels can be shared across multiple event sources and consumers, allowing for decoupling and a scalable architecture.

Subscriptions

Subscriptions are used to filter events based on their attributes. They allow developers to define which events they want to receive from a specific channel.

Triggers

Triggers define what action should be taken when an event is received. They could be anything from running a containerized function to sending a notification to a user.

Building event-driven applications on Knative

Now that we have a basic understanding of Knative Eventing, let's look at how we can use it to build event-driven applications.

We will start by building a simple application that listens for incoming HTTP requests and sends a welcome message to the user. We will use Knative Serving to deploy the application and Knative Eventing to trigger the welcome message when a new user signs up.

Deploying the application

To deploy the application, we need to create a container image and deploy it to Kubernetes.

apiVersion: serving.knative.dev/v1beta1
kind: Service
metadata:
  name: hello-world
spec:
  template:
    spec:
      containers:
        - image: gcr.io/my-project/hello-world

Once the application is deployed, we can access it through a URL provided by Knative Serving.

curl http://hello-world.default.example.com

Triggering the event

Next, we need to trigger the welcome message when a new user signs up. We will trigger the event using a Kubernetes event.

apiVersion: v1
kind: Event
metadata:
  name: new-user
  namespace: default
data:
  message: "Welcome to our platform!"

We now have an event that will be emitted every time a new user signs up. The next step is to create a channel and subscription that will consume this event.

apiVersion: messaging.knative.dev/v1beta1
kind: InMemoryChannel
metadata:
  name: user-events
spec:
  capacity: 100
  storage:
    memory:
      limits:
        memory: 100Mi
        storage: 1Gi
---
apiVersion: eventing.knative.dev/v1beta1
kind: Subscription
metadata:
  name: user-subscription
spec:
  channel:
    apiVersion: messaging.knative.dev/v1beta1
    kind: InMemoryChannel
    name: user-events
  filter:
    attributes:
      type: new-user
  subscriber:
    ref:
      apiVersion: serving.knative.dev/v1beta1
      kind: Service
      name: hello-world
      namespace: default

The above YAML creates an InMemoryChannel that will store the incoming events and a Subscription that filters events based on their attributes and sends them to the hello-world Service.

Running the application

With the channel and subscription in place, we can now run the application and start receiving events.

kubectl apply -f channel.yaml
kubectl apply -f subscription.yaml

Once the application is running, every time a new user signs up, the welcome message will be triggered automatically. This demonstrates the power of an event-driven architecture and how Knative Eventing can enable developers to build scalable and reliable applications.

Conclusion

Knative Eventing provides a powerful mechanism for building event-driven applications on Kubernetes. It enables developers to build applications that can react to changes in the environment, resulting in a more scalable and resilient architecture.

In this article, we walked through how to use Knative to build event-driven applications. We covered the key concepts of Knative Eventing and demonstrated how to build a simple application that listens for incoming HTTP requests and responds with a welcome message triggered by a Kubernetes event.

I hope this article has provided you with a better understanding of how Knative can be used to build event-driven applications on Kubernetes. If you have any questions or comments, please feel free to reach out to us at knative.run. We would love to hear from you!

Editor Recommended Sites