lumikha

3 min de lecture

KEDA sur AKS : scale-to-zero avec Azure Service Bus

KEDA sur AKS : installation, ScaledObject avec Azure Service Bus, comparaison avec le HPA natif, et le piège du cooldown period.

Le Horizontal Pod Autoscaler (HPA) natif de Kubernetes scale en fonction du CPU et de la mémoire. Mais pour un worker qui consomme des messages depuis une queue, la bonne métrique c'est la longueur de la queue — pas la charge CPU. KEDA (Kubernetes Event-Driven Autoscaling) comble exactement ce manque.

Pourquoi KEDA ?#

Le HPA natif a une limitation fondamentale : il ne peut scaler qu'en fonction de métriques de ressources (CPU, mémoire) ou de métriques custom Kubernetes. Pour des sources externes comme Azure Service Bus, Azure Storage Queue, Kafka ou Redis, il faut passer par un adapter de métriques complexe à opérer.

KEDA s'intègre directement avec ces sources externes et expose leurs métriques à Kubernetes. Il gère aussi le scale-to-zero — le HPA ne peut pas descendre à zéro réplica. Avec KEDA, un Deployment peut être complètement arrêté quand la queue est vide et redémarrer automatiquement dès qu'un message arrive.

Installation sur AKS#

KEDA est disponible comme add-on géré sur AKS :

az aks update \
  --resource-group mon-rg \
  --name mon-cluster \
  --enable-keda

Ou via Helm :

helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda --namespace keda --create-namespace
# Vérifier l'installation
kubectl get pods -n kube-system -l app=keda-operator

Configurer un ScaledObject pour Azure Service Bus#

Prérequis : authentification#

KEDA a besoin de s'authentifier auprès de Service Bus pour lire la longueur de la queue. La meilleure approche sur AKS est Workload Identity.

apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: azure-servicebus-auth
  namespace: mon-app
spec:
  podIdentity:
    provider: azure-workload-identity   # Utilise Workload Identity

La Managed Identity associée au Service Account doit avoir le rôle Azure Service Bus Data Receiver sur le namespace Service Bus.

Le ScaledObject#

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: worker-scaledobject
  namespace: mon-app
spec:
  scaleTargetRef:
    name: worker-deployment       # Le Deployment à scaler
  minReplicaCount: 0              # Scale-to-zero activé
  maxReplicaCount: 20
  cooldownPeriod: 300             # 5 minutes avant de descendre à 0
  pollingInterval: 15             # Vérification toutes les 15 secondes
  triggers:
    - type: azure-servicebus
      authenticationRef:
        name: azure-servicebus-auth
      metadata:
        queueName: ma-queue
        namespace: mon-servicebus-namespace
        messageCount: "5"         # 1 replica pour 5 messages en attente

Avec messageCount: "5", KEDA créera autant de réplicas que ceil(longueur_queue / 5). Si la queue a 50 messages → 10 réplicas. Si elle se vide → scale down jusqu'à 0.

Observer le scaling en action#

# Voir l'état du ScaledObject
kubectl get scaledobject -n mon-app

# Voir les métriques KEDA
kubectl describe scaledobject worker-scaledobject -n mon-app

# Suivre le scaling en temps réel
kubectl get pods -n mon-app --watch

Comparaison avec le HPA natif#

CritèreHPA natifKEDA
Métriques sourcesCPU, mémoire, custom K8s+50 sources externes (Azure, AWS, GCP, Kafka...)
Scale-to-zeroNon (minimum 1)Oui
Latence scale-out~1 minute~15-30 secondes (configurable)
ComplexitéFaibleFaible à moyenne
OverheadAucunLéger (pods KEDA dans le cluster)

Le piège du cooldown#

Le cooldownPeriod est exprimé en secondes et représente le temps minimum que KEDA attend après que la queue soit vide avant de descendre les réplicas à minReplicaCount.

Un cooldown trop court (< 60s) peut créer un effet ping-pong : la queue se vide, KEDA scale-down, de nouveaux messages arrivent, KEDA scale-up à nouveau — rapidement et continuellement. Chaque cold start d'un pod coûte du temps de traitement.

Un cooldown trop long (> 10 min) signifie que des pods tournent à vide pendant longtemps après que la queue soit traitée.

La valeur dépend du rythme de production de messages et du temps de démarrage du pod. Pour un worker avec un cold start de 10-15 secondes et une queue qui reçoit des messages toutes les quelques minutes, 120-300 secondes est souvent un bon compromis.

Scale-to-zero et les premiers messages#

Quand minReplicaCount: 0, il n'y a aucun pod pour traiter les messages quand la queue se remplit à nouveau. KEDA détecte des messages dans la queue, crée un premier pod, et ce pod commence à traiter. Le premier message peut donc attendre le temps de démarrage du pod (cold start).

Si la latence du premier message est critique, garder minReplicaCount: 1 — on perd le bénéfice du scale-to-zero mais le premier message est traité immédiatement.

← Tous les articles