Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Installez l' CloudWatch agent avec la collecte de métriques Prometheus sur les clusters Amazon EKS et Kubernetes
Cette section explique comment configurer l' CloudWatch agent avec la surveillance Prometheus dans un cluster exécutant Amazon EKS ou Kubernetes. Après cela, l'agent récupère et importe automatiquement les métriques pour les applications suivantes exécutées dans ce cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
Vous pouvez également configurer l'agent pour récupérer et importer à partir d'applications et sources Prometheus supplémentaires.
Avant de suivre ces étapes pour installer l' CloudWatch agent de collecte de métriques Prometheus, vous devez disposer d'un cluster exécuté sur Amazon EKS ou d'un cluster Kubernetes exécuté sur une instance Amazon EC2.
**Exigences de groupe de sécurité VPC**
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.
**Topics**
+ [Installez l' CloudWatch agent avec la collecte de métriques Prometheus sur les clusters Amazon EKS et Kubernetes](#ContainerInsights-Prometheus-Setup-roles)
+ [Récupération de sources Prometheus supplémentaires et importation de ces métriques](ContainerInsights-Prometheus-Setup-configure.md)
+ [(En option) Configuration d'exemples d'applications Amazon EKS conteneurisées pour les test de métriques Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md)
## Installez l' CloudWatch agent avec la collecte de métriques Prometheus sur les clusters Amazon EKS et Kubernetes
Cette section explique comment configurer l' CloudWatch agent avec la surveillance Prometheus dans un cluster exécutant Amazon EKS ou Kubernetes. Après cela, l'agent récupère et importe automatiquement les métriques pour les applications suivantes exécutées dans ce cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
Vous pouvez également configurer l'agent pour récupérer et importer à partir d'applications et sources Prometheus supplémentaires.
Avant de suivre ces étapes pour installer l' CloudWatch agent de collecte de métriques Prometheus, vous devez disposer d'un cluster exécuté sur Amazon EKS ou d'un cluster Kubernetes exécuté sur une instance Amazon EC2.
**Exigences de groupe de sécurité VPC**
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.
**Topics**
+ [Configuration de rôles IAM](#ContainerInsights-Prometheus-Setup-roles)
+ [Installation de l' CloudWatch agent pour collecter les métriques Prometheus](#ContainerInsights-Prometheus-Setup-install-agent)
### Configuration de rôles IAM
La première étape consiste à configurer le rôle IAM nécessaire dans le cluster. Il existe deux méthodes :
+ Configurez un rôle IAM pour un compte de service, également appelé *fonction du service*. Cette méthode fonctionne à la fois pour le type de lancement EC2 et le type de lancement Fargate.
+ Ajouter une politique IAM au rôle IAM utilisé pour le cluster. Cela ne fonctionne que pour le type de lancement EC2.
**Configurer une fonction du service (type de lancement EC2 et type de lancement Fargate)**
Pour configurer une fonction du service, saisissez la commande suivante. Remplacez *MyCluster* par le nom du cluster.
```
eksctl create iamserviceaccount \
--name cwagent-prometheus \
--namespace amazon-cloudwatch \
--cluster MyCluster \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
**Ajoutez une politique au rôle IAM du groupe de nœuds (type de lancement EC2 uniquement)**
**Pour configurer la politique IAM d’un groupe de nœuds pour la prise en charge de Prometheus**
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le panneau de navigation, choisissez **Instances**.
1. Vous devez trouver le préfixe du nom du rôle IAM pour le cluster. Pour ce faire, cochez la case en regard du nom d’une instance qui se trouve dans le cluster, puis choisissez **Actions**, **Sécurité**, **Modifier le rôle IAM**. Copiez ensuite le préfixe du rôle IAM, par exemple `eksctl-dev303-workshop-nodegroup`.
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dans le panneau de navigation, choisissez **Rôles**.
1. Utilisez la zone de recherche pour rechercher le préfixe que vous avez copié précédemment au cours de cette procédure et choisissez ce rôle.
1. Choisissez **Attacher des politiques**.
1. Utilisez le champ de recherche pour trouver **CloudWatchAgentServerPolicy**. Cochez la case à côté de **CloudWatchAgentServerPolicy**, puis choisissez **Attacher une politique**.
### Installation de l' CloudWatch agent pour collecter les métriques Prometheus
Vous devez installer l' CloudWatch agent dans le cluster pour collecter les métriques. La méthode à appliquer pour installer l'agent est différente s'il s'agit de clusters Amazon EKS ou de clusters Kubernetes.
**Supprimer les versions précédentes de l' CloudWatch agent avec le support de Prometheus**
Si vous avez déjà installé une version de l' CloudWatch agent compatible avec Prometheus dans votre cluster, vous devez supprimer cette version en saisissant la commande suivante. Cette étape est nécessaire uniquement pour les versions précédentes de l'agent avec prise en charge de Prometheus. Il n'est pas nécessaire de supprimer l' CloudWatch agent qui active Container Insights sans l'assistance de Prometheus.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
#### Installation de l' CloudWatch agent sur des clusters Amazon EKS avec le type de lancement EC2
Pour installer l' CloudWatch agent compatible avec Prometheus sur un cluster Amazon EKS, procédez comme suit.
**Pour installer l' CloudWatch agent avec le support de Prometheus sur un cluster Amazon EKS**
1. Entrez la commande suivante pour vérifier si l'espace de noms `amazon-cloudwatch` a déjà été créé :
```
kubectl get namespace
```
1. Si le fichier `amazon-cloudwatch` n'est pas affiché dans les résultats, créez-le en entrant la commande suivante :
```
kubectl create namespace amazon-cloudwatch
```
1. Pour déployer l'agent avec la configuration par défaut et lui demander d'envoyer des données à la AWS région dans laquelle il est installé, entrez la commande suivante :
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
En revanche; pour que l'agent envoie des données à une autre région, procédez comme suit :
1. Téléchargez le fichier YAML de l'agent en entrant 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
```
1. Ouvrez le fichier avec un éditeur de texte et recherchez le bloc `cwagentconfig.json` du fichier.
1. Ajoutez les lignes en surbrillance, en spécifiant la région souhaitée :
```
cwagentconfig.json: |
{
"agent": {
"region": "us-east-2"
},
"logs": { ...
```
1. Enregistrez le fichier et déployez l'agent à l'aide de votre fichier mis à jour.
```
kubectl apply -f prometheus-eks.yaml
```
#### Installation de l' CloudWatch agent sur des clusters Amazon EKS avec le type de lancement Fargate
Pour installer l' CloudWatch agent compatible avec Prometheus sur un cluster Amazon EKS avec le type de lancement Fargate, procédez comme suit.
**Pour installer l' CloudWatch agent compatible avec Prometheus sur un cluster Amazon EKS avec le type de lancement Fargate**
1. Entrez la commande suivante pour créer un profil Fargate pour CloudWatch l'agent afin qu'il puisse s'exécuter dans le cluster. Remplacez *MyCluster* par le nom du cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--name amazon-cloudwatch \
--namespace amazon-cloudwatch
```
1. Pour installer l' CloudWatch agent, entrez la commande suivante. Remplacez *MyCluster* par le nom du cluster. Ce nom est utilisé dans le nom du groupe de journaux qui stocke les événements de journaux collectés par l'agent et est également utilisé comme dimension pour les métriques collectées par l'agent.
*region*Remplacez-le par le nom de la région dans laquelle vous souhaitez que les métriques soient envoyées. Par exemple, `us-west-1`.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
#### Installation de l' CloudWatch agent sur un cluster Kubernetes
Pour installer l' CloudWatch agent compatible avec Prometheus sur un cluster exécutant Kubernetes, entrez la commande suivante :
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
Remplacez *MyCluster* par le nom du cluster. Ce nom est utilisé dans le nom du groupe de journaux qui stocke les événements de journaux collectés par l'agent et est également utilisé comme dimension pour les métriques collectées par l'agent.
*region*Remplacez-le par le nom de la AWS région dans laquelle vous souhaitez que les métriques soient envoyées. Par exemple, **us-west-1**.
#### Vérification de l'exécution de l'agent
Sur les clusters Amazon EKS et Kubernetes, vous pouvez entrer la commande suivante pour vérifier que l'agent est en cours d'exécution.
```
kubectl get pod -l "app=cwagent-prometheus" -n amazon-cloudwatch
```
Si les résultats incluent un module d' CloudWatch agent unique dans l'`Running`état, l'agent est en cours d'exécution et collecte les métriques Prometheus. Par défaut, l' CloudWatchagent collecte des métriques pour App Mesh, NGINX, Memcached, Java/JMX et toutes les minutes. HAProxy Pour plus d'informations sur ces métriques, consultez [Métriques Prometheus collectées par l'agent CloudWatch](ContainerInsights-Prometheus-metrics.md). Pour obtenir des instructions sur la façon d'afficher vos statistiques Prometheus dans, voir CloudWatch [Affichage de vos métriques Prometheus](ContainerInsights-Prometheus-viewmetrics.md)
Vous pouvez également configurer l' CloudWatch agent pour collecter des métriques auprès d'autres exportateurs Prometheus. Pour de plus amples informations, veuillez consulter [Récupération de sources Prometheus supplémentaires et importation de ces métriques](ContainerInsights-Prometheus-Setup-configure.md).
# 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 [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) dans la documentation Prometheus. L'autre concerne la configuration de l' CloudWatch agent.
Pour les clusters Amazon EKS, les configurations sont définies dans `prometheus-eks.yaml` (pour le type de lancement EC2) 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 s'exécutant sur des instances Amazon EC2, les configurations sont définies dans le fichier YAML `prometheus-k8s.yaml` 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.
**Exigences de groupe de sécurité VPC**
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](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#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\$1interval**– Définit la fréquence à laquelle récupérer les cibles.
+ **scrape\$1timeout**– 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 fichiers YAML 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 section `kubernetes-pod-jmx` par défaut suivante recoupe les métriques de JMX Exporter.
```
- 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 de plus amples informations, veuillez consulter [Intégration de métriques dans les journaux](CloudWatch_Embedded_Metric_Format.md).
Les événements de journal des clusters Amazon EKS et Kubernetes sont stockés dans le groupe de journaux **/aws/containerinsights/ /prometheus *cluster\$1name*** dans Logs. CloudWatch Les événements de journal des clusters Amazon ECS sont stockés dans le groupe de journaux **aws/ecs/containerinsights//*cluster\$1name*/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 provenant des clusters Amazon EKS et Kubernetes sont envoyées au flux de journal nommé /aws/containerinsights/ >prometheus//. *cluster\$1name* kubernetes-pod-appmesh-envoy**
Pour ajouter une nouvelle cible de récupération, vous ajoutez une nouvelle section `job_name` à la section `scrape_configs` du fichier YAML et redémarrez l'agent. Pour un exemple de ce processus, consultez [Didacticiel pour l'ajout d'une nouvelle cible de récupération Prometheus : métrique du serveur d'API Prometheus](#ContainerInsights-Prometheus-Setup-new-exporters).
## 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\$1name**– 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\$1group\$1name**– 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\$1name* /prometheus** pour les journaux des clusters Amazon EKS et Kubernetes.
+ **prometheus\$1config\$1path**– 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\$1service\$1discovery**– Il s'agit de la section qui spécifie la configuration de la découverte de service Amazon ECS Prometheus. Pour plus d'informations, consultez . [Guide détaillé de la découverte automatique sur les clusters Amazon ECS](ContainerInsights-Prometheus-Setup-autodiscovery-ecs.md).
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_cluster` est le nom du cluster Amazon ECS cible pour la découverte automatique. Ce champ est facultatif. Le nom par défaut est le nom du cluster Amazon ECS sur lequel l' CloudWatch agent est installé.
+ `sd_cluster_region` est la région du cluster Amazon ECS cible. Ce champ est facultatif. La valeur par défaut est la région du cluster Amazon ECS dans laquelle l' CloudWatch agent est installé.
+ `sd_result_file` est le chemin d'accès du fichier YAML pour les résultats de la cible 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_pattern` est le modèle à utiliser pour spécifier les définitions de tâches Amazon ECS à découvrir. Il s'agit d'une expression régulière.
+ `sd_metrics_ports` répertorie le containerPort pour les métriques Prometheus. Séparez les containerPorts par des points-virgules.
+ `sd_container_name_pattern` spécifie les noms des conteneurs de tâches Amazon ECS. 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\$1declaration** – 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_selectors` est une expression régulière qui spécifie les métriques à collecter et à envoyer à CloudWatch.
+ `dimensions` est la liste des étiquettes à utiliser comme dimensions CloudWatch 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 du paramètre `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",
...
}
```
## Didacticiel pour l'ajout d'une nouvelle cible de récupération Prometheus : métrique du serveur d'API Prometheus
Le serveur d'API Kubernetes expose les métriques Prometheus sur les points de terminaison par défaut. L'exemple officiel de la configuration de récupération du serveur d'API Kubernetes est disponible sur [Github](https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml).
Le didacticiel suivant montre comment effectuer les étapes suivantes pour commencer à importer des métriques du serveur d'API Kubernetes dans CloudWatch:
+ Ajout de la configuration de scraping Prometheus pour le serveur d'API Kubernetes au fichier YAML de l'agent. CloudWatch
+ Configuration des définitions de métriques intégrées au format métrique dans le fichier YAML de l' CloudWatch agent.
+ (Facultatif) Création d'un CloudWatch tableau de bord pour les métriques du serveur d'API Kubernetes.
**Note**
Le serveur d'API Kubernetes expose des métriques 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 Prometheus du serveur d'API Kubernetes dans CloudWatch**
1. 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 cluster Amazon EKS avec le type de lancement EC2, saisissez 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 cluster Amazon EKS avec le type de lancement Fargate, saisissez 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 s'exécutant sur une instance Amazon EC2, saisissez 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
```
1. 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
```
1. Pendant que le fichier YAML est toujours ouvert dans l'éditeur de texte, recherchez la section `cwagentconfig.json`. Ajoutez la sous-section suivante et enregistrez les modifications. Cette section place les métriques du serveur d'API dans la liste des CloudWatch agents autorisés. Trois types de métriques du serveur d'API sont ajoutés à la liste d'autorisation :
+ nombre d'objets etcd
+ Métriques du contrôleur d'enregistrement du serveur d'API
+ Métriques de demande du serveur API
```
{"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$"
]
},
```
1. 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
```
1. Déployez l' CloudWatch agent avec votre configuration mise à jour en saisissant l'une des commandes suivantes. Pour un cluster Amazon EKS avec le type de lancement EC2, saisissez :
```
kubectl apply -f prometheus-eks.yaml
```
Pour un cluster Amazon EKS avec le type de lancement Fargate, saisissez la commande suivante. Remplacez *MyCluster* et *region* par 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* et *region* par 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 groupe de journaux /aws/containerinsights/** /prometheus. *cluster\$1name*** 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 d'API Prometheus Kubernetes.
### (En option) Création d'un tableau de bord pour les métriques du serveur d'API Kubernetes.
Pour afficher les métriques du serveur d'API Kubernetes 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 métriques dans CloudWatch.
**Pour créer un tableau de bord pour les métriques du serveur d'API Kubernetes**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Assurez-vous d'avoir sélectionné la bonne AWS région.
1. Dans le panneau de navigation, choisissez **Dashboards** (Tableaux de bord).
1. Choisissez **Créer un tableau de bord**. Entrez un nom pour le nouveau tableau de bord, puis choisissez **Créer un tableau de bord**.
1. Dans **Ajouter à ce tableau de bord**, choisissez **Annuler**.
1. Choisissez **Actions**, **View/Edit Attributes** (Afficher/Modifier la source).
1. Téléchargez le fichier JSON suivant : [Source de tableau de bord d'API Kubernetes](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/kubernetes_api_server/cw_dashboard_kubernetes_api_server.json).
1. Ouvrez le fichier JSON que vous avez téléchargé avec 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.
1. Copiez l'ensemble du blob JSON et collez-le dans la zone de texte de la console CloudWatch, en remplaçant ce qui se trouve déjà dans la zone.
1. Choisissez **Mettre à jour**, **Enregistrer le tableau de bord**.
# (En option) Configuration d'exemples d'applications Amazon EKS conteneurisées pour les test de métriques Prometheus
Pour tester la prise en charge des métriques Prometheus CloudWatch dans Container Insights, vous pouvez configurer une ou plusieurs des charges de travail conteneurisées suivantes. L' CloudWatch agent qui prend en charge Prometheus collecte automatiquement les métriques de chacune de ces charges de travail. Pour voir les métriques collectées par défaut, consultez [Métriques Prometheus collectées par l'agent CloudWatch](ContainerInsights-Prometheus-metrics.md).
Avant de pouvoir installer l'une de ces charges de travail, vous devez installer Helm 3.x en entrant les commandes suivantes :
```
brew install helm
```
Pour plus d'informations, consultez [Helm](https://helm.sh).
**Topics**
+ [Configurer un AWS App Mesh exemple de charge de travail pour Amazon EKS et Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh.md)
+ [Configuration de NGINX avec un exemple de trafic sur Amazon EKS et Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-nginx.md)
+ [Configuration de memcached avec un exportateur de métriques sur Amazon EKS et Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-memcached.md)
+ [Configurer un Java/JMX exemple de charge de travail sur Amazon EKS et Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md)
+ [Configuration HAProxy avec un exportateur de métriques sur Amazon EKS et Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-haproxy.md)
+ [Didacticiel pour ajouter une nouvelle cible de récupération Prometheus : Redis OSS sur les clusters Amazon EKS et Kubernetes](ContainerInsights-Prometheus-Setup-redis-eks.md)
# Configurer un AWS App Mesh exemple de charge de travail pour Amazon EKS et Kubernetes
Le support de Prometheus dans Container Insights prend CloudWatch en charge. AWS App Mesh Les sections suivantes expliquent comment configurer App Mesh.
**Topics**
+ [Configurer un AWS App Mesh exemple de charge de travail sur un cluster Amazon EKS avec le type de lancement EC2 ou sur un cluster Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS.md)
+ [Configurer un AWS App Mesh exemple de charge de travail sur un cluster Amazon EKS avec le type de lancement Fargate](ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate.md)
# Configurer un AWS App Mesh exemple de charge de travail sur un cluster Amazon EKS avec le type de lancement EC2 ou sur un cluster Kubernetes
Utilisez ces instructions si vous configurez App Mesh sur un cluster exécutant Amazon EKS avec le type de lancement EC2 ou un cluster Kubernetes.
## Configuration des autorisations IAM
Vous devez ajouter la **AWSAppMeshFullAccess**politique au rôle IAM pour votre groupe de nœuds Amazon EKS ou Kubernetes. Sur Amazon EKS, le nom du groupe de nœuds ressemble à `eksctl-integ-test-eks-prometheus-NodeInstanceRole-ABCDEFHIJKL`. Sur Kubernetes, il peut ressembler à `nodes.integ-test-kops-prometheus.k8s.local`.
## Installation d'App Mesh
Pour installer le contrôleur App Mesh Kubernetes, suivez les instructions dans [App Mesh Controller](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller).
## Installation d'un exemple d'application
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)contient plusieurs procédures pas à pas de Kubernetes App Mesh. Pour ce didacticiel, vous installez un exemple d'application de couleur qui montre comment les acheminements http peuvent utiliser les en-têtes pour faire correspondre les requêtes entrantes.
**Pour utiliser un exemple d'application App Mesh pour tester Container Insights**
1. Installez l'application en suivant ces instructions : [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers).
1. Lancez un pod curler pour générer du trafic :
```
kubectl -n default run -it curler --image=tutum/curl /bin/bash
```
1. Enroulez différents points de terminaison en changeant les en-têtes HTTP. Exécutez la commande curl plusieurs fois, comme indiqué :
```
curl -H "color_header: blue" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: red" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: yellow" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
```
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans la AWS région dans laquelle votre cluster est exécuté, choisissez **Metrics** dans le volet de navigation. La métrique se trouve dans l'espace de noms **ContainerInsights/Prometheus.**
1. Pour voir les événements CloudWatch Logs, choisissez **Log groups** dans le volet de navigation. Les évènements sont dans le groupe de journaux ` /aws/containerinsights/your_cluster_name/prometheus ` du flux de journaux `kubernetes-pod-appmesh-envoy`.
## Suppression de l'environnement de test App Mesh
Lorsque vous avez terminé d'utiliser App Mesh et l'exemple d'application, utilisez les commandes suivantes pour supprimer les ressources inutiles. Supprimez l'exemple d'application en saisissant la commande suivante :
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-http-headers/
kubectl delete -f _output/manifest.yaml
```
Supprimez App Mesh Controller en saisissant la commande suivante :
```
helm delete appmesh-controller -n appmesh-system
```
# Configurer un AWS App Mesh exemple de charge de travail sur un cluster Amazon EKS avec le type de lancement Fargate
Utilisez ces instructions si vous configurez App Mesh sur un cluster exécutant Amazon EKS avec le type de lancement Fargate.
## Configuration des autorisations IAM
Pour configurer les autorisations IAM, saisissez la commande suivante : Remplacez *MyCluster* par le nom de votre cluster.
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
## Installation d'App Mesh
Pour installer le contrôleur App Mesh Kubernetes, suivez les instructions dans [App Mesh Controller](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller). Veillez à suivre les instructions pour Amazon EKS avec le type de lancement Fargate.
## Installation d'un exemple d'application
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)contient plusieurs procédures pas à pas de Kubernetes App Mesh. Pour ce didacticiel, vous installez un exemple d'application de couleur qui fonctionne pour les clusters Amazon EKS avec le type de lancement Fargate.
**Pour utiliser un exemple d'application App Mesh pour tester Container Insights**
1. Installez l'application en suivant ces instructions : [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate).
Ces instructions supposent que vous créez un nouveau cluster avec le bon profil Fargate. Si vous souhaitez utiliser un cluster Amazon EKS que vous avez déjà configuré, vous pouvez utiliser les commandes suivantes pour configurer ce cluster pour cette démonstration. Remplacez *MyCluster* par le nom de votre cluster.
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
```
eksctl create fargateprofile --cluster MyCluster \
--namespace howto-k8s-fargate --name howto-k8s-fargate
```
1. Port avant le déploiement de l'application frontale :
```
kubectl -n howto-k8s-fargate port-forward deployment/front 8080:8080
```
1. Enroulez l'application frontale :
```
while true; do curl -s http://localhost:8080/color; sleep 0.1; echo ; done
```
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans la AWS région dans laquelle votre cluster est exécuté, choisissez **Metrics** dans le volet de navigation. La métrique se trouve dans l'espace de noms **ContainerInsights/Prometheus.**
1. Pour voir les événements CloudWatch Logs, choisissez **Log groups** dans le volet de navigation. Les évènements sont dans le groupe de journaux ` /aws/containerinsights/your_cluster_name/prometheus ` du flux de journaux `kubernetes-pod-appmesh-envoy`.
## Suppression de l'environnement de test App Mesh
Lorsque vous avez terminé d'utiliser App Mesh et l'exemple d'application, utilisez les commandes suivantes pour supprimer les ressources inutiles. Supprimez l'exemple d'application en saisissant la commande suivante :
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-fargate/
kubectl delete -f _output/manifest.yaml
```
Supprimez App Mesh Controller en saisissant la commande suivante :
```
helm delete appmesh-controller -n appmesh-system
```
# Configuration de NGINX avec un exemple de trafic sur Amazon EKS et Kubernetes
NGINX est un serveur web qui peut également être utilisé comme équilibreur de charge et proxy inverse. Pour plus d'informations sur la façon dont Kubernetes utilise NGINX pour es entrées, veuillez consulter [kubernetes/ingress-nginx](https://github.com/kubernetes/ingress-nginx).
**Pour installer NGINX avec un exemple de service de trafic pour tester la prise en charge de Container Insights Prometheus**
1. Saisissez la commande suivante pour ajouter le référentiel ingress-nginx Helm.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
```
1. Entrez la commande suivante :
```
kubectl create namespace nginx-ingress-sample
helm install my-nginx ingress-nginx/ingress-nginx \
--namespace nginx-ingress-sample \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="10254" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. Vérifiez si les services ont démarré correctement en entrant la commande suivante :
```
kubectl get service -n nginx-ingress-sample
```
La sortie de cette commande doit afficher plusieurs colonnes, y compris une colonne `EXTERNAL-IP`.
1. Définissez une variable `EXTERNAL-IP` avec la valeur de la colonne `EXTERNAL-IP` dans la ligne du contrôleur d'entrée NGINX.
```
EXTERNAL_IP=your-nginx-controller-external-ip
```
1. Démarrez un exemple de trafic NGINX en entrant la commande suivante.
```
SAMPLE_TRAFFIC_NAMESPACE=nginx-sample-traffic
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/nginx-traffic/nginx-traffic-sample.yaml |
sed "s/{{external_ip}}/$EXTERNAL_IP/g" |
sed "s/{{namespace}}/$SAMPLE_TRAFFIC_NAMESPACE/g" |
kubectl apply -f -
```
1. Entrez la commande suivante pour vérifier que l'état des trois pods est `Running`.
```
kubectl get pod -n $SAMPLE_TRAFFIC_NAMESPACE
```
S'ils sont en cours d'exécution, vous devriez bientôt voir des métriques dans l'espace de noms **ContainerInsights/Prometheus.**
**Pour désinstaller NGINX et l'exemple d'application de trafic**
1. Supprimez l'exemple de service de trafic en entrant la commande suivante :
```
kubectl delete namespace $SAMPLE_TRAFFIC_NAMESPACE
```
1. Supprimez la sortie NGINX par le nom de la version Helm.
```
helm uninstall my-nginx --namespace nginx-ingress-sample
kubectl delete namespace nginx-ingress-sample
```
# Configuration de memcached avec un exportateur de métriques sur Amazon EKS et Kubernetes
memcached est un système de mise en cache d'objets mémoire open source. Pour plus d'informations, consultez [What is Memcached?](https://www.memcached.org).
Si vous exécutez memcached sur un cluster avec le type de lancement Fargate, vous devez configurer un profil Fargate avant de réaliser les étapes de cette procédure. Pour configurer le profil, saisissez la commande suivante. Remplacez *MyCluster* par le nom de votre cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace memcached-sample --name memcached-sample
```
**Pour installer memcached avec un exportateur de métriques afin de tester la prise en charge de Container Insights Prometheus**
1. Saisissez la commande suivante pour ajouter le référentiel :
```
helm repo add bitnami https://charts.bitnami.com/bitnami
```
1. Entrez la commande suivante pour créer un nouvel espace de noms :
```
kubectl create namespace memcached-sample
```
1. Entrez la commande suivante pour installer Memcached
```
helm install my-memcached bitnami/memcached --namespace memcached-sample \
--set metrics.enabled=true \
--set-string serviceAnnotations.prometheus\\.io/port="9150" \
--set-string serviceAnnotations.prometheus\\.io/scrape="true"
```
1. Entrez la commande suivante pour vérifier l'annotation du service en cours d'exécution :
```
kubectl describe service my-memcached-metrics -n memcached-sample
```
Les deux annotations suivantes doivent s'afficher :
```
Annotations: prometheus.io/port: 9150
prometheus.io/scrape: true
```
**Pour désinstaller memcached**
+ Entrez la commande suivante :
```
helm uninstall my-memcached --namespace memcached-sample
kubectl delete namespace memcached-sample
```
# Configurer un Java/JMX exemple de charge de travail sur Amazon EKS et Kubernetes
JMX Exporter est un exportateur Prometheus officiel qui peut récupérer et exposer des mBeans JMX en tant que métriques Prometheus. Pour plus d'informations, consultez [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
Container Insights peut collecter des métriques Prometheus prédéfinies à partir de Java Virtual Machine (JVM), Java et Tomcat (Catalina) à l'aide de JMX Exporter.
## Configuration de récupération Prometheus par défaut
Par défaut, l' CloudWatch agent compatible avec Prometheus supprime les métriques `http://CLUSTER_IP:9404/metrics` Prometheus Java/JMX présentes sur chaque pod d'un cluster Amazon EKS ou Kubernetes. Cette opération est exécutée par la découverte `role: pod` de Prometheus `kubernetes_sd_config`. 9404 est le port par défaut alloué pour JMX Exporter par Prometheus. Pour plus d'informations sur la découverte `role: pod`, consultez [pod](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#pod). Vous pouvez configurer JMX Exporter pour qu'il expose les métriques sur un autre port ou chemin d'accès. Si vous modifiez le port ou le chemin, mettez à jour le jmx scrape\$1config par défaut dans la carte de configuration de l' CloudWatch agent. Exécutez la commande suivante pour obtenir la configuration actuelle de l' CloudWatch agent Prometheus :
```
kubectl describe cm prometheus-config -n amazon-cloudwatch
```
Les champs à modifier sont les champs `/metrics` et `regex: '.*:9404$'`, comme mis en évidence dans l'exemple suivant.
```
job_name: 'kubernetes-jmx-pod'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: replace
regex: (.+)
source_labels:
```
## Autre configuration de récupération Prometheus
Si vous exposez votre application en cours d'exécution sur un ensemble de pods avec les exportateurs Prometheus Java/JMX par un service Kubernetes, vous pouvez également basculer pour utiliser la découverte `role: service` ou `role: endpoint` de Prometheus `kubernetes_sd_config`. Pour plus d'informations sur ces méthodes de découverte, consultez [service](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#service), [endpoints (points de terminaison)](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpoints), et [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config).
D'autres méta-étiquettes sont fournies par ces deux modes de découverte de services, ce qui peut vous être utile pour créer les dimensions CloudWatch des métriques. Par exemple, vous pouvez réétiqueter `__meta_kubernetes_service_name` sur `Service` et l'inclure dans la dimension de vos métriques. Pour plus d'informations sur la personnalisation de vos CloudWatch indicateurs et de leurs dimensions, consultez. [CloudWatch configuration de l'agent pour Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config)
## Image Docker avec JMX Exporter
Ensuite, créez une image Docker. Les sections suivantes fournissent deux exemples de fichiers Docker.
Lorsque vous avez créé l'image, chargez-la dans Amazon EKS ou Kubernetes, puis exécutez la commande suivante pour vérifier que les métriques Prometheus sont exposées par `JMX_EXPORTER` sur le port 9404. Remplacez *\$1JAR\$1SAMPLE\$1TRAFFIC\$1POD* par le nom du pod en cours d'exécution et remplacez *\$1JAR\$1SAMPLE\$1TRAFFIC\$1NAMESPACE* par l'espace de noms de votre application.
Si vous exécutez JMX Exporter sur un cluster avec le type de lancement Fargate, vous devez configurer un profil Fargate avant de réaliser les étapes de cette procédure. Pour configurer le profil, saisissez la commande suivante. Remplacez *MyCluster* par le nom de votre cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $JAR_SAMPLE_TRAFFIC_NAMESPACE\
--name $JAR_SAMPLE_TRAFFIC_NAMESPACE
```
```
kubectl exec $JAR_SAMPLE_TRAFFIC_POD -n $JARCAT_SAMPLE_TRAFFIC_NAMESPACE -- curl http://localhost:9404
```
## Exemple : image Apache Tomcat Docker avec métriques Prometheus
Le serveur Apache Tomcat expose les mBeans JMX par défaut. Vous pouvez intégrer JMX Exporter avec Tomcat pour exposer les mBeans JMX en tant que métriques Prometheus. L'exemple de fichier Docker suivant montre les étapes à suivre pour créer une image de test :
```
# From Tomcat 9.0 JDK8 OpenJDK
FROM tomcat:9.0-jdk8-openjdk
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
COPY ./setenv.sh /usr/local/tomcat/bin
COPY your web application.war /usr/local/tomcat/webapps/
RUN chmod o+x /usr/local/tomcat/bin/setenv.sh
ENTRYPOINT ["catalina.sh", "run"]
```
La liste suivante explique les quatre lignes `COPY` de ce fichier Docker.
+ Téléchargez le dernier fichier JAR JMX Exporter [https://github.com/prometheus/depuis](https://github.com/prometheus/jmx_exporter) jmx\$1exporter.
+ `config.yaml` est le fichier de configuration de JMX Exporter. Pour plus d'informations, consultez [https://github.com/prometheus/jmx\$1exporter \$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ).
Voici un exemple de fichier de configuration pour Java et Tomcat :
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `setenv.sh` est un script de démarrage Tomcat pour démarrer JMX exporter avec Tomcat et exposer les métriques Prometheus sur le port 9404 de l'hôte local. Il fournit également à JMX Exporter le chemin d'accès au fichier `config.yaml`.
```
$ cat setenv.sh
export JAVA_OPTS="-javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml $JAVA_OPTS"
```
+ Votre application web .war est le fichier `war` de votre application web à charger par Tomcat.
Créez une image Docker avec cette configuration et téléchargez-la dans un référentiel d'images.
## Exemple : image Docker d'application Java Jar avec métriques Prometheus
L'exemple de fichier Docker suivant montre les étapes à suivre pour créer une image de test :
```
# Alpine Linux with OpenJDK JRE
FROM openjdk:8-jre-alpine
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./SampleJavaApplication-1.0-SNAPSHOT.jar /opt/jmx_exporter
COPY ./start_exporter_example.sh /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
RUN chmod -R o+x /opt/jmx_exporter
RUN apk add curl
ENTRYPOINT exec /opt/jmx_exporter/start_exporter_example.sh
```
La liste suivante explique les quatre lignes `COPY` de ce fichier Docker.
+ Téléchargez le dernier fichier JAR JMX Exporter [https://github.com/prometheus/depuis](https://github.com/prometheus/jmx_exporter) jmx\$1exporter.
+ `config.yaml` est le fichier de configuration de JMX Exporter. Pour plus d'informations, consultez [https://github.com/prometheus/jmx\$1exporter \$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ).
Voici un exemple de fichier de configuration pour Java et Tomcat :
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `start_exporter_example.sh` est le script pour démarrer l'application JAR avec les métriques Prometheus exportées. Il fournit également à JMX Exporter le chemin d'accès au fichier `config.yaml`.
```
$ cat start_exporter_example.sh
java -javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml -cp /opt/jmx_exporter/SampleJavaApplication-1.0-SNAPSHOT.jar com.gubupt.sample.app.App
```
+ SampleJavaApplication-1.0-Snapshot.jar est l'exemple de fichier jar de l'application Java. Remplacez-le par l'application Java que vous souhaitez surveiller.
Créez une image Docker avec cette configuration et téléchargez-la dans un référentiel d'images.
# Configuration HAProxy avec un exportateur de métriques sur Amazon EKS et Kubernetes
HAProxy est une application proxy open source. Pour de plus amples informations, veuillez consulter [HAProxy](https://www.haproxy.org).
Si vous exécutez HAProxy un cluster avec le type de lancement Fargate, vous devez configurer un profil Fargate avant de suivre les étapes de cette procédure. Pour configurer le profil, saisissez la commande suivante. Remplacez *MyCluster* par le nom de votre cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace haproxy-ingress-sample --name haproxy-ingress-sample
```
**À installer HAProxy avec un exportateur de métriques pour tester le support Prometheus de Container Insights**
1. Entrez la commande suivante pour ajouter le référentiel de l'incubateur Helm :
```
helm repo add haproxy-ingress https://haproxy-ingress.github.io/charts
```
1. Entrez la commande suivante pour créer un nouvel espace de noms :
```
kubectl create namespace haproxy-ingress-sample
```
1. Entrez les commandes suivantes pour l'installation HAProxy :
```
helm install haproxy haproxy-ingress/haproxy-ingress \
--namespace haproxy-ingress-sample \
--set defaultBackend.enabled=true \
--set controller.stats.enabled=true \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="9101" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. Entrez la commande suivante pour confirmer l'annotation du service :
```
kubectl describe service haproxy-haproxy-ingress-metrics -n haproxy-ingress-sample
```
Les annotations suivantes doivent s'afficher.
```
Annotations: prometheus.io/port: 9101
prometheus.io/scrape: true
```
**Pour désinstaller HAProxy**
+ Entrez la commande suivante :
```
helm uninstall haproxy --namespace haproxy-ingress-sample
kubectl delete namespace haproxy-ingress-sample
```
# Didacticiel pour ajouter une nouvelle cible de récupération Prometheus : Redis OSS sur les clusters Amazon EKS et Kubernetes
Ce didacticiel propose une présentation pratique de l’utilisation des métriques Prometheus d’un exemple d’application Redis OSS sur Amazon EKS et Kubernetes. Redis OSS (https://redis.io/) est un magasin de structures de données open source (sous licence BSD) en mémoire, utilisé comme base de données, cache et agent de messages. Pour en savoir plus, consultez [redis](https://redis.io/).
redis\$1exportateur (sous licence MIT) est utilisé pour exposer les métriques Prometheus Redis OSS sur le port spécifié (par défaut : 0.0.0.0:9121). Pour en savoir plus, consultez [redis\$1exporter](https://github.com/oliver006/redis_exporter).
Les images Docker dans les deux référentiels Docker Hub suivants sont utilisées dans ce didacticiel :
+ [ Redis](https://hub.docker.com/_/redis?tab=description)
+ [redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**Pour installer un exemple de charge de travail Redis OSS qui expose les métriques Prometheus**
1. Définissez l’espace de noms pour l’exemple de charge de travail Redis OSS.
```
REDIS_NAMESPACE=redis-sample
```
1. Si vous exécutez Redis OSS sur un cluster avec le type de lancement Fargate, vous devez configurer un profil Fargate. Pour configurer le profil, saisissez la commande suivante. Remplacez *MyCluster* par le nom de votre cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $REDIS_NAMESPACE --name $REDIS_NAMESPACE
```
1. Saisissez la commande suivante pour installer l’exemple de charge de travail Redis OSS.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml \
| sed "s/{{namespace}}/$REDIS_NAMESPACE/g" \
| kubectl apply -f -
```
1. L’installation comprend un service nommé `my-redis-metrics` qui expose les métriques Redis OSS Prometheus sur le port 9121. Saisissez la commande suivante pour obtenir les détails du service :
```
kubectl describe service/my-redis-metrics -n $REDIS_NAMESPACE
```
Dans la `Annotations` section des résultats, vous verrez deux annotations correspondant à la configuration Prometheus Scrape de l'agent, afin qu'il puisse découvrir CloudWatch automatiquement les charges de travail :
```
prometheus.io/port: 9121
prometheus.io/scrape: true
```
La configuration de récupération Prometheus associée est disponible dans la section `- job_name: kubernetes-service-endpoints` de `kubernetes-eks.yaml` ou `kubernetes-k8s.yaml`.
**Pour commencer à collecter les métriques Prometheus de Redis OSS dans CloudWatch**
1. Téléchargez la dernière version du fichier `kubernetes-eks.yaml` ou `kubernetes-k8s.yaml` en saisissant l'une des commandes suivantes. Pour un cluster Amazon EKS avec le type de lancement EC2, saisissez cette commande.
```
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 cluster Amazon EKS avec le type de lancement Fargate, saisissez cette commande.
```
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 s'exécutant sur une instance Amazon EC2, saisissez cette commande :
```
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
```
1. Ouvrez le fichier avec un éditeur de texte et trouvez la section `cwagentconfig.json`. Ajoutez la sous-section suivante et enregistrez les modifications. Assurez-vous que l'indentation suive le modèle existant.
```
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName"]],
"metric_selectors": [
"^redis_net_(in|out)put_bytes_total$",
"^redis_(expired|evicted)_keys_total$",
"^redis_keyspace_(hits|misses)_total$",
"^redis_memory_used_bytes$",
"^redis_connected_clients$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","cmd"]],
"metric_selectors": [
"^redis_commands_total$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","db"]],
"metric_selectors": [
"^redis_db_keys$"
]
},
```
La section que vous avez ajoutée place les métriques Redis OSS dans la liste des CloudWatch agents autorisés. Pour une liste de ces métriques, reportez-vous à la section suivante.
1. Si l' CloudWatch agent compatible avec Prometheus est déjà déployé dans ce cluster, vous devez le supprimer en saisissant la commande suivante.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. Déployez l' CloudWatch agent avec votre configuration mise à jour en saisissant l'une des commandes suivantes. Remplacez *MyCluster* et *region* adaptez-le à vos paramètres.
Pour un cluster Amazon EKS avec le type de lancement EC2, saisissez cette commande.
```
kubectl apply -f prometheus-eks.yaml
```
Pour un cluster Amazon EKS avec le type de lancement Fargate, saisissez cette commande.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Pour un cluster Kubernetes, saisissez cette commande.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
## Affichage de vos métriques Prometheus Redis OSS
Ce didacticiel envoie les métriques suivantes à l'espace de noms **ContainerInsights/Prometheus** dans. CloudWatch Vous pouvez utiliser la CloudWatch console pour voir les métriques de cet espace de noms.
| Nom de la métrique | Dimensions |
| --- | --- |
| `redis_net_input_bytes_total` | ClusterName, `Namespace` |
| `redis_net_output_bytes_total` | ClusterName, `Namespace` |
| `redis_expired_keys_total` | ClusterName, `Namespace` |
| `redis_evicted_keys_total` | ClusterName, `Namespace` |
| `redis_keyspace_hits_total` | ClusterName, `Namespace` |
| `redis_keyspace_misses_total` | ClusterName, `Namespace` |
| `redis_memory_used_bytes` | ClusterName, `Namespace` |
| `redis_connected_clients` | ClusterName, `Namespace` |
| `redis_commands_total` | ClusterName`Namespace`, cmd |
| `redis_db_keys` | ClusterName,`Namespace`, base de données |
**Note**
Les valeurs de la dimension **cmd** peuvent être : `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` ou `slowlog`.
Les valeurs de la dimension **db** peuvent être `db0` ou `db15`.
Vous pouvez également créer un CloudWatch tableau de bord pour vos métriques Redis OSS Prometheus.
**Pour créer un tableau de bord pour les métriques Prometheus Redis OSS**
1. Créez des variables d'environnement, en remplaçant les valeurs ci-dessous pour correspondre à votre déploiement.
```
DASHBOARD_NAME=your_cw_dashboard_name
REGION_NAME=your_metric_region_such_as_us-east-1
CLUSTER_NAME=your_k8s_cluster_name_here
NAMESPACE=your_redis_service_namespace_here
```
1. Saisissez la commande suivante pour créer le tableau de bord.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/redis/cw_dashboard_redis.json \
| sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
| sed "s/{{YOUR_NAMESPACE}}/${NAMESPACE}/g" \
```