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.
# 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" \
```