Autoscaling

info

Cette page concerne uniquement l'installation sur un cluster existant via KOTS ou Helm.

Prérequis pour l'autoscaling

Vous pouvez utiliser soit Kubernetes HPA (Horizontal Pod Autoscaler) soit KEDA (Kubernetes Event-Driven Autoscaler) pour l'autoscaling. Les deux reposent sur les mêmes métriques mais ont des prérequis différents.

• HPA : intégré à Kubernetes, lit les métriques depuis Metrics Server ou les métriques externes poussées par Prometheus Adapter. Un peu moins réactif que KEDA. Ne peut pas scaler à zéro réplica.
• KEDA : lit les événements depuis diverses sources (ici Prometheus). Scaling plus rapide. Peut scaler à zéro réplica. Non disponible sur les installations KOTS.

Composants requis

Selon votre méthode d'autoscaling choisie, vous aurez besoin de composants différents installés dans votre cluster :

Composant	HPA	KEDA
Serveur Prometheus	Requis	Requis
Prometheus adapter	Requis	Non requis
KEDA controller	Non requis	Requis

HPA nécessite Prometheus adapter pour exposer ces métriques à l'API metrics de Kubernetes, tandis que KEDA peut interroger Prometheus directement.

Installer le serveur Prometheus

Si vous n'avez pas déjà Prometheus dans votre cluster, nous recommandons d'installer le serveur Prometheus standalone via le Helm chart officiel.

Ajoutez le dépôt Helm Prometheus Community :

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

Vous pouvez ensuite procéder à l'installation de Prometheus :

helm install prometheus prometheus-community/prometheus \
  --namespace monitoring \
  --create-namespace \
  --set alertmanager.enabled=false \
  --set prometheus-pushgateway.enabled=false

Le serveur Prometheus sera disponible à http://prometheus-server.monitoring.svc.cluster.local:80 (accessible uniquement depuis l'intérieur du cluster).

Installer Prometheus adapter

Si vous choisissez d'utiliser HPA pour l'autoscaling, installez Prometheus Adapter pour exposer les métriques Prometheus à l'API metrics de Kubernetes.

helm install prometheus-adapter prometheus-community/prometheus-adapter \
  --namespace monitoring \
  --set prometheus.url=http://prometheus-server.monitoring.svc.cluster.local \
  --set prometheus.port=80

Voir la section Configuration Prometheus Adapter ci-dessous pour les règles à ajouter.

Installer le contrôleur KEDA

Installez le contrôleur KEDA pour activer l'autoscaling. Vous pouvez l'installer via le Helm chart KEDA avec les commandes suivantes :

helm repo add kedacore https://kedacore.github.io/charts
helm install keda kedacore/keda \
  --namespace keda \
  --create-namespace

Vous devez configurer les values Helm de votre chart GitGuardian pour permettre à KEDA de se connecter à votre serveur Prometheus :

autoscaling:
  keda:
    prometheus:
      metadata:
        # Use the Prometheus server address from your installation
        # Example with the prometheus-community/prometheus chart installed above:
        serverAddress: http://prometheus-server.monitoring.svc.cluster.local:80
        # Optional. Custom headers to include in query
        customHeaders: X-Client-Id=cid,X-Tenant-Id=tid,X-Organization-Id=oid
        # Optional. Specify authentication mode (basic, bearer, tls)
        authModes: bearer
      # Optional. Specify TriggerAuthentication resource to use when authModes is specified.
      authenticationRef:
        name: keda-prom-creds

Un ScaledObject et un hpa seront créés dans le namespace GitGuardian.

Autoscaling des workers

L'autoscaling permet le scaling dynamique des pods worker en fonction de la longueur de queue de tâches Celery comme métrique externe pour les décisions de scaling, améliorant l'efficacité et les performances tout en optimisant les coûts en ressources.

Pour activer l'autoscaling basé sur les longueurs de queues Celery, vous devez d'abord activer les métriques applicatives en suivant ce guide.

Si vous utilisez KEDA, configurer Prometheus adapter n'est pas nécessaire.

Configuration Prometheus adapter

Configurez Prometheus adapter pour exposer les longueurs de queues Celery comme métriques externes. Cela se fait en mettant en place une règle personnalisée dans la configuration Prometheus Adapter.

La règle suivante doit être ajoutée à vos values Helm Prometheus Adapter pour exposer les longueurs de queues Celery :

rules:
  external:
    - seriesQuery: '{__name__="gim_celery_queue_length",queue_name!=""}'
      metricsQuery: sum(<<.Series>>{<<.LabelMatchers>>}) by (queue_name)
      resources:
        namespaced: true
        overrides:
          namespace:
            resource: namespace

Si vous utilisez le Machine Learning, vous aurez aussi besoin de cette règle :

rules:
  external:
    - seriesQuery: '{__name__="bentoml_service_request_in_progress",exported_endpoint!=""}'
      resources:
        namespaced: false
      metricsQuery: sum(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>)

Comportement d'autoscaling

Le comportement suivant sera appliqué :

• Scaling Up : si la longueur d'une queue Celery dépasse 10 tâches par réplica de worker actuel, le nombre de réplicas sera augmenté, à condition que le nombre actuel de réplicas soit en dessous de la limite maximale spécifiée.
• Scaling Down : si le nombre de tâches par réplica de worker actuel reste en dessous de 10 pendant une période continue de 5 minutes, le nombre de réplicas sera diminué, à condition que le nombre actuel de réplicas soit au-dessus de la limite minimale spécifiée.

info

En utilisant KEDA, lorsque la queue Celery est vide, le worker passera en état idle, ce qui résultera en un scaling à zéro du nombre de réplicas.

Installation via KOTS

L'installation KOTS ne permet que l'autoscaling HPA.

Naviguez sous Config > Scaling dans la console d'administration KOTS, vous aurez accès aux options de scaling des workers.

Pour chaque worker, vous pouvez activer l'autoscaling en cochant l'option Enable Horizontal Pod Autoscaling, puis vous pourrez spécifier les réplicas minimum et maximum.

Installation via Helm

Personnalisez les applications Helm via votre fichier local-values.yaml, soumis avec la commande helm.

Autoscaling des workers

Vous pouvez activer l'autoscaling des workers en définissant les values Helm suivantes (ici, nous activons HPA pour le worker « worker ») :

celeryWorkers:
  worker:
    autoscaling:
      hpa:
        enabled: true
      keda:
        enabled: false
      minReplicas: 1
      maxReplicas: 10

Autoscaling du Machine Learning Secret Engine

Pour un autoscaling efficace du Machine Learning Secret Engine, vous devez activer l'autoscaling pour les deux :

• Le worker ML traitant la queue Celery (ml-api-priority) : ce worker est responsable de la mise en file et de la distribution des tâches liées au ML. Sans autoscaling, il pourrait devenir un goulot d'étranglement, entraînant des délais dans le traitement des requêtes.

• Le Secret Engine gérant le calcul (secretEngine) : activer l'autoscaling pour le Secret Engine garantit qu'il peut se mettre à l'échelle en réponse à la demande de calculs ML.

Pour activer l'autoscaling, configurez les values Helm suivantes :

# ML Secret Engine
secretEngine:
  autoscaling:
      hpa:
        enabled: true
      keda:
        enabled: false
      minReplicas: 1
      maxReplicas: 2

celeryWorkers:
  # ML Worker
  ml-api-priority:
    autoscaling:
      hpa:
        enabled: true
      keda:
        enabled: false
      minReplicas: 1
      maxReplicas: 2

Voir la documentation de référence des values pour plus de détails.

attention

Les paramètres Helm autoscaling.hpa.enabled et autoscaling.keda.enabled sont mutuellement exclusifs, vous devez choisir entre hpa (utilisant Prometheus adapter) et le contrôleur KEDA.