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.
# Surveillance des métriques Prometheus Container Insights
CloudWatch La surveillance de Container Insights pour Prometheus automatise la découverte des métriques Prometheus à partir de systèmes et de charges de travail conteneurisés. Prometheus est une boîte à outils de surveillance de systèmes et d'alerte open source. Pour plus d'informations, consultez [What is Prometheus?](https://prometheus.io/docs/introduction/overview/) dans la documentation Prometheus.
La découverte des métriques Prometheus est prise en charge pour les clusters [Amazon Elastic Container Service](https://aws.amazon.com/ecs/), [Amazon Elastic Kubernetes Service](https://aws.amazon.com/eks/) et [Kubernetes](https://aws.amazon.com/kubernetes/) s'exécutant sur des instances Amazon EC2. Les types de métriques de compteur, de jauge et récapitulatives de Prometheus sont collectés.
Pour les clusters Amazon ECS et Amazon EKS, les types de lancements EC2 et Fargate sont pris en charge. Container Insights collecte automatiquement les métriques de plusieurs applications, et vous pouvez le configurer pour collecter les métriques à partir de n'importe quelle application.
Vous pouvez adopter Prometheus en tant que méthode open source et norme ouverte pour intégrer des métriques personnalisées dans CloudWatch. L' CloudWatch agent soutenu par Prometheus découvre et collecte les métriques Prometheus afin de surveiller, de dépanner et d'avertir plus rapidement en cas de dégradation des performances et de défaillances des applications. Cette méthode réduit également le nombre d'outils de surveillance nécessaires pour améliorer l'observabilité.
Container Insights Le support de Prometheus pay-per-use concerne les métriques et les journaux, y compris la collecte, le stockage et l'analyse. Pour plus d'informations, consultez [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/).
**Tableaux de bord préconçus pour certaines charges de travail**
La solution Container Insights Prometheus inclut des tableaux de bord préconçus pour les applications les plus populaires répertoriées dans cette section. Pour obtenir des exemples de configurations pour ces applications, consultez [(En option) Configuration d'exemples d'applications Amazon ECS conteneurisées pour les test de métriques Prometheus](ContainerInsights-Prometheus-Sample-Workloads-ECS.md) et [(En option) Configuration d'exemples d'applications Amazon EKS conteneurisées pour les test de métriques Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md).
Vous pouvez également configurer Container Insights pour collecter les métriques Prometheus à partir d'autres services et applications conteneurisés, en modifiant le fichier de configuration de l'agent.
Applications avec des tableaux de bord préconçus pour les clusters Amazon EKS et Kubernetes s'exécutant sur les instances Amazon EC2 :
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
Applications avec des tableaux de bord préconçus pour les clusters Amazon ECS :
+ AWS App Mesh
+ Java/JMX
+ NGINX
+ NGINX Plus
# Configuration de la collecte de métriques Prometheus sur des clusters Amazon ECS
Pour collecter les métriques Prometheus à partir de clusters Amazon ECS, vous pouvez utiliser CloudWatch l'agent comme collecteur ou utiliser AWS la distribution pour collecteur. OpenTelemetry Pour plus d'informations sur l'utilisation de AWS Distro for OpenTelemetry Collector, consultez [https://aws-otel.github. io/docs/getting-started/container-insights/ecs-prométhée](https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus).
Les sections suivantes expliquent comment utiliser l' CloudWatch agent comme collecteur pour récupérer les métriques Prometheus. Vous installez l' CloudWatch agent avec Prometheus monitoring sur les clusters exécutant Amazon ECS, et vous pouvez éventuellement configurer l'agent pour récupérer des cibles supplémentaires. Ces sections fournissent également des didacticiels facultatifs pour configurer des exemples d'applications à utiliser pour les tests avec la surveillance Prometheus.
Container Insights sur Amazon ECS prend en charge les combinaisons suivantes de type de lancement et de mode réseau pour les métriques Prometheus :
| Type de lancement Amazon ECS | Modes réseau pris en charge |
| --- | --- |
| EC2 (Linux) | pont, hôte et awsvpc |
| Fargate | awsvpc |
**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 ECS](ContainerInsights-Prometheus-install-ECS.md)
+ [Récupération de sources Prometheus supplémentaires et importation de ces métriques](ContainerInsights-Prometheus-Setup-configure-ECS.md)
+ [(En option) Configuration d'exemples d'applications Amazon ECS conteneurisées pour les test de métriques Prometheus](ContainerInsights-Prometheus-Sample-Workloads-ECS.md)
# Installez l' CloudWatch agent avec la collecte de métriques Prometheus sur les clusters Amazon ECS
Cette section explique comment configurer l' CloudWatch agent avec la surveillance Prometheus dans un cluster exécutant Amazon ECS. 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
+ Java/JMX
Vous pouvez également configurer l'agent pour récupérer et importer les métriques à partir d'applications et sources Prometheus supplémentaires.
## Configuration de rôles IAM
Vous avez besoin de deux rôles IAM pour définir la tâche de l' CloudWatch agent. Si vous indiquez **CreateIAMRoles=True** dans la CloudFormation pile que Container Insights doit créer ces rôles pour vous, les rôles seront créés avec les autorisations appropriées. Si vous souhaitez les créer vous-même ou utiliser des rôles existants, les autorisations et rôles suivants sont requis.
+ **CloudWatch rôle de tâche ECS** de l' CloudWatchagent : le conteneur de l'agent utilise ce rôle. Elle doit inclure la **CloudWatchAgentServerPolicy**politique et une politique gérée par le client qui contient les autorisations en lecture seule suivantes :
+ `ec2:DescribeInstances`
+ `ecs:ListTasks`
+ `ecs:ListServices`
+ `ecs:DescribeContainerInstances`
+ `ecs:DescribeServices`
+ `ecs:DescribeTasks`
+ `ecs:DescribeTaskDefinition`
+ **CloudWatch rôle d'exécution des tâches de l'agent ECS** : il s'agit du rôle dont Amazon ECS a besoin pour lancer et exécuter vos conteneurs. Assurez-vous que votre rôle d'exécution des tâches est associé à **Amazon SSMRead OnlyAccess ECSTask** **ExecutionRolePolicy, Amazon** et aux **CloudWatchAgentServerPolicy**politiques. Si vous souhaitez stocker des données plus sensibles que Amazon ECS peut utiliser, consultez [Spécification de données sensibles](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html).
## Installez l' CloudWatch agent avec le système de surveillance Prometheus en utilisant CloudFormation
Vous l'utilisez AWS CloudFormation pour installer l' CloudWatch agent avec Prometheus monitoring pour les clusters Amazon ECS. La liste suivante montre les paramètres que vous utiliserez dans le modèle CloudFormation .
+ **ECSClusterNom** — Spécifie le cluster Amazon ECS cible.
+ **Créer IAMRoles** — Spécifiez **True** pour créer de nouveaux rôles pour le rôle de tâche Amazon ECS et le rôle d'exécution de tâche Amazon ECS. Spécifiez **False** pour réutiliser les rôles existants.
+ **TaskRoleName**— Si vous avez spécifié **True** **Create IAMRoles**, cela indique le nom à utiliser pour le nouveau rôle de tâche Amazon ECS. Si vous avez spécifié **False** **Create IAMRoles**, cela indique le rôle existant à utiliser comme rôle de tâche Amazon ECS.
+ **ExecutionRoleName**— Si vous avez spécifié **True** **Create IAMRoles**, cela indique le nom à utiliser pour le nouveau rôle d'exécution de tâches Amazon ECS. Si vous avez spécifié **False** **Create IAMRoles**, cela indique le rôle existant à utiliser comme rôle d'exécution de tâches Amazon ECS.
+ **ECSNetworkMode** — Si vous utilisez le type de lancement EC2, spécifiez le mode réseau ici. Il doit être **bridge** ou **host**.
+ **ECSLaunchType** — Spécifiez **fargate** soit**EC2**.
+ **SecurityGroupID** — Si le **ECSNetworkmode est activé****awsvpc**, spécifiez l'ID du groupe de sécurité ici.
+ **SubnetId — Si le **ECSNetworkmode est défini sur Mode****awsvpc**, spécifiez l'ID** du sous-réseau ici.
### Exemples de commande
Cette section inclut des exemples de CloudFormation commandes pour installer Container Insights avec la surveillance Prometheus dans différents scénarios.
**Création d'une CloudFormation pile pour un cluster Amazon ECS en mode réseau en mode pont**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=bridge
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Création d'une CloudFormation pile pour un cluster Amazon ECS en mode réseau hôte**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=host
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Création d'une CloudFormation pile pour un cluster Amazon ECS en mode réseau awsvpc**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=EC2
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Créer une CloudFormation pile pour un cluster Fargate en mode réseau awsvpc**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=FARGATE
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
### AWS ressources créées par la CloudFormation pile
Le tableau suivant répertorie les AWS ressources créées lorsque vous configurez la surveillance CloudFormation de Container Insights with Prometheus sur un cluster Amazon ECS.
| Type de ressource | Nom de la ressource | Commentaires |
| --- | --- | --- |
| AWS::SSM::Parameter | AmazonCloudWatch- CWAgent Configurer-\$1 -\$1 -\$1 *ECS\$1CLUSTER\$1NAME* *ECS\$1LAUNCH\$1TYPE* *ECS\$1NETWORK\$1MODE* | Il s'agit de l' CloudWatch agent doté de l'App Mesh par défaut et d'une définition de format métrique Java/JMX intégrée. |
| AWS::SSM::Parameter | AmazonCloudWatch-PrometheusConfigName-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | Il s'agit de la configuration de récupération Prometheus. |
| AWS::IAM::Role | **\$1ECS\$1TASK\$1ROLE\$1NAME**. | Le rôle de tâche Amazon ECS. Ceci est créé uniquement si vous avez spécifié **True** pour `CREATE_IAM_ROLES`. |
| AWS::IAM::Role | **\$1\$1ECS\$1EXECUTION\$1ROLE\$1NAME\$1** | Le rôle d'exécution de tâche Amazon ECS. Ceci est créé uniquement si vous avez spécifié **True** pour `CREATE_IAM_ROLES`. |
| AWS::ECS::TaskDefinition | *ECS\$1CLUSTER\$1NAME*cwagent-prométheus-\$1 -\$1 *ECS\$1LAUNCH\$1TYPE* *ECS\$1NETWORK\$1MODE* | |
| AWS::ECS::Service | cwagent-prometheus-replica-service-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | |
### Supprimer la CloudFormation pile de l' CloudWatch agent grâce à la surveillance Prometheus
Pour supprimer l' CloudWatch agent d'un cluster Amazon ECS, entrez ces commandes.
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export CLOUDFORMATION_STACK_NAME=your_cloudformation_stack_name
aws cloudformation delete-stack \
--stack-name ${CLOUDFORMATION_STACK_NAME} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# Récupération de sources Prometheus supplémentaires et importation de ces métriques
L' CloudWatch agent chargé de la surveillance par 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 ECS, les configurations sont intégrées au Parameter Store de AWS Systems Manager par les secrets de la définition de tâche Amazon ECS :
+ Le secret `PROMETHEUS_CONFIG_CONTENT` concerne la configuration de récupération Prometheus.
+ Le secret `CW_CONFIG_CONTENT` réside dans la configuration de CloudWatch l'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 les fichiers YAML pour Amazon ECS tels que `cwagent-ecs-prometheus-metric-for-bridge-host.yaml`, les tâches de récupération par défaut sont configurées dans la section `ecs_service_discovery`.
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
},
"task_definition_list": [
{
"sd_job_name": "ecs-appmesh-colors",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition\/.*-ColorTeller-(white):[0-9]+",
"sd_metrics_path": "/stats/prometheus"
},
{
"sd_job_name": "ecs-appmesh-gateway",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*-ColorGateway:[0-9]+",
"sd_metrics_path": "/stats/prometheus"
}
]
}
```
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 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.
Pour ajouter une nouvelle cible de récupération, vous ajoutez une nouvelle entrée dans la section `task_definition_list` sous la section `ecs_service_discovery` 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-configure.md#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 ECS.
+ **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/ecs/containerinsights/*cluster\$1name*/prometheus** pour les journaux des clusters Amazon ECS.
+ **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 les configurations des fonctions de découverte automatique de la cible Amazon ECS Prometheus. Deux modes sont pris en charge pour découvrir les cibles Prometheus : découverte basée sur l'étiquette docker du conteneur ou découverte basée sur l'expression régulière ARN de définition de tâche Amazon ECS. Vous pouvez utiliser les deux modes ensemble et l' CloudWatchagent dédupliquera les cibles découvertes en fonction de : *\$1private\$1ip\$1 : \$1port\$1/\$1metrics\$1path\$1*.
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.
+ `service_name_list_for_tasks` est une section facultative que vous pouvez utiliser pour spécifier la configuration de la découverte de service basée sur les noms. Si vous omettez cette section, la découverte basée sur les noms n'est pas utilisée. Cette section peut contenir les champs suivants :
+ `sd_service_name_pattern` est le modèle à utiliser pour spécifier l'Amazon ECS service où les tâches doivent être découvertes. Il s'agit d'une expression régulière.
+ `sd_metrics_ports` répertorie le `containerPort` pour les métriques Prometheus. Séparez plusieurs `containerPorts` avec 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 d'accès aux métriques 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 sections `metric_declaration` pour chaque source Prometheus que l'agent CloudWatch 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",
...
}
```
# Guide détaillé de la découverte automatique sur les clusters Amazon ECS
Prometheus fournit des dizaines de mécanismes dynamiques de découverte de service, comme décrit dans [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config). Toutefois, il n'y a pas de découverte de service intégrée pour Amazon ECS. L' CloudWatch agent ajoute ce mécanisme.
Lorsque la découverte du service Amazon ECS Prometheus est activée, CloudWatch l'agent effectue régulièrement les appels d'API suivants aux frontends Amazon ECS et Amazon EC2 pour récupérer les métadonnées des tâches ECS en cours d'exécution dans le cluster ECS cible.
```
EC2:DescribeInstances
ECS:ListTasks
ECS:ListServices
ECS:DescribeContainerInstances
ECS:DescribeServices
ECS:DescribeTasks
ECS:DescribeTaskDefinition
```
Les métadonnées sont utilisées par l' CloudWatch agent pour scanner les cibles Prometheus au sein du cluster ECS. L' CloudWatch agent prend en charge trois modes de découverte de services :
+ découverte de service basée sur l'étiquette docker du conteneur ;
+ découverte de service basée sur l'expression régulière ARN de la tâche ECS ;
+ découverte de service basée sur l'expression régulière du nom du service ECS.
Tous les modes peuvent être utilisés ensemble. CloudWatch l'agent déduplique les cibles découvertes en fonction de :. `{private_ip}:{port}/{metrics_path}`
Toutes les cibles découvertes sont écrites dans un fichier de résultats spécifié par le champ `sd_result_file` de configuration du conteneur de l' CloudWatch agent. Voici un exemple de fichier de résultats :
```
- targets:
- 10.6.1.95:32785
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT: "9406"
ECS_PROMETHEUS_JOB_NAME: demo-jar-ec2-bridge-dynamic
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-jar-ec2-bridge-dynamic-port
TaskGroup: family:demo-jar-ec2-bridge-dynamic-port
TaskRevision: "7"
VpcId: vpc-01234567890
container_name: demo-jar-ec2-bridge-dynamic-port
job: demo-jar-ec2-bridge-dynamic
- targets:
- 10.6.3.193:9404
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_B: "9404"
ECS_PROMETHEUS_JOB_NAME: demo-tomcat-ec2-bridge-mapped-port
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-tomcat-ec2-bridge-mapped-port
TaskGroup: family:demo-jar-tomcat-bridge-mapped-port
TaskRevision: "12"
VpcId: vpc-01234567890
container_name: demo-tomcat-ec2-bridge-mapped-port
job: demo-tomcat-ec2-bridge-mapped-port
```
Vous pouvez directement intégrer ce fichier de résultats à la découverte de services basés sur des fichiers de Prometheus. Pour plus d'informations sur la découverte de services basée sur des fichiers de Prometheus, consultez [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config).
Supposons que le fichier de résultat soit écrit dans `/tmp/cwagent_ecs_auto_sd.yaml`. La configuration de récupération Prometheus suivante la consommera.
```
global:
scrape_interval: 1m
scrape_timeout: 10s
scrape_configs:
- job_name: cwagent-ecs-file-sd-config
sample_limit: 10000
file_sd_configs:
- files: [ "/tmp/cwagent_ecs_auto_sd.yaml" ]
```
L' CloudWatch agent ajoute également les étiquettes supplémentaires suivantes pour les cibles découvertes.
+ `container_name`
+ `TaskDefinitionFamily`
+ `TaskRevision`
+ `TaskGroup`
+ `StartedBy`
+ `LaunchType`
+ `job`
+ `__metrics_path__`
+ Étiquettes Docker
Lorsque le cluster comporte le type de lancement EC2, les trois étiquettes suivantes sont ajoutées.
+ `InstanceType`
+ `VpcId`
+ `SubnetId`
**Note**
Les étiquettes Docker qui ne correspondent pas à l'expression régulière `[a-zA-Z_][a-zA-Z0-9_]*` sont filtrés. Cela correspond aux conventions Prometheus répertoriées dans `label_name` de [Fichier de configuration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname), compris dans la documentation Prometheus.
## Exemples de configuration de la découverte de service ECS
Cette section contient des exemples qui illustrent la découverte de services ECS.
**Exemple 1**
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
}
}
```
Cet exemple montre comment activer la découverte de service basée sur les étiquettes docker. L' CloudWatch agent interrogera les métadonnées des tâches ECS une fois par minute et inscrira les cibles découvertes dans le `/tmp/cwagent_ecs_auto_sd.yaml` fichier du conteneur de l' CloudWatch agent.
La valeur par défaut de `sd_port_label` dans la section `docker_label` est `ECS_PROMETHEUS_EXPORTER_PORT`. Si un conteneur en cours d'exécution dans les tâches ECS possède une étiquette `ECS_PROMETHEUS_EXPORTER_PORT` docker, l' CloudWatchagent utilise sa valeur as `container port` pour scanner tous les ports exposés du conteneur. En cas de correspondance, le port hôte mappé ainsi que l'adresse IP privée du conteneur sont utilisés pour construire la cible de l'exportateur Prometheus au format suivant : `private_ip:host_port`.
La valeur par défaut de `sd_metrics_path_label` dans la section `docker_label` est `ECS_PROMETHEUS_METRICS_PATH`. Si le conteneur possède cette étiquette docker, sa valeur sera utilisée comme `__metrics_path__`. Si le conteneur ne possède pas cette étiquette, la valeur par défaut `/metrics` est utilisée.
La valeur par défaut de `sd_job_name_label` dans la section `docker_label` est `job`. Si le conteneur possède cette étiquette docker, sa valeur sera ajoutée comme l'une des étiquettes de la cible pour remplacer le nom de tâche par défaut spécifié dans la configuration Prometheus. La valeur de cette étiquette Docker est utilisée comme nom du flux de journaux dans le groupe de CloudWatch journaux Logs.
**Exemple 2**
```
"ecs_service_discovery": {
"sd_frequency": "15s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A",
"sd_job_name_label": "ECS_PROMETHEUS_JOB_NAME"
}
}
```
Cet exemple permet la découverte de services basée sur des étiquettes docker. THe CloudWatch l'agent interrogera les métadonnées des tâches ECS toutes les 15 secondes et écrira les cibles découvertes dans le `/tmp/cwagent_ecs_auto_sd.yaml` fichier du conteneur de l' CloudWatch agent. Les conteneurs possédant une étiquette docker `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` seront analysés. La valeur de l'étiquette docker `ECS_PROMETHEUS_JOB_NAME` est utilisée comme nom de tâche.
**Exemple 3**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"task_definition_list": [
{
"sd_job_name": "java-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9404; 9406",
"sd_task_definition_arn_pattern": ".*:task-definition/.*javajmx.*:[0-9]+"
},
{
"sd_job_name": "envoy-prometheus",
"sd_metrics_path": "/stats/prometheus",
"sd_container_name_pattern": "^envoy$",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*appmesh.*:23"
}
]
}
```
Cet exemple montre comment activer la découverte de service basée sur l'expression régulière ARN de la tâche ECS. L' CloudWatch agent interroge les métadonnées des tâches ECS toutes les cinq minutes et écrit les cibles découvertes dans le `/tmp/cwagent_ecs_auto_sd.yaml` fichier du conteneur de l' CloudWatch agent.
Deux sections d'expressions régulières ARN de définition de tâche sont définies :
+ Pour la première section, les tâches ECS avec `javajmx` dans leur ARN de définition de tâche ECS sont filtrées pour l'analyse des ports de conteneur. Si les conteneurs de ces tâches ECS exposent le port de conteneur sur 9404 ou 9406, le port hôte mappé ainsi que l'adresse IP privée du conteneur sont utilisés pour créer les cibles d'exportation Prometheus. La valeur de `sd_metrics_path` définit `__metrics_path__` sur `/metrics`. L' CloudWatch agent extraira donc les métriques Prometheus, qui seront envoyées au flux `private_ip:host_port/metrics` CloudWatch de journaux dans Logs `java-prometheus` du groupe de journaux. `/aws/ecs/containerinsights/cluster_name/prometheus`
+ Pour la deuxième section, les tâches ECS avec `appmesh` dans leur ARN de définition de tâche ECS et avec la `version` `:23` sont filtrées pour l'analyse des ports de conteneur. Pour les conteneurs dont le nom est `envoy` qui exposent le port de conteneur sur `9901`, le port hôte mappé ainsi que l'adresse IP privée du conteneur sont utilisés pour créer les cibles d'exportation Prometheus. La valeur de ces tâches ECS expose le port de conteneur sur 9404 ou 9406, le port hôte mappé ainsi que l'adresse IP privée du conteneur sont utilisés pour créer les cibles d'exportation Prometheus. La valeur de `sd_metrics_path` définit `__metrics_path__` sur `/stats/prometheus`. L' CloudWatch agent extraira donc les métriques Prometheus et les enverra au flux `private_ip:host_port/stats/prometheus` CloudWatch de journaux dans Logs `envoy-prometheus` du groupe de journaux. `/aws/ecs/containerinsights/cluster_name/prometheus`
**Exemple 4**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-.*"
},
{
"sd_job_name": "haproxy-prometheus",
"sd_metrics_path": "/stats/metrics",
"sd_container_name_pattern": "^haproxy$",
"sd_metrics_ports": "8404",
"sd_service_name_pattern": ".*haproxy-service.*"
}
]
}
```
Cet exemple montre comment activer la découverte de service basée sur l'expression régulière du nom du service ECS. L' CloudWatch agent interroge les métadonnées des services ECS toutes les cinq minutes et écrit les cibles découvertes dans le `/tmp/cwagent_ecs_auto_sd.yaml` fichier du conteneur de l' CloudWatch agent.
Deux sections d'expressions régulières de nom de service sont définies :
+ Dans la première section, les tâches ECS associées aux services ECS dont les noms correspondent à l'expression régulière `^nginx-.*` sont filtrées pour l'analyse du port du conteneur. Si les conteneurs de ces tâches ECS exposent le port de conteneur sur 9113, le port hôte mappé ainsi que l'adresse IP privée du conteneur sont utilisés pour créer les cibles d'exportation Prometheus. La valeur de `sd_metrics_path` définit `__metrics_path__` sur `/metrics`. L' CloudWatch agent extraira donc les métriques Prometheus, et les métriques `private_ip:host_port/metrics` supprimées seront envoyées au flux CloudWatch de journaux dans Logs `nginx-prometheus` du groupe de journaux. `/aws/ecs/containerinsights/cluster_name/prometheus`
+ ou la seconde section, les tâches ECS associées aux services ECS dont les noms correspondent à l'expression régulière `.*haproxy-service.*` sont filtrées pour l'analyse du port du conteneur. Pour les conteneurs dont le nom est `haproxy` qui exposent le port de conteneur sur 8404, le port hôte mappé ainsi que l'adresse IP privée du conteneur sont utilisés pour créer les cibles d'exportation Prometheus. La valeur de `sd_metrics_path` définit `__metrics_path__` sur `/stats/metrics`. L' CloudWatchagent extraira donc les métriques Prometheus, et les métriques `private_ip:host_port/stats/metrics` supprimées seront envoyées au flux CloudWatch de journaux dans Logs `haproxy-prometheus` du groupe de journaux. `/aws/ecs/containerinsights/cluster_name/prometheus`
**Exemple 5**
```
"ecs_service_discovery": {
"sd_frequency": "1m30s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "MY_PROMETHEUS_EXPORTER_PORT_LABEL",
"sd_metrics_path_label": "MY_PROMETHEUS_METRICS_PATH_LABEL",
"sd_job_name_label": "MY_PROMETHEUS_METRICS_NAME_LABEL"
}
"task_definition_list": [
{
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": "*memcached.*"
}
]
}
```
Cet exemple montre comment activer les deux modes de découverte de service ECS. L' CloudWatch agent interroge les métadonnées des tâches ECS toutes les 90 secondes et écrit les cibles découvertes dans le `/tmp/cwagent_ecs_auto_sd.yaml` fichier du conteneur de l' CloudWatch agent.
Pour la configuration de découverte de service basée sur Docker :
+ Les tâches ECS avec l'étiquette docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` seront filtrées pour l'analyse du port Prometheus. Le port de conteneur Prometheus cible est spécifié par la valeur de l'étiquette `MY_PROMETHEUS_EXPORTER_PORT_LABEL`.
+ La valeur de l'étiquette docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` est utilisée pour `__metrics_path__`. Si le conteneur ne possède pas cette étiquette docker, la valeur par défaut `/metrics` est utilisée.
+ La valeur de l'étiquette docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` est utilisée comme étiquette de tâche. Si le conteneur n'a pas cette étiquette docker, le nom de tâche défini dans la configuration Prometheus est utilisé.
Pour la configuration de la découverte de service basée sur l'expression régulière ARN de la tâche ECS :
+ Les tâches ECS avec `memcached` dans l'ARN de définition de tâche ECS sont filtrées pour l'analyse des ports de conteneur. Le port de conteneur Prometheus cible est 9150 tel que défini par `sd_metrics_ports`. Le chemin d'accès aux métriques par défaut `/metrics` est utilisé. Le nom de tâche défini dans la configuration Prometheus est utilisé.
# (En option) Configuration d'exemples d'applications Amazon ECS 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).
**Topics**
+ [Exemple d'application App Mesh pour les clusters Amazon ECS](ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh.md)
+ [Exemple de Java/JMX charge de travail pour les clusters Amazon ECS](ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx.md)
+ [Exemple d'application NGINX pour les clusters Amazon ECS](ContainerInsights-Prometheus-Setup-nginx-ecs.md)
+ [Exemple d'application NGINX Plus pour les clusters Amazon ECS](ContainerInsights-Prometheus-Setup-nginx-plus-ecs.md)
+ [Didacticiel pour l'ajout d'une nouvelle cible de récupération Prometheus : Memcached sur Amazon ECS](ContainerInsights-Prometheus-Setup-memcached-ecs.md)
+ [Didacticiel pour récupérer les métriques Prometheus Redis OSS sur Amazon ECS Fargate](ContainerInsights-Prometheus-Setup-redis-ecs.md)
# Exemple d'application App Mesh pour les clusters Amazon ECS
Pour collecter des métriques à partir d'un exemple d'application Prometheus pour Amazon ECS, vous devez exécuter Container Insights dans le cluster. Pour plus d'informations sur l'installation de Container Insights, consultez [Configuration de Container Insights sur Amazon ECS](deploy-container-insights-ECS.md).
Tout d'abord, suivez cette [démonstration](https://github.com/aws/aws-app-mesh-examples/tree/main/examples/apps/colorapp#app-mesh-walkthrough-deploy-the-color-app-on-ecs) pour déployer l'exemple d'application de couleur dans votre cluster Amazon ECS. Une fois que vous avez terminé, les métriques App Mesh Prometheus seront exposées sur le port 9901.
Procédez ensuite comme suit pour installer l' CloudWatch agent avec Prometheus monitoring sur le même cluster Amazon ECS où vous avez installé l'application couleur. Les étapes décrites dans cette section permettent d'installer l' CloudWatch agent en mode réseau en mode pont.
Les variables d'environnement `ENVIRONMENT_NAME`,`AWS_PROFILE`, et `AWS_DEFAULT_REGION` que vous définissez dans la démonstration seront également utilisées dans les étapes suivantes.
**Pour installer l' CloudWatch agent avec la surveillance Prometheus à des fins de test**
1. Téléchargez le CloudFormation modèle en saisissant la commande suivante.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. Définissez le mode réseau en saisissant les commandes suivantes.
```
export ECS_CLUSTER_NAME=${ENVIRONMENT_NAME}
export ECS_NETWORK_MODE=bridge
```
1. Créez la CloudFormation pile en saisissant les commandes suivantes.
```
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=True \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=CWAgent-Prometheus-TaskRole-${ECS_CLUSTER_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=CWAgent-Prometheus-ExecutionRole-${ECS_CLUSTER_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
1. (Facultatif) Lorsque la CloudFormation pile est créée, un `CREATE_COMPLETE` message s'affiche. Si vous souhaitez vérifier l'état avant d'afficher ce message, saisissez la commande suivante.
```
aws cloudformation describe-stacks \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--query 'Stacks[0].StackStatus' \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Résolution des problèmes**
Les étapes de la démonstration utilisent jq pour analyser le résultat de sortie de la AWS CLI. Pour plus d'informations sur l'installation de jq, consultez [jq](https://stedolan.github.io/jq/). Utilisez la commande suivante pour définir le format de sortie par défaut de votre AWS CLI sur JSON afin que jq puisse l'analyser correctement.
```
$ aws configure
```
Lorsque la réponse arrive à `Default output format`, saisissez **json**.
## Désinstallez l' CloudWatch agent avec le système de surveillance Prometheus
Lorsque vous avez terminé le test, entrez la commande suivante pour désinstaller l' CloudWatchagent en supprimant la CloudFormation pile.
```
aws cloudformation delete-stack \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# Exemple de Java/JMX charge de travail pour les clusters Amazon ECS
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).
L' CloudWatch agent prenant en charge Prometheus extrait les métriques Prometheus en fonction de la Java/JMX configuration de découverte de services dans le cluster Amazon ECS. 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 la `ecs_service_discovery` section par défaut dans la configuration de l' CloudWatch agent.
Pour collecter des métriques à partir d'un exemple d'application Prometheus pour Amazon ECS, vous devez exécuter Container Insights dans le cluster. Pour plus d'informations sur l'installation de Container Insights, consultez [Configuration de Container Insights sur Amazon ECS](deploy-container-insights-ECS.md).
**Pour installer l' Java/JMX exemple de charge de travail pour les clusters Amazon ECS**
1. Suivez les étapes décrites dans ces sections pour créer vos images Docker.
+ [Exemple : image Docker d'application Java Jar avec métriques Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-jar)
+ [Exemple : image Apache Tomcat Docker avec métriques Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-tomcat)
1. Spécifiez les deux étiquettes docker suivantes dans le fichier de définition de tâche Amazon ECS. Vous pouvez ensuite exécuter la définition de tâche en tant que Amazon ECS service ou tâche Amazon ECS dans le cluster.
+ Définissez `ECS_PROMETHEUS_EXPORTER_PORT` pour pointer vers le ContainerPort où les métriques Prometheus sont exposées.
+ Définissez `Java_EMF_Metrics` sur `true`. L' CloudWatch agent utilise cet indicateur pour générer le format de métrique intégré dans le journal des événements.
Voici un exemple :
```
{
"family": "workload-java-ec2-bridge",
"taskRoleArn": "{{task-role-arn}}",
"executionRoleArn": "{{execution-role-arn}}",
"networkMode": "bridge",
"containerDefinitions": [
{
"name": "tomcat-prometheus-workload-java-ec2-bridge-dynamic-port",
"image": "your_docker_image_tag_for_tomcat_with_prometheus_metrics",
"portMappings": [
{
"hostPort": 0,
"protocol": "tcp",
"containerPort": 9404
}
],
"dockerLabels": {
"ECS_PROMETHEUS_EXPORTER_PORT": "9404",
"Java_EMF_Metrics": "true"
}
}
],
"requiresCompatibilities": [
"EC2" ],
"cpu": "256",
"memory": "512"
}
```
Le paramètre par défaut de l' CloudWatch agent dans le CloudFormation modèle permet à la fois la découverte de services basée sur les étiquettes docker et la découverte de services basée sur l'ARN par définition de tâches. Pour consulter ces paramètres par défaut, reportez-vous à la ligne 65 du [fichier de configuration YAML de l' CloudWatch agent](https://github.com/aws-samples/amazon-cloudwatch-container-insights/blob/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml#L65). Les conteneurs avec l'étiquette `ECS_PROMETHEUS_EXPORTER_PORT` seront automatiquement découverts en fonction du port de conteneur spécifié pour la récupération Prometheus.
Le paramètre par défaut de l' CloudWatch agent contient également le `metric_declaration` paramètre correspondant Java/JMX à la ligne 112 du même fichier. Toutes les étiquettes docker des conteneurs cibles seront ajoutées en tant qu'étiquettes supplémentaires dans les métriques Prometheus et envoyées à Logs. CloudWatch Pour les Java/JMX conteneurs dotés d'une étiquette docker`Java_EMF_Metrics=“true”`, le format métrique intégré sera généré.
# Exemple d'application NGINX pour les clusters Amazon ECS
NGINX Prometheus Exporter peut récupérer et exposer les données NGINX en tant que métriques Prometheus. Cet exemple utilise l'exportateur conjointement au service de proxy inverse NGINX pour Amazon ECS.
Pour plus d'informations sur l'exportateur Prometheus de NGINX, rendez-vous sur Github. [ nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) Pour plus d'informations sur le proxy inverse NGINX, consultez [ ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)Github.
L' CloudWatch agent compatible avec Prometheus extrait les métriques NGINX Prometheus en fonction de la configuration de découverte de services dans le cluster Amazon ECS. Vous pouvez configurer NGINX Prometheus 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 la `ecs_service_discovery` section dans le fichier de configuration de l' CloudWatch agent.
## Installation de l'application d'exemple de proxy inverse NGINX pour les clusters Amazon ECS
Suivez ces étapes pour installer l'application d'exemple de proxy inverse NGINX.
### Création des images Docker
**Pour créer les images Docker pour l'application d'exemple de proxy inverse NGINX**
1. [Téléchargez le dossier suivant depuis le dépôt de proxy inverse NGINX : https://github.com/awslabs/ecs-nginx-reverse-proxy/-proxy/. tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)
1. Recherchez le répertoire `app` et créez une image à partir de ce répertoire :
```
docker build -t web-server-app ./path-to-app-directory
```
1. Créez une image personnalisée pour NGINX. Pour commencer, créez un répertoire avec les deux fichiers suivants :
+ Un exemple de fichier Docker :
```
FROM nginx
COPY nginx.conf /etc/nginx/nginx.conf
```
+ Un `nginx.conf` fichier, modifié depuis [ https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/) :
```
events {
worker_connections 768;
}
http {
# Nginx will handle gzip compression of responses from the app server
gzip on;
gzip_proxied any;
gzip_types text/plain application/json;
gzip_min_length 1000;
server{
listen 8080;
location /stub_status {
stub_status on;
}
}
server {
listen 80;
# Nginx will reject anything not matching /api
location /api {
# Reject requests with unsupported HTTP method
if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
return 405;
}
# Only requests matching the whitelist expectations will
# get sent to the application server
proxy_pass http://app:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_cache_bypass $http_upgrade;
}
}
}
```
**Note**
`stub_status` doit être activé sur le même port sur lequel `nginx-prometheus-exporter` est configuré pour récupérer les métriques. Dans notre exemple de définition de tâche, `nginx-prometheus-exporter` est configuré pour extraire les métriques depuis le port 8080.
1. Créez une image à partir des fichiers de votre nouveau répertoire :
```
docker build -t nginx-reverse-proxy ./path-to-your-directory
```
1. Téléchargez vos nouvelles images dans un répertoire d'images pour une utilisation ultérieure.
### Création de la définition de tâche pour exécuter NGINX et l'application serveur web dans Amazon ECS
Ensuite, vous configurez la définition de tâche.
Cette définition de tâche permet la collecte et l'exportation des métriques NGINX Prometheus. Le conteneur NGINX suit les entrées de l'application et expose ces données au port 8080, comme défini dans `nginx.conf`. Le conteneur d'exportation NGINX Prometheus récupère ces métriques et les publie sur le port 9113, pour les utiliser dans. CloudWatch
**Pour configurer la définition de tâche pour l'application Amazon ECS d'exemple NGINX**
1. Créez un fichier JSON de définition de tâche avec le contenu suivant. *your-customized-nginx-iamge*Remplacez-le par l'URI de l'image de votre image NGINX personnalisée et remplacez-le *your-web-server-app-image* par l'URI de l'image de votre application de serveur Web.
```
{
"containerDefinitions": [
{
"name": "nginx",
"image": "your-customized-nginx-image",
"memory": 256,
"cpu": 256,
"essential": true,
"portMappings": [
{
"containerPort": 80,
"protocol": "tcp"
}
],
"links": [
"app"
]
},
{
"name": "app",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 256,
"essential": true
},
{
"name": "nginx-prometheus-exporter",
"image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
"memory": 256,
"cpu": 256,
"essential": true,
"command": [
"-nginx.scrape-uri",
"http://nginx:8080/stub_status"
],
"links":[
"nginx"
],
"portMappings":[
{
"containerPort": 9113,
"protocol": "tcp"
}
]
}
],
"networkMode": "bridge",
"placementConstraints": [],
"family": "nginx-sample-stack"
}
```
1. Enregistrez la définition de tâche en saisissant la commande suivante.
```
aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
```
1. Créez un service pour exécuter la tâche en saisissant la commande suivante :
Veillez à ne pas modifier le nom du service. Nous exécuterons un service d' CloudWatch agent à l'aide d'une configuration qui recherche les tâches en utilisant les modèles de noms des services qui les ont démarrées. Par exemple, pour que l' CloudWatch agent trouve la tâche lancée par cette commande, vous pouvez spécifier la valeur de `sd_service_name_pattern` to be`^nginx-service$`. La section suivante fournit plus de détails.
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-service \
--task-definition nginx-sample-stack:1 \
--desired-count 1
```
### Configurer l' CloudWatch agent pour extraire les métriques NGINX Prometheus
La dernière étape consiste à configurer l' CloudWatch agent pour récupérer les métriques NGINX. Dans cet exemple, l' CloudWatch agent découvre la tâche via le modèle de nom de service et le port 9113, où l'exportateur expose les métriques prometheus pour NGINX. Une fois la tâche découverte et les métriques disponibles, l' CloudWatch agent commence à publier les métriques collectées dans le flux de log **nginx-prometheus-exporter**.
**Pour configurer l' CloudWatch agent afin de récupérer les métriques NGINX**
1. Téléchargez la dernière version du fichier YAML nécessaire en saisissant la commande suivante.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. Ouvrez le fichier dans un éditeur de texte et trouvez la configuration complète de l' CloudWatch agent dans la `value` clé de la section. `resource:CWAgentConfigSSMParameter` Ensuite, dans la section `ecs_service_discovery`, ajoutez la section `service_name_list_for_tasks` suivante.
```
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-service$"
}
],
```
1. Dans le même fichier, ajoutez la section suivante dans la section `metric_declaration` pour autoriser les métriques NGINX. Veillez à suivre le modèle d'indentation existant.
```
{
"source_labels": ["job"],
"label_matcher": ".*nginx.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
"metric_selectors": [
"^nginx_.*$"
]
},
```
1. Si l' CloudWatch agent n'est pas déjà déployé dans ce cluster, passez à l'étape 8.
Si l' CloudWatch agent est déjà déployé dans le cluster Amazon ECS à l'aide de AWS CloudFormation, vous pouvez créer un ensemble de modifications en saisissant les commandes suivantes :
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name nginx-scraping-support
```
1. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Passez en revue le nouvel ensemble de modifications. **nginx-scraping-support** Vous devriez voir une modification appliquée à la SSMParameter ressource **CWAgentConfig**. Exécutez le changeset et redémarrez la tâche de l' CloudWatch agent en saisissant la commande suivante :
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Patientez environ 10 secondes, puis saisissez la commande suivante.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Si vous installez l' CloudWatch agent avec la collecte de métriques Prometheus sur le cluster pour la première fois, entrez les commandes suivantes.
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Affichage des journaux et métriques NGINX
Vous pouvez maintenant afficher les métriques NGINX collectées.
**Pour examiner les métriques de votre application NGINX**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans la région où votre cluster s'exécute, choisissez **Metrics (Métriques)** dans le volet de navigation de gauche. Trouvez l'espace de noms **ContainerInsights/Prometheus** pour voir les métriques.
1. Pour voir les événements CloudWatch Logs, choisissez **Log groups** dans le volet de navigation. Les événements se trouvent dans le groupe de journaux **/aws/containerinsights/ *your\$1cluster\$1name* /prometheus**, dans le flux de journaux. *nginx-prometheus-exporter*
# Exemple d'application NGINX Plus pour les clusters Amazon ECS
NGINX Plus est la version commerciale de NGINX. Vous devez disposer d'une licence pour l'utiliser. Pour en savoir plus, consultez [NGINX Plus](https://www.nginx.com/products/nginx/).
NGINX Prometheus Exporter peut récupérer et exposer les données NGINX en tant que métriques Prometheus. Cet exemple utilise l'exportateur conjointement au service de proxy inverse NGINX Plus pour Amazon ECS.
Pour plus d'informations sur l'exportateur Prometheus de NGINX, rendez-vous sur Github. [ nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) Pour plus d'informations sur le proxy inverse NGINX, consultez [ ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)Github.
L' CloudWatch agent compatible avec Prometheus extrait les métriques NGINX Plus Prometheus en fonction de la configuration de découverte de services dans le cluster Amazon ECS. Vous pouvez configurer NGINX Prometheus 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 la `ecs_service_discovery` section dans le fichier de configuration de l' CloudWatch agent.
## Installation de l'application d'exemple de proxy inverse NGINX Plus pour les clusters Amazon ECS
Suivez ces étapes pour installer l'application d'exemple de proxy inverse NGINX.
### Création des images Docker
**Pour créer les images Docker pour l'application d'exemple de proxy inverse NGINX Plus**
1. [Téléchargez le dossier suivant depuis le dépôt de proxy inverse NGINX : https://github.com/awslabs/ecs-nginx-reverse-proxy/-proxy/. tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)
1. Recherchez le répertoire `app` et créez une image à partir de ce répertoire :
```
docker build -t web-server-app ./path-to-app-directory
```
1. Créez une image personnalisée pour NGINX Plus. Avant de pouvoir créer l'image pour NGINX Plus, vous devez obtenir la clé nommée `nginx-repo.key` et le certificat SSL `nginx-repo.crt` pour votre licence NGINX Plus. Créez un répertoire et stockez-les dans vos fichiers `nginx-repo.key` et `nginx-repo.crt`.
Dans le répertoire que vous venez de créer, créez les deux fichiers suivants :
+ Créez un exemple de fichier Docker incluant le contenu suivant. Ce fichier docker est adopté à partir d'un exemple de fichier fourni sur [https://docs.nginx.com/nginx/admin- guide/installing-nginx/installing -nginx-docker/](https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/#docker_plus_image) \$1docker\$1plus\$1image. Le changement important que nous faisons est que nous chargeons un fichier séparé, appelé `nginx.conf`, qui sera créé à l'étape suivante.
```
FROM debian:buster-slim
LABEL maintainer="NGINX Docker Maintainers “
# Define NGINX versions for NGINX Plus and NGINX Plus modules
# Uncomment this block and the versioned nginxPackages block in the main RUN
# instruction to install a specific release
# ENV NGINX_VERSION 21
# ENV NJS_VERSION 0.3.9
# ENV PKG_RELEASE 1~buster
# Download certificate and key from the customer portal (https://cs.nginx.com (https://cs.nginx.com/))
# and copy to the build context
COPY nginx-repo.crt /etc/ssl/nginx/
COPY nginx-repo.key /etc/ssl/nginx/
# COPY nginx.conf /etc/ssl/nginx/nginx.conf
RUN set -x \
# Create nginx user/group first, to be consistent throughout Docker variants
&& addgroup --system --gid 101 nginx \
&& adduser --system --disabled-login --ingroup nginx --no-create-home --home /nonexistent --gecos "nginx user" --shell /bin/false --uid 101 nginx \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y ca-certificates gnupg1 \
&& \
NGINX_GPGKEY=573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62; \
found=''; \
for server in \
ha.pool.sks-keyservers.net (http://ha.pool.sks-keyservers.net/) \
hkp://keyserver.ubuntu.com:80 \
hkp://p80.pool.sks-keyservers.net:80 \
pgp.mit.edu (http://pgp.mit.edu/) \
; do \
echo "Fetching GPG key $NGINX_GPGKEY from $server"; \
apt-key adv --keyserver "$server" --keyserver-options timeout=10 --recv-keys "$NGINX_GPGKEY" && found=yes && break; \
done; \
test -z "$found" && echo >&2 "error: failed to fetch GPG key $NGINX_GPGKEY" && exit 1; \
apt-get remove --purge --auto-remove -y gnupg1 && rm -rf /var/lib/apt/lists/* \
# Install the latest release of NGINX Plus and/or NGINX Plus modules
# Uncomment individual modules if necessary
# Use versioned packages over defaults to specify a release
&& nginxPackages=" \
nginx-plus \
# nginx-plus=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-xslt \
# nginx-plus-module-xslt=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-geoip \
# nginx-plus-module-geoip=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-image-filter \
# nginx-plus-module-image-filter=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-perl \
# nginx-plus-module-perl=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-njs \
# nginx-plus-module-njs=${NGINX_VERSION}+${NJS_VERSION}-${PKG_RELEASE} \
" \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Peer \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Host \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslCert \"/etc/ssl/nginx/nginx-repo.crt\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslKey \"/etc/ssl/nginx/nginx-repo.key\";" >> /etc/apt/apt.conf.d/90nginx \
&& printf "deb https://plus-pkgs.nginx.com/debian buster nginx-plus\n" > /etc/apt/sources.list.d/nginx-plus.list \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
$nginxPackages \
gettext-base \
curl \
&& apt-get remove --purge --auto-remove -y && rm -rf /var/lib/apt/lists/* /etc/apt/sources.list.d/nginx-plus.list \
&& rm -rf /etc/apt/apt.conf.d/90nginx /etc/ssl/nginx
# Forward request logs to Docker log collector
RUN ln -sf /dev/stdout /var/log/nginx/access.log \
&& ln -sf /dev/stderr /var/log/nginx/error.log
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
STOPSIGNAL SIGTERM
CMD ["nginx", "-g", "daemon off;"]
```
+ Un `nginx.conf` fichier, modifié à partir de [ https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx).
```
events {
worker_connections 768;
}
http {
# Nginx will handle gzip compression of responses from the app server
gzip on;
gzip_proxied any;
gzip_types text/plain application/json;
gzip_min_length 1000;
upstream backend {
zone name 10m;
server app:3000 weight=2;
server app2:3000 weight=1;
}
server{
listen 8080;
location /api {
api write=on;
}
}
match server_ok {
status 100-599;
}
server {
listen 80;
status_zone zone;
# Nginx will reject anything not matching /api
location /api {
# Reject requests with unsupported HTTP method
if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
return 405;
}
# Only requests matching the whitelist expectations will
# get sent to the application server
proxy_pass http://backend;
health_check uri=/lorem-ipsum match=server_ok;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_cache_bypass $http_upgrade;
}
}
}
```
1. Créez une image à partir des fichiers de votre nouveau répertoire :
```
docker build -t nginx-plus-reverse-proxy ./path-to-your-directory
```
1. Téléchargez vos nouvelles images dans un répertoire d'images pour une utilisation ultérieure.
### Création de la définition de tâche pour exécuter NGINX Plus et l'application serveur web dans Amazon ECS
Ensuite, vous configurez la définition de tâche.
Cette définition de tâche permet la collecte et l'exportation des métriques NGINX Plus Prometheus. Le conteneur NGINX suit les entrées de l'application et expose ces données au port 8080, comme défini dans `nginx.conf`. Le conteneur d'exportation NGINX Prometheus récupère ces métriques et les publie sur le port 9113, pour les utiliser dans. CloudWatch
**Pour configurer la définition de tâche pour l'application Amazon ECS d'exemple NGINX**
1. Créez un fichier JSON de définition de tâche avec le contenu suivant. *your-customized-nginx-plus-image*Remplacez-le par l'URI de l'image de votre image NGINX Plus personnalisée et remplacez-le *your-web-server-app-image* par l'URI de l'image de votre application de serveur Web.
```
{
"containerDefinitions": [
{
"name": "nginx",
"image": "your-customized-nginx-plus-image",
"memory": 256,
"cpu": 256,
"essential": true,
"portMappings": [
{
"containerPort": 80,
"protocol": "tcp"
}
],
"links": [
"app",
"app2"
]
},
{
"name": "app",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 128,
"essential": true
},
{
"name": "app2",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 128,
"essential": true
},
{
"name": "nginx-prometheus-exporter",
"image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
"memory": 256,
"cpu": 256,
"essential": true,
"command": [
"-nginx.plus",
"-nginx.scrape-uri",
"http://nginx:8080/api"
],
"links":[
"nginx"
],
"portMappings":[
{
"containerPort": 9113,
"protocol": "tcp"
}
]
}
],
"networkMode": "bridge",
"placementConstraints": [],
"family": "nginx-plus-sample-stack"
}
```
1. Enregistrez la définition de tâche :
```
aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
```
1. Créez un service pour exécuter la tâche en saisissant la commande suivante :
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-plus-service \
--task-definition nginx-plus-sample-stack:1 \
--desired-count 1
```
Veillez à ne pas modifier le nom du service. Nous exécuterons un service d' CloudWatch agent à l'aide d'une configuration qui recherche les tâches en utilisant les modèles de noms des services qui les ont démarrées. Par exemple, pour que l' CloudWatch agent trouve la tâche lancée par cette commande, vous pouvez spécifier la valeur de `sd_service_name_pattern` to be`^nginx-plus-service$`. La section suivante fournit plus de détails.
### Configurer l' CloudWatch agent pour récupérer les métriques NGINX Plus Prometheus
La dernière étape consiste à configurer l' CloudWatch agent pour récupérer les métriques NGINX. Dans cet exemple, l' CloudWatch agent découvre la tâche via le modèle de nom de service et le port 9113, où l'exportateur expose les métriques prometheus pour NGINX. Une fois la tâche découverte et les métriques disponibles, l' CloudWatch agent commence à publier les métriques collectées dans le flux de log **nginx-prometheus-exporter**.
**Pour configurer l' CloudWatch agent afin de récupérer les métriques NGINX**
1. Téléchargez la dernière version du fichier YAML nécessaire en saisissant la commande suivante.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. Ouvrez le fichier dans un éditeur de texte et trouvez la configuration complète de l' CloudWatch agent dans la `value` clé de la section. `resource:CWAgentConfigSSMParameter` Ensuite, dans la section `ecs_service_discovery`, ajoutez la section `service_name_list_for_tasks` suivante.
```
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-plus-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-plus.*"
}
],
```
1. Dans le même fichier, ajoutez la section suivante dans la section `metric_declaration` pour autoriser les métriques NGINX Plus. Veillez à suivre le modèle d'indentation existant.
```
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
"metric_selectors": [
"^nginxplus_connections_accepted$",
"^nginxplus_connections_active$",
"^nginxplus_connections_dropped$",
"^nginxplus_connections_idle$",
"^nginxplus_http_requests_total$",
"^nginxplus_ssl_handshakes$",
"^nginxplus_ssl_handshakes_failed$",
"^nginxplus_up$",
"^nginxplus_upstream_server_health_checks_fails$"
]
},
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "upstream"]],
"metric_selectors": [
"^nginxplus_upstream_server_response_time$"
]
},
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "code"]],
"metric_selectors": [
"^nginxplus_upstream_server_responses$",
"^nginxplus_server_zone_responses$"
]
},
```
1. Si l' CloudWatch agent n'est pas déjà déployé dans ce cluster, passez à l'étape 8.
Si l' CloudWatch agent est déjà déployé dans le cluster Amazon ECS à l'aide de AWS CloudFormation, vous pouvez créer un ensemble de modifications en saisissant les commandes suivantes :
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name nginx-plus-scraping-support
```
1. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Passez en revue le nouvel ensemble de modifications. **nginx-plus-scraping-support** Vous devriez voir une modification appliquée à la SSMParameter ressource **CWAgentConfig**. Exécutez le changeset et redémarrez la tâche de l' CloudWatch agent en saisissant la commande suivante :
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Patientez environ 10 secondes, puis saisissez la commande suivante.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Si vous installez l' CloudWatch agent avec la collecte de métriques Prometheus sur le cluster pour la première fois, entrez les commandes suivantes.
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Affichage des journaux et métriques NGINX Plus
Vous pouvez maintenant afficher les métriques NGINX Plus collectées.
**Pour examiner les métriques de votre application NGINX**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans la région où votre cluster s'exécute, choisissez **Metrics (Métriques)** dans le volet de navigation de gauche. Trouvez l'espace de noms **ContainerInsights/Prometheus** pour voir les métriques.
1. Pour voir les événements CloudWatch Logs, choisissez **Log groups** dans le volet de navigation. Les événements se trouvent dans le groupe de journaux **/aws/containerinsights/ *your\$1cluster\$1name* /prometheus**, dans le flux de journaux. *nginx-plus-prometheus-exporter*
# Didacticiel pour l'ajout d'une nouvelle cible de récupération Prometheus : Memcached sur Amazon ECS
Ce didacticiel propose une présentation pratique pour récupérer les métriques Prometheus d'un exemple d'application Memcached sur un cluster Amazon ECS avec le type de lancement EC2. La cible de l'exportateur Prometheus Memcached sera découverte automatiquement par l' CloudWatch agent par le biais de la découverte de services basée sur la définition des tâches ECS.
Memcached est un système de mise en cache de mémoire distribuée polyvalent. Il est souvent utilisé pour accélérer la vitesse des sites web dynamiques de base de données en mettant en cache les données et les objets dans la mémoire RAM pour réduire le nombre de fois où une source de données externe (telle qu'une base de données ou une API) doit être lue. Pour en savoir plus, consultez [Qu'est-ce que Memcached ?](https://www.memcached.org/).
Le [memchached\$1exporter](https://github.com/prometheus/memcached_exporter) (licence Apache 2.0) est l'un des exportateurs officiels de Prometheus. Par défaut, le memcache\$1exporter sert sur le port 0.0.0.0:9150 à l'adresse `/metrics.`
Les images Docker dans les deux référentiels Docker Hub suivants sont utilisées dans ce didacticiel :
+ [ Memcached](https://hub.docker.com/_/memcached?tab=description)
+ [prom/memcached-exporter](https://hub.docker.com/r/prom/memcached-exporter/)
**Prérequis**
Pour collecter des métriques à partir d'un exemple d'application Prometheus pour Amazon ECS, vous devez exécuter Container Insights dans le cluster. Pour plus d'informations sur l'installation de Container Insights, consultez [Configuration de Container Insights sur Amazon ECS](deploy-container-insights-ECS.md).
**Topics**
+ [Définition des variables d'environnement de cluster Amazon ECS EC2](#ContainerInsights-Prometheus-Setup-memcached-ecs-environment)
+ [Installation de l'exemple d'application Memcached](#ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload)
+ [Configurer l' CloudWatch agent pour extraire les métriques Prometheus de Memcached](#ContainerInsights-Prometheus-Setup-memcached-ecs-agent)
+ [Affichage de vos métriques Memcached](#ContainerInsights-Prometheus-ECS-memcached-view)
## Définition des variables d'environnement de cluster Amazon ECS EC2
**Pour définir des variables d'environnement de cluster Amazon ECS EC2**
1. Installez l'interface de ligne de commande (CLI) Amazon ECS, si vous ne l'avez pas déjà fait. Pour en savoir plus, consultez [Installation de l'interface de ligne de commande (CLI) Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html).
1. Définissez le nouveau nom de cluster Amazon ECS et la nouvelle région. Par exemple :
```
ECS_CLUSTER_NAME=ecs-ec2-memcached-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (Facultatif) Si vous ne possédez pas encore de cluster Amazon ECS de type de lancement EC2 dans lequel vous souhaitez installer l'exemple de charge de travail et d' CloudWatch agent Memcached, vous pouvez en créer un en saisissant la commande suivante.
```
ecs-cli up --capability-iam --size 1 \
--instance-type t3.medium \
--cluster $ECS_CLUSTER_NAME \
--region $AWS_REGION
```
Le résultat attendu de cette commande est le suivant :
```
WARN[0000] You will not be able to SSH into your EC2 instances without a key pair.
INFO[0000] Using recommended Amazon Linux 2 AMI with ECS Agent 1.44.4 and Docker version 19.03.6-ce
INFO[0001] Created cluster cluster=ecs-ec2-memcached-tutorial region=ca-central-1
INFO[0002] Waiting for your cluster resources to be created...
INFO[0002] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
INFO[0063] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
INFO[0124] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
VPC created: vpc-xxxxxxxxxxxxxxxxx
Security Group created: sg-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Cluster creation succeeded.
```
## Installation de l'exemple d'application Memcached
**Pour installer l'exemple d'application Memcached qui expose les métriques Prometheus**
1. Téléchargez le CloudFormation modèle Memcached en saisissant la commande suivante.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/memcached/memcached-traffic-sample.yaml
```
1. Définissez les noms de rôles IAM à créer pour Memcached en saisissant les commandes suivantes.
```
MEMCACHED_ECS_TASK_ROLE_NAME=memcached-prometheus-demo-ecs-task-role-name
MEMCACHED_ECS_EXECUTION_ROLE_NAME=memcached-prometheus-demo-ecs-execution-role-name
```
1. Installez l'exemple d'application Memcached en saisissant la commande suivante. Cet exemple installe l'application dans le mode réseau `host`.
```
MEMCACHED_ECS_NETWORK_MODE=host
aws cloudformation create-stack --stack-name Memcached-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MODE \
--template-body file://memcached-traffic-sample.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=ECSNetworkMode,ParameterValue=$MEMCACHED_ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$MEMCACHED_ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$MEMCACHED_ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
La CloudFormation pile crée quatre ressources :
+ Un rôle de tâche ECS
+ Un rôle d'exécution de tâche ECS
+ Une définition de tâche Memcached
+ Un service Memcached
Dans la définition de la tâche Memcached, deux conteneurs sont définis :
+ Le conteneur principal exécute une application Memcached simple et ouvre le port 11211 pour l'accès.
+ L’autre conteneur exécute le processus d’exportation Redis OSS pour exposer les métriques Prometheus sur le port 9150. Il s'agit du contenant à découvrir et à gratter par l' CloudWatch agent.
## Configurer l' CloudWatch agent pour extraire les métriques Prometheus de Memcached
**Pour configurer l' CloudWatch agent afin de récupérer les métriques Prometheus mises en cache par Memcached**
1. Téléchargez la dernière version du fichier `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` en saisissant la commande suivante.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
```
1. Ouvrez le fichier dans un éditeur de texte et recherchez la configuration complète de l' CloudWatch agent située derrière la `value` clé dans la `resource:CWAgentConfigSSMParameter` section.
Ensuite, dans la section `ecs_service_discovery`, ajoutez la configuration suivante dans la section `task_definition_list`.
```
{
"sd_job_name": "ecs-memcached",
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": ".*:task-definition/memcached-prometheus-demo.*:[0-9]+"
},
```
Pour la section `metric_declaration`, le paramètre par défaut n'autorise aucune métrique Memcached. Ajoutez la section suivante pour autoriser les métriques Memcached. Veillez à suivre le modèle d'indentation existant.
```
{
"source_labels": ["container_name"],
"label_matcher": "memcached-exporter-.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily"]],
"metric_selectors": [
"^memcached_current_(bytes|items|connections)$",
"^memcached_items_(reclaimed|evicted)_total$",
"^memcached_(written|read)_bytes_total$",
"^memcached_limit_bytes$",
"^memcached_commands_total$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "memcached-exporter-.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily","status","command"], ["ClusterName", "TaskDefinitionFamily","command"]],
"metric_selectors": [
"^memcached_commands_total$"
]
},
```
1. Si l' CloudWatch agent est déjà déployé dans le cluster Amazon ECS par CloudFormation, vous pouvez créer un ensemble de modifications en saisissant les commandes suivantes.
```
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name memcached-scraping-support
```
1. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Vérifiez le jeu de modifications `memcached-scraping-support` nouvellement créé. Vous devriez voir une modification appliquée à la ressource `CWAgentConfigSSMParameter`. Exécutez l'ensemble de modifications et redémarrez la tâche de l' CloudWatch agent en saisissant les commandes suivantes.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Patientez environ 10 secondes, puis saisissez la commande suivante.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Si vous installez l' CloudWatch agent avec la collecte de métriques Prometheus pour le cluster pour la première fois, entrez les commandes suivantes :
```
ECS_NETWORK_MODEE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Affichage de vos métriques Memcached
Ce didacticiel envoie les métriques suivantes à l'espace de **ECS/ContainerInsights/Prometheus**noms dans CloudWatch. Vous pouvez utiliser la CloudWatch console pour voir les métriques de cet espace de noms.
| Nom de la métrique | Dimensions |
| --- | --- |
| `memcached_current_items` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_current_connections` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_limit_bytes` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_current_bytes` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_written_bytes_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_read_bytes_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_items_evicted_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_items_reclaimed_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_commands_total` | `ClusterName`, `TaskDefinitionFamily` `ClusterName` TaskDefinitionFamily, commande `ClusterName` TaskDefinitionFamily, statut, commande |
**Note**
La valeur de la dimension **command** peut être : `delete`, `get`, `cas`, `set`, `decr`, `touch`, `incr` ou `flush`.
La valeur de la dimension **status** peut être `hit`, `miss`, ou `badval`.
Vous pouvez également créer un CloudWatch tableau de bord pour vos métriques Prometheus Memcached.
**Pour créer un tableau de bord pour les métriques Prometheus Memcached**
1. Créez des variables d'environnement, en remplaçant les valeurs ci-dessous pour correspondre à votre déploiement.
```
DASHBOARD_NAME=your_memcached_cw_dashboard_name
ECS_TASK_DEF_FAMILY=memcached-prometheus-demo-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MOD
```
1. Saisissez la commande suivante pour créer le tableau de bord.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json \
| sed "s/{{YOUR_AWS_REGION}}/$AWS_REGION/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/$ECS_CLUSTER_NAME/g" \
| sed "s/{{YOUR_TASK_DEF_FAMILY}}/$ECS_TASK_DEF_FAMILY/g" \
| xargs -0 aws cloudwatch put-dashboard --dashboard-name ${DASHBOARD_NAME} --region $AWS_REGION --dashboard-body
```
# Didacticiel pour récupérer les métriques Prometheus Redis OSS sur Amazon ECS Fargate
Ce didacticiel propose une présentation pratique de l’utilisation des métriques Prometheus d’un exemple d’application Redis OSS dans un cluster Amazon ECS Fargate. La cible de l'exportateur Prometheus de Redis OSS sera découverte automatiquement par l' CloudWatch agent avec le support métrique Prometheus sur la base des étiquettes docker du conteneur.
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)
**Prérequis**
Pour collecter des métriques à partir d'un exemple d'application Prometheus pour Amazon ECS, vous devez exécuter Container Insights dans le cluster. Pour plus d'informations sur l'installation de Container Insights, consultez [Configuration de Container Insights sur Amazon ECS](deploy-container-insights-ECS.md).
**Topics**
+ [Définition de la variable d'environnement de cluster Amazon ECS Fargate](#ContainerInsights-Prometheus-Setup-redis-ecs-variable)
+ [Définition des variables d'environnement réseau pour le cluster Amazon ECS Fargate](#ContainerInsights-Prometheus-Setup-redis-ecs-variable2)
+ [Installer l’exemple de charge de travail Redis OSS](#ContainerInsights-Prometheus-Setup-redis-ecs-install-workload)
+ [Configurer l' CloudWatch agent pour récupérer les métriques Prometheus de Redis OSS](#ContainerInsights-Prometheus-Setup-redis-ecs-agent)
+ [Afficher vos métriques Redis OSS](#ContainerInsights-Prometheus-Setup-redis-view)
## Définition de la variable d'environnement de cluster Amazon ECS Fargate
**Pour définir la variable d'environnement de cluster Amazon ECS Fargate**
1. Installez l'interface de ligne de commande (CLI) Amazon ECS, si vous ne l'avez pas déjà fait. Pour en savoir plus, consultez [Installation de l'interface de ligne de commande (CLI) Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html).
1. Définissez le nouveau nom de cluster Amazon ECS et la nouvelle région. Par exemple :
```
ECS_CLUSTER_NAME=ecs-fargate-redis-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (Facultatif) Si vous ne possédez pas encore de cluster Amazon ECS Fargate dans lequel vous souhaitez installer l'exemple de charge de travail CloudWatch et d'agent Redis OSS, vous pouvez en créer un en saisissant la commande suivante.
```
ecs-cli up --capability-iam \
--cluster $ECS_CLUSTER_NAME \
--launch-type FARGATE \
--region $AWS_DEFAULT_REGION
```
Le résultat attendu de cette commande est le suivant :
```
INFO[0000] Created cluster cluster=ecs-fargate-redis-tutorial region=ca-central-1
INFO[0001] Waiting for your cluster resources to be created...
INFO[0001] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
VPC created: vpc-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Cluster creation succeeded.
```
## Définition des variables d'environnement réseau pour le cluster Amazon ECS Fargate
**Pour définir les variables d'environnement réseau pour le cluster Amazon ECS Fargate**
1. Définissez votre VPC et votre ID de sous-réseau du cluster Amazon ECS. Si vous avez créé un nouveau cluster dans la procédure précédente, ces valeurs s'affichent dans le résultat de la commande finale. Sinon, utilisez IDs le cluster existant que vous allez utiliser avec Redis.
```
ECS_CLUSTER_VPC=vpc-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_1=subnet-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_2=subnet-xxxxxxxxxxxxxxxxx
```
1. Dans ce didacticiel, nous allons installer l'application Redis OSS et l' CloudWatch agent dans le groupe de sécurité par défaut du VPC du cluster Amazon ECS. Le groupe de sécurité par défaut autorise toutes les connexions réseau au sein du même groupe de sécurité afin que l' CloudWatch agent puisse supprimer les métriques Prometheus exposées sur les conteneurs Redis OSS. Dans un environnement de production réel, vous souhaiterez peut-être créer des groupes de sécurité dédiés pour l'application et l' CloudWatch agent Redis OSS et définir des autorisations personnalisées pour eux.
Saisissez la commande suivante pour obtenir l'ID du groupe de sécurité par défaut.
```
aws ec2 describe-security-groups \
--filters Name=vpc-id,Values=$ECS_CLUSTER_VPC \
--region $AWS_DEFAULT_REGION
```
Définissez ensuite la variable de groupe de sécurité par défaut du cluster Fargate en saisissant la commande suivante, en la *my-default-security-group* remplaçant par la valeur que vous avez trouvée dans la commande précédente.
```
ECS_CLUSTER_SECURITY_GROUP=my-default-security-group
```
## Installer l’exemple de charge de travail Redis OSS
**Pour installer l’exemple de charge de travail Redis OSS qui expose les métriques Prometheus**
1. Téléchargez le CloudFormation modèle Redis OSS en saisissant la commande suivante.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml
```
1. Définissez les noms de rôles IAM à créer pour Redis OSS en saisissant les commandes suivantes.
```
REDIS_ECS_TASK_ROLE_NAME=redis-prometheus-demo-ecs-task-role-name
REDIS_ECS_EXECUTION_ROLE_NAME=redis-prometheus-demo-ecs-execution-role-name
```
1. Installez l’exemple de charge de travail Redis OSS en saisissant la commande suivante.
```
aws cloudformation create-stack --stack-name Redis-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-fargate-awsvpc \
--template-body file://redis-traffic-sample.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET_1 \
ParameterKey=TaskRoleName,ParameterValue=$REDIS_ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$REDIS_ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_DEFAULT_REGION
```
La CloudFormation pile crée quatre ressources :
+ Un rôle de tâche ECS
+ Un rôle d'exécution de tâche ECS
+ Une définition de tâche Redis OSS
+ Un service Redis OSS
Dans la définition de la tâche Redis OSS, deux conteneurs sont définis :
+ Le conteneur principal exécute une application Redis OSS simple et ouvre le port 6379 pour l’accès.
+ L’autre conteneur exécute le processus d’exportation Redis OSS pour exposer les métriques Prometheus sur le port 9121. Il s'agit du contenant à découvrir et à gratter par l' CloudWatch agent. L'étiquette docker suivante est définie afin que l' CloudWatch agent puisse découvrir ce conteneur en fonction de celle-ci.
```
ECS_PROMETHEUS_EXPORTER_PORT: 9121
```
## Configurer l' CloudWatch agent pour récupérer les métriques Prometheus de Redis OSS
**Pour configurer l' CloudWatch agent afin de récupérer les métriques Prometheus de Redis OSS**
1. Téléchargez la dernière version du fichier `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` en saisissant la commande suivante.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
```
1. Ouvrez le fichier dans un éditeur de texte et recherchez la configuration complète de l' CloudWatch agent située derrière la `value` clé dans la `resource:CWAgentConfigSSMParameter` section.
Ensuite, dans la section `ecs_service_discovery` présentée ici, la découverte de service basée sur `docker_label` est activée avec les paramètres par défaut qui sont basés sur `ECS_PROMETHEUS_EXPORTER_PORT`, qui correspond à l’étiquette docker que nous avons définie dans la définition de tâche ECS Redis OSS. Nous n'avons donc pas besoin d'apporter des modifications dans cette section :
```
ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
* "docker_label": {
},*
...
```
Pour la section `metric_declaration`, le paramètre par défaut n’autorise aucune métrique Redis OSS. Ajoutez la section suivante pour autoriser les métriques Redis OSS. Veillez à suivre le modèle d'indentation existant.
```
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily"]],
"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": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily","cmd"]],
"metric_selectors": [
"^redis_commands_total$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily","db"]],
"metric_selectors": [
"^redis_db_keys$"
]
},
```
1. Si l' CloudWatch agent est déjà déployé dans le cluster Amazon ECS par CloudFormation, vous pouvez créer un ensemble de modifications en saisissant les commandes suivantes.
```
ECS_LAUNCH_TYPE=FARGATE
CREATE_IAM_ROLES=True
ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--change-set-name redis-scraping-support
```
1. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Vérifiez le jeu de modifications `redis-scraping-support` nouvellement créé. Vous devriez voir une modification appliquée à la ressource `CWAgentConfigSSMParameter`. Exécutez l'ensemble de modifications et redémarrez la tâche de l' CloudWatch agent en saisissant les commandes suivantes.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
--region ${AWS_DEFAULT_REGION}
```
1. Patientez environ 10 secondes, puis saisissez la commande suivante.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
--region ${AWS_DEFAULT_REGION}
```
1. Si vous installez l' CloudWatch agent avec la collecte de métriques Prometheus pour le cluster pour la première fois, entrez les commandes suivantes :
```
ECS_LAUNCH_TYPE=FARGATE
CREATE_IAM_ROLES=True
ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION}
```
## Afficher vos métriques Redis OSS
Ce didacticiel envoie les métriques suivantes à l'espace de **ECS/ContainerInsights/Prometheus**noms 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, `TaskDefinitionFamily` |
| `redis_net_output_bytes_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_expired_keys_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_evicted_keys_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_keyspace_hits_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_keyspace_misses_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_memory_used_bytes` | ClusterName, `TaskDefinitionFamily` |
| `redis_connected_clients` | ClusterName, `TaskDefinitionFamily` |
| `redis_commands_total` | ` ClusterName`, `TaskDefinitionFamily`, `cmd` |
| `redis_db_keys` | `ClusterName`, `TaskDefinitionFamily`, `db` |
**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
ECS_TASK_DEF_FAMILY=redis-prometheus-demo-$ECS_CLUSTER_NAME-fargate-awsvpc
```
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" \
```
# Configuration de la collecte de métriques Prometheus sur des clusters Amazon EKS et Kubernetes
Pour collecter les métriques Prometheus à partir de clusters exécutant Amazon EKS ou Kubernetes, vous pouvez utiliser CloudWatch l'agent comme collecteur ou utiliser Distro pour collecteur. AWS OpenTelemetry Pour plus d'informations sur l'utilisation de AWS Distro for OpenTelemetry Collector, consultez [https://aws-otel.github. io/docs/getting-started/container-insights/eks-prométhée](https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus).
Les sections suivantes expliquent comment collecter les métriques Prometheus à l'aide de l'agent. CloudWatch Ils expliquent comment installer l' CloudWatch agent avec Prometheus monitoring sur des clusters exécutant Amazon EKS ou Kubernetes, et comment configurer l'agent pour récupérer des cibles supplémentaires. Elles fournissent également des didacticiels facultatifs pour configurer des exemples d'applications à utiliser pour les tests avec la surveillance Prometheus.
**Topics**
+ [Installez l' CloudWatch agent avec la collecte de métriques Prometheus sur les clusters Amazon EKS et Kubernetes](ContainerInsights-Prometheus-Setup.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**
+ [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" \
```
# Conversion du type métrique Prometheus par l'Agent CloudWatch
Les bibliothèques clientes Prometheus proposent quatre types de métriques principaux :
+ Compteur
+ Jauge
+ Résumé
+ Histogramme
L' CloudWatch agent prend en charge les types de métriques de compteur, de jauge et de synthèse.
Les métriques Prometheus dont le type de métrique d'histogramme n'est pas pris en charge sont supprimées par l'agent. CloudWatch Pour de plus amples informations, veuillez consulter [Journalisation des métriques Prometheus ignorées](ContainerInsights-Prometheus-troubleshooting-EKS.md#ContainerInsights-Prometheus-troubleshooting-droppedmetrics).
**Métriques de jauge**
Une métrique de jauge Prometheus est une métrique qui représente une valeur numérique unique qui peut arbitrairement monter et descendre. L' CloudWatch agent extrait les métriques de jauge et envoie ces valeurs directement.
**Métriques de compteur**
Une métrique de compteur Prometheus est une métrique cumulative qui représente un compteur monotone unique dont la valeur ne peut qu'augmenter ou être réinitialisée à zéro. L' CloudWatch agent calcule un delta à partir du scrape précédent et envoie la valeur delta sous forme de valeur métrique dans le journal des événements. L' CloudWatch agent commencera donc à produire un événement journal à partir de la deuxième éraflure et continuera avec les éraflures suivantes, le cas échéant.
**Métriques de résumé**
Une métrique de résumé Prometheus est un type de métrique complexe qui est représenté par plusieurs points de données. Elle fournit un nombre total d'observations et une somme de toutes les valeurs observées. Elle calcule les quantiles configurables sur une fenêtre temporelle coulissante.
La somme et le nombre d'une métrique de résumé sont cumulatifs, mais les quantiles ne le sont pas. L'exemple suivant illustre la variance des quantiles.
```
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 7.123e-06
go_gc_duration_seconds{quantile="0.25"} 9.204e-06
go_gc_duration_seconds{quantile="0.5"} 1.1065e-05
go_gc_duration_seconds{quantile="0.75"} 2.8731e-05
go_gc_duration_seconds{quantile="1"} 0.003841496
go_gc_duration_seconds_sum 0.37630427
go_gc_duration_seconds_count 9774
```
L' CloudWatch agent gère la somme et le nombre d'une métrique récapitulative de la même manière qu'il gère les contre-métriques, comme décrit dans la section précédente. L' CloudWatch agent conserve les valeurs quantiles telles qu'elles ont été initialement indiquées.
# Métriques Prometheus collectées par l'agent CloudWatch
L' CloudWatch agent bénéficiant du support de Prometheus collecte automatiquement les métriques de plusieurs services et charges de travail. Les métriques collectées par défaut sont répertoriées dans les sections suivantes. Vous pouvez également configurer l'agent pour collecter plus de métriques à partir de ces services, et pour collecter des métriques Prometheus à partir d'autres applications et services. Pour plus d'informations sur la collecte de métriques supplémentaires, consultez [CloudWatch configuration de l'agent pour Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config).
**Les métriques Prometheus collectées à partir des clusters Amazon EKS et Kubernetes se trouvent dans l'espace de noms /Prometheus. ContainerInsights** Les métriques Prometheus collectées à partir des clusters Amazon ECS se trouvent dans l'espace de noms. **ECS/ContainerInsights/Prometheus**
**Topics**
+ [Métriques Prometheus pour App Mesh](#ContainerInsights-Prometheus-metrics-appmesh)
+ [Métriques Prometheus pour NGINX](#ContainerInsights-Prometheus-metrics-nginx)
+ [Métriques Prometheus pour Memcached](#ContainerInsights-Prometheus-metrics-memcached)
+ [Métriques Prometheus pour Java/JMX](#ContainerInsights-Prometheus-metrics-jmx)
+ [Métriques Prometheus pour HAProxy](#ContainerInsights-Prometheus-metrics-haproxy)
## Métriques Prometheus pour App Mesh
Les métriques suivantes sont automatiquement collectées à partir de App Mesh.
**Métriques Prometheus pour App Mesh sur les clusters Amazon EKS et Kubernetes**
| Nom de la métrique | Dimensions |
| --- | --- |
| `envoy_http_downstream_rq_total` | ClusterName, `Namespace` |
| `envoy_http_downstream_rq_xx` | ClusterName, `Namespace` ClusterName, envoy\$1http\$1conn\$1manager\$1prefix`Namespace`, envoy\$1response\$1code\$1class |
| `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `Namespace` |
| `envoy_cluster_membership_healthy` | ClusterName, `Namespace` |
| `envoy_cluster_membership_total` | ClusterName, `Namespace` |
| `envoy_server_memory_heap_size` | ClusterName, `Namespace` |
| `envoy_server_memory_allocated` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_timeout` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_retry` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_retry_success` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `Namespace` |
| `envoy_server_live` | ClusterName, `Namespace` |
| `envoy_server_uptime` | ClusterName, `Namespace` |
**Métriques Prometheus pour App Mesh sur les clusters Amazon ECS**
| Nom de la métrique | Dimensions |
| --- | --- |
| `envoy_http_downstream_rq_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_http_downstream_rq_xx` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_membership_healthy` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_membership_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_memory_heap_size` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_memory_allocated` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_timeout` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry_success` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_live` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_uptime` | ClusterName, `TaskDefinitionFamily` |
| `envoy_http_downstream_rq_xx` | ClusterName, envoy\$1http\$1conn\$1manager\$1prefix TaskDefinitionFamily, envoy\$1response\$1code\$1class ClusterName, TaskDefinitionFamily envoy\$1response\$1code\$1class |
**Note**
`TaskDefinitionFamily` est l'espace de noms Kubernetes du maillage.
La valeur de `envoy_http_conn_manager_prefix` peut être `ingress`, `egress` ou `admin`.
La valeur de `envoy_response_code_class` peut être `1` (signifie `1xx`), `2` (signifie `2xx`), `3` (signifie `3xx`), `4` (signifie `4xx`), ou `5` (signifie `5xx`).
## Métriques Prometheus pour NGINX
Les métriques suivantes sont automatiquement collectées à partir de NGINX sur les clusters Amazon EKS et Kubernetes.
| Nom de la métrique | Dimensions |
| --- | --- |
| `nginx_ingress_controller_nginx_process_cpu_seconds_total` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_success` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_requests` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_nginx_process_connections` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_nginx_process_connections_total` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_nginx_process_resident_memory_bytes` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_config_last_reload_successful` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_requests` | ClusterName,`Namespace`, Service, statut |
## Métriques Prometheus pour Memcached
Les métriques suivantes sont automatiquement collectées à partir de Memcached sur les clusters Amazon EKS et Kubernetes.
| Nom de la métrique | Dimensions |
| --- | --- |
| `memcached_current_items` | ClusterName, `Namespace`, Service |
| `memcached_current_connections` | ClusterName, `Namespace`, Service |
| `memcached_limit_bytes` | ClusterName, `Namespace`, Service |
| `memcached_current_bytes` | ClusterName, `Namespace`, Service |
| `memcached_written_bytes_total` | ClusterName, `Namespace`, Service |
| `memcached_read_bytes_total` | ClusterName, `Namespace`, Service |
| `memcached_items_evicted_total` | ClusterName, `Namespace`, Service |
| `memcached_items_reclaimed_total` | ClusterName, `Namespace`, Service |
| `memcached_commands_total` | ClusterName, `Namespace`, Service ClusterName,`Namespace`, Service, commande ClusterName,`Namespace`, Service, statut, commande |
## Métriques Prometheus pour Java/JMX
**Métriques collectées sur les clusters Amazon EKS et Kubernetes**
Sur les clusters Amazon EKS et Kubernetes, Container Insights peut collecter les métriques Prometheus prédéfinies suivantes à partir de Java Virtual Machine (JVM), Java et Tomcat (Catalina) à l'aide de JMX Exporter. Pour plus d'informations, consultez [ prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) sur Github.
**Java/JMX sur les clusters Amazon EKS et Kubernetes**
| Nom de la métrique | Dimensions |
| --- | --- |
| `jvm_classes_loaded` | `ClusterName`, `Namespace` |
| `jvm_threads_current` | `ClusterName`, `Namespace` |
| `jvm_threads_daemon` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_processcpuload` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `Namespace` |
| `jvm_memory_bytes_used` | `ClusterName`, `Namespace`, area |
| `jvm_memory_pool_bytes_used` | `ClusterName`, `Namespace`, pool |
**Note**
Les valeurs de la dimension `area` peuvent être `heap` ou `nonheap`.
Les valeurs de la dimension `pool` peuvent être `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` ou `Metaspace`.
**Tomcat/JMX sur les clusters Amazon EKS et Kubernetes**
Outre les Java/JMX métriques du tableau précédent, les métriques suivantes sont également collectées pour la charge de travail Tomcat.
| Nom de la métrique | Dimensions |
| --- | --- |
| `catalina_manager_activesessions` | `ClusterName`, `Namespace` |
| `catalina_manager_rejectedsessions` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `Namespace` |
**Java/JMX sur les clusters Amazon ECS**
| Nom de la métrique | Dimensions |
| --- | --- |
| `jvm_classes_loaded` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_threads_current` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_threads_daemon` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_processcpuload` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_memory_bytes_used` | `ClusterName`, TaskDefinitionFamily, région |
| `jvm_memory_pool_bytes_used` | `ClusterName` TaskDefinitionFamily, piscine |
**Note**
Les valeurs de la dimension `area` peuvent être `heap` ou `nonheap`.
Les valeurs de la dimension `pool` peuvent être `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` ou `Metaspace`.
**Tomcat/JMX sur les clusters Amazon ECS**
Outre les Java/JMX métriques du tableau précédent, les métriques suivantes sont également collectées pour la charge de travail Tomcat sur les clusters Amazon ECS.
| Nom de la métrique | Dimensions |
| --- | --- |
| `catalina_manager_activesessions` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_manager_rejectedsessions` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `TaskDefinitionFamily` |
## Métriques Prometheus pour HAProxy
Les métriques suivantes sont automatiquement collectées à partir des clusters HAProxy Amazon EKS et Kubernetes.
Les statistiques collectées dépendent de la version d' HAProxy Ingress que vous utilisez. Pour plus d'informations sur HAProxy Ingress et ses versions, consultez [haproxy-ingress](https://artifacthub.io/packages/helm/haproxy-ingress/haproxy-ingress).
| Nom de la métrique | Dimensions | Disponibilité |
| --- | --- | --- |
| `haproxy_backend_bytes_in_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_backend_bytes_out_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_backend_connection_errors_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_backend_connections_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_backend_current_sessions` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_backend_http_responses_total` | `ClusterName`, `Namespace`, Service, code, backend | Toutes les versions de HAProxy Ingress |
| `haproxy_backend_status` | `ClusterName`, `Namespace`, Service | Uniquement dans les versions 0.10 ou ultérieures d'Ingress HAProxy |
| `haproxy_backend_up` | `ClusterName`, `Namespace`, Service | Uniquement dans les versions d' HAProxy Ingress antérieures à 0.10 |
| `haproxy_frontend_bytes_in_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_frontend_bytes_out_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_frontend_connections_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_frontend_current_sessions` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_frontend_http_requests_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_frontend_http_responses_total` | `ClusterName`, `Namespace`, Service, code, frontend | Toutes les versions de HAProxy Ingress |
| `haproxy_frontend_request_errors_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
| `haproxy_frontend_requests_denied_total` | `ClusterName`, `Namespace`, Service | Toutes les versions de HAProxy Ingress |
**Note**
Les valeurs de la dimension `code` peuvent être `1xx`, `2xx`, `3xx`, `4xx`, `5xx` ou `other`.
Les valeurs de la dimension `backend` peuvent être :
`http-default-backend``http-shared-backend`, ou `httpsback-shared-backend` pour HAProxy Ingress version 0.0.27 ou antérieure.
`_default_backend`pour les versions HAProxy d'Ingress ultérieures à 0.0.27.
Les valeurs de la dimension `frontend` peuvent être :
`httpfront-default-backend``httpfront-shared-frontend`, ou `httpfronts` pour HAProxy Ingress version 0.0.27 ou antérieure.
`_front_http`ou `_front_https` pour les versions HAProxy d'Ingress ultérieures à 0.0.27.
# Affichage de vos métriques Prometheus
Vous pouvez surveiller et déclencher des alarmes sur toutes vos métriques Prometheus, y compris les mesures préagrégées sélectionnées par App Mesh, NGINX, Java/JMX, Memcached HAProxy et tout autre exportateur Prometheus configuré manuellement que vous avez éventuellement ajouté. Pour plus d'informations sur la collecte de métriques à partir d'autres exportateurs Prometheus, consultez [Didacticiel pour l'ajout d'une nouvelle cible de récupération Prometheus : métrique du serveur d'API Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).
Dans la CloudWatch console, Container Insights fournit les rapports prédéfinis suivants :
+ Pour les clusters Amazon EKS et Kubernetes, il existe des rapports prédéfinis pour App Mesh, NGINX, HAPROXY, Memcached et Java/JMX.
+ Pour les clusters Amazon ECS, il existe des rapports prédéfinis pour App Mesh et Java/JMX.
Container Insights fournit également des tableaux de bord personnalisés pour chacune des applications à partir desquelles Container Insights collecte des métriques organisées. Vous pouvez télécharger ces tableaux de bord sur GitHub
**Pour afficher toutes vos métriques Prometheus**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, sélectionnez **Métriques**.
1. Dans la liste des espaces de noms, choisissez **ContainerInsights/Prometheus** ou. **ECS/ContainerInsights/Prometheus**
1. Choisissez l'un des ensembles de dimensions de la liste suivante. Cochez ensuite la case en regard des métriques que vous souhaitez afficher.
**Pour afficher les rapports prédéfinis sur vos métriques Prometheus**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, choisissez **Surveillance des performances**.
1. Dans la liste déroulante située en haut de la page, choisissez l'une des options de Prometheus.
Dans l'autre liste déroulante, choisissez un cluster à afficher
Nous avons également fourni des tableaux de bord personnalisés pour NGINX, App Mesh, Memcached et Java/JMX. HAProxy
**Pour utiliser un tableau de bord personnalisé fourni par Amazon**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
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 l'un des fichiers JSON suivants :
+ [ Source de tableau de bord personnalisé NGINX sur Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/nginx-ingress/cw_dashboard_nginx_ingress_controller.json).
+ [ Source de tableau de bord personnalisé App Mesh sur Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/appmesh/cw_dashboard_awsappmesh.json).
+ [Source de tableau de bord personnalisé Memcached sur Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json)
+ [ HAProxy-Source de tableau de bord personnalisée Ingress sur Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/haproxy-ingress/cw_dashboard_haproxy_ingress.json)
+ [ Java/JMX source de tableau de bord personnalisée sur Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/javajmx/cw_dashboard_javajmx.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 `{{YOUR_REGION}}` chaînes par la AWS région dans laquelle votre cluster est exécuté. Par exemple, **us-west-1** assurez-vous de ne pas ajouter d'espaces avant ou après le texte.
+ Remplacez toutes les chaînes `{{YOUR_NAMESPACE}}` par l'espace de noms exact de votre application.
+ Remplacez toutes les chaînes `{{YOUR_SERVICE_NAME}}` par le nom de service exact de votre application. Par exemple, **haproxy-haproxy-ingress-controller-metrics**
1. Copiez l'intégralité du blob JSON et collez-le dans la zone de texte de la CloudWatch console, en remplaçant ce qui s'y trouve déjà.
1. Choisissez **Mettre à jour**, **Enregistrer le tableau de bord**.
# Résolution des problèmes rencontrés avec les métriques Prometheus
Cette section fournit de l'aide pour résoudre les problèmes de configuration des métriques Prometheus.
**Topics**
+ [Résolution des problèmes rencontrés avec les métriques Prometheus sur Amazon ECS](ContainerInsights-Prometheus-troubleshooting-ECS.md)
+ [Résolution des problèmes liés aux métriques Prometheus sur les clusters Amazon EKS et Kubernetes](ContainerInsights-Prometheus-troubleshooting-EKS.md)
# Résolution des problèmes rencontrés avec les métriques Prometheus sur Amazon ECS
Cette section fournit de l'aide pour résoudre les problèmes de configuration des métriques Prometheus sur les clusters Amazon ECS.
## Je ne vois pas les métriques de Prometheus envoyées à Logs CloudWatch
**Les métriques Prometheus doivent être ingérées sous forme d'événements de journal dans le groupe de journaux/. aws/ecs/containerinsights/cluster-name/Prometheus** Si le groupe de journaux n'est pas créé ou si les métriques Prometheus ne sont pas envoyées au groupe de journaux, vous devez d'abord vérifier si les cibles Prometheus ont été correctement découvertes par l'agent. CloudWatch Vérifiez ensuite le groupe de sécurité et les paramètres d'autorisation de l' CloudWatch agent. Les étapes suivantes vous guident pour réaliser le débogage.
**Étape 1 : activer le mode de débogage de CloudWatch l'agent**
Tout d'abord, passez l' CloudWatch agent en mode de débogage en ajoutant les lignes en gras suivantes à votre fichier CloudFormation modèle, `cwagent-ecs-prometheus-metric-for-bridge-host.yaml` ou`cwagent-ecs-prometheus-metric-for-awsvpc.yaml`. Ensuite, enregistrez le fichier.
```
cwagentconfig.json: |
{
"agent": {
"debug": true
},
"logs": {
"metrics_collected": {
```
Créez un nouvel ensemble de CloudFormation modifications par rapport à la pile existante. Définissez les autres paramètres du changeset sur les mêmes valeurs que dans votre CloudFormation pile existante. L'exemple suivant concerne un CloudWatch agent installé dans un cluster Amazon ECS utilisant le type de lancement EC2 et le mode réseau de pont.
```
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
NEW_CHANGESET_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name $NEW_CHANGESET_NAME
```
Accédez à la CloudFormation console pour consulter le nouvel ensemble de modifications,`$NEW_CHANGESET_NAME`. Une modification doit être appliquée à la SSMParameter ressource **CWAgentConfig**. Exécutez l'ensemble de modifications et redémarrez la tâche de l' CloudWatch agent en saisissant les commandes suivantes.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service your_service_name_here \
--region $AWS_REGION
```
Patientez environ 10 secondes, puis saisissez la commande suivante.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service your_service_name_here \
--region $AWS_REGION
```
**Étape 2 : vérification des journaux de découverte de service ECS**
La définition de tâche ECS de l' CloudWatch agent active les journaux par défaut dans la section ci-dessous. Les journaux sont envoyés à CloudWatch Logs dans le groupe de journaux **/ecs/ ecs-cwagent-prometheus**.
```
LogConfiguration:
LogDriver: awslogs
Options:
awslogs-create-group: 'True'
awslogs-group: "/ecs/ecs-cwagent-prometheus"
awslogs-region: !Ref AWS::Region
awslogs-stream-prefix: !Sub 'ecs-${ECSLaunchType}-awsvpc'
```
Filtrez les journaux par la chaîne `ECS_SD_Stats` pour obtenir les métriques liées à la découverte de service ECS, comme illustré dans l'exemple suivant.
```
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeContainerInstances: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeInstancesRequest: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_ListTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: Exporter_DiscoveredTargetCount: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_EC2MetaData: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_ContainerInstance: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: Latency: 43.399783ms
```
La signification de chaque métrique pour un cycle de découverte de service ECS particulier est la suivante :
+ **AWSCLI\$1DescribeContainerInstances**— le nombre d'appels d'`ECS::DescribeContainerInstances`API effectués.
+ **AWSCLI\$1DescribeInstancesRequest**— le nombre d'appels d'`ECS::DescribeInstancesRequest`API effectués.
+ **AWSCLI\$1DescribeTaskDefinition**— le nombre d'appels d'`ECS::DescribeTaskDefinition`API effectués.
+ **AWSCLI\$1DescribeTasks**— le nombre d'appels d'`ECS::DescribeTasks`API effectués.
+ **AWSCLI\$1ListTasks**— le nombre d'appels d'`ECS::ListTasks`API effectués.
+ **ExporterDiscoveredTargetCount**— le nombre de cibles Prometheus découvertes et exportées avec succès dans le fichier de résultats cible contenu dans le conteneur.
+ **LRUCache\$1Get\$1 EC2 MetaData** — le nombre de fois où les métadonnées des instances de conteneur ont été extraites du cache.
+ **LRUCache\$1Get\$1 TaskDefinition** — le nombre de fois où les métadonnées de définition de tâche ECS ont été extraites du cache.
+ **LRUCache\$1Size\$1 ContainerInstance** — le nombre de métadonnées d'une instance de conteneur unique mises en cache en mémoire.
+ **LRUCache\$1Size\$1 TaskDefinition** — le nombre de définitions de tâches ECS uniques mises en cache en mémoire.
+ **Latency** – combien de temps prend le cycle de découverte de service.
Vérifiez la valeur de `ExporterDiscoveredTargetCount` pour voir si les cibles Prometheus découvertes correspondent à vos attentes. Si ce n'est pas le cas, les raisons possibles sont les suivantes :
+ La configuration de la découverte de service ECS peut ne pas correspondre aux paramètres de votre application. Pour la découverte de services basée sur des étiquettes docker, il est possible que l'étiquette docker nécessaire ne soit pas configurée dans l'agent CloudWatch pour les détecter automatiquement dans vos conteneurs cibles. Pour la découverte de services basée sur l'expression régulière ARN de définition de tâche ECS, le paramètre regex de l' CloudWatch agent peut ne pas correspondre à la définition de tâche de votre application.
+ Le rôle de tâche ECS de l' CloudWatch agent n'est peut-être pas autorisé à récupérer les métadonnées des tâches ECS. Vérifiez que les autorisations de lecture seule suivantes ont été accordées à l' CloudWatch agent :
+ `ec2:DescribeInstances`
+ `ecs:ListTasks`
+ `ecs:DescribeContainerInstances`
+ `ecs:DescribeTasks`
+ `ecs:DescribeTaskDefinition`
**Étape 3 : Vérification de la connexion réseau et de la politique de rôle de tâche ECS**
Si aucun événement de journal n'est toujours envoyé au groupe de CloudWatch journaux Logs cible, même si la valeur de `Exporter_DiscoveredTargetCount` indique que des cibles Prometheus ont été découvertes, cela peut être dû à l'un des facteurs suivants :
+ L' CloudWatch agent ne sera peut-être pas en mesure de se connecter aux ports cibles de Prometheus. Vérifiez le paramètre du groupe de sécurité sous-jacent à l' CloudWatch agent. L'adresse IP privée doit permettre à l' CloudWatch agent de se connecter aux ports de l'exportateur Prometheus.
+ Le rôle de tâche ECS de l' CloudWatch agent n'est peut-être pas doté de la politique **CloudWatchAgentServerPolicy**gérée. Le rôle de tâche ECS de l' CloudWatchagent doit respecter cette politique pour pouvoir envoyer les métriques Prometheus sous forme d'événements de journal. Si vous avez utilisé l'exemple de CloudFormation modèle pour créer automatiquement les rôles IAM, le rôle de tâche ECS et le rôle d'exécution ECS sont dotés du moindre privilège pour effectuer la surveillance Prometheus.
# Résolution des problèmes liés aux métriques Prometheus sur les clusters Amazon EKS et Kubernetes
Cette section fournit de l'aide pour résoudre les problèmes de configuration des métriques Prometheus sur les clusters Amazon EKS et Kubernetes.
## Étapes de résolution des problèmes générales sur Amazon EKS
Pour vérifier que l' CloudWatch agent est en cours d'exécution, entrez la commande suivante.
```
kubectl get pod -n amazon-cloudwatch
```
La sortie doit inclure une ligne avec `cwagent-prometheus-id` dans la colonne `NAME` et `Running` dans la colonne `STATUS column.`
Pour afficher des détails sur le pod en cours d'exécution, entrez la commande suivante. *pod-name*Remplacez-le par le nom complet de votre module dont le nom commence par`cw-agent-prometheus`.
```
kubectl describe pod pod-name -n amazon-cloudwatch
```
Si CloudWatch Container Insights est installé, vous pouvez utiliser CloudWatch Logs Insights pour interroger les journaux de l' CloudWatch agent qui collecte les métriques Prometheus.
**Pour interroger les journaux d'application**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le volet de navigation, sélectionnez **CloudWatch Logs Insights**.
1. Sélectionnez le groupe de journaux pour les journaux des applications, **/aws/containerinsights/ *cluster-name* /application**
1. Remplacez l'expression de requête de recherche par la requête suivante, puis choisissez **Exécuter la requête**
```
fields ispresent(kubernetes.pod_name) as haskubernetes_pod_name, stream, kubernetes.pod_name, log |
filter haskubernetes_pod_name and kubernetes.pod_name like /cwagent-prometheus
```
Vous pouvez également confirmer que les métriques et les métadonnées de Prometheus sont CloudWatch ingérées sous forme d'événements Logs.
**Pour vérifier que les données Prometheus sont ingérées**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le volet de navigation, sélectionnez **CloudWatch Logs Insights**.
1. Sélectionnez le fichier **/aws/containerinsights/ /prometheus *cluster-name***
1. Remplacez l'expression de requête de recherche par la requête suivante, puis choisissez **Exécuter la requête**
```
fields @timestamp, @message | sort @timestamp desc | limit 20
```
## Journalisation des métriques Prometheus ignorées
Cette version ne collecte pas les métriques Prometheus de type histogramme. Vous pouvez utiliser l' CloudWatch agent pour vérifier si des métriques Prometheus sont supprimées car il s'agit de métriques d'histogrammes. Vous pouvez également enregistrer une liste des 500 premières métriques Prometheus supprimées et non envoyées car il s'agit de métriques CloudWatch d'histogrammes.
Pour voir si des métriques sont ignorées, entrez la commande suivante :
```
kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
```
Si des métriques sont ignorées, les lignes suivantes s'affichent dans le fichier `/opt/aws/amazon-cloudwatch-agent/logs/amazon-cloudwatch-agent.log`.
```
I! Drop Prometheus metrics with unsupported types. Only Gauge, Counter and Summary are supported.
I! Please enable CWAgent debug mode to view the first 500 dropped metrics
```
Si ces lignes s'affichent et si vous souhaitez savoir quelles métriques sont ignorées, procédez comme suit.
**Pour enregistrer une liste des métriques Prometheus ignorées**
1. Passez l' CloudWatch agent en mode de débogage en ajoutant les lignes en gras suivantes à votre `prometheus-k8s.yaml` fichier `prometheus-eks.yaml` ou en enregistrant le fichier.
```
{
"agent": {
"debug": true
},
```
Cette section du fichier doit alors ressembler à ceci :
```
cwagentconfig.json: |
{
"agent": {
"debug": true
},
"logs": {
"metrics_collected": {
```
1. Réinstallez l' CloudWatch agent pour activer le mode de débogage en saisissant les commandes suivantes :
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
kubectl apply -f prometheus.yaml
```
Les métriques supprimées sont enregistrées dans le module de l' CloudWatch agent.
1. Pour récupérer les journaux depuis le module de l' CloudWatch agent, entrez la commande suivante :
```
kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
```
Ou, si la journalisation Fluentd de Container Insights est installée, les journaux sont également enregistrés dans le groupe de journaux Logs CloudWatch **/aws/containerinsights/ *cluster\$1name* /application**.
Pour interroger ces journaux, vous pouvez suivre les étapes nécessaires pour interroger les journaux d'application dans [Étapes de résolution des problèmes générales sur Amazon EKS](#ContainerInsights-Prometheus-troubleshooting-general).
## Où sont ingérées CloudWatch les métriques Prometheus lorsque Logs enregistre les événements ?
L' CloudWatch agent crée un flux de journal pour chaque configuration de tâche Prometheus Scrape. Par exemple, dans les fichiers `prometheus-eks.yaml` et `prometheus-k8s.yaml`, la ligne `job_name: 'kubernetes-pod-appmesh-envoy'` récupère les métriques App Mesh. La cible Prometheus est définie en tant que `kubernetes-pod-appmesh-envoy`. **Ainsi, toutes les métriques App Mesh Prometheus sont ingérées sous forme d'événements Logs dans le **kubernetes-pod-appmesh-envoy**flux de journaux CloudWatch sous le groupe de journaux nommé/. aws/containerinsights/cluster-name/Prometheus**
## Je ne vois pas les métriques Amazon EKS ou Kubernetes Prometheus dans les métriques CloudWatch
**Tout d'abord, assurez-vous que les métriques Prometheus sont ingérées sous forme d'événements de journal dans le groupe de journaux/. aws/containerinsights/cluster-name/Prometheus** Utilisez les informations de [Où sont ingérées CloudWatch les métriques Prometheus lorsque Logs enregistre les événements ?](#ContainerInsights-Prometheus-troubleshooting-metrics_ingested) pour vous aider à vérifier le flux de journaux cible. Si le flux de journaux n'est pas créé ou s'il n'y a pas de nouveaux événements de journaux dans le flux de journaux, vérifiez les points suivants :
+ Vérifiez que les points de terminaison de l'exportateur de métriques Prometheus sont correctement configurés
+ Vérifiez que les configurations de scraping de Prometheus dans `config map: cwagent-prometheus` la section du fichier YAML de CloudWatch l'agent sont correctes. La configuration doit être la même que dans un fichier de configuration Prometheus. Pour plus d'informations, consultez [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) dans la documentation Prometheus.
Si les métriques Prometheus sont correctement ingérées sous forme d'événements de journal, vérifiez que les paramètres de format de métrique intégrés sont ajoutés aux événements du journal pour générer les métriques. CloudWatch
```
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"envoy_http_downstream_cx_destroy_remote_active_rq"
}
],
"Dimensions":[
[
"ClusterName",
"Namespace"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
```
Pour plus d'informations sur le format de métrique intégrée, consultez [Spécifications : format de métrique intégrée](CloudWatch_Embedded_Metric_Format_Specification.md).
Si aucun format métrique n'est intégré dans le journal des événements, vérifiez que la `metric_declaration` section est correctement configurée dans la `config map: prometheus-cwagentconfig` section du fichier YAML d'installation de l' CloudWatch agent. Pour de plus amples informations, veuillez consulter [Didacticiel pour l'ajout d'une nouvelle cible de récupération Prometheus : métrique du serveur d'API Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).