Configuration de récupération Prometheus CloudWatch configuration de l'agent pour Prometheus Tutoriel pour ajouter une nouvelle cible Prometheus Scrape : Prometheus Server metrics API

Récupération de sources Prometheus supplémentaires et importation de ces métriques

L' CloudWatch agent chargé de surveiller Prometheus a besoin de deux configurations pour récupérer les métriques Prometheus. L'une concerne les configurations standard Prometheus, comme décrit dans <scrape_config> dans la documentation Prometheus. L'autre concerne la configuration de l' CloudWatch agent.

Pour les EKS clusters Amazon, les configurations sont définies dans prometheus-eks.yaml (pour le type de EC2 lancement) ou prometheus-eks-fargate.yaml (pour le type de lancement Fargate) sous la forme de deux cartes de configuration :

La section name: prometheus-config contient les paramètres pour la récupération Prometheus.
La name: prometheus-cwagentconfig section contient la configuration de l' CloudWatch agent. Vous pouvez utiliser cette section pour configurer la manière dont les métriques Prometheus sont collectées par. CloudWatch Par exemple, vous spécifiez les métriques dans lesquelles vous souhaitez CloudWatch importer et définissez leurs dimensions.

Pour les clusters Kubernetes exécutés sur des EC2 instances Amazon, les configurations sont définies dans le prometheus-k8s.yaml YAML fichier sous la forme de deux cartes de configuration :

La section name: prometheus-config contient les paramètres pour la récupération Prometheus.
La name: prometheus-cwagentconfig section contient la configuration de l' CloudWatch agent.

Pour extraire des sources de métriques Prometheus supplémentaires et les importer, CloudWatch vous devez modifier à la fois la configuration de Prometheus Scrape et la configuration de l'agent, puis redéployer CloudWatch l'agent avec la configuration mise à jour.

VPCexigences relatives aux groupes de sécurité

Les règles d'entrée des groupes de sécurité pour les charges de travail Prometheus doivent ouvrir les ports Prometheus à l'agent pour récupérer les métriques Prometheus par CloudWatch l'adresse IP privée.

Les règles de sortie du groupe de sécurité pour l' CloudWatch agent doivent permettre à l'agent de se connecter au CloudWatch port des charges de travail Prometheus via une adresse IP privée.

Configuration de récupération Prometheus

L' CloudWatch agent prend en charge les configurations standard de Prometheus scrape, comme indiquéhttps://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config <scrape_config>dans la documentation de Prometheus. Vous pouvez modifier cette section pour mettre à jour les configurations déjà présentes dans ce fichier et ajouter des cibles de récupération Prometheus supplémentaires. Par défaut, l'exemple de fichier de configuration contient les lignes de configuration globale suivantes :


global:
  scrape_interval: 1m
  scrape_timeout: 10s

scrape_interval– Définit la fréquence à laquelle récupérer les cibles.
scrape_timeout– Définit le temps d'attente avant l'expiration d'une requête de récupération.

Vous pouvez également définir différentes valeurs pour ces paramètres au niveau de la tâche, afin de remplacer les configurations globales.

Tâches de récupération Prometheus

Certaines tâches de scraping par défaut sont déjà configurées dans les YAML fichiers de l' CloudWatch agent. Par exemple, dans prometheus-eks.yaml, les tâches de récupération par défaut sont configurées dans les lignes job_name de la section scrape_configs. Dans ce fichier, la kubernetes-pod-jmx section par défaut suivante supprime les métriques de JMX l'exportateur.


   - job_name: 'kubernetes-pod-jmx'
      sample_limit: 10000
      metrics_path: /metrics
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__address__]
        action: keep
        regex: '.*:9404$'
      - action: labelmap
        regex: __meta_kubernetes_pod_label_(.+)
      - action: replace
        source_labels:
        - __meta_kubernetes_namespace
        target_label: Namespace
      - source_labels: [__meta_kubernetes_pod_name]
        action: replace
        target_label: pod_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_container_name
        target_label: container_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_controller_name
        target_label: pod_controller_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_controller_kind
        target_label: pod_controller_kind
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_phase
        target_label: pod_phase

Chacune de ces cibles par défaut est supprimée et les métriques sont envoyées dans le journal des événements CloudWatch à l'aide d'un format de métrique intégré. Pour plus d’informations, consultez Intégration de métriques dans les journaux.

Les événements de journal des clusters Amazon EKS et Kubernetes sont stockés dans le fichier /aws/containerinsights/ cluster_namegroupe de journaux /prometheus dans Logs. CloudWatch Les événements de journal des ECS clusters Amazon sont stockés dans le fichier /aws/ecs/containerinsights/cluster_namegroupe de journaux /prometheus.

Chaque tâche de récupération est contenue dans un flux de journaux différent au sein de ce groupe de journaux. Par exemple, la tâche de récupération Prometheus kubernetes-pod-appmesh-envoy est définie pour App Mesh. Toutes les métriques App Mesh Prometheus des clusters EKS Amazon et Kubernetes sont envoyées au flux de journal nommé /aws/containerinsights/ cluster_name>prométhée//kubernetes-pod-appmesh-envoy.

Pour ajouter une nouvelle cible de scraping, vous devez ajouter une nouvelle job_name section à la scrape_configs section du YAML fichier et redémarrer l'agent. Pour un exemple de ce processus, consultez Tutoriel pour ajouter une nouvelle cible Prometheus Scrape : Prometheus Server metrics API.

CloudWatch configuration de l'agent pour Prometheus

Le fichier de configuration de l' CloudWatch agent contient une prometheus section metrics_collected dédiée à la configuration du scraping de Prometheus. Elle inclut les options de configuration suivantes :

cluster_name– Spécifie le nom du cluster à ajouter en tant qu'étiquette dans l'évènement du journal. Ce champ est facultatif. Si vous l'omettez, l'agent peut détecter le nom du cluster Amazon EKS ou Kubernetes.
log_group_name– Spécifie le nom du groupe de journaux pour les métriques Prometheus récupérées. Ce champ est facultatif. Si vous l'omettez, utilisez CloudWatch /aws/containerinsights/ cluster_name/prometheus pour les journaux des clusters Amazon EKS et Kubernetes.
prometheus_config_path– Spécifie le chemin d'accès du fichier de configuration de récupération Prometheus. Si la valeur de ce champ commence par env:, le contenu du fichier de configuration de récupération Prometheus sera récupéré à partir de la variable d'environnement du conteneur. Ne modifiez pas ce champ.
ecs_service_discovery — est la section qui définit la configuration pour la découverte des services Amazon ECS Prometheus. Pour plus d’informations, consultez Guide détaillé pour la découverte automatique sur les clusters Amazon ECS.

La section ecs_service_discovery peut contenir les champs suivants :
- sd_frequency est la fréquence de découverte des exportateurs Prometheus. Spécifiez un nombre et un suffixe d'unité. Par exemple, 1m pour une fois par minute ou 30s pour une fois toutes les 30 secondes. Les suffixes d'unités valides sont ns, us, ms, s, m et h.
  
  Ce champ est facultatif. La valeur par défaut est de 60 secondes (1 minute).
- sd_target_clusterest le nom du ECS cluster Amazon cible pour la découverte automatique. Ce champ est facultatif. Le nom par défaut est le nom du ECS cluster Amazon sur lequel l' CloudWatch agent est installé.
- sd_cluster_regionest la région du ECS cluster Amazon cible. Ce champ est facultatif. La valeur par défaut est la région du ECS cluster Amazon où l' CloudWatch agent est installé.
- sd_result_fileest le chemin du YAML fichier pour les résultats cibles de Prometheus. La configuration de récupération Prometheus fera référence à ce fichier.
- docker_label est une section facultative que vous pouvez utiliser pour spécifier la configuration de la découverte de service basée sur des étiquettes de docker. Si vous omettez cette section, la découverte basée sur les étiquettes docker n'est pas utilisée. Cette section peut contenir les champs suivants :
  - sd_port_label est le nom de l'étiquette docker du conteneur qui spécifie le port du conteneur pour les métriques Prometheus. La valeur par défaut est ECS_PROMETHEUS_EXPORTER_PORT. Si le conteneur ne possède pas cette étiquette docker, l' CloudWatch agent l'ignorera.
  - sd_metrics_path_label est le nom de l'étiquette docker du conteneur qui spécifie le chemin d'accès aux métriques Prometheus. La valeur par défaut est ECS_PROMETHEUS_METRICS_PATH. Si le conteneur n'a pas cette étiquette docker, l'agent utilise le chemin par défaut /metrics.
  - sd_job_name_label est le nom de l'étiquette docker du conteneur qui spécifie le nom de la tâche de récupération Prometheus. La valeur par défaut est job. Si le conteneur ne possède pas cette étiquette docker, l' CloudWatch agent utilise le nom de la tâche dans la configuration Prometheus Scrape.
- task_definition_list est une section facultative que vous pouvez utiliser pour spécifier la configuration de la découverte de service basée sur les définitions de tâches. Si vous omettez cette section, la découverte basée sur les définitions de tâches n'est pas utilisée. Cette section peut contenir les champs suivants :
  - sd_task_definition_arn_patternest le modèle à utiliser pour spécifier les définitions de ECS tâches Amazon à découvrir. Il s'agit d'une expression régulière.
  - sd_metrics_portsrépertorie les containerPort métriques pour Prometheus. Séparez-les par containerPorts des points-virgules.
  - sd_container_name_patternspécifie les noms des conteneurs de ECS tâches Amazon. Il s'agit d'une expression régulière.
  - sd_metrics_path spécifie le chemin de métrique Prometheus. Si vous ne spécifiez pas ce paramètre, l'agent utilise le chemin par défaut /metrics
  - sd_job_name spécifie le nom de la tâche de récupération Prometheus. Si vous omettez ce champ, l' CloudWatch agent utilise le nom de la tâche dans la configuration Prometheus Scrape.
metric_declaration – Ce sont des sections qui spécifient le tableau de journaux avec le format de métrique intégré à générer. Il existe des metric_declaration sections pour chaque source Prometheus à partir de laquelle CloudWatch l'agent importe par défaut. Chacune de ces sections comprend les champs suivants :
- label_matcher est une expression régulière qui vérifie la valeur des étiquettes répertoriées dans source_labels. Les métriques correspondantes sont activées pour être incluses dans le format de métrique intégré envoyé à CloudWatch.
  
  Si plusieurs étiquettes sont spécifiées dans source_labels, nous vous recommandons de ne pas utiliser les caractères ^ ou $ dans l'expression régulière pour label_matcher.
- source_labels spécifie la valeur des étiquettes qui sont vérifiées par la ligne label_matcher.
- label_separator spécifie le séparateur à utiliser dans la ligne label_matcher si plusieurs source_labels sont spécifiées. La valeur par défaut est ;. Vous pouvez voir cette valeur par défaut utilisée dans la ligne label_matcher dans l'exemple suivant.
- metric_selectorsest une expression régulière qui spécifie les métriques à collecter et à envoyer CloudWatch.
- dimensionsest la liste des étiquettes à utiliser comme CloudWatch dimensions pour chaque métrique sélectionnée.

Consultez l'exemple metric_declaration suivant.


"metric_declaration": [
  {
     "source_labels":[ "Service", "Namespace"],
     "label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system",
     "dimensions":[
        ["Service", "Namespace"]
     ],
     "metric_selectors":[
        "^coredns_dns_request_type_count_total$"
     ]
  }
]

Cet exemple montre comment configurer une section de format de métrique intégrée à envoyer en tant qu'événement de journaux si les conditions suivantes sont remplies :

La valeur de Service contient node-exporter ou kube-dns.
La valeur de Namespace est kube-system.
La métrique Prometheus coredns_dns_request_type_count_total contient les deux étiquettes Namespace et Service.

L'événement de journal envoyé inclut la section en surbrillance suivante :


{
   "CloudWatchMetrics":[
      {
         "Metrics":[
            {
               "Name":"coredns_dns_request_type_count_total"
            }
         ],
         "Dimensions":[
            [
               "Namespace",
               "Service"
            ]
         ],
         "Namespace":"ContainerInsights/Prometheus"
      }
   ],
   "Namespace":"kube-system",
   "Service":"kube-dns",
   "coredns_dns_request_type_count_total":2562,
   "eks_amazonaws_com_component":"kube-dns",
   "instance":"192.168.61.254:9153",
   "job":"kubernetes-service-endpoints",
   ...
}

Tutoriel pour ajouter une nouvelle cible Prometheus Scrape : Prometheus Server metrics API

Le serveur API Kubernetes expose les métriques Prometheus sur les terminaux par défaut. L'exemple officiel de configuration de scraping de Kubernetes API Server est disponible sur Github.

Le didacticiel suivant montre comment effectuer les étapes suivantes pour commencer à importer les métriques de Kubernetes API Server dans : CloudWatch

Ajout de la configuration de scraping Prometheus pour API Kubernetes Server au fichier agent. CloudWatch YAML
Configuration des définitions de métriques intégrées au format métrique dans le YAML fichier de l' CloudWatch agent.
(Facultatif) Création d'un CloudWatch tableau de bord pour les métriques du serveur Kubernetes. API

Note

Le API serveur Kubernetes expose les indicateurs de jauge, de compteur, d'histogramme et de synthèse. Dans cette version de Prometheus Metrics Support CloudWatch , seule les métriques de type jauge, compteur et résumé sont importées.

Pour commencer à collecter les métriques API Prometheus de Kubernetes Server dans CloudWatch

Téléchargez la dernière version du fichier prometheus-eks.yaml, prometheus-eks-fargate.yaml ou prometheus-k8s.yaml en saisissant l'une des commandes suivantes.

Pour un EKS cluster Amazon avec le type de EC2 lancement, entrez la commande suivante :


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml

Pour un EKS cluster Amazon avec le type de lancement Fargate, entrez la commande suivante :


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml

Pour un cluster Kubernetes exécuté sur une EC2 instance Amazon, entrez la commande suivante :


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml

Ouvrez le fichier avec un éditeur de texte, recherchez la section prometheus-config et ajoutez la section suivante à l'intérieur de cette section. Ensuite, enregistrez les modifications :


    # Scrape config for API servers
    - job_name: 'kubernetes-apiservers'
      kubernetes_sd_configs:
        - role: endpoints
          namespaces:
            names:
              - default
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true
      bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
      relabel_configs:
      - source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
        action: keep
        regex: kubernetes;https
      - action: replace
        source_labels:
        - __meta_kubernetes_namespace
        target_label: Namespace
      - action: replace
        source_labels:
        - __meta_kubernetes_service_name
        target_label: Service

Pendant que le YAML fichier est toujours ouvert dans l'éditeur de texte, recherchez la cwagentconfig.json section. Ajoutez la sous-section suivante et enregistrez les modifications. Cette section place les métriques API du serveur dans la liste d'autorisation des CloudWatch agents. Trois types de métriques de API serveur sont ajoutés à la liste d'autorisation :

nombre d'objets etcd
APIMétriques du contrôleur d'enregistrement du serveur
APIMétriques relatives aux demandes du serveur


{"source_labels": ["job", "resource"],
  "label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)",
  "dimensions": [["ClusterName","Service","resource"]],
  "metric_selectors": [
  "^etcd_object_counts$"
  ]
},
{"source_labels": ["job", "name"],
   "label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$",
   "dimensions": [["ClusterName","Service","name"]],
   "metric_selectors": [
   "^workqueue_depth$",
   "^workqueue_adds_total$",
   "^workqueue_retries_total$"
  ]
},
{"source_labels": ["job","code"],
  "label_matcher": "^kubernetes-apiservers;2[0-9]{2}$",
  "dimensions": [["ClusterName","Service","code"]],
  "metric_selectors": [
   "^apiserver_request_total$"
  ]
},
{"source_labels": ["job"],
  "label_matcher": "^kubernetes-apiservers",
  "dimensions": [["ClusterName","Service"]],
  "metric_selectors": [
  "^apiserver_request_total$"
  ]
},

Si l' CloudWatch agent compatible avec Prometheus est déjà déployé dans le cluster, vous devez le supprimer en saisissant la commande suivante :
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
Déployez l' CloudWatch agent avec votre configuration mise à jour en saisissant l'une des commandes suivantes. Pour un EKS cluster Amazon avec le type de EC2 lancement, entrez :
```
kubectl apply -f prometheus-eks.yaml
```
Pour un EKS cluster Amazon avec le type de lancement Fargate, entrez la commande suivante. Remplacez MyCluster and region avec des valeurs correspondant à votre déploiement.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Pour un cluster Kubernetes, saisissez la commande suivante : Remplacez MyCluster and region avec des valeurs correspondant à votre déploiement.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```

Une fois cela fait, vous devriez voir un nouveau flux de journal nommé kubernetes-apiservers dans le fichier /aws/containerinsights/ cluster_namegroupe de journaux /prometheus. Ce flux de journal doit inclure les événements de journaux avec une définition intégrée du format de métrique comme suit :


{
   "CloudWatchMetrics":[
      {
         "Metrics":[
            {
               "Name":"apiserver_request_total"
            }
         ],
         "Dimensions":[
            [
               "ClusterName",
               "Service"
            ]
         ],
         "Namespace":"ContainerInsights/Prometheus"
      }
   ],
   "ClusterName":"my-cluster-name",
   "Namespace":"default",
   "Service":"kubernetes",
   "Timestamp":"1592267020339",
   "Version":"0",
   "apiserver_request_count":0,
   "apiserver_request_total":0,
   "code":"0",
   "component":"apiserver",
   "contentType":"application/json",
   "instance":"192.0.2.0:443",
   "job":"kubernetes-apiservers",
   "prom_metric_type":"counter",
   "resource":"pods",
   "scope":"namespace",
   "verb":"WATCH",
   "version":"v1"
}

Vous pouvez consulter vos métriques dans la CloudWatch console, dans l'espace de noms ContainerInsights/Prometheus. Vous pouvez également créer éventuellement un CloudWatch tableau de bord pour les métriques de votre serveur Prometheus API Kubernetes.

(Facultatif) Création d'un tableau de bord pour les métriques de Kubernetes Server API

Pour voir les statistiques de Kubernetes API Server dans votre tableau de bord, vous devez d'abord avoir effectué les étapes décrites dans les sections précédentes pour commencer à collecter ces statistiques dans. CloudWatch

Pour créer un tableau de bord pour les métriques de Kubernetes Server API

Ouvrez la CloudWatch console à l'adresse https://console.aws.amazon.com/cloudwatch/.
Assurez-vous que vous avez sélectionné la bonne AWS région.
Dans le panneau de navigation, choisissez Dashboards (Tableaux de bord).
Choisissez Créer un tableau de bord. Entrez un nom pour le nouveau tableau de bord, puis choisissez Créer un tableau de bord.
Dans Ajouter à ce tableau de bord, choisissez Annuler.
Choisissez Actions, View/Edit Attributes (Afficher/Modifier la source).
Téléchargez le JSON fichier suivant : Source du tableau de bord Kubernetes. API
Ouvrez le JSON fichier que vous avez téléchargé dans un éditeur de texte et apportez les modifications suivantes :
- Remplacez toutes les chaînes {{YOUR_CLUSTER_NAME}} par le nom exact de votre cluster. Assurez-vous de ne pas ajouter d'espaces avant ou après le texte.
- Remplacez toutes les chaînes {{YOUR_AWS_REGION}} par le nom de la région dans laquelle les métriques sont collectées. Par exemple, us-west-2. Assurez-vous de ne pas ajouter d'espaces avant ou après le texte.
Copiez le JSON blob entier et collez-le dans la zone de texte de la CloudWatch console, en remplaçant ce qui s'y trouve déjà.
Choisissez Mettre à jour, Enregistrer le tableau de bord.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Configuration sur des clusters Amazon EKS et Kubernetes

(Facultatif) Configurez des exemples de charges de EKS travail Amazon conteneurisées pour les tests métriques de Prometheus