Skip to main content
Malaysia
AIMenta
K

KEDA

by CNCF

CNCF-graduated Kubernetes Event-Driven Autoscaling operator enabling APAC platform teams to scale deployments from zero based on external event sources including message queues, Kafka topics, HTTP traffic, cron schedules, and 60+ cloud and open-source triggers.

Visit KEDA (opens in new tab) Get a recommendation
AIMenta verdict
Recommended
5/5

"KEDA is the CNCF-graduated Kubernetes Event-Driven Autoscaler for APAC platform teams — scaling pods from zero based on queue depth, Kafka consumer lag, HTTP traffic, and 60+ event sources. Best for APAC engineering teams with bursty workloads."

Features
7
Use cases
4
Watch outs
4
What it does

Key features

  • Scale-to-zero — scale APAC Kubernetes deployments to zero pods when idle, eliminating idle compute cost for event-driven workloads
  • 60+ scalers — AWS SQS, Kafka, RabbitMQ, Azure Service Bus, GCP Pub/Sub, Prometheus, HTTP, cron, and more for APAC event sources
  • ScaledObject CRD — declarative Kubernetes resource defining trigger sources, target deployment, and scaling parameters for APAC workloads
  • ScaledJob — create one Kubernetes Job per event for isolated processing of APAC queue messages and batch tasks
  • Prometheus scaler — drive autoscaling from any APAC application metric exported to Prometheus
  • HTTP add-on — scale APAC HTTP workloads to zero and back up on incoming request traffic
  • HPA integration — KEDA works alongside the Kubernetes HPA, extending it with external metric sources rather than replacing it
When to reach for it

Best for

  • APAC engineering teams running message queue consumers (SQS, Kafka, RabbitMQ) that need to scale with queue depth rather than CPU utilisation
  • Platform teams implementing cost-efficient APAC Kubernetes workloads by scaling event-driven services to zero during idle periods
  • Data engineering teams processing APAC batch workloads through Kubernetes Jobs that should scale with backlog size
  • APAC multi-cloud platform teams needing a unified autoscaling solution across AWS, GCP, and Azure event sources in Kubernetes
Don't get burned

Limitations to know

  • ! Scaler polling interval — KEDA polls external metrics on a configurable interval (default 30s); scale-up response time depends on polling frequency, which may be too slow for APAC latency-sensitive workloads
  • ! Scale-from-zero cold start — when scaling from zero, APAC Kubernetes must schedule and start pods before the first request or message is processed; cold start latency is application-dependent and unavoidable
  • ! Complex multi-scaler logic — KEDA applies the highest scaler recommendation across multiple triggers; APAC teams needing AND logic (scale only when BOTH condition A and condition B are true) must implement custom metrics
  • ! Kafka consumer group rebalancing — scaling Kafka consumers triggers consumer group rebalancing; APAC high-throughput Kafka deployments should tune KEDA trigger thresholds to avoid excessive rebalancing
Context

About KEDA

KEDA (Kubernetes Event-Driven Autoscaling) is a CNCF-graduated open-source Kubernetes operator that extends Kubernetes' native Horizontal Pod Autoscaler (HPA) to enable APAC platform engineering teams to scale workloads based on external event metrics — queue depth in AWS SQS, RabbitMQ, or Azure Service Bus; consumer lag on Kafka topics; HTTP request rate; custom Prometheus metrics; cron schedules; and 60+ additional scalers — including scaling deployments and jobs to zero replicas when no events are queued.

KEDA's scaler ecosystem — where KEDA ScaledObjects reference built-in scalers for AWS (SQS, DynamoDB Streams, Kinesis, CloudWatch), GCP (Pub/Sub, Cloud Tasks), Azure (Service Bus, Event Hubs, Storage Queues), Kafka, RabbitMQ, NATS, Redis, MySQL, PostgreSQL, Prometheus, and HTTP requests — enables APAC platform teams to drive Kubernetes autoscaling from any data source their applications depend on, without building custom metric exporters or external metric APIs.

KEDA's scale-to-zero capability — where a KEDA ScaledObject can define `minReplicaCount: 0`, scaling the deployment to zero pods when the trigger metric reaches zero (empty queue, no pending jobs), and scaling back up when events arrive — enables APAC engineering teams to run event-driven workloads (message queue consumers, batch job processors, webhook handlers) with zero idle cost, a capability the native Kubernetes HPA cannot provide since it cannot scale below one replica.

KEDA's job-based scaling — where KEDA ScaledJobs create a new Kubernetes Job for each event (rather than scaling long-running pods), with configurable parallelism and completion concurrency — enables APAC data engineering teams to process queue messages, batch jobs, and data pipeline tasks as isolated Kubernetes Jobs that complete and clean up, rather than maintaining a pool of persistent consumer pods.

KEDA's Prometheus integration — where any application metric exported to Prometheus (request latency, active connections, processing backlog, business metrics like pending orders) can drive Kubernetes autoscaling through KEDA's Prometheus scaler — enables APAC platform teams to implement application-aware autoscaling based on the metrics that directly reflect workload demand, not just CPU and memory proxies.

Beyond this tool

Where this category meets practice depth.

A tool only matters in context. Browse the service pillars that operationalise it, the industries where it ships, and the Asian markets where AIMenta runs adoption programs.

Or browse All tools · Encyclopedia · Case studies · Rankings