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