Kubernetes-based event-driven autoscaling (KEDA) is a powerful tool for automating the scaling of your Kubernetes applications based on event-driven workloads. KEDA is an open-source project that is built on top of Kubernetes, and it allows you to scale your workloads dynamically based on the volume of events that are generated by your applications. In this blog post, we’ll provide an introduction to KEDA and show you how to get started using it with examples in Java, Golang, and YAML code.

What is KEDA?

KEDA is an event-driven autoscaling platform that is designed to work with Kubernetes. It provides a scalable and reliable way to run your applications in a Kubernetes cluster. KEDA monitors the event sources that are associated with your applications and automatically scales your workloads up or down based on the volume of events that are generated. This allows you to optimize your resource usage and reduce costs, while ensuring that your applications are responsive and scalable.

KEDA supports a wide range of event sources, including Azure Queues, Kafka, RabbitMQ, and more. It also provides a range of scaling strategies, including scaling based on the number of events, scaling based on the size of the event payload, and more.

Getting Started with KEDA :

To get started with KEDA, you will need to have a Kubernetes cluster up and running. You will also need to have kubectl installed on your local machine. Once you have these prerequisites in place, you can follow the steps below to get started with KEDA.

Step 1: Install KEDA :

To install KEDA on your Kubernetes cluster, you can use the following command:

kubectl apply -f https://github.com/kedacore/keda/releases/download/v2.0.0/keda-2.0.0.yaml

This will download the KEDA YAML file and apply it to your Kubernetes cluster.

Step 2: Create a Kubernetes deployment

Next, you will need to create a Kubernetes deployment that includes the KEDA scaler. For this example, we will use a simple Java application that generates events.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: java-app
  template:
    metadata:
      labels:
        app: java-app
    spec:
      containers:
      - name: java-container
        image: your-java-image
        ports:
        - containerPort: 8080
      - name: keda-container
        image: kedacore/keda:latest
        env:
        - name: KEDA_ENABLED
          value: "true"
        - name: KEDA_TARGET_SIZE
          value: "5"

In this deployment, we have added a container that includes the KEDA scaler. We have also set the KEDATARGETSIZE environment variable to 5, which means that KEDA will scale up our deployment to a maximum of 5 replicas when events are generated.

Step 3: Create a KEDA trigger

Next, you will need to create a KEDA trigger that specifies the event source for your application. For this example, we will use an Azure Queue as our event source.

apiVersion: keda.k8s.io/v1alpha1
kind: AzureQueueTrigger
metadata:
  name: azure-queue-trigger
spec:
  storageConnectionString: YOUR_STORAGE_ACCOUNT_CONNECTION_STRING
  queueName: YOUR_QUEUE_NAME
  pollingInterval: 5
  authentication:
    type: ConnectionString

This trigger specifies the storage account connection string and the queue name that will be used as the event source for our application. We have also set the polling interval to 5 seconds, which means that KEDA will check for new events every 5 seconds.

Step 4: Deploy the Kubernetes resources

Once you have created the deployment and trigger YAML files, you can deploy them to your Kubernetes cluster using the following command:

kubectl apply -f deployment.yaml
kubectl apply -f trigger.yaml

This will create the Kubernetes deployment and KEDA trigger in your cluster.

Step 5: Generate events

Finally, you can generate events to test your application and KEDA scaler. For this example, we will use a simple Golang program that sends messages to our Azure Queue.

package main

import (
 "context"
 "fmt"
 "time"

 "github.com/Azure/azure-sdk-for-go/storage"
)

func main() {
 accountName := "YOUR_STORAGE_ACCOUNT_NAME"
 accountKey := "YOUR_STORAGE_ACCOUNT_KEY"
 queueName := "YOUR_QUEUE_NAME"

 connString := fmt.Sprintf("DefaultEndpointsProtocol=https;AccountName=%s;AccountKey=%s;EndpointSuffix=core.windows.net", accountName, accountKey)

 client, err := storage.NewQueueClient(connString, queueName)
 if err != nil {
  panic(err)
 }

 for i := 0; i < 10; i++ {
  message := fmt.Sprintf("Message %d", i)
  err = client.PutMessage(context.Background(), message, time.Minute*5, time.Minute*5)
  if err != nil {
   panic(err)
  }
  fmt.Printf("Sent message: %s\n", message)
  time.Sleep(time. Second)
 }
}

In this Golang program, we are using the Azure SDK for Go to send messages to our Azure Queue. We are sending 10 messages with a delay of 1 second between each message.

Step 6: Check the scaling

Once you have generated some events, you can check the scaling of your Kubernetes deployment by running the following command:

kubectl get deployment java-deployment

This will show you the current number of replicas for your deployment. You should see that KEDA has scaled up your deployment to handle the increased workload.

Conclusion In this blog post, I have provided an introduction to KEDA and shown you how to get started using it with examples in Java, Golang, and YAML code.

KEDA is a powerful tool for automating the scaling of your Kubernetes applications based on event-driven workloads, and it can help you optimize your resource usage and reduce costs while ensuring that your applications are responsive and scalable.

Official Github Repo : https://github.com/kedacore/keda