Container Service for Kubernetes:Configure horizontal pod autoscaling with Prometheus metrics

Option A : Utiliser les métriques ACK intégrées

Prometheus Service est installé par défaut dans ACK et collecte des métriques, notamment :

• Les métriques de conteneurs cAdvisor

• Les métriques d'infrastructure Node Exporter

• Les métriques GPU Exporter

• Toutes les métriques supplémentaires que vous avez connectées à Prometheus Service

Pour afficher toutes les métriques connectées :

1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, choisissez Operations > Prometheus Monitoring.

3. Dans le coin supérieur droit, cliquez sur Alert Settings . Si le lien n'apparaît pas, mettez à jour Managed Service for Prometheus vers la dernière version. Consultez Prérequis.

4. Dans la console Prometheus Service, cliquez sur Settings dans le volet de navigation de gauche pour afficher toutes les métriques connectées.

Option B : Exposer des métriques personnalisées depuis un pod

Si votre application expose des métriques au format Prometheus, récupérez-les à l'aide d'un ServiceMonitor. Cet exemple déploie une application exemple qui expose http_requests_total et configure la collecte.

Mettre à jour la configuration de l'adaptateur

1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

2. Cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Applications > Helm.

3. Recherchez ack-alibaba-cloud-metrics-adapter et cliquez sur Update dans la colonne Actions.

4. Dans le panneau Update Release, mettez à jour le YAML avec votre configuration et cliquez sur OK.

   Détails YAML

   AlibabaCloudMetricsAdapter:
   ......
     prometheus:
       enabled: true    # Enable the Prometheus adapter.
       # Prometheus Service data request URL. See "Get the Prometheus data request URL" below.
       url: https://cn-beijing.arms.aliyuncs.com:9443/api/v1/prometheus/xxxx/xxxx/xxxx/cn-beijing
       # Prometheus V1 with token authentication enabled:
       prometheusHeader:
       - Authorization: {Token}
       # Prometheus V2 without password-free access (uncomment and replace the V1 block above):
       # prometheusHeader:
       # - Authorization: Basic <base64Encode(<accessKey:secretKey>)>
       metricsRelistInterval: 1m  # Interval for refreshing the metric list. Keep the default.
       logLevel: 5                # Debug log level. Keep the default.
       adapter:
         rules:
           default: false  # Do not expose predefined metrics by default.
           custom:
           # Example: convert container_memory_working_set_bytes to container_memory_working_set_bytes_per_second
           - seriesQuery: 'container_memory_working_set_bytes{namespace!="",pod!=""}'
             resources:
               overrides:
                 namespace: { resource: "namespace" }
                 pod: { resource: "pod" }
             name:
               matches: "^(.*)_bytes"
               as: "${1}_bytes_per_second"
             metricsQuery: 'sum(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>)'
           # Example: convert container_cpu_usage_seconds_total to container_cpu_usage_core_per_second
           - seriesQuery: 'container_cpu_usage_seconds_total{namespace!="",pod!=""}'
             resources:
               overrides:
                 namespace: { resource: "namespace" }
                 pod: { resource: "pod" }
             name:
               matches: "^(.*)_seconds_total"
               as: "${1}_core_per_second"
             metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[1m])) by (<<.GroupBy>>)'
           # Example: convert http_requests_total to http_requests_per_second
           - seriesQuery: 'http_requests_total{namespace!="",pod!=""}'
             resources:
               overrides:
                 namespace: {resource: "namespace"}
                 pod: {resource: "pod"}
             name:
               matches: "^(.*)_total"
               as: "${1}_per_second"
             metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m])) by (<<.GroupBy>>)'
   ......

Le tableau suivant répertorie les champs clés de l'adaptateur. Pour la référence complète, consultez Référence de configuration de l'adaptateur.

Vérifier le fonctionnement de l'adaptateur

Exécutez ces commandes pour confirmer que l'adaptateur expose les métriques via l'API d'agrégation Kubernetes.

Vérifier les Custom Metrics :

# List all available Custom Metrics
kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1/" | jq .

# Query container_memory_working_set_bytes_per_second for pods in kube-system
kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1/namespaces/kube-system/pods/*/container_memory_working_set_bytes_per_second" | jq .

# Query container_cpu_usage_core_per_second for pods in kube-system
kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1/namespaces/kube-system/pods/*/container_cpu_usage_core_per_second" | jq .

Une réponse réussie se présente comme suit :

{
  "kind": "MetricValueList",
  "apiVersion": "custom.metrics.k8s.io/v1beta1",
  "metadata": {
    "selfLink": "/apis/custom.metrics.k8s.io/v1beta1/namespaces/kube-system/pods/%2A/container_cpu_usage_core_per_second"
  },
  "items": [
    {
      "describedObject": {
        "kind": "Pod",
        "namespace": "kube-system",
        "name": "ack-cost-exporter-7f44d55c66-cgtz7",
        "apiVersion": "/v1"
      },
      "metricName": "container_cpu_usage_core_per_second",
      "timestamp": "2025-12-30T03:30:21Z",
      "value": "4m",
      "selector": null
    }
  ]
}

La réponse confirme que l'adaptateur a découvert la métrique et l'a associée au bon pod. Le tableau items répertorie une entrée par pod. Le champ value utilise le suffixe m (milli-unités), ce qui signifie que 4m correspond à 0,004 cœur CPU par seconde.

Vérifier les External Metrics :

# List all available External Metrics
kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1/" | jq .

# Query http_requests_per_second in the default namespace
kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1/namespaces/default/http_requests_per_second" | jq .

Une réponse réussie se présente comme suit :

{
  "kind": "ExternalMetricValueList",
  "apiVersion": "external.metrics.k8s.io/v1beta1",
  "metadata": {},
  "items": [
    {
      "metricName": "http_requests_per_second",
      "metricLabels": {},
      "timestamp": "2025-12-30T03:29:40Z",
      "value": "328m"
    }
  ]
}

Contrairement aux Custom Metrics, la réponse des External Metrics contient une seule valeur agrégée (et non une valeur par pod), car la métrique n'est pas limitée à un objet Kubernetes spécifique.

Variables de modèle dans metricsQuery

Le champ metricsQuery est un modèle Go, et non du PromQL brut. L'adaptateur le renseigne avec les valeurs issues de la requête HPA avant d'interroger Prometheus. Les délimiteurs sont << et >> (et non {{ et }}) afin d'éviter les conflits avec la syntaxe PromQL.

Découverte

seriesQuery spécifie la métrique Prometheus à convertir et accepte tout sélecteur PromQL valide, y compris les filtres d'étiquettes.

- seriesQuery: 'http_requests_total{namespace!="",pod!=""}'

Les filtres d'étiquettes namespace!="" et pod!="" limitent la métrique aux pods disposant des deux étiquettes, condition requise pour l'association des ressources à l'étape suivante.

Pour affiner la correspondance des séries, ajoutez un bloc seriesFilters :

- seriesQuery: 'http_requests_total{namespace!="",pod!=""}'
  seriesFilters:
    - isNot: "^container_.*_seconds_total"

seriesFilters accepte deux opérateurs :

• is:<regex> : conserve uniquement les séries dont le nom correspond à l'expression régulière.

• isNot:<regex> : exclut les séries dont le nom correspond à l'expression régulière.

Association

resources.overrides mappe les noms d'étiquettes Prometheus aux ressources de l'API Kubernetes. Cela indique à l'adaptateur quelle étiquette faire correspondre lorsque le HPA demande une métrique pour un pod ou un namespace spécifique.

- seriesQuery: 'http_requests_total{namespace!="",pod!=""}'
  resources:
    overrides:
      namespace: {resource: "namespace"}
      pod: {resource: "pod"}

Les clés (namespace, pod) correspondent aux noms d'étiquettes Prometheus. Les valeurs ("namespace", "pod") représentent les types de ressources de l'API Kubernetes, tels que listés par kubectl api-resources -o wide. Chaque clé doit exister en tant qu'étiquette dans vos données Prometheus.

Dénomination

Le champ name convertit le nom de la métrique Prometheus en nom de métrique HPA à l'aide d'une expression régulière. Le nom original de la métrique Prometheus reste inchangé.

- seriesQuery: 'http_requests_total{namespace!="",pod!=""}'
  resources:
    overrides:
      namespace: {resource: "namespace"}
      pod: {resource: "pod"}
  name:
    matches: "^(.*)_total"
    as: "${1}_per_second"

L'expression matches est une regex qui capture une partie du nom de la métrique Prometheus. Le champ as définit le nom de la métrique HPA, en utilisant ${1} pour faire référence au premier groupe de capture. Ici, http_requests_total devient http_requests_per_second.

Pour les External Metrics, convertissez les lettres majuscules du nom de la métrique Prometheus en minuscules dans le nom de la métrique HPA.

Pour lister tous les noms de métriques HPA disponibles :

kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1"

Interrogation

Le champ metricsQuery définit l'expression PromQL que l'adaptateur envoie à Prometheus après substitution des variables de modèle.

- seriesQuery: 'http_requests_total{namespace!="",pod!=""}'
  resources:
    overrides:
      namespace: {resource: "namespace"}
      pod: {resource: "pod"}
  name:
    matches: "^(.*)_total"
    as: "${1}_per_second"
  metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m])) by (<<.GroupBy>>)'

Les sélecteurs d'étiquettes dans metricsQuery sont injectés via <<.LabelMatchers>> au moment de la requête et n'héritent pas des filtres de seriesQuery .

Alibaba Cloud Prometheus Service

1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

2. Cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, choisissez Operations > Prometheus Monitoring.

3. Dans le coin supérieur droit, cliquez sur Alert Settings . Si le lien n'apparaît pas, mettez à jour ack-arms-prometheus vers la dernière version. Consultez la section Prérequis.

4. Dans la console Prometheus Service, cliquez sur Settings > Settings pour trouver l'adresse HTTP API Address (Grafana Read URL) . Utilisez l'adresse Internal Network lorsqu'elle est disponible ; sinon, utilisez l'adresse Internet.

   

5. Configurez l'authentification pour votre version de Prometheus.

   • Prometheus V1 (authentification par jeton désactivée par défaut) : si elle est activée, copiez le jeton depuis la console Prometheus et configurez l'adaptateur.

     

     prometheus:
       prometheusHeader:
       - Authorization: {Token}

   • Prometheus V2 (authentification AccessKey activée par défaut) : si l'accès sans mot de passe n'est pas activé, encodez en Base64 votre ID AccessKey et votre secret AccessKey.

     1. Générez une chaîne encodée en Base64.

        Concaténez votre ID AccessKey et votre secret AccessKey sous la forme AccessKey:AccessSecret, puis encodez en Base64 :

        echo -n 'accessKey:secretKey' | base64

     2. Configurez le composant.

        Saisissez la chaîne générée au format Basic <chaîne encodée> dans le champ Authorization de prometheusHeader.

        ...
            prometheus:
              prometheusHeader:
              - Authorization: Basic YWxxxxeQ==
        ...

Prometheus open source

Pour un Prometheus auto-géré, exposez son API via un service Kubernetes et définissez l'URL du service dans la configuration de l'adaptateur.

Cet exemple utilise le chart Helm ack-prometheus-operator disponible sur ACK Marketplace. Consultez la section Surveillance Prometheus open source.

1. Déployez ack-prometheus-operator.

   1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, choisissez Marketplace > Marketplace.

   2. Recherchez ack-prometheus-operator, cliquez sur sa vignette, puis cliquez sur Deploy.

   3. Sélectionnez le Cluster et le Namespace, définissez le Release Name, puis cliquez sur Next. Ajustez les Parameters selon vos besoins et cliquez sur OK.

2. Vérifiez le déploiement.

   1. Exposez l'API Prometheus via un service. Cet exemple utilise le service ack-prometheus-operator-prometheus.

   2. Dans un navigateur, accédez à ServiceIP:9090. Pour un accès public, exposez le service via une instance SLB.

   3. Dans la console Prometheus, cliquez sur Status > Targets pour afficher toutes les tâches de collecte. Si toutes les tâches affichent un State défini sur UP, la collecte fonctionne correctement.

   4. Notez le nom du service et l'espace de noms à partir de la colonne Labels. Ici, le service est ack-prometheus-operator-prometheus dans l'espace de noms monitoring.

3. Définissez l'URL Prometheus dans l'adaptateur. Pour un accès interne :

   AlibabaCloudMetricsAdapter:
     prometheus:
       enabled: true
       url: http://ack-prometheus-operator-prometheus.monitoring.svc.cluster.local:9090

   Pour un accès public :

   AlibabaCloudMetricsAdapter:
     prometheus:
       enabled: true
       url: http://your_domain.com:9090   # Replace with your public IP address or domain.

Pour ajouter une source de données Prometheus, consultez la section Ajouter une source de données Prometheus dans Grafana.