---

What is KEDA?

Kubernetes Event-Driven Autoscaling (KEDA) is an open-source project that extends Kubernetes' native Horizontal Pod Autoscaler (HPA) to support event-driven scaling. Unlike traditional autoscalers that rely solely on CPU or memory metrics, KEDA allows workloads to scale based on various external event sources, such as message queues, databases, and cloud services.

KEDA works as a lightweight component that monitors external sources and triggers scaling actions based on predefined thresholds. It introduces ScaledObjects, a custom resource definition (CRD) that enables dynamic scaling without complex configurations.

How is KEDA helping in Kubernetes?

Kubernetes' native autoscaling capabilities are often limited to CPU and memory-based scaling, which may not be suitable for modern cloud-native applications that require event-driven scaling. This is where KEDA excels by allowing applications to

• Scale up and down dynamically based on real-time demand.

• Reduce costs by efficiently managing resources.

• Support various event sources like Kafka, RabbitMQ, AWS SQS, Prometheus, and more.

• Run lightweight, serverless-like workloads within Kubernetes.

Is KEDA Really Solving the Problem?

Yes! KEDA helps overcome limitations of the default Kubernetes autoscaler by providing

• Fine-grained scaling: Scale workloads based on custom event-driven metrics, not just CPU/memory.

• Cost efficiency: No need to run pods 24/7; KEDA allows scaling to zero when no events are present.

• Ease of use: Simple YAML-based configurations for autoscaling rules.

With KEDA, businesses running event-driven applications, batch jobs, or serverless workloads on Kubernetes can achieve improved scalability and resource optimization.

Step-by-Step Implementation of KEDA in Kubernetes

Prerequisites

Before proceeding, ensure you have:

• Kubernetes Cluster: A running Kubernetes cluster. You can use Minikube for local testing or a managed cluster on AWS, Azure, or GCP.

• kubectl: The command-line tool for interacting with Kubernetes. Install it following the official guide.

• Helm: A package manager for Kubernetes. Install it using the Helm installation guide.

Step 1: Install KEDA

KEDA can be installed using Helm for easy deployment.

1. Add the KEDA Helm repository:

    helm repo add kedacore https://kedacore.github.io/charts
   

2. Update your Helm repositories:

    helm repo update
   

3. Install KEDA in your cluster:

    helm install keda kedacore/keda --namespace keda --create-namespace
   

   This command deploys KEDA components into the kedanamespace.

Step 2: Deploy a Sample Application

To demonstrate KEDA's capabilities, we'll deploy an NGINX application.

1. Create a deployment YAML file:nginx-deployment.yaml

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx
      labels:
        app: nginx
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.14.2
            ports:
            - containerPort: 80
   

2. Apply the deployment:

    kubectl apply -f nginx-deployment.yaml
   

3. Expose the deployment as a service:

    kubectl expose deployment nginx --port=80 --type=NodePort
   

   This creates a NodePort service, making NGINX accessible externally.

Step 3: Configure KEDA to Scale the Application

KEDA uses Custom Resource Definitions (CRDs) to define scaling behavior. Let's configure KEDA to scale NGINX based on CPU utilization.

1. Create a ScaledObject YAML file (nginx-scaledobject.yaml):

    apiVersion: keda.sh/v1alpha1
    kind: ScaledObject
    metadata:
      name: nginx-scaledobject
      namespace: default
    spec:
      scaleTargetRef:
        name: nginx
      minReplicaCount: 1
      maxReplicaCount: 10
      triggers:
      - type: cpu
        metadata:
          type: Utilization
          value: "50"
   

2. Apply theScaledObject

    kubectl apply -f nginx-scaledobject.yaml
   

   KEDA will now manage the scaling of the NGINX deployment based on CPU utilization.

Step 4: Verify Autoscaling

To test autoscaling:

1. Generate load on the NGINX application using a tool like ab Apache Benchmark:

    ab -n 10000 -c 100 http://<NODE_IP>:<NODE_PORT>/
   

   Replace <NODE_IP> with your cluster node's IP address and <NODE_PORT> with the port assigned to the NGINX service.

2. Monitor the deployment's replica count:

    kubectl get hpa nginx --watch
   

   You should observe the number of replicas increasing or decreasing based on CPU load, demonstrating KEDA's event-driven scaling.

Conclusion

By following these steps, you've integrated KEDA into your Kubernetes cluster and configured it to autoscale a sample application based on CPU utilization. KEDA’s flexibility allows for scaling based on various event sources, making it an essential tool for modern cloud-native applications.

For more details and advanced configurations, refer to the official KEDA documentation.