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.
# Installieren Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken auf Amazon EKS- und Kubernetes-Clustern
In diesem Abschnitt wird erklärt, wie Sie den CloudWatch Agenten mit Prometheus-Überwachung in einem Cluster einrichten, auf dem Amazon EKS oder Kubernetes ausgeführt wird. Danach scrapt und importiert der Agent automatisch Metriken für die folgenden Workloads, die in diesem Cluster ausgeführt werden.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
Sie können den Agenten auch so konfigurieren, dass er aus weiteren Prometheus-Workloads und -Quellen importiert.
Bevor Sie diese Schritte ausführen, um den CloudWatch Agenten für die Prometheus-Metrikerfassung zu installieren, müssen Sie einen Cluster auf Amazon EKS oder einen Kubernetes-Cluster auf einer Amazon EC2 EC2-Instance ausführen.
**Anforderungen an VPC-Sicherheitsgruppen**
Die Eingangsregeln der Sicherheitsgruppen für die Prometheus-Workloads müssen die Prometheus-Ports für den CloudWatch Agenten öffnen, damit er die Prometheus-Metriken über die private IP scrapen kann.
Die Ausgangsregeln der Sicherheitsgruppe für den CloudWatch Agenten müssen es dem CloudWatch Agenten ermöglichen, über eine private IP eine Verbindung zum Port der Prometheus-Workloads herzustellen.
**Topics**
+ [Installieren Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken auf Amazon EKS- und Kubernetes-Clustern](#ContainerInsights-Prometheus-Setup-roles)
+ [Scraping zusätzlicher Prometheus-Quellen und Importieren dieser Metriken](ContainerInsights-Prometheus-Setup-configure.md)
+ [(Optional) Einrichten von containerisierten Beispiel-Amazon-EKS-Workloads für Prometheus-Metrik-Tests](ContainerInsights-Prometheus-Sample-Workloads.md)
## Installieren Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken auf Amazon EKS- und Kubernetes-Clustern
In diesem Abschnitt wird erklärt, wie Sie den CloudWatch Agenten mit Prometheus-Überwachung in einem Cluster einrichten, auf dem Amazon EKS oder Kubernetes ausgeführt wird. Danach scrapt und importiert der Agent automatisch Metriken für die folgenden Workloads, die in diesem Cluster ausgeführt werden.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
Sie können den Agenten auch so konfigurieren, dass er aus weiteren Prometheus-Workloads und -Quellen importiert.
Bevor Sie diese Schritte ausführen, um den CloudWatch Agenten für die Prometheus-Metrikerfassung zu installieren, müssen Sie einen Cluster auf Amazon EKS oder einen Kubernetes-Cluster auf einer Amazon EC2 EC2-Instance ausführen.
**Anforderungen an VPC-Sicherheitsgruppen**
Die Eingangsregeln der Sicherheitsgruppen für die Prometheus-Workloads müssen die Prometheus-Ports für den CloudWatch Agenten öffnen, damit er die Prometheus-Metriken über die private IP scrapen kann.
Die Ausgangsregeln der Sicherheitsgruppe für den CloudWatch Agenten müssen es dem CloudWatch Agenten ermöglichen, über eine private IP eine Verbindung zum Port der Prometheus-Workloads herzustellen.
**Topics**
+ [Einrichten von IAM-Rollen](#ContainerInsights-Prometheus-Setup-roles)
+ [Installation des CloudWatch Agenten zur Erfassung von Prometheus-Metriken](#ContainerInsights-Prometheus-Setup-install-agent)
### Einrichten von IAM-Rollen
Der erste Schritt besteht darin, die erforderliche IAM-Richtlinie in dem Cluster einzurichten. Es gibt zwei Methoden:
+ Richten Sie eine IAM-Rolle für ein Servicekonto ein, die auch als *Servicerolle* bezeichnet wird. Diese Methode funktioniert sowohl für den EC2-Starttyp als auch für den Fargate-Starttyp.
+ Fügen Sie der IAM-Rolle eine IAM-Richtlinie hinzu, die für den Cluster verwendet wird. Dies funktioniert nur für den Starttyp EC2.
**Einrichten einer Servicerolle (EC2-Starttyp und Fargate-Starttyp)**
Geben Sie zum Einrichten einer Service-Rolle den folgenden Befehl ein. Ersetzen Sie es *MyCluster* durch den Namen des Clusters.
```
eksctl create iamserviceaccount \
--name cwagent-prometheus \
--namespace amazon-cloudwatch \
--cluster MyCluster \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
**Hinzufügen einer Richtlinie zur IAM-Rolle der Knotengruppe (nur EC2-Starttyp)**
**So richten Sie die IAM-Richtlinie in einer Knotengruppe für die Prometheus-Unterstützung ein:**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Instances** aus.
1. Sie müssen das Präfix des IAM-Rollennamens für den Cluster finden. Markieren Sie dazu das Kontrollkästchen neben dem Namen einer Instance, die sich im Cluster befindet, und wählen Sie **Aktionen**, **Sicherheit**, **IAM-Rolle ändern**. Kopieren Sie dann das Präfix der IAM-Rolle, z. B. `eksctl-dev303-workshop-nodegroup`.
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im Navigationsbereich **Rollen**.
1. Verwenden Sie das Suchfeld, um das Präfix zu finden, das Sie zuvor in diesem Verfahren kopiert haben, und wählen Sie diese Rolle aus.
1. Wählen Sie **Richtlinien anfügen**.
1. Verwenden Sie das Suchfeld, um zu suchen **CloudWatchAgentServerPolicy**. Aktivieren Sie das Kontrollkästchen neben **CloudWatchAgentServerPolicy**und wählen Sie **Richtlinie anhängen** aus.
### Installation des CloudWatch Agenten zur Erfassung von Prometheus-Metriken
Sie müssen den CloudWatch Agenten im Cluster installieren, um die Metriken zu sammeln. Die Installation des Agenten unterscheidet sich für Amazon-EKS-Cluster und Kubernetes-Cluster.
**Löschen Sie frühere Versionen des CloudWatch Agenten mit Prometheus-Unterstützung**
Wenn Sie bereits eine Version des CloudWatch Agenten mit Prometheus-Unterstützung in Ihrem Cluster installiert haben, müssen Sie diese Version löschen, indem Sie den folgenden Befehl eingeben. Dies ist nur für frühere Versionen des Agenten mit Prometheus-Unterstützung erforderlich. Sie müssen den CloudWatch Agenten, der Container Insights ohne Prometheus-Unterstützung aktiviert, nicht löschen.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
#### Installation des CloudWatch Agenten auf Amazon EKS-Clustern mit dem EC2-Starttyp
Gehen Sie wie folgt vor, um den CloudWatch Agenten mit Prometheus-Unterstützung auf einem Amazon EKS-Cluster zu installieren.
**Um den CloudWatch Agenten mit Prometheus-Unterstützung auf einem Amazon EKS-Cluster zu installieren**
1. Geben Sie den folgenden Befehl ein, um zu prüfen, ob der `amazon-cloudwatch`-Namespace bereits erstellt wurde:
```
kubectl get namespace
```
1. Wenn `amazon-cloudwatch` nicht in den Ergebnissen angezeigt wird, erstellen Sie ihn, indem Sie den folgenden Befehl eingeben:
```
kubectl create namespace amazon-cloudwatch
```
1. Geben Sie den folgenden Befehl ein, um den Agenten mit der Standardkonfiguration bereitzustellen und Daten an die AWS Region senden zu lassen, in der er installiert ist:
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Gehen Sie folgendermaßen vor, damit der Agent stattdessen Daten an eine andere Region sendet:
1. Laden Sie die YAML-Datei für den Agenten herunter, indem Sie den folgenden Befehl eingeben:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
1. Öffnen Sie die Datei mit einem Texteditor und suchen Sie nach dem `cwagentconfig.json`-Block der Datei.
1. Fügen Sie die markierten Zeilen hinzu und geben Sie die gewünschte Region an:
```
cwagentconfig.json: |
{
"agent": {
"region": "us-east-2"
},
"logs": { ...
```
1. Speichern Sie die Datei und stellen Sie den Agenten mithilfe der aktualisierten Datei bereit.
```
kubectl apply -f prometheus-eks.yaml
```
#### Installation des CloudWatch Agenten auf Amazon EKS-Clustern mit dem Starttyp Fargate
Gehen Sie wie folgt vor, um den CloudWatch Agenten mit Prometheus-Unterstützung auf einem Amazon EKS-Cluster mit dem Starttyp Fargate zu installieren.
**Um den CloudWatch Agenten mit Prometheus-Unterstützung auf einem Amazon EKS-Cluster mit dem Starttyp Fargate zu installieren**
1. Geben Sie den folgenden Befehl ein, um ein Fargate-Profil für den CloudWatch Agenten zu erstellen, damit er innerhalb des Clusters ausgeführt werden kann. *MyCluster*Ersetzen Sie es durch den Namen des Clusters.
```
eksctl create fargateprofile --cluster MyCluster \
--name amazon-cloudwatch \
--namespace amazon-cloudwatch
```
1. Geben Sie den folgenden Befehl ein, um den CloudWatch Agenten zu installieren. *MyCluster*Ersetzen Sie ihn durch den Namen des Clusters. Dieser Name wird im Protokollgruppennamen, in dem die vom Agenten erfassten Protokollereignisse gespeichert werden, und auch als Dimension für die vom Agenten erfassten Metriken verwendet.
*region*Ersetzen Sie es durch den Namen der Region, in die die Metriken gesendet werden sollen. Beispiel, `us-west-1`.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
#### Den CloudWatch Agenten auf einem Kubernetes-Cluster installieren
Um den CloudWatch Agenten mit Prometheus-Unterstützung auf einem Cluster zu installieren, auf dem Kubernetes ausgeführt wird, geben Sie den folgenden Befehl ein:
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
Ersetzen Sie ihn durch *MyCluster* den Namen des Clusters. Dieser Name wird im Protokollgruppennamen, in dem die vom Agenten erfassten Protokollereignisse gespeichert werden, und auch als Dimension für die vom Agenten erfassten Metriken verwendet.
*region*Ersetzen Sie es durch den Namen der AWS Region, in die die Metriken gesendet werden sollen. Beispiel, **us-west-1**.
#### Überprüfen, ob der Agent ausgeführt wird
Auf Amazon-EKS- und Kubernetes-Clustern können Sie den folgenden Befehl eingeben, um zu prüfen, ob der Agent ausgeführt wird.
```
kubectl get pod -l "app=cwagent-prometheus" -n amazon-cloudwatch
```
Wenn die Ergebnisse einen einzelnen CloudWatch Agent-Pod im `Running` Status enthalten, läuft der Agent und sammelt Prometheus-Metriken. Standardmäßig sammelt der CloudWatch Agent Metriken für App Mesh, NGINX, Memcached, Java/JMX und jede Minute. HAProxy Weitere Informationen zu diesen Metriken finden Sie unter [Vom Agenten gesammelte Prometheus-Metriken CloudWatch](ContainerInsights-Prometheus-metrics.md). Eine Anleitung, wie Sie Ihre Prometheus-Metriken einsehen können, finden Sie unter CloudWatch [Anzeigen Ihrer Prometheus-Metriken](ContainerInsights-Prometheus-viewmetrics.md)
Sie können den CloudWatch Agenten auch so konfigurieren, dass er Metriken von anderen Prometheus-Exporteuren sammelt. Weitere Informationen finden Sie unter [Scraping zusätzlicher Prometheus-Quellen und Importieren dieser Metriken](ContainerInsights-Prometheus-Setup-configure.md).
# Scraping zusätzlicher Prometheus-Quellen und Importieren dieser Metriken
Der CloudWatch Agent mit Prometheus-Überwachung benötigt zwei Konfigurationen, um die Prometheus-Metriken zu erfassen. Er folgt der standardmäßigen Prometheus-Konfiguration, wie in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) in der Prometheus-Dokumentation erläutert. Die andere ist für die Agentenkonfiguration vorgesehen. CloudWatch
Für Amazon-EKS-Cluster sind die Konfigurationen in `prometheus-eks.yaml` (für den Starttyp EC2) oder `prometheus-eks-fargate.yaml` (für den Starttyp Fargate) als zwei Konfigurationszuordnungen definiert:
+ Der `name: prometheus-config`-Abschnitt enthält die Einstellungen für Prometheus-Scraping.
+ Der `name: prometheus-cwagentconfig` Abschnitt enthält die Konfiguration für den CloudWatch Agenten. In diesem Abschnitt können Sie konfigurieren, wie die Prometheus-Metriken von erfasst werden. CloudWatch Sie geben beispielsweise an, in welche Metriken importiert werden sollen CloudWatch, und definieren deren Dimensionen.
Für Kubernetes-Cluster, die auf Amazon-EC2-Instances ausgeführt werden, sind die Konfigurationen in der `prometheus-k8s.yaml` YAML-Datei als zwei Konfigurationszuordnungen definiert:
+ Der `name: prometheus-config`-Abschnitt enthält die Einstellungen für Prometheus-Scraping.
+ Der `name: prometheus-cwagentconfig` Abschnitt enthält die Konfiguration für den CloudWatch Agenten.
Um zusätzliche Prometheus-Metrikquellen zu scrapen und diese Metriken zu importieren CloudWatch, ändern Sie sowohl die Prometheus-Scrape-Konfiguration als auch die Agentenkonfiguration und stellen dann den CloudWatch Agenten mit der aktualisierten Konfiguration erneut bereit.
**Anforderungen an VPC-Sicherheitsgruppen**
Die Eingangsregeln der Sicherheitsgruppen für die Prometheus-Workloads müssen die Prometheus-Ports für den CloudWatch Agenten öffnen, damit er die Prometheus-Metriken über die private IP scrapen kann.
Die Ausgangsregeln der Sicherheitsgruppe für den CloudWatch Agenten müssen es dem CloudWatch Agenten ermöglichen, über eine private IP eine Verbindung zum Port der Prometheus-Workloads herzustellen.
## Prometheus-Scrape-Konfiguration
Der CloudWatch Agent unterstützt die standardmäßigen Prometheus-Scrape-Konfigurationen, wie[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) in der Prometheus-Dokumentation dokumentiert. Sie können diesen Abschnitt bearbeiten, um die Konfigurationen zu aktualisieren, die sich bereits in dieser Datei befinden, und zusätzliche Prometheus-Scraping-Ziele hinzufügen. Standardmäßig enthält die Beispielkonfigurationsdatei die folgenden globalen Konfigurationszeilen:
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval** – Definiert, wie oft das Scraping von zielen durchgeführt werden soll.
+ **scrape\$1timeout** – Definiert, wie lange gewartet werden soll, bis für eine Scrape-Anforderung eine Zeitüberschreitung eintritt.
Sie können auch verschiedene Werte für diese Einstellungen auf Auftragsebene definieren, um die globalen Konfigurationen zu überschreiben.
### Prometheus-Scraping-Aufträge
Für die YAML-Dateien des CloudWatch Agenten sind bereits einige Standard-Scraping-Jobs konfiguriert. In `prometheus-eks.yaml` werden beispielsweise die Standard-Scraping-Aufträge in den `job_name`-Zeilen im Abschnitt `scrape_configs` konfiguriert. In dieser Datei kratzt der folgende Standard-`kubernetes-pod-jmx`-Abschnitt JMX-Exporter-Metriken.
```
- job_name: 'kubernetes-pod-jmx'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: labelmap
regex: __meta_kubernetes_pod_label_(.+)
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- source_labels: [__meta_kubernetes_pod_name]
action: replace
target_label: pod_name
- action: replace
source_labels:
- __meta_kubernetes_pod_container_name
target_label: container_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_name
target_label: pod_controller_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_kind
target_label: pod_controller_kind
- action: replace
source_labels:
- __meta_kubernetes_pod_phase
target_label: pod_phase
```
Jedes dieser Standardziele wird gelöscht, und die Metriken werden im eingebetteten Metrikformat CloudWatch an Protokollereignisse gesendet. Weitere Informationen finden Sie unter [Einbetten von Metriken in Protokollen](CloudWatch_Embedded_Metric_Format.md).
Protokollereignisse von Amazon EKS- und Kubernetes-Clustern werden in der Protokollgruppe **/aws/containerinsights/ /prometheus unter *cluster\$1name*** Logs gespeichert. CloudWatch Protokollereignisse von Amazon ECS-Clustern werden in der Protokollgruppe**/aws/ecs/containerinsights/*cluster\$1name*/prometheus** gespeichert.
Jeder Scraping-Auftrag ist in einem anderen Protokoll-Stream in dieser Protokollgruppe enthalten. Beispielsweise ist der Prometheus-Scraping-Auftrag `kubernetes-pod-appmesh-envoy` für App Mesh definiert. **Alle App Mesh Prometheus-Metriken von Amazon EKS- und Kubernetes-Clustern werden an den Protokollstream mit dem Namen /aws/containerinsights/ >prometheus//gesendet. *cluster\$1name* kubernetes-pod-appmesh-envoy**
Um ein neues Scraping-Ziel hinzuzufügen, fügen Sie dem Abschnitt `scrape_configs` der YAML-Datei einen neuen `job_name`-Abschnitt hinzu und starten Sie den Agenten neu. Ein Beispiel für diesen Prozess finden Sie unter [Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Prometheus-API-Server-Metriken](#ContainerInsights-Prometheus-Setup-new-exporters).
## CloudWatch Agentenkonfiguration für Prometheus
Die CloudWatch Agentenkonfigurationsdatei enthält einen `prometheus` Abschnitt `metrics_collected` für die Prometheus-Scraping-Konfiguration. Es sind folgende Konfigurationsoptionen enthalten:
+ **Clustername** – Gibt den Clusternamen an, der als Bezeichnung im Protokollereignis hinzugefügt werden soll. Dies ist ein optionales Feld. Wenn Sie es weglassen, kann der Agent den Amazon-EKS- oder Kubernetes-Clusternamen erkennen.
+ **log\$1group\$1name** – Gibt den Namen der Protokollgruppe für die Prometheus-Scrape-Metriken an. Dies ist ein optionales Feld. Wenn Sie es weglassen, wird **/aws/containerinsights/ *cluster\$1name* /prometheus** für Protokolle von Amazon EKS- und Kubernetes-Clustern CloudWatch verwendet.
+ **prometheus\$1config\$1path** – gibt den Pfad der Prometheus-Scrape-Konfigurationsdatei an. Wenn der Wert dieses Felds mit `env:` beginnt, wird der Inhalt der Prometheus-Scrape-Konfigurationsdatei aus der Umgebungsvariablen des Containers abgerufen. Ändern Sie dieses Feld nicht.
+ **ecs\$1service\$1discovery** – ist der Abschnitt zum Angeben der Konfiguration für die Amazon-ECS-Prometheus-Serviceerkennung. Weitere Informationen finden Sie unter [Ausführliche Anleitung zu Autodiscovery auf Amazon-ECS-Clustern](ContainerInsights-Prometheus-Setup-autodiscovery-ecs.md).
Der Abschnitt `ecs_service_discovery` kann die folgenden Felder enthalten:
+ `sd_frequency` ist die Häufigkeit, mit der die Prometheus-Exporteure entdeckt werden. Geben Sie eine Zahl und ein Einheitensuffix an. Zum Beispiel `1m` für einmal pro Minute oder `30s` für einmal pro 30 Sekunden. Gültige Einheitensuffixe sind `ns`, `us`, `ms`, `s`, `m` und `h`.
Dies ist ein optionales Feld. Der Standardwert ist 60 Sekunden (1 Minute).
+ `sd_target_cluster` ist der Name des Amazon-ECS-Ziel-Clusters für die automatische Erkennung. Dies ist ein optionales Feld. Der Standard ist der Name des Amazon ECS-Clusters, auf dem der CloudWatch Agent installiert ist.
+ `sd_cluster_region` ist die Region des Amazon-ECS-Ziel-Clusters. Dies ist ein optionales Feld. Die Standardeinstellung ist die Region des Amazon ECS-Clusters, in der der CloudWatch Agent installiert ist.
+ `sd_result_file` ist der Pfad der YAML-Datei für die Prometheus Zielergebnisse. Die Prometheus-Scrape-Konfiguration bezieht sich auf diese Datei.
+ `docker_label` ist ein optionaler Abschnitt, mit dem Sie die Konfiguration für die Docker-Beschriftungs-basierte Service-Discovery angeben können. Wenn Sie diesen Abschnitt auslassen, wird die Docker-Bezeichnungs-basierte Erkennung nicht verwendet. Dieser Abschnitt kann die folgenden Felder enthalten:
+ `sd_port_label` ist der Docker-Bezeichnungsname des Containers, der den Container-Port für Prometheus Metriken angibt. Der Standardwert ist `ECS_PROMETHEUS_EXPORTER_PORT`. Wenn der Container dieses Docker-Label nicht hat, überspringt der CloudWatch Agent es.
+ `sd_metrics_path_label` ist der Docker-Bezeichnungsname des Containers, der den Pfad für Prometheus Metriken angibt. Der Standardwert ist `ECS_PROMETHEUS_METRICS_PATH`. Wenn der Container nicht über diese Docker-Bezeichnung verfügt, nimmt der Agent den Standardpfad `/metrics` an.
+ `sd_job_name_label` ist der Docker-Bezeichnungsname des Containers, der den Container-Scraping-Auftrag-Namen für Prometheus angibt. Der Standardwert ist `job`. Wenn der Container dieses Docker-Label nicht hat, verwendet der CloudWatch Agent den Jobnamen in der Prometheus-Scrape-Konfiguration.
+ `task_definition_list` ist ein optionaler Abschnitt, den Sie verwenden können, um die Konfiguration der aufgabendefinitionsbasierten Serviceerkennung anzugeben. Wenn Sie diesen Abschnitt auslassen, wird die aufgabendefinitionsbasierte Erkennung nicht verwendet. Dieser Abschnitt kann die folgenden Felder enthalten:
+ `sd_task_definition_arn_pattern` ist das Muster, das verwendet wird, um die zu erkennenden Amazon-ECS-Aufgabendefinitionen anzugeben. Dies ist ein regulärer Ausdruck.
+ `sd_metrics_ports` listet den containerPort für die Prometheus-Metriken auf. Trennen Sie die ContainerPorts durch Semikolons.
+ `sd_container_name_pattern` gibt die Namen des Amazon-ECS-Aufgabencontainers an. Dies ist ein regulärer Ausdruck.
+ `sd_metrics_path` gibt den Prometheus-Metrikpfad an. Wenn Sie dies weglassen, übernimmt der Agent den Standardpfad `/metrics`
+ `sd_job_name` gibt den Namen des Prometheus -Scrape-Auftrags an. Wenn Sie dieses Feld weglassen, verwendet der CloudWatch Agent den Jobnamen in der Prometheus-Scrape-Konfiguration.
+ **metric\$1declaration** – sind Abschnitte, die das Array von Protokollen mit eingebettetem Metrikformat angeben, das generiert werden soll. Für jede Prometheus-Quelle, aus der der CloudWatch Agent standardmäßig importiert, gibt es `metric_declaration` Abschnitte. Diese Abschnitte enthalten jeweils die folgenden Felder:
+ `label_matcher` ist ein regulärer Ausdruck, der den Wert der in `source_labels` aufgelisteten Beschriftungen überprüft. Die übereinstimmenden Metriken werden für die Aufnahme in das eingebettete Metrikformat aktiviert, an das gesendet wird. CloudWatch
Wenn in `source_labels` mehrere Bezeichnungen angegeben sind, empfehlen wir, keine `^`- oder `$`-Zeichen im regulären Ausdruck für `label_matcher` zu verwenden.
+ `source_labels` gibt den Wert der Beschriftungen an, die von der `label_matcher`-Zeile überprüft werden.
+ `label_separator` gibt das Trennzeichen an, das in der Zeile ` label_matcher`verwendet werden soll, wenn mehrere `source_labels` angegeben werden. Der Standardwert ist `;`. Sie können diesen Standardwert in der Zeile `label_matcher` im folgenden Beispiel sehen.
+ `metric_selectors` ist ein regulärer Ausdruck, der die Metriken angibt, die erfasst und an CloudWatch gesendet werden sollen.
+ `dimensions` ist die Liste der Beschriftungen, die als CloudWatch-Dimensionen für jede ausgewählte Metrik verwendet werden sollen.
Sehen Sie sich das folgende `metric_declaration`-Beispiel an.
```
"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$"
]
}
]
```
In diesem Beispiel wird ein eingebetteter Metrikformatabschnitt konfiguriert, der als Protokollereignis gesendet wird, wenn die folgenden Bedingungen erfüllt sind:
+ Der Wert von `Service` enthält entweder `node-exporter` oder `kube-dns`.
+ Der Wert von `Namespace` ist `kube-system`.
+ Die Prometheus-Metrik `coredns_dns_request_type_count_total` enthält sowohl `Service`-als auch `Namespace`-Beschriftungen.
Das Protokollereignis, das gesendet wird, enthält den folgenden hervorgehobenen Abschnitt:
```
{
"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",
...
}
```
## Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Prometheus-API-Server-Metriken
Der Kubernetes API Server stellt Prometheus-Metriken standardmäßig auf Endpunkten zur Verfügung. Das offizielle Beispiel für die Kubernetes API Server-Scraping-Konfiguration ist auf [Github](https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml) verfügbar.
Das folgende Tutorial zeigt, wie Sie die folgenden Schritte ausführen, um mit dem Importieren von Kubernetes API Server-Metriken in CloudWatch zu beginnen:
+ Hinzufügen der Prometheus-Scraping-Konfiguration für Kubernetes API Server zur Agenten-YAML-Datei. CloudWatch
+ Konfiguration der Metrikdefinitionen im eingebetteten Metrikformat in der Agenten-YAML-Datei. CloudWatch
+ (Optional) Erstellen eines CloudWatch Dashboards für die Kubernetes API-Server-Metriken.
**Anmerkung**
Der Kubernetes API Server stellt Mess-, Zähler-, Histogramm- und Übersichtsmetriken zur Verfügung. In dieser Version der Prometheus-Metrikunterstützung werden nur die Metriken mit den Typen Messgerät, Zähler und Zusammenfassung CloudWatch importiert.
**Um mit der Erfassung von Kubernetes API Server Prometheus-Metriken zu beginnen in CloudWatch**
1. Laden Sie die aktuelle Version der `prometheus-eks.yaml`-, `prometheus-eks-fargate.yaml`- oder `prometheus-k8s.yaml`-Datei herunter, indem Sie einen der folgenden Befehle eingeben.
Geben Sie den folgenden 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 den folgenden 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, den folgenden 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, suchen Sie den Abschnitt `prometheus-config` und fügen Sie den folgenden Abschnitt in diesem Abschnitt hinzu. Speichern Sie dann die Änderungen:
```
# Scrape config for API servers
- job_name: 'kubernetes-apiservers'
kubernetes_sd_configs:
- role: endpoints
namespaces:
names:
- default
scheme: https
tls_config:
ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
insecure_skip_verify: true
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
relabel_configs:
- source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
action: keep
regex: kubernetes;https
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- action: replace
source_labels:
- __meta_kubernetes_service_name
target_label: Service
```
1. Während Sie die YAML-Datei noch im Texteditor geöffnet haben, suchen Sie den Abschnitt `cwagentconfig.json`. Fügen Sie den folgenden Unterabschnitt hinzu und speichern Sie die Änderungen. In diesem Abschnitt werden die API-Server-Metriken in die Zulassungsliste für Agenten aufgenommen CloudWatch . Drei Typen von API-Server-Metriken werden der Genehmigungsliste hinzugefügt:
+ etcd-Objektanzahl
+ API-Server-Registrierungscontroller-Metriken
+ API-Server-Anforderungsmetriken
```
{"source_labels": ["job", "resource"],
"label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)",
"dimensions": [["ClusterName","Service","resource"]],
"metric_selectors": [
"^etcd_object_counts$"
]
},
{"source_labels": ["job", "name"],
"label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$",
"dimensions": [["ClusterName","Service","name"]],
"metric_selectors": [
"^workqueue_depth$",
"^workqueue_adds_total$",
"^workqueue_retries_total$"
]
},
{"source_labels": ["job","code"],
"label_matcher": "^kubernetes-apiservers;2[0-9]{2}$",
"dimensions": [["ClusterName","Service","code"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
{"source_labels": ["job"],
"label_matcher": "^kubernetes-apiservers",
"dimensions": [["ClusterName","Service"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
```
1. Wenn Sie den CloudWatch Agenten mit Prometheus-Unterstützung bereits im 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. Geben Sie für einen Amazon-EKS-Cluster mit dem Starttyp EC2 Folgendes ein:
```
kubectl apply -f prometheus-eks.yaml
```
Geben Sie den folgenden Befehl für einen Amazon-EKS-Cluster mit dem Fargate-Starttyp ein. Ersetzen Sie *MyCluster* und *region* durch Werte, die Ihrer Bereitstellung entsprechen.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Geben Sie für einen Kubernetes-Cluster den folgenden Befehl ein. Ersetzen Sie *MyCluster* und *region* durch Werte, die Ihrer Bereitstellung entsprechen.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
**Sobald Sie dies getan haben, sollten Sie einen neuen Protokollstream mit dem Namen **kubernetes-apiservers in der Protokollgruppe /aws/containerinsights/** /prometheus-Protokollgruppe sehen. *cluster\$1name*** Dieser Protokoll-Stream sollte Protokollereignisse mit einer Definition des eingebetteten Metrikformats wie folgt einschließen:
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"apiserver_request_total"
}
],
"Dimensions":[
[
"ClusterName",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"ClusterName":"my-cluster-name",
"Namespace":"default",
"Service":"kubernetes",
"Timestamp":"1592267020339",
"Version":"0",
"apiserver_request_count":0,
"apiserver_request_total":0,
"code":"0",
"component":"apiserver",
"contentType":"application/json",
"instance":"192.0.2.0:443",
"job":"kubernetes-apiservers",
"prom_metric_type":"counter",
"resource":"pods",
"scope":"namespace",
"verb":"WATCH",
"version":"v1"
}
```
Sie können Ihre Metriken in der CloudWatch Konsole im **ContainerInsights/Prometheus-Namespace** anzeigen. Sie können optional auch ein CloudWatch Dashboard für Ihre Prometheus Kubernetes API Server-Metriken erstellen.
### (Optional) Erstellen eines Dashboards für die Kubernetes API-Server-Metriken.
Um Kubernetes API Server-Metriken in Ihrem Dashboard anzuzeigen, müssen Sie zuerst die Schritte in den vorherigen Abschnitten ausgeführt haben, damit mit dem Sammeln dieser Metriken in CloudWatch begonnen wird.
**So erstellen Sie ein Dashboard für Kubernetes-API-Server-Metriken**
1. Öffnen Sie die Konsole unter. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Vergewissern Sie sich, dass Sie die richtige AWS Region ausgewählt haben.
1. Wählen Sie im Navigationsbereich **Dashboards** aus.
1. Klicken Sie auf **Create Dashboard (Dashboard erstellen)**. Geben Sie einen Namen für das neue Dashboard ein und wählen Sie **Create dashboard (Dashboard erstellen)**.
1. Wählen Sie unter **Add to this dashboard (Zu diesem Dashboard hinzufügen)** die Option **Cancel (Abbrechen)**.
1. Wählen Sie **Actions (Aktionen)**, **View/edit source (Quelle anzeigen/bearbeiten)**.
1. Laden Sie die folgende JSON-Datei herunter: [Kubernetes API Dashboard-Quelle](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/kubernetes_api_server/cw_dashboard_kubernetes_api_server.json).
1. Öffnen Sie die heruntergeladene JSON-Datei mit einem Texteditor und nehmen Sie die folgenden Änderungen vor:
+ Ersetzen Sie alle `{{YOUR_CLUSTER_NAME}}`-Zeichenfolgen durch den genauen Namen Ihres Clusters. Stellen Sie sicher, dass keine Leerzeichen vor oder nach dem Text hinzugefügt werden.
+ Ersetzen Sie alle `{{YOUR_AWS_REGION}}`-Zeichenfolgen durch den Namen der Region, in der die Metriken erfasst werden. Zum Beispiel `us-west-2`. Stellen Sie sicher, dass keine Leerzeichen vor oder nach dem Text hinzugefügt werden.
1. Kopieren Sie das gesamte JSON-Blob und fügen Sie es in das Textfeld in der CloudWatch-Konsole ein. Ersetzen Sie dabei den Inhalt des Feldes.
1. Wählen Sie **Update (Aktualisieren)**, **Save dashboard (Dashboard speichern)**.
# (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" \
```