KEDA
KEDA is a Kubernetes component that scales workloads from signals such as queue depth, request rate, or scheduled activity. It connects those signals to Kubernetes autoscaling so applications can respond to demand, including scaling eligible workloads to zero.
itCloud native tools and technologies | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — KEDA
KEDA is the small translator stationed between an external sign of work and Kubernetes autoscaling. Kubernetes is already excellent at running Pods. It is less telepathic about a queue quietly filling up while the workers are idle. KEDA supplies the missing clue, then lets the Horizontal Pod Autoscaler, or HPA, do its familiar replica arithmetic.
The important shape is pleasantly short: event source, scaler, external metric, HPA, replicas. A scaler knows how to ask one kind of source what is happening. A trigger gives it the connection details and target. KEDA turns the reply into an external metric. The HPA uses that metric to change the number of Pods. This is not sorcery. It is a chain of controllers, which is fortunate because chains can be inspected when they get ideas.
The unusual part happens at zero. A ScaledObject connects a long-running workload to one or more triggers. KEDA handles the journey from zero to one replica and back again; the HPA handles the busier territory from one to many. That split explains why pollingInterval, cooldownPeriod, and HPA behavior are three different knobs wearing suspiciously similar hats. Polling asks whether work exists. Cool-down waits before returning to zero. HPA behavior governs positive replica counts.
Choose the signal as if it were a job description, because it is. Queue depth suits waiting messages. Consumer lag suits a stream processor. A Prometheus query can suit a request-driven service. CPU and memory cannot wake a workload from zero because a zero-Pod workload has no Pods left to report them. The metric has to remain visible while the application has vanished from the stage.
KEDA also offers ScaledJob for finite batch work. That is not a very energetic Deployment with a new name. A ScaledJob creates Kubernetes Jobs as demand arrives, while a ScaledObject changes replicas on a long-running target. Pick the model that matches the work before negotiating with settings that cannot change its nature.
There are boundaries. KEDA does not add nodes, repair unreachable sources, or make a poor metric wiser. It can choose a fallback replica count after repeated scaler errors, but that is a degraded posture, not a certificate of health. Keep credentials in a TriggerAuthentication resource where possible, keep the scope narrow, and make the whole route observable.
Read the Intro for the architecture and the division of responsibility. Use Slides for the control loop at a glance. Keep the Cheatsheet nearby when choosing fields and diagnosing a delay. Then use the Practice Reference and Exercise to make a queue wake a zero-replica worker, which is where the machinery stops being a diagram and starts being evidence.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://keda.sh/
Supports
- KEDA as Kubernetes event-driven autoscaling
- Official project and documentation entry point
- https://keda.sh/docs/2.20/concepts/
Supports
- KEDA architecture and component responsibilities
- Zero-to-one operator path and one-to-many HPA path
- ScaledObject, ScaledJob, and TriggerAuthentication roles
- CPU and memory scale-to-zero limitation
- https://keda.sh/docs/2.20/deploy/
Supports
- Official Helm, Operator Hub, release manifest, and MicroK8s installation paths
- Installation verification and upgrade context
- https://keda.sh/docs/2.20/setupscaler/
Supports
- Initial workload and scaler setup sequence
- Observing KEDA resources and scaling
- RabbitMQ scaler setup as a representative event-driven exercise
- https://keda.sh/docs/2.20/scalers/
Supports
- Official scaler catalog
- Scalers as source-specific activity and metric adapters
- https://keda.sh/docs/2.20/reference/scaledobject-spec/
Supports
- ScaledObject target, trigger, timing, replica, fallback, and advanced HPA fields
- Same-namespace target requirement
- Distinction between KEDA cool-down and positive-replica HPA behavior
- https://keda.sh/docs/2.20/concepts/scaling-jobs/
Supports
- ScaledJob model for event-driven finite Kubernetes Jobs
- Difference between Job creation and long-running workload replica scaling
- https://keda.sh/docs/2.20/concepts/authentication/
Supports
- TriggerAuthentication and ClusterTriggerAuthentication scope
- Secret, environment, workload identity, and supported provider patterns
- https://keda.sh/docs/2.20/troubleshooting/
Supports
- ScaledObject status, Events, HPA, operator logs, and metrics server logs as diagnostic evidence
- Authentication, connectivity, and scaler failure investigation
- https://keda.sh/docs/2.20/integrations/prometheus/
Supports
- KEDA Prometheus endpoints and metric groups
- Scaler activity, value, latency, error, and pause metrics
- Dashboard guidance
- https://keda.sh/docs/2.20/operate/cluster/
Supports
- Cluster network and runtime requirements
- Component high-availability limitations
- Production operation controls
- https://github.com/sindresorhus/awesome
Supports
- Starting index used for required awesome-list discovery
- Discovery of the Awesome Kubernetes list
- https://github.com/ramitsurana/awesome-kubernetes/wiki/Awesome---Kubernetes
Supports
- Discovery of KEDA in the Kubernetes ecosystem
- Discovery of Helm, Prometheus, and K9s as related Kubernetes tools
- https://helm.sh/docs/
Supports
- Helm as the Kubernetes package manager
- Chart and command documentation used to manage packaged Kubernetes applications
- https://prometheus.io/docs/introduction/overview/
Supports
- Prometheus time-series collection, querying, monitoring, and alerting model
- Metrics as operational evidence and scaling inputs
- https://k9scli.io/topics/commands/
Supports
- Namespaced and context-aware Kubernetes resource views
- Resource details, logs, filters, and read-only operation
- https://keda.sh/blog/2020-03-31-keda-cncf-sandbox/
Supports
- KEDA 1.0 release on 2019-11-19
- KEDA CNCF Sandbox acceptance on 2020-03-31
- https://keda.sh/blog/2020-11-04-keda-2.0-release/
Supports
- KEDA 2.0 release and the ScaledObject and ScaledJob split
- Multiple triggers and scale-subresource targets
- https://keda.sh/blog/2021-06-24-announcing-http-add-on/
Supports
- KEDA HTTP Add-on request-aware scaling architecture
- https://www.cncf.io/announcements/2023/08/22/cloud-native-computing-foundation-announces-graduation-of-kubernetes-autoscaler-keda/
Supports
- KEDA CNCF incubation in August 2021
- KEDA CNCF graduation on 2023-08-22
- https://keda.sh/blog/2022-12-12-keda-2.9-release/
Supports
- KEDA 2.9 dashboard, Prometheus metrics, and caching changes
- https://keda.sh/blog/2023-05-16-keda-2.10-certificate-management/
Supports
- KEDA 2.10 admission webhooks and certificate-management changes
- https://github.com/kedacore/keda/blob/main/CHANGELOG.md
Supports
- KEDA 2.16 validating-webhook and explicit-RBAC changes
- https://github.com/kedacore/keda/blob/main/ROADMAP.md
Supports
- KEDA 2.16 release date on 2024-11-07
- https://github.com/kedacore/keda/discussions/4412
Supports
- Practitioner report of scale-to-zero cold-start cost for queued work
- https://keda.sh/docs/2.20/concepts/admission-webhooks/
Supports
- Conflicts caused by two autoscaling controllers managing one workload
- https://knative.dev/docs/serving/autoscaling/
Supports
- Knative Serving request-driven autoscaling and scale-to-zero
- https://kubernetes.io/docs/concepts/cluster-administration/node-autoscaling/
Supports
- Karpenter and Cluster Autoscaler as node autoscalers
- Distinction between node capacity and workload replica autoscaling
