KEDA Concepts

What KEDA is and how it works

Warning

You are currently viewing v"2.7" of the documentation and it is not the latest. For the most recent documentation, kindly click here.

What is KEDA?

KEDA is a Kubernetes-based Event Driven Autoscaler. With KEDA, you can drive the scaling of any container in Kubernetes based on the number of events needing to be processed.

KEDA is a single-purpose and lightweight component that can be added into any Kubernetes cluster. KEDA works alongside standard Kubernetes components like the Horizontal Pod Autoscaler and can extend functionality without overwriting or duplication. With KEDA you can explicitly map the apps you want to use event-driven scale, with other apps continuing to function. This makes KEDA a flexible and safe option to run alongside any number of any other Kubernetes applications or frameworks.

How KEDA works

KEDA performs two key roles within Kubernetes:

Agent — KEDA activates and deactivates Kubernetes Deployments to scale to and from zero on no events. This is one of the primary roles of the keda-operator container that runs when you install KEDA.
Metrics — KEDA acts as a Kubernetes metrics server that exposes rich event data like queue length or stream lag to the Horizontal Pod Autoscaler to drive scale out. It is up to the Deployment to consume the events directly from the source. This preserves rich event integration and enables gestures like completing or abandoning queue messages to work out of the box. The metric serving is the primary role of the keda-operator-metrics-apiserver container that runs when you install KEDA.

Architecture

The diagram below shows how KEDA works in conjunction with the Kubernetes Horizontal Pod Autoscaler, external event sources, and Kubernetes’ etcd data store:

Event sources and scalers

KEDA has a wide range of scalers that can both detect if a deployment should be activated or deactivated, and feed custom metrics for a specific event source. The following scalers are available:

ActiveMQ ActiveMQ Artemis Apache Kafka AWS CloudWatch AWS DynamoDB AWS Kinesis Stream AWS SQS Queue Azure Application Insights Azure Blob Storage Azure Data Explorer Azure Event Hubs Azure Log Analytics Azure Monitor Azure Pipelines Azure Service Bus Azure Storage Queue Cassandra CPU Cron Datadog Elasticsearch External External Push Google Cloud Platform Stackdriver Google Cloud Platform Storage Google Cloud Platform‎ Pub/Sub Graphite Huawei Cloudeye IBM MQ InfluxDB Kubernetes Workload Liiklus Topic Memory Metrics API MongoDB MSSQL MySQL NATS Streaming New Relic OpenStack Metric OpenStack Swift PostgreSQL Predictkube Prometheus RabbitMQ Queue Redis Lists Redis Lists (supports Redis Cluster) Redis Lists (supports Redis Sentinel) Redis Streams Redis Streams (supports Redis Cluster) Redis Streams (supports Redis Sentinel) Selenium Grid Scaler Solace PubSub+ Event Broker

Custom Resources (CRD)

When you install KEDA, it creates four custom resources:

scaledobjects.keda.sh
scaledjobs.keda.sh
triggerauthentications.keda.sh
clustertriggerauthentications.keda.sh

These custom resources enable you to map an event source (and the authentication to that event source) to a Deployment, StatefulSet, Custom Resource or Job for scaling.

ScaledObjects represent the desired mapping between an event source (e.g. Rabbit MQ) and the Kubernetes Deployment, StatefulSet or any Custom Resource that defines /scale subresource.
ScaledJobs represent the mapping between event source and Kubernetes Job.
ScaledObject/ScaledJob may also reference a TriggerAuthentication or ClusterTriggerAuthentication which contains the authentication configuration or secrets to monitor the event source.

Deploy KEDA

See the Deployment documentation for instructions on how to deploy KEDA into any cluster using tools like Helm.