KEDA scalers for custom workloads (Azure Container Apps)

Azure Container Apps (ACA) soporta un gran rango de KEDA scalers fuera de servicios de Azure. Estos scalers permiten tener event-driven scaling basado en Apache Kafka, Redis queue depth y muchos más servicios.

Explorar available KEDA scalers

ACA soporta cualquier ScaledObject basado en KEDA scalers. Estos soportan muchas más herramientas de las aquí puestas como PostgreSQL, MongoDB y APIs externas. Cada scaler monitoriza un event source específico y reporta métricas que derivan en decisiones sobre el escalado.

Configurar Apache Kafka scaling

Kafka es una plataforma event-driven. Permite transportar, almacenar y procesar grandes volúmenes de eventos de forma continua. Se basa en los conceptos Producer/Consumer/Topic

Los triggers de Kafka para el escalado se basan en consumer group lag. El scaler analiza el lag del consumer group y cuando este incrementa, el scaler aumenta las réplicas para procesar más rápido y reducir el backlog.

Los key metadata params para Kafka scaling incluye bootstrapServers, consumerGroup, topic y lagThreshold. Este último permite especificar el lag por partición que hace trigger del escalado. Si ponemos un threshold de 100 y detecta que el consumer group tiene 500 mensajes de lag a lo largo de todas las particiones, el scaler calcula que hacen falta 5 réplicas.

IMPORTANTE

Al igual que los Event Hubs, las particiones de Kafka afectan a su escalado máximo efectivo. Cada partición solo puede tener un consumer activo por consumer group, por lo que solo es efectivo tener tantas réplicas como consumer groups tengamos.

/IMPORTANTE

scale:
  minReplicas: 1
  maxReplicas: 50
  rules:
    - name: kafka-scaling
      custom:
        type: kafka
        metadata:
          bootstrapServers: "kafka-broker:9092"
          consumerGroup: "order-consumers"
          topic: "orders"
          lagThreshold: "100"
        auth:
          - secretRef: kafka-credentials
            triggerParameter: sasl

Configurar Redis scaling

Redis scaling soporta workloads que usen Redis Lists o Streams como task queues. El scaler monitoriza la queue depth y ajusta las réplicas basadas en el trabajo pendiente.

Existen dos tipos de scalers:

  • Redis Lists scalers: monitoriza la length de la lista
  • Redis Streams scalers: monitoriza las pending entries del consumer group

Redis List scalers

Scaler más simple. Mira la length de la lista y la compara contra el threshold. Funciona bien con arq. productor/consumidor donde los items se ponen en una lista y los comsumidores les hacen pop

Redis Streams scalers

Scaler más sofisticado para apps que usen streams. Trackea el número de pending entries para un consumer group específico. Tiene en cuenta los mensajes que se han entregado pero no se ha hecho acknowledge todavía.

Maneja mejor los fallos que las listas ya que tiene en cuenta el WIP.

Configurar cron-based scaling

Sirve como método avanzado de scaling cuando se combina junto a otros scalers.

Lo podemos usar para establecer la baseline durante horas pico, y usar scalers HTTP o event-driven para manejar picos de carga no esperados.

IMPORTANTE

Cuando hay múltiples scalers activo ACA usa el que sea más alto.

ejemplo que combina CRON con HTTP. El CRON mantiene 5 réplicas durante business hours, mientras que el HTTP se encarga de los picos y variaciones en volumen de requests

/IMPORTANTE

scale:
  minReplicas: 0
  maxReplicas: 20
  rules:
    - name: business-hours
      custom:
        type: cron
        metadata:
          timezone: "America/New_York"
          start: "0 8 * * 1-5"
          end: "0 18 * * 1-5"
          desiredReplicas: "5"
    - name: http-scaling
      http:
        metadata:
          concurrentRequests: "50"

Configurar Prometheus metrics scaling

Prometheus es una herramienta de monitorización y alertas. Usada especialmente en cloud, microservicios y k8s. Replica métrica de apps e infra, las almacena y permite analizarlas para conocer estado y rendimiento de los sistemas

Prometheus scaling se basa en custom metrics expuestas por tu app o infra. El scaler hace query a un Prometheus server y evaluar el resultado contra tu threshold.

Convertir especificaciones KEDA a ACA rules

Al migrar de K8s con KEDA o adaptar ejemplos, hay que convertir las especificaciones KEDA ScaledObject a ACA rules. El proceso envuelve extraer key values del formato KEDA y mapearlas a ACA CLI params o YAML.

No memorizar los siguientes pasos pero que me suenen

Pasos para convertir de KEDA a ACA rules:

  1. KEDA type triggers[].type -> --scale-rule-type (CLI) / type (under custom) (YAML)
  2. KEDA type triggers[].metadata -> –scale-rule-metadata (CLI) / metadata (YAML)
  3. Auth params en KEDA TriggerAuthentication -> ACA secrets y credenciales y referenciar en --scale-rule-auth (CLI) / auth (YAML); Otra alternativa es usar Managed Identity con --scale-rule-identity
  4. KEDA scale limits minReplicaCount / maxReplicaCount -> --min-replicas / --max-replicas

Best practices

  • Comenzar con Azure-native scalers: Usar los scalers nativos antes de considerar alternativas de la comunidad
  • Testear scale behaviour en UAT: Validar y testear scaling patterns en entornos no productivos. Monitorizar y validar la rapidez del escalado
  • Combinar escalado programado con escalado reactivo: Usar CRON scalers para la baseline durante picos conocidos. Usar event-driven scaling para picos no esperados
  • Documentar custom scalers: El escalado es complejo y los custom más. Documentar por qué se eligen algunos límites, como se maneja la auth y que métricas se usan

Additional resources

Scalers
Cron