explaingit

kedacore/keda

10,181GoAudience · ops devopsComplexity · 4/5Setup · moderate

TLDR

KEDA lets Kubernetes services scale automatically based on real demand signals, like message queue depth, including scaling all the way to zero when there is nothing to process, so you only pay for compute when work actually arrives.

Mindmap

mindmap
  root((KEDA))
    What it does
      Event-driven scaling
      Scale to zero
      Feeds Kubernetes HPA
    Triggers
      Message queues
      Cloud storage
      Streaming platforms
    Setup
      Kubernetes cluster
      Custom resource files
    Use Cases
      Batch job workers
      Cost reduction
      Real-demand scaling
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Scale a message-processing worker up when a queue fills and back to zero when it empties, eliminating idle compute costs.

USE CASE 2

Replace CPU-based autoscaling with event-driven signals like Kafka topic lag or Azure Service Bus queue depth.

USE CASE 3

Run Kubernetes batch jobs that spin up only when work arrives and terminate automatically when done.

USE CASE 4

Drive autoscaling from cloud storage events or streaming platforms without replacing Kubernetes' built-in machinery.

Tech stack

GoKubernetes

Getting it running

Difficulty · moderate Time to first run · 1h+

Requires a running Kubernetes cluster with kubectl access and credentials for the event source being scaled on.

In plain English

KEDA stands for Kubernetes-based Event Driven Autoscaling. It is a component you add to a Kubernetes cluster to control how many copies of a service are running based on real workload signals, rather than only on CPU or memory usage. The core idea is straightforward: instead of guessing how many containers to keep running at all times, you let external signals decide. If messages are piling up in a queue, KEDA can spin up more containers to process them. When the queue drains, it can scale back down, including all the way down to zero so nothing is running when there is nothing to do. Scaling to zero is significant because it means you pay for compute only when actual work arrives. KEDA works alongside Kubernetes' built-in scaling system rather than replacing it. It acts as an additional metrics source, feeding event-driven signals into the same autoscaling machinery that Kubernetes already uses. It supports a wide range of event sources based on its documentation, including message queues, cloud storage, and streaming platforms. Configuration is done by defining custom resource files in Kubernetes, so teams manage it the same way they manage other cluster settings. The project is a graduated project under the Cloud Native Computing Foundation, which is the same organization that stewards Kubernetes itself. That status reflects a level of maturity and adoption in production environments. It can run in cloud environments or on the edge. For teams already running applications on Kubernetes, KEDA is a way to make scaling decisions based on the actual demand hitting a service, rather than on background resource metrics that may not reflect real user activity.

Copy-paste prompts

Prompt 1
Write a KEDA ScaledObject manifest that scales a deployment from 0 to 10 replicas based on the number of messages in an AWS SQS queue.
Prompt 2
I have a Kubernetes worker that sits idle most of the day. Show me how to configure KEDA with a cron trigger to scale it to zero outside business hours.
Prompt 3
How do I install KEDA on an existing Kubernetes cluster using Helm and verify it is working with kubectl?
Prompt 4
Explain what KEDA ScaledJob is, how it differs from ScaledObject, and give me an example of when to use each.
Open on GitHub → Explain another repo

← kedacore on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.