Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# (Optional) Einrichten von containerisierten Beispiel-Amazon-EKS-Workloads für Prometheus-Metrik-Tests
Um die Unterstützung von Prometheus-Metriken in CloudWatch Container Insights zu testen, können Sie einen oder mehrere der folgenden containerisierten Workloads einrichten. Der CloudWatch Agent mit Prometheus-Unterstützung sammelt automatisch Metriken von jeder dieser Workloads. Informationen zum Anzeigen der Metriken, die standardmäßig erfasst werden, finden Sie unter [Vom Agenten gesammelte Prometheus-Metriken CloudWatch](ContainerInsights-Prometheus-metrics.md).
Bevor Sie einen dieser Workloads installieren können, müssen Sie Helm 3.x installieren, indem Sie die folgenden Befehle eingeben:
```
brew install helm
```
Weitere Informationen finden Sie unter [Helm](https://helm.sh).
**Topics**
+ [AWS App Mesh Beispiel-Workload für Amazon EKS und Kubernetes einrichten](ContainerInsights-Prometheus-Sample-Workloads-appmesh.md)
+ [Einrichten von NGINX mit Beispielverkehr auf Amazon EKS und Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-nginx.md)
+ [Einrichten von Memcached mit einem Metrik-Exporter auf Amazon EKS und Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-memcached.md)
+ [Java/JMX Beispiel-Workload auf Amazon EKS und Kubernetes einrichten](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md)
+ [Einrichtung HAProxy mit einem Metrik-Exporter auf Amazon EKS und Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-haproxy.md)
+ [Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Redis OSS auf Amazon-EKS- und Kubernetes-Clustern](ContainerInsights-Prometheus-Setup-redis-eks.md)
# AWS App Mesh Beispiel-Workload für Amazon EKS und Kubernetes einrichten
Prometheus Prometheus-Unterstützung in CloudWatch Container Insights unterstützt. AWS App Mesh In den folgenden Abschnitten wird erläutert, wie Sie App Mesh einrichten.
**Topics**
+ [Richten Sie einen AWS App Mesh Beispiel-Workload auf einem Amazon EKS-Cluster mit dem EC2-Starttyp oder einem Kubernetes-Cluster ein](ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS.md)
+ [Richten Sie einen AWS App Mesh Beispiel-Workload auf einem Amazon EKS-Cluster mit dem Starttyp Fargate ein](ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate.md)
# Richten Sie einen AWS App Mesh Beispiel-Workload auf einem Amazon EKS-Cluster mit dem EC2-Starttyp oder einem Kubernetes-Cluster ein
Gehen Sie wie folgt vor, wenn Sie App Mesh auf einem Cluster einrichten, auf dem Amazon EKS mit dem EC2-Starttyp, oder einem Kubernetes-Cluster ausgeführt wird.
## Konfigurieren Sie IAM-Berechtigungen
Sie müssen die **AWSAppMeshFullAccess**Richtlinie zur IAM-Rolle für Ihre Amazon EKS- oder Kubernetes-Knotengruppe hinzufügen. Auf Amazon EKS sieht dieser Knotengruppenname ähnlich wie `eksctl-integ-test-eks-prometheus-NodeInstanceRole-ABCDEFHIJKL` aus. Auf Kubernetes könnte er ähnlich wie `nodes.integ-test-kops-prometheus.k8s.local` aussehen.
## Installieren Sie App Mesh
Um den App-Mesh-Kubernetes-Controller zu installieren, befolgen Sie die Anweisungen in [App-Mesh-Controller](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller).
## Installieren einer Beispielanwendung
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)enthält mehrere Komplettlösungen für Kubernetes App Mesh. In diesem Lernprogramm installieren Sie eine Beispielfarbanwendung, die zeigt, wie HTTP-Routen Header zum Abgleichen von eingehenden Anforderungen verwenden können.
**So verwenden Sie eine App-Mesh-Beispielanwendung zum Testen von Container Insights**
1. Installieren Sie die Anwendung mithilfe der folgenden Anweisungen: [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. Starten Sie einen Curler-Pod, um Datenverkehr zu generieren:
```
kubectl -n default run -it curler --image=tutum/curl /bin/bash
```
1. Curlen Sie verschiedene Endpunkte durch Ändern von HTTP-Headern. Führen Sie den Befehl curl mehrmals aus, wie gezeigt:
```
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. Öffnen Sie die Konsole unter. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie in der AWS Region, in der Ihr Cluster ausgeführt wird, im Navigationsbereich die Option **Metrics** aus. Die Metrik befindet sich im **ContainerInsights/Prometheus-Namespace**.
1. Um die CloudWatch Logs-Ereignisse zu sehen, wählen Sie im **Navigationsbereich Protokollgruppen** aus. Die Ereignisse befinden sich in der Protokollgruppe ` /aws/containerinsights/your_cluster_name/prometheus ` im Protokollstream `kubernetes-pod-appmesh-envoy`.
## Löschen der App-Mesh-Testumgebung
Wenn Sie mit der Verwendung von App Mesh und der Beispielanwendung fertig sind, verwenden Sie die folgenden Befehle, um die nicht benötigten Ressourcen zu löschen. Löschen Sie die Beispielanwendung, indem Sie den folgenden Befehl eingeben:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-http-headers/
kubectl delete -f _output/manifest.yaml
```
Löschen Sie den App-Mesh-Controller, indem Sie den folgenden Befehl eingeben:
```
helm delete appmesh-controller -n appmesh-system
```
# Richten Sie einen AWS App Mesh Beispiel-Workload auf einem Amazon EKS-Cluster mit dem Starttyp Fargate ein
Gehen Sie wie folgt vor, wenn Sie App Mesh auf einem Cluster einrichten, auf dem Amazon EKS mit dem Fargate-Starttyp ausgeführt wird.
## Konfigurieren Sie IAM-Berechtigungen
Geben Sie den folgenden Befehl ein, um IAM-Berechtigungen einzurichten. Ersetzen Sie *MyCluster* mit dem Namen Ihres Clusters.
```
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
```
## Installieren Sie App Mesh
Um den App-Mesh-Kubernetes-Controller zu installieren, befolgen Sie die Anweisungen in [App-Mesh-Controller](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller). Befolgen Sie unbedingt die Anweisungen für Amazon EKS mit dem Fargate-Starttyp.
## Installieren einer Beispielanwendung
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)enthält mehrere Komplettlösungen für Kubernetes App Mesh. Für dieses Tutorial installieren Sie eine Beispielfarbanwendung, die für Amazon-EKS-Cluster mit dem Starttyp Fargate funktioniert.
**So verwenden Sie eine App-Mesh-Beispielanwendung zum Testen von Container Insights**
1. Installieren Sie die Anwendung mithilfe der folgenden Anweisungen: [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).
Bei diesen Anweisungen wird davon ausgegangen, dass Sie einen neuen Cluster mit dem korrekten Fargate-Profil erstellen. Wenn Sie einen Amazon-EKS-Cluster verwenden möchten, den Sie bereits eingerichtet haben, können Sie die folgenden Befehle verwenden, um diesen Cluster für diese Demonstration einzurichten. Ersetzen Sie *MyCluster* mit dem Namen Ihres Clusters.
```
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-Weiterleitung der Front-Anwendungsbereitstellung:
```
kubectl -n howto-k8s-fargate port-forward deployment/front 8080:8080
```
1. Curl der Front-App:
```
while true; do curl -s http://localhost:8080/color; sleep 0.1; echo ; done
```
1. Öffnen Sie die Konsole unter. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie in der AWS Region, in der Ihr Cluster ausgeführt wird, im Navigationsbereich die Option **Metrics** aus. Die Metrik befindet sich im **ContainerInsights/Prometheus-Namespace**.
1. Um die CloudWatch Logs-Ereignisse zu sehen, wählen Sie im **Navigationsbereich Protokollgruppen** aus. Die Ereignisse befinden sich in der Protokollgruppe ` /aws/containerinsights/your_cluster_name/prometheus ` im Protokollstream `kubernetes-pod-appmesh-envoy`.
## Löschen der App-Mesh-Testumgebung
Wenn Sie mit der Verwendung von App Mesh und der Beispielanwendung fertig sind, verwenden Sie die folgenden Befehle, um die nicht benötigten Ressourcen zu löschen. Löschen Sie die Beispielanwendung, indem Sie den folgenden Befehl eingeben:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-fargate/
kubectl delete -f _output/manifest.yaml
```
Löschen Sie den App-Mesh-Controller, indem Sie den folgenden Befehl eingeben:
```
helm delete appmesh-controller -n appmesh-system
```
# Einrichten von NGINX mit Beispielverkehr auf Amazon EKS und Kubernetes
NGINX ist ein Webserver, der auch als Load Balancer und Reverse Proxy verwendet werden kann. Weitere Informationen darüber, wie Kubernetes NGINX für Ingress nutzt, finden Sie unter [kubernetes/ingress-nginx](https://github.com/kubernetes/ingress-nginx).
**So installieren Sie Ingress-NGINX mit einem Beispiels-Datenverkehrsservice zum Testen der Unterstützung für Container Insights Prometheus**
1. Geben Sie den folgenden Befehl ein, um das Repo „Helm ingress-nginx“ hinzuzufügen.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
```
1. Geben Sie die folgenden Befehle ein.
```
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. Überprüfen Sie, ob die Services korrekt gestartet wurden, indem Sie den folgenden Befehl eingeben:
```
kubectl get service -n nginx-ingress-sample
```
Die Ausgabe dieses Befehls sollte mehrere Spalten, einschließlich einer `EXTERNAL-IP`-Spalte, anzeigen.
1. Setzen Sie eine `EXTERNAL-IP`-Variable auf den Wert der `EXTERNAL-IP`-Spalte in der Zeile des NGINX-Ingress-Controllers.
```
EXTERNAL_IP=your-nginx-controller-external-ip
```
1. Starten Sie NGINX-Beispieldatenverkehr, indem Sie den folgenden Befehl eingeben.
```
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. Geben Sie den folgenden Befehl ein, um zu bestätigen, dass sich alle drei Pods im Status `Running` befinden.
```
kubectl get pod -n $SAMPLE_TRAFFIC_NAMESPACE
```
Wenn sie ausgeführt werden, sollten Sie bald Metriken im **ContainerInsights/Prometheus-Namespace** sehen.
**So deinstallieren Sie NGINX und die Beispieldatenverkehrsanwendung:**
1. Löschen Sie den Beispielverkehrsservice, indem Sie den folgenden Befehl eingeben:
```
kubectl delete namespace $SAMPLE_TRAFFIC_NAMESPACE
```
1. Löschen Sie den NGINX-Ausgang nach dem Helm-Versionsnamen.
```
helm uninstall my-nginx --namespace nginx-ingress-sample
kubectl delete namespace nginx-ingress-sample
```
# Einrichten von Memcached mit einem Metrik-Exporter auf Amazon EKS und Kubernetes
Memcached ist ein Open-Source-Speicherobjekt-Caching-System. Weitere Informationen finden Sie unter [Was ist Memcached?](https://www.memcached.org).
Wenn Sie Memcached auf einem Cluster mit dem Starttyp Fargate ausführen, müssen Sie ein Fargate-Profil einrichten, bevor Sie die Schritte in diesem Verfahren ausführen. Geben Sie zum Einrichten des Profils den folgenden Befehl ein. Ersetzen Sie *MyCluster* mit dem Namen Ihres Clusters.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace memcached-sample --name memcached-sample
```
**So installieren Sie memcached mit einem Metrik-Exporter, um die Container Insights Prometheus-Unterstützung zu testen**
1. Geben Sie den folgenden Befehl ein, um das Repo hinzuzufügen.
```
helm repo add bitnami https://charts.bitnami.com/bitnami
```
1. Geben Sie den folgenden Befehl ein, um einen neuen Namespace zu erstellen.
```
kubectl create namespace memcached-sample
```
1. Geben Sie den folgenden Befehl ein, um Memcached zu installieren.
```
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. Geben Sie den folgenden Befehl ein, um die Anmerkung des ausgeführten Services zu prüfen:
```
kubectl describe service my-memcached-metrics -n memcached-sample
```
Sie sollten die folgenden zwei Anmerkungen sehen:
```
Annotations: prometheus.io/port: 9150
prometheus.io/scrape: true
```
**So deinstallieren Sie memcached:**
+ Geben Sie die folgenden Befehle ein.
```
helm uninstall my-memcached --namespace memcached-sample
kubectl delete namespace memcached-sample
```
# Java/JMX Beispiel-Workload auf Amazon EKS und Kubernetes einrichten
JMX Exporter ist ein offizieller Prometheus-Exporter, der JMX mBeans als Prometheus-Metriken erfassen und verfügbar machen kann. Weitere Informationen finden Sie unter [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
Container Insights kann vordefinierte Prometheus-Metriken von Java Virtual Machine (JVM), Java und Tomcat (Catalina) mithilfe des JMX Exporter erfassen.
## Standard-Prometheus-Scrape-Konfiguration
Standardmäßig scannt der CloudWatch Agent mit Prometheus-Unterstützung die Java/JMX-Prometheus-Metriken von jedem Pod in einem Amazon EKS- oder `http://CLUSTER_IP:9404/metrics` Kubernetes-Cluster. Dies geschieht durch `role: pod` Erkennung von Prometheus `kubernetes_sd_config`. 9404 ist der von Prometheus für JMX Exporter zugewiesene Standardport. Weitere Informationen zu `role: pod` Discovery finden Sie unter [pod](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#pod). Sie können den JMX Exporter so konfigurieren, dass die Metriken auf einem anderen Port oder metrics\$1path verfügbar gemacht werden. Wenn Sie den Port oder Pfad ändern, aktualisieren Sie die Standardeinstellung jmx scrape\$1config in der Agentenkonfigurationsübersicht. CloudWatch Führen Sie den folgenden Befehl aus, um die aktuelle Prometheus-Konfiguration des CloudWatch Agenten abzurufen:
```
kubectl describe cm prometheus-config -n amazon-cloudwatch
```
Die zu ändernden Felder sind die Felder `/metrics` und `regex: '.*:9404$'`, wie im folgenden Beispiel hervorgehoben.
```
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:
```
## Andere Prometheus-Scrape-Konfiguration
Wenn Sie Ihre Anwendung, die auf einer Reihe von Pods mit Java/JMX-Prometheus-Exportern von einem Kubernetes-Service ausgeführt wird, verfügbar machen, können Sie auch zur Verwendung der `role: service`-Erkennung oder `role: endpoint`-Erkennung von Prometheus `kubernetes_sd_config` wechseln. Weitere Informationen zu diesen Ermittlungsmethoden finden Sie unter [Service](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#service), [Endpunkte](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpoints) und [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config).
Diese beiden Service-Discovery-Modi bieten mehr Metalabels, die für Sie beim Erstellen der CloudWatch Metrik-Dimensionen nützlich sein könnten. Sie können beispielsweise `__meta_kubernetes_service_name` in `Service` umbenennen und in die Dimension Ihrer Metriken aufnehmen. Weitere Informationen zum Anpassen Ihrer CloudWatch Metriken und ihrer Dimensionen finden Sie unter. [CloudWatch Agentenkonfiguration für Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config)
## Docker-Image mit JMX Exporter
Richten Sie anschließend ein Docker-Image ein. In den folgenden Abschnitten finden Sie zwei Beispiel-Dockerfiles.
Wenn Sie das Image erstellt haben, laden Sie es in Amazon EKS oder Kubernetes und führen Sie dann den folgenden Befehl aus, um zu überprüfen, ob Prometheus-Metriken von `JMX_EXPORTER` auf Port 9404 verfügbar gemacht werden. *\$1JAR\$1SAMPLE\$1TRAFFIC\$1POD*Ersetzen Sie es durch den Namen des laufenden Pods und *\$1JAR\$1SAMPLE\$1TRAFFIC\$1NAMESPACE* ersetzen Sie es durch den Namespace Ihrer Anwendung.
Wenn Sie JMX Exporter auf einem Cluster mit dem Fargate-Starttyp ausführen, müssen Sie auch ein Fargate-Profil einrichten, bevor Sie die Schritte in diesem Verfahren ausführen. Geben Sie zum Einrichten des Profils den folgenden Befehl ein. Ersetzen Sie *MyCluster* mit dem Namen Ihres Clusters.
```
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
```
## Beispiel: Apache-Tomcat-Docker-Image mit Prometheus-Metriken
Der Apache Tomcat-Server stellt JMX mBeans standardmäßig zur Verfügung. Sie können JMX Exporter mit Tomcat integrieren, um JMX mBeans als Prometheus-Metriken verfügbar zu machen. Das folgende Beispiel-Dockerfile zeigt die Schritte zum Erstellen eines Test-Images:
```
# 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"]
```
In der folgenden Liste werden die vier `COPY`-Zeilen in diesem Dockerfile erläutert.
+ [Laden Sie die neueste JMX Exporter Exporter-JAR-Datei von https://github.com/prometheus/ jmx\$1exporter herunter.](https://github.com/prometheus/jmx_exporter)
+ `config.yaml` ist die JMX Exporter-Konfigurationsdatei. [Weitere Informationen finden Sie unter jmx\$1exporter \$1Configuration. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter#Configuration )
Hier ist eine Beispielkonfigurationsdatei für Java und 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` ist ein Tomcat-Startup-Skript zum Starten des JMX Exporter zusammen mit Tomcat, und um Prometheus-Metriken auf Port 9404 des lokalen Hosts verfügbar zu machen. Dazu übergibt es den `config.yaml`-Dateipfad an den JMX Exporter.
```
$ 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"
```
+ Application.war ist Ihre Webanwendungs-`war`-Datei, die Tomcat zu finden hat.
Erstellen Sie ein Docker-Image mit dieser Konfiguration und laden Sie es in ein Image-Repository hoch.
## Beispiel: Docker-Image der Java-Jar-Anwendung mit Prometheus-Metriken
Das folgende Beispiel-Dockerfile zeigt die Schritte zum Erstellen eines Test-Images:
```
# 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
```
In der folgenden Liste werden die vier `COPY`-Zeilen in diesem Dockerfile erläutert.
+ [Laden Sie die neueste JMX Exporter Exporter-JAR-Datei von https://github.com/prometheus/ jmx\$1exporter herunter.](https://github.com/prometheus/jmx_exporter)
+ `config.yaml` ist die JMX Exporter-Konfigurationsdatei. [Weitere Informationen finden Sie unter jmx\$1exporter \$1Configuration. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter#Configuration )
Hier ist eine Beispielkonfigurationsdatei für Java und 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` ist das Skript zum Starten der JAR-Anwendung mit den exportierten Prometheus-Metriken. Dazu übergibt es den `config.yaml`-Dateipfad an den JMX Exporter.
```
$ 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 ist die JAR-Beispieldatei für eine Java-Anwendung. Ersetzen Sie sie durch die Java-Anwendung, die Sie überwachen möchten.
Erstellen Sie ein Docker-Image mit dieser Konfiguration und laden Sie es in ein Image-Repository hoch.
# Einrichtung HAProxy mit einem Metrik-Exporter auf Amazon EKS und Kubernetes
HAProxy ist eine Open-Source-Proxyanwendung. Weitere Informationen finden Sie unter [HAProxy](https://www.haproxy.org).
Wenn Sie HAProxy auf einem Cluster mit dem Starttyp Fargate arbeiten, müssen Sie ein Fargate-Profil einrichten, bevor Sie die Schritte in diesem Verfahren ausführen. Geben Sie zum Einrichten des Profils den folgenden Befehl ein. Ersetzen Sie *MyCluster* mit dem Namen Ihres Clusters.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace haproxy-ingress-sample --name haproxy-ingress-sample
```
**Zur Installation HAProxy mit einem Metrik-Exporter zum Testen der Container Insights Prometheus-Unterstützung**
1. Geben Sie den folgenden Befehl ein, um den Helm-Incubator-Repo hinzuzufügen:
```
helm repo add haproxy-ingress https://haproxy-ingress.github.io/charts
```
1. Geben Sie den folgenden Befehl ein, um einen neuen Namespace zu erstellen.
```
kubectl create namespace haproxy-ingress-sample
```
1. Geben Sie zur Installation die folgenden Befehle ein: 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. Geben Sie den folgenden Befehl ein, um die Anmerkung des Services zu bestätigen:
```
kubectl describe service haproxy-haproxy-ingress-metrics -n haproxy-ingress-sample
```
Sie sollten die folgenden Anmerkungen sehen.
```
Annotations: prometheus.io/port: 9101
prometheus.io/scrape: true
```
**Um zu deinstallieren HAProxy**
+ Geben Sie die folgenden Befehle ein.
```
helm uninstall haproxy --namespace haproxy-ingress-sample
kubectl delete namespace haproxy-ingress-sample
```
# Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Redis OSS auf Amazon-EKS- und Kubernetes-Clustern
Dieses Tutorial bietet eine praktische Einführung zum Scraping der Prometheus-Metriken einer Redis-OSS-Beispielanwendung auf Amazon EKS und Kubernetes. Redis OSS (https://redis.io/) ist ein Open Source (BSD lizenziert), In-Memory-Datenstrukturspeicher, der als Datenbank, Cache und Message Broker verwendet wird. Weitere Informationen finden Sie unter [redis](https://redis.io/).
redis\$1exporter (mit MIT-Lizenz lizenziert) wird verwendet, um die Redis-OSS-Prometheus-Metriken auf dem angegebenen Port verfügbar zu machen (Standard: 0.0.0.0:9121). Weitere Informationen finden Sie unter [redis\$1exporter](https://github.com/oliver006/redis_exporter).
Die Docker-Images in den folgenden zwei Docker Hub-Repositories werden in diesem Tutorial verwendet:
+ [ redis](https://hub.docker.com/_/redis?tab=description)
+ [ redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**So installieren Sie eine Redis-OSS-Beispiel-Workload, die Prometheus-Metriken verfügbar macht**
1. Legen Sie den Namespace für die Redis-OSS-Beispiel-Workload fest.
```
REDIS_NAMESPACE=redis-sample
```
1. Wenn Sie Redis OSS auf einem Cluster mit dem Starttyp Fargate ausführen, müssen Sie ein Fargate-Profil einrichten. Geben Sie zum Einrichten des Profils den folgenden Befehl ein. Ersetzen Sie *MyCluster* mit dem Namen Ihres Clusters.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $REDIS_NAMESPACE --name $REDIS_NAMESPACE
```
1. Geben Sie den folgenden Befehl ein, um die Redis-OSS-Beispiel-Workload zu installieren.
```
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. Die Installation umfasst einen Service namens `my-redis-metrics`, der die Redis-OSS-Prometheus-Metrik auf Port 9121 verfügbar macht. Geben Sie den folgenden Befehl ein, um die Details des Services abzurufen:
```
kubectl describe service/my-redis-metrics -n $REDIS_NAMESPACE
```
Im `Annotations` Bereich der Ergebnisse sehen Sie zwei Anmerkungen, die der Prometheus-Scrape-Konfiguration des CloudWatch Agenten entsprechen, sodass er die Workloads automatisch erkennen kann:
```
prometheus.io/port: 9121
prometheus.io/scrape: true
```
Die zugehörige Prometheus-Scrape-Konfiguration finden Sie im `- job_name: kubernetes-service-endpoints`-Abschnitt von `kubernetes-eks.yaml` oder `kubernetes-k8s.yaml`.
**Um mit der Erfassung von Redis OSS Prometheus-Metriken zu beginnen in CloudWatch**
1. Laden Sie die aktuelle Version der `kubernetes-eks.yaml`- oder `kubernetes-k8s.yaml`-Datei herunter, indem Sie einen der folgenden Befehle eingeben. Geben Sie diesen Befehl für einen Amazon-EKS-Cluster mit dem EC2-Starttyp ein.
```
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
```
Geben Sie diesen Befehl für einen Amazon-EKS-Cluster mit dem Fargate-Starttyp ein.
```
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
```
Geben Sie für einen Kubernetes-Cluster, der auf einer Amazon-EC2-Instance ausgeführt wird, diesen Befehl ein.
```
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. Öffnen Sie die Datei mit einem Texteditor und suchen Sie den Abschnitt `cwagentconfig.json`. Fügen Sie den folgenden Unterabschnitt hinzu und speichern Sie die Änderungen. Stellen Sie sicher, dass die Einrückung dem vorhandenen Muster folgt.
```
{
"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$"
]
},
```
In dem von Ihnen hinzugefügten Abschnitt werden die Redis OSS-Metriken in die CloudWatch Zulassungsliste für Agenten aufgenommen. Eine Liste dieser Metriken finden Sie im folgenden Abschnitt.
1. Wenn Sie den CloudWatch Agenten mit Prometheus-Unterstützung bereits in diesem Cluster bereitgestellt haben, müssen Sie ihn löschen, indem Sie den folgenden Befehl eingeben.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. Stellen Sie den CloudWatch Agenten mit Ihrer aktualisierten Konfiguration bereit, indem Sie einen der folgenden Befehle eingeben. Ersetzen Sie ihn *MyCluster* und passen *region* Sie ihn Ihren Einstellungen an.
Geben Sie diesen Befehl für einen Amazon-EKS-Cluster mit dem EC2-Starttyp ein.
```
kubectl apply -f prometheus-eks.yaml
```
Geben Sie diesen Befehl für einen Amazon-EKS-Cluster mit dem Fargate-Starttyp ein.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Geben Sie für einen Kubernetes-Cluster folgenden Befehl ein.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
## Anzeigen Ihrer Redis-OSS-Prometheus-Metriken
Dieses Tutorial sendet die folgenden Metriken an den **ContainerInsights/Prometheus-Namespace** in. CloudWatch Sie können die CloudWatch Konsole verwenden, um die Metriken in diesem Namespace zu sehen.
| Metrikname | Dimensionen |
| --- | --- |
| `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`, db |
**Anmerkung**
Die Werte der **cmd**-Dimension können `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` oder `slowlog` sein.
Die Werte der **Db**-Dimension können `db0` oder `db15` sein.
Sie können auch ein CloudWatch Dashboard für Ihre Redis OSS Prometheus-Metriken erstellen.
**So erstellen Sie ein Dashboard für Redis-OSS-Prometheus-Metriken**
1. Erstellen Sie Umgebungsvariablen und ersetzen Sie die folgenden Werte entsprechend Ihrer Bereitstellung.
```
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. Verwenden Sie den folgenden Befehl, um das Dashboard zu erstellen.
```
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" \
```