KEDA lets Kubernetes workloads scale in response to queues, streams, cloud services, schedules, and other event sources—including scaling from zero when an event signal arrives. It works alongside Kubernetes’ Horizontal Pod Autoscaler (HPA): KEDA handles activation between zero and one replica, while the HPA manages scaling above one. “Serverless” describes that scale-to-zero experience; it does not remove the need to run and operate a Kubernetes cluster.
How KEDA event-driven autoscaling works
KEDA, the Kubernetes Event-driven Autoscaler, connects a workload to an event source and makes event-related metrics available to Kubernetes. The KEDA project describes it as a “Kubernetes-based Event Driven Autoscaler” in its official documentation.
As an Amazon Associate I earn from qualifying purchases.
The control flow has two phases. When a workload is at zero replicas, KEDA evaluates its configured trigger and activates the workload when the event signal calls for it. Once a replica is running, the HPA uses metrics exposed through KEDA’s metrics API server to scale the workload up or down. KEDA’s documentation calls these the activation phase (zero to one and one to zero) and scaling phase (one to N and N to one). See the KEDA concepts and scaling documentation.
This division matters operationally: event-source polling is relevant to waking a workload from zero, while HPA metric checks govern scaling when it is active. Neither means that a new replica appears instantly. Activation latency depends on KEDA settings and the source, and active scaling also depends on the Kubernetes controller-manager’s HPA sync interval.
#1 Best Overall
Which Kubernetes workloads can KEDA scale?
KEDA’s resource choice depends on whether the application is a continuously running service or a batch worker.
| Resource pattern | KEDA resource | When it fits |
|---|---|---|
| Deployment or StatefulSet | ScaledObject | Scale a long-running workload using configured event triggers. |
Custom resource with Kubernetes’ /scale subresource |
ScaledObject | Scale a compatible custom resource. |
| Batch processing | ScaledJob | Create Kubernetes Jobs in response to external metrics. |
A ScaledObject also supports a target reference and triggers, with settings for polling, cooldown, replica bounds, fallback, and HPA behavior. Credentials for event sources can be configured separately from the target workload using TriggerAuthentication. The exact fields, defaults, and semantics are version-specific; consult the v2.21 ScaledObject specification and concepts documentation.
What you need to configure KEDA
- Provide a reachable Kubernetes cluster. KEDA is installed into a running cluster; it does not provide the cluster itself.
- Install KEDA and configure
kubectl. Follow the KEDA setup guidance for the installation method and cluster requirements. - Choose a scaler that matches the event source. Check its own prerequisites for credentials, identity, metrics, and source connectivity before creating the scaling resource. Some scalers are separate add-ons rather than part of KEDA’s core installation.
- Choose ScaledObject or ScaledJob. Use a ScaledObject for a supported workload that should scale its replicas; use a ScaledJob for batch processing that should create Jobs based on external metrics.
- Configure and apply the resource, then inspect it in the cluster. Set the trigger, authentication as needed, replica limits, polling and cooldown behavior, and any HPA behavior appropriate to the workload.
The setup documentation also describes an HTTP add-on for incoming HTTP traffic and labels it beta in the consulted v2.21 documentation. Treat it as an add-on with its own status and setup requirements, not as an automatic feature of the core installation.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsHow to choose settings without assuming scaling is instantaneous
The v2.21 ScaledObject reference specifies a 30-second default polling interval and a default maximum replica count of 100. These are documented defaults, not universal production recommendations. Set bounds and timing based on the workload, event source limits, and the consequences of delay or excess capacity.
- At zero replicas: consider how often KEDA evaluates the source, how quickly it must activate the workload, and whether polling could strain or exceed source/API limits.
- Above zero: account for the HPA’s metric checks and configure scale-up and scale-down behavior that fits the work rate and resource limits.
- On scaler errors: the ScaledObject specification describes fallback behavior, subject to supported trigger types. Decide what capacity is safe if the event metric cannot be read.
- For replica bounds: choose minimum and maximum values based on service needs and available capacity rather than copying sample values.
KEDA passes HPA behavior settings through its ScaledObject configuration, subject to the Kubernetes version’s supported API. The v2.21 reference notes that configurable HPA tolerance is beta in Kubernetes v1.34 and can be specified by default there; verify the API support for the version actually running in your cluster.
Why CPU or memory alone cannot wake a zero-replica workload
CPU and memory scaling depend on Kubernetes Metrics Server and pod resource requests or limits. With no running pods, there are no pod CPU or memory metrics to trigger a restart, so CPU or memory alone cannot provide scale-from-zero activation. KEDA’s CPU guidance says CPU or memory can be combined with at least one additional non-CPU/non-memory scaler to provide an activation signal when minimum replicas are zero. See the CPU scaler documentation.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What KEDA does not solve for queue consumers
KEDA changes replica decisions; it does not make an event consumer correct or safe by itself. For a queue worker, replicas pull work from the source, so scaling depends on how much work each replica can process and on the source’s delivery behavior. Before choosing trigger thresholds or replica limits, account for backlog, consumer throughput, retries, ordering, dead-letter handling, and checkpoints. The workload and event source must still handle these correctly.
Where KEDA fits in a Kubernetes platform
KEDA is not limited to one cloud provider: its official overview describes it as compatible with Kubernetes clusters generally. For a concrete platform example, AWS documents using KEDA for event-driven application autoscaling on Amazon EKS. EKS is one place to run a KEDA-enabled cluster, not a requirement for using KEDA.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
