Aller au contenu principal

Autoscaling

info

Cette page concerne uniquement l'installation sur un existing cluster à l'aide de KOTS ou de 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 transmises par Prometheus Adapter. Un peu moins réactif que KEDA. Ne peut pas réduire à zéro réplica.
  • KEDA : lit les événements depuis diverses sources (ici Prometheus). Scaling plus rapide. Peut réduire à zéro réplica. Non disponible sur les installations basées sur KOTS.

Composants requis​

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

ComposantHPAKEDA
Serveur PrometheusRequisRequis
Prometheus adapterRequisNon requis
Contrôleur KEDANon requisRequis

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

Installer le serveur Prometheus​

Les deux méthodes d'autoscaling nécessitent un Prometheus qui scrape les métriques de l'application GitGuardian. Deux configurations sont prises en charge, selon que vous exécutez ou non le Prometheus Operator dans votre cluster.

Prérequis : autoriser l'export des métriques

Quelle que soit l'option que vous choisissez, l'application GitGuardian doit d'abord être configurée pour exposer ses métriques, sinon Prometheus scrape des endpoints vides. Consultez Autoriser la collecte des métriques pour activer l'export de l'application.

Lequel choisir ?

Un serveur Prometheus autonome ne lit pas les ressources ServiceMonitor — il ne scrape que ce que son propre fichier de configuration liste. Les objets ServiceMonitor intégrés au chart GitGuardian n'ont donc aucun effet sur un serveur autonome, et vous devez à la place ajouter une configuration de scrape manuelle.

  • Option A (recommandée) — si vous exécutez déjà, ou êtes prêt à installer, kube-prometheus-stack (regroupe l'opérateur + un Prometheus managé). Le chart GitGuardian fournit les objets ServiceMonitor, donc la collecte consiste simplement à les activer.
  • Option B — si vous voulez un unique Prometheus autonome sans opérateur. Vous écrivez la configuration de scrape à la main.

Ajoutez le dépôt Helm Prometheus Community (utilisé par les deux options) :

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

Pour l'autoscaling, vous n'avez besoin que de l'opérateur (pour traiter les objets ServiceMonitor) et de l'instance Prometheus elle-même. Désactivez tous les autres composants pour garder l'installation légère. Créez un kube-prometheus-stack-values.yaml :

# Operator (prometheusOperator) and Prometheus stay enabled by default —
# everything below is cluster-wide monitoring that autoscaling does not need.
alertmanager:
enabled: false
grafana:
enabled: false
nodeExporter:
enabled: false # disables the prometheus-node-exporter subchart
kubeStateMetrics:
enabled: false # disables the kube-state-metrics subchart
defaultRules:
create: false # skip the bundled Kubernetes alerting/recording rules
# Skip scraping of Kubernetes control-plane and node components
kubeApiServer:
enabled: false
kubelet:
enabled: false
kubeControllerManager:
enabled: false
coreDns:
enabled: false
kubeDns:
enabled: false
kubeEtcd:
enabled: false
kubeScheduler:
enabled: false
kubeProxy:
enabled: false
helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
--namespace monitoring \
--create-namespace \
-f kube-prometheus-stack-values.yaml

Le Prometheus managé est alors accessible dans le cluster à l'adresse http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090.

Activez les objets ServiceMonitor de GitGuardian dans votre local-values.yaml :

observability:
exporters:
statefulAppExporter:
enabled: true
serviceMonitors:
enabled: true
labels:
# Must match the Helm release name of your kube-prometheus-stack install.
# The stack's Prometheus only selects ServiceMonitors carrying this label.
release: kube-prometheus-stack
Le label release est obligatoire

Par défaut, le Prometheus de la stack a serviceMonitorSelector: {matchLabels: {release: <stack-release-name>}}. Un ServiceMonitor sans ce label exact est silencieusement ignoré — aucune cible, aucune métrique, et le Prometheus Adapter finit par ne rien exposer. Soit définissez le label comme indiqué ci-dessus, soit définissez prometheus.prometheusSpec.serviceMonitorSelectorNilUsesHelmValues=false sur la stack pour qu'elle sélectionne tous les ServiceMonitor.

Après le helm upgrade du chart GitGuardian, vérifiez que les cibles sont bien prises en compte (état UP) dans l'interface Prometheus sous Status > Targets, ou :

kubectl -n monitoring port-forward svc/kube-prometheus-stack-prometheus 9090
# then browse http://localhost:9090/targets and look for serviceMonitor/<gim-namespace>/...

Option B : Prometheus autonome avec configuration de scrape manuelle​

Installez le serveur autonome :

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

Le serveur est alors accessible dans le cluster à l'adresse http://prometheus-server.monitoring.svc.cluster.local:80.

Comme le serveur autonome ignore les objets ServiceMonitor, ajoutez une tâche de scrape pointant vers les endpoints de métriques de GitGuardian. La métrique de longueur de file Celery (gim_celery_queue_length) est publiée par l'app exporter, un unique endpoint d'agrégation — donc une seule cible statique suffit. Définissez ceci dans les values du chart Prometheus autonome :

extraScrapeConfigs: |
- job_name: "gim"
static_configs:
# Replace <gim-namespace> with the namespace your GitGuardian release is installed in
- targets: ["app-exporter.<gim-namespace>.svc.cluster.local:9808"]
metric_relabel_configs:
# The adapter rule maps metrics to a namespace (overrides.namespace), so the
# series must carry a `namespace` label. A static target has none, so derive
# it from the instance hostname: app-exporter.<namespace>.svc... -> <namespace>
- source_labels: [instance]
regex: '.*\.([^.]+)\.svc.*'
target_label: namespace
action: replace
replacement: '$1'
Mettez à jour le nom d'hôte générique

<gim-namespace> dans app-exporter.<gim-namespace>.svc.cluster.local est le namespace de votre release GitGuardian — remplacez-le par le namespace dans lequel vous avez installé. Le bloc metric_relabel_configs dérive ensuite le label namespace de ce que vous avez défini, alors gardez les deux cohérents.

info

Le service app-exporter n'existe que lorsque l'exporter d'agrégation est activé — définissez observability.exporters.statefulAppExporter.enabled: true dans vos values GitGuardian.

Pour l'autoscaling du Machine Learning Secret Engine, vous avez également besoin de bentoml_service_request_in_progress, qui est servi par le secret engine lui-même plutôt que par l'app exporter. Ajoutez une seconde cible statique pour celui-ci (le port 3000 est la valeur par défaut de secretEngine.port — ne le modifiez que si vous avez remplacé cette valeur) :

- job_name: "gim-ml-secret-engine"
metrics_path: /metrics
static_configs:
# Replace <gim-namespace> with your namespace, and 3000 if you changed secretEngine.port
- targets: ["ml-secret-engine.<gim-namespace>.svc.cluster.local:3000"]
metric_relabel_configs:
- source_labels: [instance]
regex: '.*\.([^.]+)\.svc.*'
target_label: namespace
action: replace
replacement: '$1'

Gardez observability.serviceMonitors.enabled: false (la valeur par défaut) pour cette option. Une installation Prometheus autonome n'enregistre pas les CRD monitoring.coreos.com (celles-ci viennent avec le Prometheus Operator). Si vous l'activez, le chart GitGuardian tente de créer des objets ServiceMonitor dont la CRD est absente et le helm install/helm upgrade échoue avec une erreur no matches for kind "ServiceMonitor". Le serveur autonome ignorerait de toute façon ces objets — la collecte provient ici uniquement de la configuration de scrape ci-dessus.

Installer Prometheus adapter​

Si vous choisissez HPA pour l'autoscaling, installez Prometheus Adapter pour exposer les métriques Prometheus à l'API de métriques Kubernetes. Pointez prometheus.url/prometheus.port vers le Prometheus que vous avez installé ci-dessus — c'est la mauvaise configuration la plus courante.

Pour l'Option A (kube-prometheus-stack) :

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

Pour l'Option B (serveur autonome) :

helm install prometheus-adapter prometheus-community/prometheus-adapter \
--namespace monitoring \
--set prometheus.url=http://prometheus-server.monitoring.svc.cluster.local \
--set prometheus.port=80
Adapter pointant vers le mauvais Prometheus

Si prometheus.url pointe vers un service qui n'existe pas (par exemple, vous avez migré du serveur autonome vers la stack mais avez laissé l'adapter sur l'ancienne URL), l'adapter reste AVAILABLE=True mais expose zéro métrique. Vérifiez avec :

kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1" | jq '.resources[].name'
kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1" | jq '.resources[].name'

Une liste resources vide signifie que l'adapter n'atteint aucune série correspondante — vérifiez d'abord l'URL, puis les règles.

Consultez la section Configuration de 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 à l'aide du chart Helm 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:
# Option A (kube-prometheus-stack): http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090
# Option B (standalone server): http://prometheus-server.monitoring.svc.cluster.local:80
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 un scaling dynamique des pods worker en fonction de la longueur de la file de tâches Celery utilisée comme métrique externe pour les décisions de scaling, améliorant l'efficacité et les performances tout en optimisant les coûts de ressources.

Pour activer l'autoscaling basé sur les longueurs de file Celery, vous devez d'abord autoriser la collecte des métriques afin que l'application expose ses métriques.

Si vous utilisez KEDA, la configuration de Prometheus adapter n'est pas nécessaire.

Configuration de Prometheus adapter​

Configurez Prometheus adapter pour exposer les longueurs de file Celery en tant que métriques externes. Cela se fait en configurant une règle personnalisée dans la configuration de Prometheus Adapter.

La règle suivante doit être ajoutée à vos values Helm de Prometheus Adapter pour exposer les longueurs de file 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 également 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 de l'autoscaling​

Le comportement suivant sera appliqué :

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

HPA behavior

info

Avec KEDA, lorsque la file Celery est vide, le worker passe à un état inactif, ce qui entraîne la réduction du nombre de réplicas à zéro.

Autoscaling des applications web​

Les déploiements web (par exemple public_api, internal_api) se scalent en fonction de la latence des requêtes, en lisant les métriques Prometheus de votre contrôleur ingress. GitGuardian fournit une requête de latence intégrée pour un ensemble de contrôleurs ; pour tout autre contrôleur, vous fournissez votre propre trigger KEDA.

Exigence de routage

L'autoscaling des webapps nécessite le routage Gateway API (routingApi: gateway-api) — le mode activement développé qui expose les métriques par webapp lues par l'autoscaler. Il n'est pas disponible avec le routage nginx intégré par défaut (routingApi: ingress), qui fait transiter tout le trafic par un unique pod nginx dans le chart et n'expose aucune métrique par webapp.

Prérequis​

En plus de Prometheus et KEDA, la requête intégrée lit les métriques émises par votre contrôleur ingress, que GitGuardian n'installe pas et ne scrape pas. Vous devez donc :

  1. Activer les métriques Prometheus du contrôleur, sur le propre chart du contrôleur — par exemple :
    • traefik : metrics.prometheus.serviceMonitor.enabled=true
    • istio / contour : leurs métriques de proxy Envoy (aucun flag supplémentaire, mais voir le point suivant)
  2. Faire scraper celles-ci par Prometheus, via un ServiceMonitor/PodMonitor (Prometheus Operator). La plupart des charts de contrôleurs en fournissent un derrière un flag (par exemple traefik …metrics.serviceMonitor.enabled=true) ; l'Envoy d'istio et de Contour est scrapé avec un PodMonitor sur les pods proxy (chemin /stats/prometheus).

Avec la configuration standard ServiceMonitor, Prometheus renomme le label service du contrôleur en exported_service (collision de label avec la cible de scrape) — ce qui correspond à ce que matchent les requêtes intégrées. Si les séries attendues sont absentes, l'autoscaling n'a pas de données : vérifiez dans Prometheus que la métrique de durée de requête du contrôleur existe avant de déboguer le chart.

Contrôleurs pris en charge​

La requête de latence intégrée est sélectionnée par ingress.controller :

ingress.controllerRequête de latence intégrée
istio✅
traefik✅
contour✅ (nécessite le canal CRD experimental de Gateway API — voir ci-dessous)
nginx-gateway-fabric❌ (pas de métriques par route dans l'édition OSS)
other❌ (par conception — fournissez votre propre trigger)

La requête intégrée couvre istio, traefik et contour. Contour nécessite en plus le canal CRD experimental de Gateway API (le canal de release du SIG Kubernetes Gateway API upstream). Tout autre data plane (nginx-gateway-fabric, Kong, Cilium, Envoy Gateway, aws_alb, …) n'a pas de requête intégrée — définissez controller: other et fournissez votre propre trigger KEDA comme celui ci-dessous.

Autoscaling de latence intégré (contrôleurs pris en charge)​

Définissez un seuil de latence (en millisecondes) ; le chart construit automatiquement la bonne requête Prometheus pour votre contrôleur :

ingress:
controller: istio # one of: istio, traefik, contour
webapps:
public_api:
autoscaling:
keda: { enabled: true }
minReplicas: 1
maxReplicas: 5
metrics:
targetLatency: 1000 # ms

Trigger personnalisé pour un contrôleur non listé (par exemple Gateway API avec Kong / Cilium / Envoy Gateway)​

Lorsque votre data plane n'a pas de requête intégrée, définissez ingress.controller: other, désactivez la requête intégrée avec targetLatency: null, et fournissez votre propre trigger KEDA. Le routage n'est pas affecté — other génère des HTTPRoutes Gateway API standard (ou un simple Ingress avec votre ingressClassName).

ingress:
routingApi: gateway-api
controller: other
gatewayApi:
gatewayClassName: kong # your Gateway API controller
webapps:
public_api:
autoscaling:
keda:
enabled: true
triggers:
- type: prometheus
metricType: Value
metadata:
serverAddress: http://prometheus-server.monitoring.svc.cluster.local:80
query: 'sum(rate(kong_http_requests_total{service="gim.public-api.pnum-5051"}[1m]))'
threshold: "20"
minReplicas: 1
maxReplicas: 5
metrics:
targetLatency: null # disables the built-in query

Remplacer la requête intégrée​

Vous pouvez également remplacer la requête intégrée par la vôtre (par exemple scaler sur une métrique, un percentile ou une fenêtre différents) : définissez targetLatency: null pour supprimer la requête intégrée et définir votre trigger. Une fois targetLatency à null, la valeur controller n'affecte plus l'autoscaling, vous pouvez donc conserver votre véritable contrôleur (par exemple istio) ou définir controller: other — les deux se comportent de la même façon avec un trigger personnalisé.

ingress:
controller: istio # or "other" — irrelevant for autoscaling once targetLatency is null
webapps:
public_api:
autoscaling:
keda:
enabled: true
triggers:
- type: prometheus
metricType: Value
metadata:
serverAddress: http://prometheus-server.monitoring.svc.cluster.local:80
# e.g. p99 instead of the default p95 latency
query: 'histogram_quantile(0.99, sum(rate(istio_request_duration_milliseconds_bucket{destination_service_name="public-api"}[2m])) by (destination_service_name, le))'
threshold: "800"
minReplicas: 1
maxReplicas: 5
metrics:
targetLatency: null
info

autoscaling.keda.triggers sont transmis tels quels à KEDA, vous n'êtes donc pas limité à Prometheus — n'importe quel scaler KEDA (CPU, mémoire, Kafka, SQS, …) peut être utilisé.

Installation basée sur KOTS​

L'installation basée sur KOTS n'autorise que l'autoscaling HPA.

Naviguez sous Config > Scaling dans la KOTS Admin Console, 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 le minimum et le maximum de réplicas. Worker Autoscaling configuration

Installation basée sur Helm​

Personnalisez les applications Helm à l'aide de 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 ML Worker traitant la file Celery (ml-api-priority) : ce worker est responsable de la mise en file et de la répartition des tâches liées au ML. Sans autoscaling, il pourrait devenir un goulot d'étranglement, entraînant des retards 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 scaler 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

Consultez 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.