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.

# Überwachung von Container Insights Prometheus-Metriken
<a name="ContainerInsights-Prometheus"></a>

CloudWatch Die Überwachung von Container Insights für Prometheus automatisiert die Erkennung von Prometheus-Metriken aus containerisierten Systemen und Workloads. Prometheus ist ein Open-Source-Toolkit zur Überwachung und Benachrichtigung für Systeme. Weitere Informationen finden Sie unter [Was ist Prometheus?](https://prometheus.io/docs/introduction/overview/) in der Prometheus-Dokumentation.

Das Erkennen von Prometheus-Metriken wird für [Amazon Elastic Container Service](https://aws.amazon.com/ecs/), [Amazon Elastic Kubernetes Service](https://aws.amazon.com/eks/) und [Kubernetes](https://aws.amazon.com/kubernetes/)-Cluster unterstützt, die auf Amazon-EC2-Instances ausgeführt werden. Die Prometheus-Zähler-, Messinstrument- und Zusammenfassungsmetriktypen werden erfasst.

Für Amazon-ECS- und Amazon-EKS-Cluster werden sowohl die Starttypen EC2 als auch Fargate unterstützt. Container Insights erfasst automatisch Metriken aus mehreren Workloads. Sie können sie so konfigurieren, dass Metriken aus jeder Workload erfasst werden.

Sie können Prometheus als Open-Source-Methode und Open-Standard-Methode verwenden, um benutzerdefinierte Metriken in CloudWatch einzulesen. Der CloudWatch Agent mit Prometheus-Unterstützung erkennt und sammelt Prometheus-Metriken, um Leistungseinbußen und Ausfälle von Anwendungen schneller zu überwachen, Fehler zu beheben und Warnmeldungen zu geben. Dies reduziert auch die Anzahl der Tools, die zur Verbesserung der Überwachung erforderlich sind.

Die Unterstützung pay-per-use von Container Insights Prometheus umfasst Metriken und Protokolle, einschließlich der Erfassung, Speicherung und Analyse. Weitere Informationen finden Sie unter [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/).

**Vorgefertigte Dashboards für einige Workloads**

Die Container-Insights-Prometheus-Lösung enthält vorgefertigte Dashboards für die in diesem Abschnitt aufgeführten beliebten Workloads. Beispielkonfigurationen für diese Workloads finden Sie unter [(Optional) Einrichten von containerisierten Beispiel-Amazon-ECS-Workloads für Prometheus-Metrik-Tests](ContainerInsights-Prometheus-Sample-Workloads-ECS.md) und [(Optional) Einrichten von containerisierten Beispiel-Amazon-EKS-Workloads für Prometheus-Metrik-Tests](ContainerInsights-Prometheus-Sample-Workloads.md).

Sie können Container Insights auch so konfigurieren, dass Prometheus-Metriken von anderen containerisierten Services und Anwendungen erfasst werden, indem Sie die Agentkonfigurationsdatei bearbeiten.

Workloads mit vordefinierten Dashbords für Amazon-EKS-Cluster und Kubernetes-Cluster, die auf Amazon-EC2-Instances ausgeführt werden:
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy

Workloads mit vordefinierten Dashbords für Amazon-ECS-Cluster:
+ AWS App Mesh
+ Java/JMX
+ NGINX
+ NGINX Plus

# Einrichten und Konfigurieren der Prometheus-Metrikensammlung in Amazon-ECS-Clustern
<a name="ContainerInsights-Prometheus-Setup-ECS"></a>

Um Prometheus-Metriken aus Amazon ECS-Clustern zu sammeln, können Sie den CloudWatch Agenten als Collector oder die AWS Distro for Collector verwenden. OpenTelemetry [Informationen zur Verwendung von AWS Distro for OpenTelemetry Collector finden Sie unter https://aws-otel.github. io/docs/getting-started/container-insights/ecs-Prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus).

In den folgenden Abschnitten wird erklärt, wie der CloudWatch Agent als Collector zum Abrufen von Prometheus-Metriken verwendet wird. Sie installieren den CloudWatch Agenten mit Prometheus-Überwachung auf Clustern, auf denen Amazon ECS ausgeführt wird, und Sie können den Agenten optional so konfigurieren, dass er zusätzliche Ziele scannt. Diese Abschnitte enthalten auch optionale Tutorials zum Einrichten von Beispiel-Workloads zum Testen mit der Prometheus-Überwachung. 

Container Insights auf Amazon ECS unterstützt die folgenden Kombinationen von Starttyp und Netzwerkmodus für Prometheus Metriken:


| Amazon-ECS-Starttyp | Unterstützte Netzwerkmodi | 
| --- | --- | 
|  EC2 (Linux)  |  bridge, Host und awsvpc  | 
|  Fargate  |  awsvpc  | 

**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 ECS-Clustern](ContainerInsights-Prometheus-install-ECS.md)
+ [Scraping zusätzlicher Prometheus-Quellen und Importieren dieser Metriken](ContainerInsights-Prometheus-Setup-configure-ECS.md)
+ [(Optional) Einrichten von containerisierten Beispiel-Amazon-ECS-Workloads für Prometheus-Metrik-Tests](ContainerInsights-Prometheus-Sample-Workloads-ECS.md)

# Installieren Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken auf Amazon ECS-Clustern
<a name="ContainerInsights-Prometheus-install-ECS"></a>

In diesem Abschnitt wird erklärt, wie Sie den CloudWatch Agenten mit Prometheus-Überwachung in einem Cluster einrichten, auf dem Amazon ECS 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
+ Java/JMX

Sie können den Agenten auch so konfigurieren, dass er Metriken aus weiteren Prometheus-Workloads und -Quellen importiert.

## Einrichten von IAM-Rollen
<a name="ContainerInsights-Prometheus-Setup-ECS-IAM"></a>

Für die Aufgabendefinition des Agenten benötigen Sie zwei IAM-Rollen. CloudWatch Wenn Sie **CreateIAMRoles=True** im CloudFormation Stack angeben, dass Container Insights diese Rollen für Sie erstellen soll, werden die Rollen mit den richtigen Berechtigungen erstellt. Wenn Sie sie selbst erstellen oder vorhandene Rollen verwenden möchten, sind die folgenden Rollen und Berechtigungen erforderlich.
+ **CloudWatch ECS-Aufgabenrolle für Agenten** — Der CloudWatch Agent-Container verwendet diese Rolle. Sie muss die **CloudWatchAgentServerPolicy**Richtlinie und eine vom Kunden verwaltete Richtlinie enthalten, die die folgenden schreibgeschützten Berechtigungen enthält:
  + `ec2:DescribeInstances`
  + `ecs:ListTasks`
  + `ecs:ListServices`
  + `ecs:DescribeContainerInstances`
  + `ecs:DescribeServices`
  + `ecs:DescribeTasks`
  + `ecs:DescribeTaskDefinition`
+ **CloudWatch Rolle zur Ausführung von ECS-Aufgaben für Agenten** — Dies ist die Rolle, die Amazon ECS benötigt, um Ihre Container zu starten und auszuführen. Stellen Sie sicher, dass Ihrer Aufgabenausführungsrolle die **Amazon** - SSMRead OnlyAccess ECSTaskExecutionRolePolicy, **Amazon** - und **CloudWatchAgentServerPolicy**Richtlinien zugeordnet sind. Wenn Sie sensiblere Daten zur Verwendung durch Amazon ECS speichern möchten, finden Sie weitere Informationen unter [Angabe sensibler Daten](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html).

## Installieren Sie den CloudWatch Agenten mit Prometheus-Überwachung mithilfe von CloudFormation
<a name="ContainerInsights-Prometheus-Setup-ECS-CFN"></a>

Sie verwenden AWS CloudFormation , um den CloudWatch Agenten mit Prometheus-Überwachung für Amazon ECS-Cluster zu installieren. Die folgende Liste zeigt die Parameter, die Sie in der CloudFormation -Vorlage verwenden werden.
+ **ECSClusterName** — Gibt den Amazon ECS-Zielcluster an.
+ **Erstellen IAMRoles** — Geben Sie **True** an, ob neue Rollen für die Amazon ECS-Aufgabenrolle und die Amazon ECS-Aufgabenausführungsrolle erstellt werden sollen. Geben Sie **False** an, um vorhandene Rollen wiederzuverwenden.
+ **TaskRoleName**— Wenn Sie **Create** angegeben **True** habenIAMRoles, gibt dies den Namen an, der für die neue Amazon ECS-Aufgabenrolle verwendet werden soll. Wenn Sie **Create** angegeben **False** habenIAMRoles, gibt dies die bestehende Rolle an, die als Amazon ECS-Aufgabenrolle verwendet werden soll. 
+ **ExecutionRoleName**— Wenn Sie **Create** angegeben **True** habenIAMRoles, gibt dies den Namen an, der für die neue Amazon ECS-Aufgabenausführungsrolle verwendet werden soll. Wenn Sie **Create** angegeben **False** habenIAMRoles, gibt dies die bestehende Rolle an, die als Amazon ECS-Aufgabenausführungsrolle verwendet werden soll. 
+ **ECSNetworkModus** — Wenn Sie den EC2-Starttyp verwenden, geben Sie hier den Netzwerkmodus an. Es muss entweder **bridge** oder **host** sein.
+ **ECSLaunchTyp** — Geben Sie entweder **fargate** oder **EC2** an.
+ **SecurityGroupID** — Wenn der **ECSNetworkModus aktiviert** ist**awsvpc**, geben Sie hier die Sicherheitsgruppen-ID an.
+ **SubnetID** — Wenn der **ECSNetworkModus aktiviert** ist**awsvpc**, geben Sie hier die Subnetz-ID an.

### Befehlsbeispiele
<a name="ContainerInsights-Prometheus-Setup-ECS-CFNcommands"></a>

Dieser Abschnitt enthält CloudFormation Beispielbefehle zur Installation von Container Insights mit Prometheus-Überwachung in verschiedenen Szenarien.

**Erstellen Sie einen CloudFormation Stack für einen Amazon ECS-Cluster im Bridge-Netzwerkmodus**

```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=bridge
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name

curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml

aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
    --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
    --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
                 ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
                 ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
                 ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
                 ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
    --capabilities CAPABILITY_NAMED_IAM \
    --region ${AWS_DEFAULT_REGION} \
    --profile ${AWS_PROFILE}
```

** CloudFormation Stack für einen Amazon ECS-Cluster im Host-Netzwerkmodus erstellen**

```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=host
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml

aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
    --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
    --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
                 ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
                 ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
                 ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
                 ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \ 
    --capabilities CAPABILITY_NAMED_IAM \
    --region ${AWS_DEFAULT_REGION} \
    --profile ${AWS_PROFILE}
```

**Erstellen Sie einen CloudFormation Stack für einen Amazon ECS-Cluster im awsvpc-Netzwerkmodus**

```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=EC2
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name

curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml

aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
    --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
    --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
                 ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
                 ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
                 ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
                 ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
                 ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
                 ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
    --capabilities CAPABILITY_NAMED_IAM \
    --region ${AWS_DEFAULT_REGION} \
    --profile ${AWS_PROFILE}
```

**Erstellen Sie einen CloudFormation Stack für einen Fargate-Cluster im awsvpc-Netzwerkmodus**

```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=FARGATE
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name            

curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml

aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
    --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
    --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
                 ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
                 ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
                 ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
                 ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
                 ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
                 ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
    --capabilities CAPABILITY_NAMED_IAM \
    --region ${AWS_DEFAULT_REGION} \
    --profile ${AWS_PROFILE}
```

### AWS Ressourcen, die durch den Stack erstellt wurden CloudFormation
<a name="ContainerInsights-Prometheus-Setup-ECS-resources"></a>

In der folgenden Tabelle sind die AWS Ressourcen aufgeführt, die erstellt werden, wenn Sie CloudFormation Container Insights mit Prometheus-Überwachung auf einem Amazon ECS-Cluster einrichten.


| Ressourcentyp | Ressourcenname | Kommentare | 
| --- | --- | --- | 
|  AWS::SSM::Parameter  |  AmazonCloudWatch- CWAgent Config-\$1 -\$1 -\$1 *ECS\$1CLUSTER\$1NAME* *ECS\$1LAUNCH\$1TYPE* *ECS\$1NETWORK\$1MODE*  |  Dies ist der CloudWatch Agent mit dem standardmäßigen App Mesh und der Java/JMX eingebetteten metrischen Formatdefinition.  | 
|  AWS::SSM::Parameter  |  AmazonCloudWatch-PrometheusConfigName-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE*  |  Dies ist die Prometheus-Scraping-Konfiguration.  | 
|  AWS::IAM::Role  |  **\$1ECS\$1TASK\$1ROLE\$1NAME**.   |  Die Amazon-ECS-Aufgabenrolle. Dies wird nur erstellt, wenn Sie **True**für `CREATE_IAM_ROLES` angegeben haben.  | 
|  AWS::IAM::Role  |  **\$1\$1ECS\$1EXECUTION\$1ROLE\$1NAME\$1**   |  IAM-Rolle für die Amazon-ECS-Aufgabenausführung Dies wird nur erstellt, wenn Sie **True**für `CREATE_IAM_ROLES` angegeben haben.  | 
|  AWS::ECS::TaskDefinition  |  cagent-prometheus-\$1 -\$1 -\$1 *ECS\$1CLUSTER\$1NAME* *ECS\$1LAUNCH\$1TYPE* *ECS\$1NETWORK\$1MODE*   |   | 
|  AWS::ECS::Service  |  cwagent-prometheus-replica-service-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE*  |   | 

### Löschen des CloudFormation Stacks für den CloudWatch Agenten mit Prometheus-Überwachung
<a name="ContainerInsights-Prometheus-ECS-delete"></a>

Um den CloudWatch Agenten aus einem Amazon ECS-Cluster zu löschen, geben Sie diese Befehle ein.

```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export CLOUDFORMATION_STACK_NAME=your_cloudformation_stack_name

aws cloudformation delete-stack \
--stack-name ${CLOUDFORMATION_STACK_NAME} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```

# Scraping zusätzlicher Prometheus-Quellen und Importieren dieser Metriken
<a name="ContainerInsights-Prometheus-Setup-configure-ECS"></a>

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 [<scrape\$1config>](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-ECS-Cluster werden die Konfigurationen durch die Secrets in der Amazon-ECS-Aufgabendefinition in den Parameter Store von AWS Systems Manager integriert:
+ Das Secret `PROMETHEUS_CONFIG_CONTENT` ist für die Scrape-Konfiguration von Prometheus.
+ Das Geheimnis bezieht `CW_CONFIG_CONTENT` sich auf die CloudWatch Agentenkonfiguration. 

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
<a name="ContainerInsights-Prometheus-Setup-config-global"></a>

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) <scrape\$1config>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
<a name="ContainerInsights-Prometheus-Setup-config-scrape"></a>

Für die YAML-Dateien des CloudWatch Agenten sind bereits einige Standard-Scraping-Jobs konfiguriert. In den YAML-Dateien für Amazon ECS wie `cwagent-ecs-prometheus-metric-for-bridge-host.yaml` werden beispielsweise die Standard-Scraping-Aufträge im Abschnitt `ecs_service_discovery` konfiguriert.

```
"ecs_service_discovery": {
                  "sd_frequency": "1m",
                  "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
                  "docker_label": {
                  },
                  "task_definition_list": [
                    {
                      "sd_job_name": "ecs-appmesh-colors",
                      "sd_metrics_ports": "9901",
                      "sd_task_definition_arn_pattern": ".*:task-definition\/.*-ColorTeller-(white):[0-9]+",
                      "sd_metrics_path": "/stats/prometheus"
                    },
                    {
                      "sd_job_name": "ecs-appmesh-gateway",
                      "sd_metrics_ports": "9901",
                      "sd_task_definition_arn_pattern": ".*:task-definition/.*-ColorGateway:[0-9]+",
                      "sd_metrics_path": "/stats/prometheus"
                    }
                  ]
                }
```

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 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.

Um ein neues Scraping-Ziel hinzuzufügen, fügen Sie im Abschnitt `task_definition_list` unter dem Abschnitt `ecs_service_discovery` der YAML-Datei einen neuen Eintrag hinzu und starten 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-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).

## CloudWatch Agentenkonfiguration für Prometheus
<a name="ContainerInsights-Prometheus-Setup-cw-agent-config"></a>

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-ECS-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/ecs/containerinsights/*cluster\$1name*/prometheus** für Protokolle von Amazon ECS-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 Konfigurationen der Ziel-Auto-Discovery-Funktionen von Amazon ECS Prometheus. Zur Ermittlung der Prometheus-Ziele werden zwei Modi unterstützt: Ermittlung basierend auf der Docker-Bezeichnung des Containers oder Ermittlung basierend auf dem regulären ARN-Ausdruck der Amazon-ECS-Aufgabendefinition. Sie können die beiden Modi zusammen verwenden und der CloudWatch Agent dedupliziert die erkannten Ziele auf der Grundlage von: *\$1private\$1ip\$1: \$1port\$1/\$1metrics\$1path\$1*.

  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.
  + `service_name_list_for_tasks` ist ein optionaler Abschnitt, den Sie verwenden können, um die Konfiguration der auf Servicenamen basierenden Erkennung anzugeben. Wenn Sie diesen Abschnitt auslassen, wird die auf Servicenamen basierende Erkennung nicht verwendet. Dieser Abschnitt kann die folgenden Felder enthalten:
    + `sd_service_name_pattern` ist das Muster, das verwendet werden soll, um den Amazon-ECS-Service anzugeben, in dem Aufgaben erkannt werden sollen. Dies ist ein regulärer Ausdruck.
    + `sd_metrics_ports` listet den `containerPort` für die Prometheus-Metriken auf. Trennen Sie mehrere `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. Es gibt `metric_declaration`-Abschnitte für jede Prometheus-Quelle, aus der der CloudWatch -Agent standardmäßig importiert. 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 sind für die Aufnahme in das eingebettete Metrikformat aktiviert, das an 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",
   ...
}
```

# Ausführliche Anleitung zu Autodiscovery auf Amazon-ECS-Clustern
<a name="ContainerInsights-Prometheus-Setup-autodiscovery-ecs"></a>

Prometheus bietet Dutzende dynamischer Service-Discovery-Mechanismen, wie in [<scrape\$1config>](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) beschrieben. Es gibt jedoch keine integrierte Service-Erkennung für Amazon ECS. Der CloudWatch Agent fügt diesen Mechanismus hinzu.

Wenn die Amazon ECS Prometheus Service Discovery aktiviert ist, führt der CloudWatch Agent regelmäßig die folgenden API-Aufrufe an Amazon ECS- und Amazon EC2 EC2-Frontends durch, um die Metadaten der laufenden ECS-Aufgaben im ECS-Zielcluster abzurufen. 

```
EC2:DescribeInstances
ECS:ListTasks
ECS:ListServices
ECS:DescribeContainerInstances
ECS:DescribeServices
ECS:DescribeTasks
ECS:DescribeTaskDefinition
```

Die Metadaten werden vom CloudWatch Agenten verwendet, um die Prometheus-Ziele innerhalb des ECS-Clusters zu scannen. Der CloudWatch Agent unterstützt drei Modi für die Diensterkennung:
+ Container-Docker-Label-basierte Service-Erkennung
+ ECS-Aufgabendefinition, ARN basierte Service-Discovery mit regulären Ausdrücken
+ ECS-Servicename, reguläre Ausdrucks-basierte Service-Erkennung

Alle Modi können zusammen verwendet werden. CloudWatch Der Agent dedupliziert die erkannten Ziele auf der Grundlage von:. `{private_ip}:{port}/{metrics_path}`

Alle erkannten Ziele werden in eine Ergebnisdatei geschrieben, die durch das `sd_result_file` Konfigurationsfeld im CloudWatch Agentencontainer angegeben wird. Das Folgende ist eine Beispielergebnisdatei: 

```
- targets:
  - 10.6.1.95:32785
  labels:
    __metrics_path__: /metrics
    ECS_PROMETHEUS_EXPORTER_PORT: "9406"
    ECS_PROMETHEUS_JOB_NAME: demo-jar-ec2-bridge-dynamic
    ECS_PROMETHEUS_METRICS_PATH: /metrics
    InstanceType: t3.medium
    LaunchType: EC2
    SubnetId: subnet-123456789012
    TaskDefinitionFamily: demo-jar-ec2-bridge-dynamic-port
    TaskGroup: family:demo-jar-ec2-bridge-dynamic-port
    TaskRevision: "7"
    VpcId: vpc-01234567890
    container_name: demo-jar-ec2-bridge-dynamic-port
    job: demo-jar-ec2-bridge-dynamic
- targets:
  - 10.6.3.193:9404
  labels:
    __metrics_path__: /metrics
    ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_B: "9404"
    ECS_PROMETHEUS_JOB_NAME: demo-tomcat-ec2-bridge-mapped-port
    ECS_PROMETHEUS_METRICS_PATH: /metrics
    InstanceType: t3.medium
    LaunchType: EC2
    SubnetId: subnet-123456789012
    TaskDefinitionFamily: demo-tomcat-ec2-bridge-mapped-port
    TaskGroup: family:demo-jar-tomcat-bridge-mapped-port
    TaskRevision: "12"
    VpcId: vpc-01234567890
    container_name: demo-tomcat-ec2-bridge-mapped-port
    job: demo-tomcat-ec2-bridge-mapped-port
```

Sie können diese Ergebnisdatei direkt in die dateibasierte Service-Erkennung von Prometheus integrieren. Weitere Informationen zur dateibasierten Serviceerkennung von Prometheus finden Sie unter [<file\$1sd\$1config>](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config)

 Angenommen, die Ergebnisdatei wird in `/tmp/cwagent_ecs_auto_sd.yaml` geschrieben. Die folgende Prometheus-Scrape-Konfiguration verbraucht sie.

```
global:
  scrape_interval: 1m
  scrape_timeout: 10s
scrape_configs:
  - job_name: cwagent-ecs-file-sd-config
    sample_limit: 10000
    file_sd_configs:
      - files: [ "/tmp/cwagent_ecs_auto_sd.yaml" ]
```

Der CloudWatch Agent fügt außerdem die folgenden zusätzlichen Bezeichnungen für die erkannten Ziele hinzu.
+ `container_name`
+ `TaskDefinitionFamily`
+ `TaskRevision`
+ `TaskGroup`
+ `StartedBy`
+ `LaunchType`
+ `job`
+ `__metrics_path__`
+ Docker-Bezeichnungen

Wenn der Cluster den Starttyp EC2 hat, werden die folgenden drei Bezeichnungen hinzugefügt.
+ `InstanceType`
+ `VpcId`
+ `SubnetId`

**Anmerkung**  
Docker-Bezeichnungen, die nicht dem regulären Ausdruck `[a-zA-Z_][a-zA-Z0-9_]*` entsprechen, werden herausgefiltert. Dies stimmt mit den Prometheus-Konventionen überein, die unter `label_name` in der [Konfigurationsdatei](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname) in der Prometheus-Dokumentation aufgeführt sind.

## Beispiele für die ECS-Serviceerkennung
<a name="ContainerInsights-Prometheus-Setup-autodiscovery-ecs-examples"></a>

Dieser Abschnitt enthält Beispiele, die die Ermittlung von ECS-Services veranschaulichen.

**Beispiel 1**

```
"ecs_service_discovery": {
  "sd_frequency": "1m",
  "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
  "docker_label": {
  }
}
```

In diesem Beispiel wird die Docker-Bezeichnungs-basierte Service-Discovery aktiviert. Der CloudWatch Agent fragt die Metadaten der ECS-Aufgaben einmal pro Minute ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im CloudWatch Agentencontainer.

Der Standardwert von `sd_port_label` im `docker_label`-Abschnitt ist `ECS_PROMETHEUS_EXPORTER_PORT`. Wenn ein laufender Container in den ECS-Aufgaben ein `ECS_PROMETHEUS_EXPORTER_PORT` Docker-Label hat, verwendet der CloudWatch Agent seinen Wert, `container port` um alle exponierten Ports des Containers zu scannen. Bei Übereinstimmung werden der zugeordnete Host-Port plus die private IP des Containers verwendet, um das Prometheus-Exporterziel im folgenden Format zu erstellen: `private_ip:host_port`. 

Der Standardwert von `sd_metrics_path_label` im `docker_label`-Abschnitt ist `ECS_PROMETHEUS_METRICS_PATH`. Wenn der Container diese Docker-Bezeichnung hat, wird sein Wert als `__metrics_path__` verwendet. Wenn der Container diese Bezeichnung nicht hat, wird der Standardwert `/metrics` verwendet.

Der Standardwert von `sd_job_name_label` im `docker_label`-Abschnitt ist `job`. Wenn der Container über diese Docker-Bezeichnung verfügt, wird sein Wert als eine der Beschriftungen für das Ziel angehängt, um den in der Prometheus-Konfiguration angegebenen Standardauftragsnamen zu ersetzen. Der Wert dieses Docker-Labels wird als Log-Stream-Name in der CloudWatch Log-Protokollgruppe verwendet. 

**Beispiel 2**

```
"ecs_service_discovery": {
  "sd_frequency": "15s",
  "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
  "docker_label": {
    "sd_port_label": "ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A",
    "sd_job_name_label": "ECS_PROMETHEUS_JOB_NAME"  
  }
}
```

Dieses Beispiel ermöglicht die auf Docker-Labels basierende Serviceerkennung. THe CloudWatch Der Agent fragt alle 15 Sekunden die Metadaten der ECS-Aufgaben ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im Agentencontainer. CloudWatch Die Container mit einer Docker-Bezeichnung von `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` werden gescannt. Der Wert der Docker-Bezeichnung `ECS_PROMETHEUS_JOB_NAME` wird als Auftragsname verwendet.

**Beispiel 3**

```
"ecs_service_discovery": {
  "sd_frequency": "5m",
  "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
  "task_definition_list": [
    {
      "sd_job_name": "java-prometheus",
      "sd_metrics_path": "/metrics",
      "sd_metrics_ports": "9404; 9406",
      "sd_task_definition_arn_pattern": ".*:task-definition/.*javajmx.*:[0-9]+"
    },
    {
      "sd_job_name": "envoy-prometheus",
      "sd_metrics_path": "/stats/prometheus",
      "sd_container_name_pattern": "^envoy$", 
      "sd_metrics_ports": "9901",
      "sd_task_definition_arn_pattern": ".*:task-definition/.*appmesh.*:23"
    }
  ]
}
```

In diesem Beispiel wird die auf regulären Ausdrücken basierende Serviceerkennung des ECS-Aufgabendefinitions-ARN aktiviert. Der CloudWatch Agent fragt die Metadaten der ECS-Aufgaben alle fünf Minuten ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im CloudWatch Agentencontainer.

Es werden zwei reguläre ARN Expresionsabschnitte für Aufgabendefinition definiert:
+  Für den ersten Abschnitt werden die ECS-Aufgaben mit `javajmx` in ihrem ECS-Aufgabendefinitions-ARN für den Container-Port-Scan gefiltert. Wenn die Container innerhalb dieser ECS-Aufgaben den Container-Port auf 9404 oder 9406 verfügbar machen, werden der zugeordnete Host-Port zusammen mit der privaten IP-Adresse des Containers zum Erstellen der Prometheus-Exportziele verwendet. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/metrics`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus`private_ip:host_port/metrics`, die gescrapten Metriken werden an den Log-Stream unter CloudWatch Logs in der `java-prometheus` Log-Gruppe gesendet. `/aws/ecs/containerinsights/cluster_name/prometheus` 
+  Für den zweiten Abschnitt werden die ECS-Aufgaben mit `appmesh` in ihrem ECS-Aufgabendefinitions-ARN und mit `:23` von `version` für den Container-Port-Scan gefiltert. Für Container mit dem Namen `envoy` legen Sie den Container-Port auf `9901` offen. Der zugeordnete Host-Port wird zusammen mit der privaten IP des Containers verwendet, um die Prometheus-Exporterziele zu erstellen. Der Wert innerhalb dieser ECS-Aufgaben stellt den Container-Port auf 9404 oder 9406 zur Verfügung, der zugeordnete Host-Port zusammen mit der privaten IP des Containers werden verwendet, um die Prometheus-Exportziele zu erstellen. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/stats/prometheus`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus `private_ip:host_port/stats/prometheus` und sendet die gescrapten Metriken an den Log-Stream unter `envoy-prometheus` CloudWatch Logs in der Log-Gruppe. `/aws/ecs/containerinsights/cluster_name/prometheus` 

**Beispiel 4**

```
"ecs_service_discovery": {
  "sd_frequency": "5m",
  "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
  "service_name_list_for_tasks": [
    {
      "sd_job_name": "nginx-prometheus",
      "sd_metrics_path": "/metrics",
      "sd_metrics_ports": "9113",
      "sd_service_name_pattern": "^nginx-.*"
    },
    {
      "sd_job_name": "haproxy-prometheus",
      "sd_metrics_path": "/stats/metrics",
      "sd_container_name_pattern": "^haproxy$",
      "sd_metrics_ports": "8404",
      "sd_service_name_pattern": ".*haproxy-service.*"
    }
  ]
}
```

In diesem Beispiel wird die auf regulären Ausdrücken basierende Serviceerkennung für ECS-Servicenamen aktiviert. Der CloudWatch Agent fragt alle fünf Minuten die Metadaten der ECS-Services ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im Agentencontainer. CloudWatch 

Es werden zwei reguläre Expresionsabschnitte des Servicenamens definiert:
+  Im ersten Abschnitt werden die ECS-Aufgaben, die ECS-Services zugeordnet sind, deren Namen mit dem regulären Ausdruck `^nginx-.*` übereinstimmen, für den Container-Port-Scan gefiltert Wenn die Container innerhalb dieser ECS-Aufgaben den Container-Port auf 9113 verfügbar machen, werden der zugeordnete Host-Port zusammen mit der privaten IP-Adresse des Containers zum Erstellen der Prometheus-Exportziele verwendet. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/metrics`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus`private_ip:host_port/metrics`, und die gescrapten Metriken werden an den `nginx-prometheus` Protokollstream unter CloudWatch Logs in der Protokollgruppe gesendet. `/aws/ecs/containerinsights/cluster_name/prometheus` 
+  Im zweiten Abschnitt werden die ECS-Aufgaben, die ECS-Services zugeordnet sind, deren Namen mit dem regulären Ausdruck `.*haproxy-service.*` übereinstimmen, für den Container-Port-Scan gefiltert Für Container mit dem Namen `haproxy` legen Sie den Container-Port auf 8404 offen. Der zugeordnete Host-Port wird zusammen mit der privaten IP des Containers verwendet, um die Prometheus-Exporterziele zu erstellen. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/stats/metrics`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus`private_ip:host_port/stats/metrics`, und die gescrapten Metriken werden an den `haproxy-prometheus` Protokollstream unter CloudWatch Logs in der Protokollgruppe gesendet. `/aws/ecs/containerinsights/cluster_name/prometheus` 

**Beispiel 5**

```
"ecs_service_discovery": {
  "sd_frequency": "1m30s",
  "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
  "docker_label": {
    "sd_port_label": "MY_PROMETHEUS_EXPORTER_PORT_LABEL",
    "sd_metrics_path_label": "MY_PROMETHEUS_METRICS_PATH_LABEL",
    "sd_job_name_label": "MY_PROMETHEUS_METRICS_NAME_LABEL"  
  }
  "task_definition_list": [
    {
      "sd_metrics_ports": "9150",
      "sd_task_definition_arn_pattern": "*memcached.*"
    }
  ]
}
```

In diesem Beispiel werden beide ECS-Service-Ermittlungsmodi aktiviert. Der CloudWatch Agent fragt alle 90 Sekunden die Metadaten der ECS-Aufgaben ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im Agentencontainer. CloudWatch 

Für die Docker-basierte Service-Discovery-Konfiguration:
+ Die ECS-Aufgaben mit Docker-Bezeichnugn `MY_PROMETHEUS_EXPORTER_PORT_LABEL` werden für den Prometheus-Port-Scan gefiltert. Der Ziel-Prometheus-Container-Port wird durch den Wert der Bezeichnung `MY_PROMETHEUS_EXPORTER_PORT_LABEL` angegeben. 
+ Der Wert der Docker-Bezeichnung `MY_PROMETHEUS_EXPORTER_PORT_LABEL` wird für `__metrics_path__` verwendet. Wenn der Container diese Docker-Bezeichnung nicht hat, wird der Standardwert `/metrics` verwendet. 
+ Der Wert der Docker-Bezeichnung `MY_PROMETHEUS_EXPORTER_PORT_LABEL` wird als Auftragsbezeichnung verwendet. Wenn der Container nicht über diese Docker-Bezeichnung verfügt, wird der in der Prometheus-Konfiguration definierte Auftragsname verwendet.

Für die ECS-Aufgabendefinition ARN-basierte Serviceerkennungskonfiguration:
+ Die ECS-Aufgaben mit `memcached` im ARN der ECS-Aufgabendefinition werden für den Container-Port-Scan gefiltert. Der Ziel-Container-Port von Prometheus ist 9150, wie durch `sd_metrics_ports` definiert. Der Standard-Metrikpfad `/metrics`wird verwendet. Der Auftragsname, der in der Prometheus-Konfiguration definiert ist, wird verwendet.

# (Optional) Einrichten von containerisierten Beispiel-Amazon-ECS-Workloads für Prometheus-Metrik-Tests
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS"></a>

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).

**Topics**
+ [Beispiel für App-Mesh-Workload für Amazon-ECS-Cluster](ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh.md)
+ [Java/JMX Beispiel-Workload für Amazon ECS-Cluster](ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx.md)
+ [Beispiel für NGINX-Workload für Amazon ECS-Cluster](ContainerInsights-Prometheus-Setup-nginx-ecs.md)
+ [Beispiel für NGINX-Plus-Workload für Amazon-ECS-Cluster](ContainerInsights-Prometheus-Setup-nginx-plus-ecs.md)
+ [Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Memcached auf Amazon ECS](ContainerInsights-Prometheus-Setup-memcached-ecs.md)
+ [Tutorial zum Scraping von Redis-OSS-Prometheus-Metriken auf Amazon ECS Fargate](ContainerInsights-Prometheus-Setup-redis-ecs.md)

# Beispiel für App-Mesh-Workload für Amazon-ECS-Cluster
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh"></a>

Um Metriken aus einem Prometheus-Beispiel-Workload für Amazon ECS zu erfassen, müssen Sie Container Insights im Cluster ausführen. Informationen zur Installation von Container Insights finden Sie unter [Einrichten von Container Insights für Amazon ECS](deploy-container-insights-ECS.md).

Befolgen Sie zunächst dieses [Walkthrough](https://github.com/aws/aws-app-mesh-examples/tree/main/examples/apps/colorapp#app-mesh-walkthrough-deploy-the-color-app-on-ecs), um die Beispielfarb-App auf Ihrem Amazon-ECS-Cluster bereitzustellen. Nachdem Sie fertig sind, werden App Mesh Prometheus-Metriken auf Port 9901 verfügbar gemacht.

Gehen Sie anschließend wie folgt vor, um den CloudWatch Agenten mit Prometheus-Überwachung auf demselben Amazon ECS-Cluster zu installieren, auf dem Sie die Farb-App installiert haben. Mit den Schritten in diesem Abschnitt wird der CloudWatch Agent im Bridge-Netzwerkmodus installiert. 

Die Umgebungsvariablen `ENVIRONMENT_NAME`, `AWS_PROFILE` und `AWS_DEFAULT_REGION`, die Sie im Walkthrough festgelegt haben, werden auch in den folgenden Schritten verwendet.

**Um den CloudWatch Agenten mit Prometheus-Überwachung zu Testzwecken zu installieren**

1. Laden Sie die CloudFormation Vorlage herunter, indem Sie den folgenden Befehl eingeben.

   ```
   curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
   ```

1. Legen Sie den Netzwerkmodus fest, indem Sie die folgenden Befehle eingeben.

   ```
   export ECS_CLUSTER_NAME=${ENVIRONMENT_NAME}
   export ECS_NETWORK_MODE=bridge
   ```

1. Erstellen Sie den CloudFormation Stack, indem Sie die folgenden Befehle eingeben.

   ```
   aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
       --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
                    ParameterKey=CreateIAMRoles,ParameterValue=True \
                    ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
                    ParameterKey=TaskRoleName,ParameterValue=CWAgent-Prometheus-TaskRole-${ECS_CLUSTER_NAME} \
                    ParameterKey=ExecutionRoleName,ParameterValue=CWAgent-Prometheus-ExecutionRole-${ECS_CLUSTER_NAME} \
       --capabilities CAPABILITY_NAMED_IAM \
       --region ${AWS_DEFAULT_REGION} \
       --profile ${AWS_PROFILE}
   ```

1. (Optional) Wenn der CloudFormation Stapel erstellt wird, wird eine `CREATE_COMPLETE` Meldung angezeigt. Wenn Sie den Status überprüfen möchten, bevor Sie diese Meldung sehen, geben Sie den folgenden Befehl ein.

   ```
   aws cloudformation describe-stacks \
   --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
   --query 'Stacks[0].StackStatus' \
   --region ${AWS_DEFAULT_REGION} \
   --profile ${AWS_PROFILE}
   ```

**Fehlersuche**

Die Schritte im Walkthrough verwenden jq, um das Ausgabeergebnis des AWS CLI zu analysieren. Weitere Informationen zum Installieren von jq finden Sie unter [ jq](https://stedolan.github.io/jq/). Verwenden Sie den folgenden Befehl, um das Standardausgabeformat Ihres AWS CLI auf JSON festzulegen, damit jq es richtig analysieren kann. 

```
$ aws configure
```

Wenn die Antwort auf `Default output format` kommt, geben Sie den Wert **json** ein.

## Deinstallieren Sie den CloudWatch Agenten mit Prometheus-Überwachung
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh-uninstall"></a>

Wenn Sie mit dem Testen fertig sind, geben Sie den folgenden Befehl ein, um den CloudWatch Agenten zu deinstallieren, indem Sie den CloudFormation Stack löschen.

```
aws cloudformation delete-stack \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```

# Java/JMX Beispiel-Workload für Amazon ECS-Cluster
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx"></a>

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).

Der CloudWatch Agent mit Prometheus-Unterstützung scannt die Java/JMX Prometheus-Metriken auf der Grundlage der Service Discovery-Konfiguration im Amazon ECS-Cluster. 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 den `ecs_service_discovery` Standardabschnitt in der Agentenkonfiguration. CloudWatch 

Um Metriken aus einem Prometheus-Beispiel-Workload für Amazon ECS zu erfassen, müssen Sie Container Insights im Cluster ausführen. Informationen zur Installation von Container Insights finden Sie unter [Einrichten von Container Insights für Amazon ECS](deploy-container-insights-ECS.md).

**So installieren Sie den Java/JMX Beispiel-Workload für Amazon ECS-Cluster**

1. Führen Sie die Schritte in diesen Abschnitten aus, um Ihre Docker-Images zu erstellen.
   + [Beispiel: Docker-Image der Java-Jar-Anwendung mit Prometheus-Metriken](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-jar)
   + [Beispiel: Apache-Tomcat-Docker-Image mit Prometheus-Metriken](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-tomcat)

1. Geben Sie die folgenden zwei Docker-Bezeichnungen in der Amazon-ECS-Aufgabendefinitionsdatei an. Anschließend können Sie die Aufgabendefinition als Amazon-ECS-Service oder Amazon-ECS-Aufgabe im Cluster ausführen.
   + Legen Sie `ECS_PROMETHEUS_EXPORTER_PORT` so fest, dass es auf den ContainerPort zeigt, in dem die Prometheus-Metriken verfügbar gemacht werden.
   + Setzen Sie `Java_EMF_Metrics` auf `true`. Der CloudWatch Agent verwendet dieses Flag, um das eingebettete metrische Format im Protokollereignis zu generieren.

   Im Folgenden wird ein Beispiel gezeigt:

   ```
   {
     "family": "workload-java-ec2-bridge",
     "taskRoleArn": "{{task-role-arn}}",
     "executionRoleArn": "{{execution-role-arn}}",
     "networkMode": "bridge",
     "containerDefinitions": [
       {
         "name": "tomcat-prometheus-workload-java-ec2-bridge-dynamic-port",
         "image": "your_docker_image_tag_for_tomcat_with_prometheus_metrics",
         "portMappings": [
           {
             "hostPort": 0,
             "protocol": "tcp",
             "containerPort": 9404
           }
         ],
         "dockerLabels": {
           "ECS_PROMETHEUS_EXPORTER_PORT": "9404",
           "Java_EMF_Metrics": "true"
         }
       }
     ],
     "requiresCompatibilities": [
       "EC2"  ],
     "cpu": "256",
     "memory": "512"
     }
   ```

Die Standardeinstellung des CloudWatch Agenten in der CloudFormation Vorlage ermöglicht sowohl die auf Docker-Labels basierende Diensterkennung als auch die ARN-basierte Diensterkennung mit Aufgabendefinitionen. [Diese Standardeinstellungen finden Sie in Zeile 65 der YAML-Konfigurationsdatei für den CloudWatch Agenten.](https://github.com/aws-samples/amazon-cloudwatch-container-insights/blob/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml#L65) Die Container mit der `ECS_PROMETHEUS_EXPORTER_PORT`-Bezeichnung werden basierend auf dem angegebenen Container-Port für das Prometheus-Scraping automatisch erkannt. 

Die Standardeinstellung des CloudWatch Agenten hat auch die `metric_declaration` Einstellung für Java/JMX in Zeile 112 derselben Datei. Alle Docker-Labels der Zielcontainer werden als zusätzliche Labels zu den Prometheus-Metriken hinzugefügt und an Logs gesendet. CloudWatch Für die Java/JMX Container mit Docker-Label `Java_EMF_Metrics=“true”` wird das eingebettete metrische Format generiert. 

# Beispiel für NGINX-Workload für Amazon ECS-Cluster
<a name="ContainerInsights-Prometheus-Setup-nginx-ecs"></a>

Der NGINX Prometheus Exporter kann NGINX-Daten als Prometheus-Metriken scrapen und verfügbar machen. In diesem Beispiel wird der Exporter zusammen mit dem NGINX-Reverse-Proxy-Service für Amazon ECS verwendet.

Weitere Informationen zum NGINX Prometheus Exporter finden Sie auf Github. [ nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) Weitere Informationen zum NGINX-Reverse-Proxy finden Sie auf Github. [ ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)

Der CloudWatch Agent mit Prometheus-Unterstützung scannt die NGINX Prometheus-Metriken auf der Grundlage der Service Discovery-Konfiguration im Amazon ECS-Cluster. Sie können den NGINX Prometheus 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 den Abschnitt in der `ecs_service_discovery` Agenten-Konfigurationsdatei. CloudWatch 

## Installieren Sie den NGINX-Reverse-Proxy-Beispiel-Workload für Amazon ECS-Cluster
<a name="ContainerInsights-Prometheus-nginx-ecs-setup"></a>

Zum Installieren des NGINX-Reverse-Proxy-Beispiel-Workloads führen Sie die folgenden Schritte aus.

### Erstellen der Docker-Images
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-docker"></a>

**So erstellen Sie die Docker-Images für die NGINX-Reverse-Proxy-Beispiel-Workload**

1. [Laden Sie den folgenden Ordner aus dem NGINX-Reverse-Proxy-Repo herunter: https://github.com/awslabs/ecs-nginx-reverse-proxy/-proxy/. tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)

1. Suchen Sie das `app`-Verzeichnis und erstellen Sie ein Image aus diesem Verzeichnis:

   ```
   docker build -t web-server-app ./path-to-app-directory
   ```

1. Erstellen Sie ein benutzerdefiniertes Image für NGINX. Erstellen Sie zunächst ein Verzeichnis mit den folgenden zwei Dateien:
   + Eine Beispieldatei für Dockerdatei:

     ```
     FROM nginx
     COPY nginx.conf /etc/nginx/nginx.conf
     ```
   + [Eine `nginx.conf` Datei, geändert von/-proxy/: https://github.com/awslabs/ ecs-nginx-reverse-proxy tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)

     ```
     events {
       worker_connections 768;
     }
     
     http {
       # Nginx will handle gzip compression of responses from the app server
       gzip on;
       gzip_proxied any;
       gzip_types text/plain application/json;
       gzip_min_length 1000;
     
       server{
         listen 8080;
         location /stub_status {
             stub_status   on;
         }
       }
     
       server {
         listen 80;
     
         # Nginx will reject anything not matching /api
         location /api {
           # Reject requests with unsupported HTTP method
           if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
             return 405;
           }
     
           # Only requests matching the whitelist expectations will
           # get sent to the application server
           proxy_pass http://app:3000;
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection 'upgrade';
           proxy_set_header Host $host;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_cache_bypass $http_upgrade;
         }
       }
     }
     ```
**Anmerkung**  
`stub_status` muss auf demselben Port aktiviert sein, für den `nginx-prometheus-exporter` konfiguriert ist, um Metriken zu scrapen. In unserer Beispielaufgabendefinition ist `nginx-prometheus-exporter` so konfiguriert, dass Metriken von Port 8080 gescrapet werden.

1. Erstellen Sie ein Image aus Dateien in Ihrem neuen Verzeichnis:

   ```
   docker build -t nginx-reverse-proxy ./path-to-your-directory
   ```

1. Laden Sie Ihre neuen Images zur späteren Verwendung in ein Bild-Repository hoch.

### Erstellen Sie die Aufgabendefinition zum Ausführen von NGINX und der Webserver-App in Amazon ECS
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-task"></a>

Als Nächstes richten Sie die Aufgabendefinition ein.

Diese Aufgabendefinition ermöglicht das Sammeln und Exportieren von NGINX-Prometheus-Metriken. Der NGINX-Container verfolgt die Eingaben von der App und stellt diese Daten an Port 8080 bereit, wie in `nginx.conf` festgelegt. Der NGINX-Prometheus-Exporter-Container scannt diese Metriken und sendet sie zur Verwendung in Port 9113. CloudWatch

**So richten Sie die Aufgabendefinition für die NGINX-Beispiel-Amazon ECS-Workload ein**

1. Erstellen Sie eine Aufgabendefinitions-JSON-Datei mit dem folgenden Inhalt. *your-customized-nginx-iamge*Ersetzen Sie sie durch die Bild-URI für Ihr benutzerdefiniertes NGINX-Image und durch die Bild-URI für Ihr *your-web-server-app-image* Webserver-App-Image.

   ```
   {
     "containerDefinitions": [
       {
         "name": "nginx",
         "image": "your-customized-nginx-image",
         "memory": 256,
         "cpu": 256,
         "essential": true,
         "portMappings": [
           {
             "containerPort": 80,
             "protocol": "tcp"
           }
         ],
         "links": [
           "app"
         ]
       },
       {
         "name": "app",
         "image": "your-web-server-app-image",
         "memory": 256,
         "cpu": 256,
         "essential": true
       },
       {
         "name": "nginx-prometheus-exporter",
         "image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
         "memory": 256,
         "cpu": 256,
         "essential": true,
         "command": [
           "-nginx.scrape-uri",
           "http://nginx:8080/stub_status"
       ],
       "links":[
         "nginx"
       ],
         "portMappings":[
           {
             "containerPort": 9113,
             "protocol": "tcp"
           }
         ]
       }
     ],
     "networkMode": "bridge",
     "placementConstraints": [],
     "family": "nginx-sample-stack"
   }
   ```

1. Registrieren Sie die Aufgabendefinition, indem Sie den folgenden Befehl eingeben.

   ```
   aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
   ```

1. Erstellen Sie einen Service zum Ausführen der Aufgabe, indem Sie den folgenden Befehl eingeben:

   Stellen Sie sicher, dass Sie den Servicenamen nicht ändern. Wir werden einen CloudWatch Agentendienst mit einer Konfiguration ausführen, die anhand der Namensmuster der Dienste, die sie gestartet haben, nach Aufgaben sucht. Damit der CloudWatch Agent beispielsweise die mit diesem Befehl gestartete Aufgabe finden kann, können Sie den Wert `sd_service_name_pattern` to be angeben`^nginx-service$`. Im nächsten Abschnitt finden Sie weitere Details.

   ```
   aws ecs create-service \
    --cluster your-cluster-name \
    --service-name nginx-service \
    --task-definition nginx-sample-stack:1 \
    --desired-count 1
   ```

### Konfigurieren Sie den CloudWatch Agenten für das Scrapen von NGINX Prometheus-Metriken
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-agent"></a>

Der letzte Schritt besteht darin, den CloudWatch Agenten so zu konfigurieren, dass er die NGINX-Metriken scannt. In diesem Beispiel erkennt der CloudWatch Agent die Aufgabe anhand des Dienstnamenmusters und des Ports 9113, wo der Exporter die Prometheus-Metriken für NGINX verfügbar macht. Sobald die Aufgabe erkannt wurde und die Metriken verfügbar sind, beginnt der CloudWatch Agent, die gesammelten Metriken im Log-Stream zu posten. **nginx-prometheus-exporter** 

**Um den CloudWatch Agenten so zu konfigurieren, dass er die NGINX-Metriken scannt**

1. Laden Sie die neueste Version der erforderlichen YAML-Datei herunter, indem Sie den folgenden Befehl eingeben.

   ```
   curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
   ```

1. Öffnen Sie die Datei mit einem Texteditor und finden Sie die vollständige CloudWatch Agentenkonfiguration im Schlüssel im `value` Abschnitt. `resource:CWAgentConfigSSMParameter` Fügen Sie dann im `ecs_service_discovery`-Abschnitt den folgenden `service_name_list_for_tasks`-Abschnitt hinzu.

   ```
   "service_name_list_for_tasks": [
     {
       "sd_job_name": "nginx-prometheus-exporter",
       "sd_metrics_path": "/metrics",
       "sd_metrics_ports": "9113",
       "sd_service_name_pattern": "^nginx-service$"
      }
   ],
   ```

1. Fügen Sie in derselben Datei den folgenden Abschnitt im Abschnitt `metric_declaration` hinzu, um NGINX-Metriken zuzulassen. Beachten Sie unbedingt das vorhandene Einrückungsmuster.

   ```
   {
     "source_labels": ["job"],
     "label_matcher": ".*nginx.*",
     "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
     "metric_selectors": [
       "^nginx_.*$"
     ]
   },
   ```

1. Wenn Sie den CloudWatch Agenten noch nicht in diesem Cluster bereitgestellt haben, fahren Sie mit Schritt 8 fort.

   Wenn Sie den CloudWatch Agenten bereits mithilfe von im Amazon ECS-Cluster bereitgestellt haben AWS CloudFormation, können Sie einen Änderungssatz erstellen, indem Sie die folgenden Befehle eingeben:

   ```
   ECS_CLUSTER_NAME=your_cluster_name
   AWS_REGION=your_aws_region
   ECS_NETWORK_MODE=bridge
   CREATE_IAM_ROLES=True
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
       --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_REGION \
       --change-set-name nginx-scraping-support
   ```

1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Überprüfen Sie das neu erstellte Changeset. **nginx-scraping-support** Sie sollten sehen, dass eine Änderung an der **CWAgentSSMParameterConfig-Ressource** vorgenommen wurde. Führen Sie das Changeset aus und starten Sie die CloudWatch Agententask neu, indem Sie den folgenden Befehl eingeben:

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 0 \
   --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
   --region $AWS_REGION
   ```

1. Warten Sie etwa 10 Sekunden und geben Sie den folgenden Befehl ein.

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 1 \
   --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
   --region $AWS_REGION
   ```

1. Wenn Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken zum ersten Mal auf dem Cluster installieren, geben Sie die folgenden Befehle ein.

   ```
   ECS_CLUSTER_NAME=your_cluster_name
   AWS_REGION=your_aws_region
   ECS_NETWORK_MODE=bridge
   CREATE_IAM_ROLES=True
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
       --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_REGION
   ```

## Anzeigen Ihrer NGINX-Metriken und Protokolle
<a name="ContainerInsights-Prometheus-Setup-nginx-view"></a>

Sie können jetzt die gesammelten NGINX-Metriken anzeigen.

**So zeigen Sie die Metriken für Ihren NGINX-Beispiel-Workload an**

1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie in der Region, in der Ihr Cluster ausgeführt wird, im linken Navigationsbereich **Metriken** aus. Suchen Sie den **ContainerInsights/Prometheus-Namespace**, um die Metriken zu sehen.

1. Um die CloudWatch Logs-Ereignisse zu sehen, wählen Sie im **Navigationsbereich Protokollgruppen** aus. Die Ereignisse befinden sich in der Protokollgruppe ***your\$1cluster\$1name*/aws/containerinsights/** /prometheus im Protokollstream. *nginx-prometheus-exporter*

# Beispiel für NGINX-Plus-Workload für Amazon-ECS-Cluster
<a name="ContainerInsights-Prometheus-Setup-nginx-plus-ecs"></a>

NGINX Plus ist die kommerzielle Version von NGINX. Sie müssen über eine Lizenz verfügen, um sie zu verwenden. Weitere Informationen finden Sie unter [NGINX Plus](https://www.nginx.com/products/nginx/).

Der NGINX Prometheus Exporter kann NGINX-Daten als Prometheus-Metriken scrapen und verfügbar machen. In diesem Beispiel wird der Exporter zusammen mit dem NGINX-Plus-Reverse-Proxy-Service für Amazon ECS verwendet.

Weitere Informationen zum NGINX Prometheus Exporter finden Sie auf Github. [ nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) Weitere Informationen zum NGINX-Reverse-Proxy finden Sie auf Github. [ ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)

Der CloudWatch Agent mit Prometheus-Unterstützung scannt die NGINX Plus Prometheus-Metriken auf der Grundlage der Service Discovery-Konfiguration im Amazon ECS-Cluster. Sie können den NGINX Prometheus 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 den Abschnitt in der `ecs_service_discovery` Agenten-Konfigurationsdatei. CloudWatch 

## Installieren Sie den NGINX-Plus-Reverse-Proxy-Beispiel-Workload für Amazon-ECS-Cluster
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup"></a>

Zum Installieren des NGINX-Reverse-Proxy-Beispiel-Workloads führen Sie die folgenden Schritte aus.

### Erstellen der Docker-Images
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup-docker"></a>

**So erstellen Sie die Docker-Images für die NGINX-Plus-Reverse-Proxy-Beispiel-Workload**

1. [Laden Sie den folgenden Ordner aus dem NGINX-Reverse-Proxy-Repo herunter: https://github.com/awslabs/ecs-nginx-reverse-proxy/-proxy/. tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)

1. Suchen Sie das `app`-Verzeichnis und erstellen Sie ein Image aus diesem Verzeichnis:

   ```
   docker build -t web-server-app ./path-to-app-directory
   ```

1. Erstellen Sie ein benutzerdefiniertes Image für NGINX Plus. Bevor Sie das Image für NGINX Plus erstellen können, benötigen Sie den Schlüssel mit dem Namen `nginx-repo.key` und das SSL-Zertifikat `nginx-repo.crt` für Ihr lizenziertes NGINX Plus. Erstellen Sie ein Verzeichnis und speichern Sie darin Ihre `nginx-repo.key`- und `nginx-repo.crt`-Dateien. 

   Erstellen Sie in dem Verzeichnis, das Sie gerade erstellt haben, die folgenden zwei Dateien:
   + Ein Beispiel-Dockerfile mit dem folgenden Inhalt. Diese Docker-Datei wurde aus einer Beispieldatei übernommen, die unter [https://docs.nginx.com/nginx/admin- guide/installing-nginx/installing -nginx-docker/](https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/#docker_plus_image) \$1docker\$1plus\$1image bereitgestellt wird. Die wichtige Änderung, die wir vornehmen, ist, dass wir eine separate Datei namens `nginx.conf` laden, die im nächsten Schritt erstellt wird.

     ```
     FROM debian:buster-slim
     
     LABEL maintainer="NGINX Docker Maintainers <docker-maint@nginx.com>“
     
     # Define NGINX versions for NGINX Plus and NGINX Plus modules
     # Uncomment this block and the versioned nginxPackages block in the main RUN
     # instruction to install a specific release
     # ENV NGINX_VERSION 21
     # ENV NJS_VERSION 0.3.9
     # ENV PKG_RELEASE 1~buster
     
     # Download certificate and key from the customer portal (https://cs.nginx.com (https://cs.nginx.com/))
     # and copy to the build context
     COPY nginx-repo.crt /etc/ssl/nginx/
     COPY nginx-repo.key /etc/ssl/nginx/
     # COPY nginx.conf /etc/ssl/nginx/nginx.conf
     
     RUN set -x \
     # Create nginx user/group first, to be consistent throughout Docker variants
     && addgroup --system --gid 101 nginx \
     && adduser --system --disabled-login --ingroup nginx --no-create-home --home /nonexistent --gecos "nginx user" --shell /bin/false --uid 101 nginx \
     && apt-get update \
     && apt-get install --no-install-recommends --no-install-suggests -y ca-certificates gnupg1 \
     && \
     NGINX_GPGKEY=573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62; \
     found=''; \
     for server in \
     ha.pool.sks-keyservers.net (http://ha.pool.sks-keyservers.net/) \
     hkp://keyserver.ubuntu.com:80 \
     hkp://p80.pool.sks-keyservers.net:80 \
     pgp.mit.edu (http://pgp.mit.edu/) \
     ; do \
     echo "Fetching GPG key $NGINX_GPGKEY from $server"; \
     apt-key adv --keyserver "$server" --keyserver-options timeout=10 --recv-keys "$NGINX_GPGKEY" && found=yes && break; \
     done; \
     test -z "$found" && echo >&2 "error: failed to fetch GPG key $NGINX_GPGKEY" && exit 1; \
     apt-get remove --purge --auto-remove -y gnupg1 && rm -rf /var/lib/apt/lists/* \
     # Install the latest release of NGINX Plus and/or NGINX Plus modules
     # Uncomment individual modules if necessary
     # Use versioned packages over defaults to specify a release
     && nginxPackages=" \
     nginx-plus \
     # nginx-plus=${NGINX_VERSION}-${PKG_RELEASE} \
     # nginx-plus-module-xslt \
     # nginx-plus-module-xslt=${NGINX_VERSION}-${PKG_RELEASE} \
     # nginx-plus-module-geoip \
     # nginx-plus-module-geoip=${NGINX_VERSION}-${PKG_RELEASE} \
     # nginx-plus-module-image-filter \
     # nginx-plus-module-image-filter=${NGINX_VERSION}-${PKG_RELEASE} \
     # nginx-plus-module-perl \
     # nginx-plus-module-perl=${NGINX_VERSION}-${PKG_RELEASE} \
     # nginx-plus-module-njs \
     # nginx-plus-module-njs=${NGINX_VERSION}+${NJS_VERSION}-${PKG_RELEASE} \
     " \
     && echo "Acquire::https::plus-pkgs.nginx.com::Verify-Peer \"true\";" >> /etc/apt/apt.conf.d/90nginx \
     && echo "Acquire::https::plus-pkgs.nginx.com::Verify-Host \"true\";" >> /etc/apt/apt.conf.d/90nginx \
     && echo "Acquire::https::plus-pkgs.nginx.com::SslCert \"/etc/ssl/nginx/nginx-repo.crt\";" >> /etc/apt/apt.conf.d/90nginx \
     && echo "Acquire::https::plus-pkgs.nginx.com::SslKey \"/etc/ssl/nginx/nginx-repo.key\";" >> /etc/apt/apt.conf.d/90nginx \
     && printf "deb https://plus-pkgs.nginx.com/debian buster nginx-plus\n" > /etc/apt/sources.list.d/nginx-plus.list \
     && apt-get update \
     && apt-get install --no-install-recommends --no-install-suggests -y \
     $nginxPackages \
     gettext-base \
     curl \
     && apt-get remove --purge --auto-remove -y && rm -rf /var/lib/apt/lists/* /etc/apt/sources.list.d/nginx-plus.list \
     && rm -rf /etc/apt/apt.conf.d/90nginx /etc/ssl/nginx
     
     # Forward request logs to Docker log collector
     RUN ln -sf /dev/stdout /var/log/nginx/access.log \
     && ln -sf /dev/stderr /var/log/nginx/error.log
     
     COPY nginx.conf /etc/nginx/nginx.conf
     
     EXPOSE 80
     
     STOPSIGNAL SIGTERM
     
     CMD ["nginx", "-g", "daemon off;"]
     ```
   + [Eine Datei, geändert von/. `nginx.conf` https://github.com/awslabs/ ecs-nginx-reverse-proxy tree/master/reverse-proxy/nginx](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx)

     ```
     events {
       worker_connections 768;
     }
     
     http {
       # Nginx will handle gzip compression of responses from the app server
       gzip on;
       gzip_proxied any;
       gzip_types text/plain application/json;
       gzip_min_length 1000;
     
       upstream backend {
         zone name 10m;
         server app:3000    weight=2;
         server app2:3000    weight=1;
       }
     
       server{
         listen 8080;
         location /api {
           api write=on;
         }
       }
     
       match server_ok {
         status 100-599;
       }
     
       server {
         listen 80;
         status_zone zone;
         # Nginx will reject anything not matching /api
         location /api {
           # Reject requests with unsupported HTTP method
           if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
             return 405;
           }
     
           # Only requests matching the whitelist expectations will
           # get sent to the application server
           proxy_pass http://backend;
           health_check uri=/lorem-ipsum match=server_ok;
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection 'upgrade';
           proxy_set_header Host $host;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_cache_bypass $http_upgrade;
         }
       }
     }
     ```

1. Erstellen Sie ein Image aus Dateien in Ihrem neuen Verzeichnis:

   ```
   docker build -t nginx-plus-reverse-proxy ./path-to-your-directory
   ```

1. Laden Sie Ihre neuen Images zur späteren Verwendung in ein Bild-Repository hoch.

### Erstellen Sie die Aufgabendefinition zum Ausführen von NGINX Plus und der Webserver-App in Amazon ECS
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup-task"></a>

Als Nächstes richten Sie die Aufgabendefinition ein.

Diese Aufgabendefinition ermöglicht das Sammeln und Exportieren von NGINX-Plus-Prometheus-Metriken. Der NGINX-Container verfolgt die Eingaben von der App und stellt diese Daten an Port 8080 bereit, wie in `nginx.conf` festgelegt. Der NGINX-Prometheus-Exporter-Container scannt diese Metriken und sendet sie zur Verwendung in Port 9113. CloudWatch

**So richten Sie die Aufgabendefinition für die NGINX-Beispiel-Amazon ECS-Workload ein**

1. Erstellen Sie eine Aufgabendefinitions-JSON-Datei mit dem folgenden Inhalt. *your-customized-nginx-plus-image*Ersetzen Sie sie durch die Bild-URI für Ihr benutzerdefiniertes NGINX Plus-Image und durch die Bild-URI für Ihr *your-web-server-app-image* Webserver-App-Image.

   ```
   {
     "containerDefinitions": [
       {
         "name": "nginx",
         "image": "your-customized-nginx-plus-image",
         "memory": 256,
         "cpu": 256,
         "essential": true,
         "portMappings": [
           {
             "containerPort": 80,
             "protocol": "tcp"
           }
         ],
         "links": [
           "app",
           "app2"
         ]
       },
       {
         "name": "app",
         "image": "your-web-server-app-image",
         "memory": 256,
         "cpu": 128,
         "essential": true
       },
       {
         "name": "app2",
         "image": "your-web-server-app-image",
         "memory": 256,
         "cpu": 128,
         "essential": true
       },
       {
         "name": "nginx-prometheus-exporter",
         "image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
         "memory": 256,
         "cpu": 256,
         "essential": true,
         "command": [
           "-nginx.plus",
           "-nginx.scrape-uri",
            "http://nginx:8080/api"
       ],
       "links":[
         "nginx"
       ],
         "portMappings":[
           {
             "containerPort": 9113,
             "protocol": "tcp"
           }
         ]
       }
     ],
     "networkMode": "bridge",
     "placementConstraints": [],
     "family": "nginx-plus-sample-stack"
   }
   ```

1. Registrieren Sie die Aufgabendefinition:

   ```
   aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
   ```

1. Erstellen Sie einen Service zum Ausführen der Aufgabe, indem Sie den folgenden Befehl eingeben:

   ```
   aws ecs create-service \
    --cluster your-cluster-name \
    --service-name nginx-plus-service \
    --task-definition nginx-plus-sample-stack:1 \
    --desired-count 1
   ```

   Stellen Sie sicher, dass Sie den Servicenamen nicht ändern. Wir werden einen CloudWatch Agentendienst mit einer Konfiguration ausführen, die anhand der Namensmuster der Dienste, die sie gestartet haben, nach Aufgaben sucht. Damit der CloudWatch Agent beispielsweise die mit diesem Befehl gestartete Aufgabe finden kann, können Sie den Wert `sd_service_name_pattern` to be angeben`^nginx-plus-service$`. Im nächsten Abschnitt finden Sie weitere Details.

### Konfigurieren Sie den CloudWatch Agenten für das Scraping von NGINX Plus Prometheus-Metriken
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup-agent"></a>

Der letzte Schritt besteht darin, den CloudWatch Agenten so zu konfigurieren, dass er die NGINX-Metriken scannt. In diesem Beispiel erkennt der CloudWatch Agent die Aufgabe anhand des Dienstnamenmusters und des Ports 9113, wo der Exporter die Prometheus-Metriken für NGINX verfügbar macht. Sobald die Aufgabe erkannt wurde und die Metriken verfügbar sind, beginnt der CloudWatch Agent, die gesammelten Metriken im Log-Stream zu posten. **nginx-prometheus-exporter** 

**Um den CloudWatch Agenten so zu konfigurieren, dass er die NGINX-Metriken scannt**

1. Laden Sie die neueste Version der erforderlichen YAML-Datei herunter, indem Sie den folgenden Befehl eingeben.

   ```
   curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
   ```

1. Öffnen Sie die Datei mit einem Texteditor und finden Sie die vollständige CloudWatch Agentenkonfiguration im Schlüssel im `value` Abschnitt. `resource:CWAgentConfigSSMParameter` Fügen Sie dann im `ecs_service_discovery`-Abschnitt den folgenden `service_name_list_for_tasks`-Abschnitt hinzu.

   ```
   "service_name_list_for_tasks": [
     {
       "sd_job_name": "nginx-plus-prometheus-exporter",
       "sd_metrics_path": "/metrics",
       "sd_metrics_ports": "9113",
       "sd_service_name_pattern": "^nginx-plus.*"
      }
   ],
   ```

1. Fügen Sie in derselben Datei den folgenden Abschnitt im Abschnitt `metric_declaration` hinzu, um NGINX-Plus-Metriken zuzulassen. Beachten Sie unbedingt das vorhandene Einrückungsmuster.

   ```
   {
     "source_labels": ["job"],
     "label_matcher": "^nginx-plus.*",
     "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
     "metric_selectors": [
       "^nginxplus_connections_accepted$",
       "^nginxplus_connections_active$",
       "^nginxplus_connections_dropped$",
       "^nginxplus_connections_idle$",
       "^nginxplus_http_requests_total$",
       "^nginxplus_ssl_handshakes$",
       "^nginxplus_ssl_handshakes_failed$",
       "^nginxplus_up$",
       "^nginxplus_upstream_server_health_checks_fails$"
     ]
   },
   {
     "source_labels": ["job"],
     "label_matcher": "^nginx-plus.*",
     "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "upstream"]],
     "metric_selectors": [
       "^nginxplus_upstream_server_response_time$"
     ]
   },
   {
     "source_labels": ["job"],
     "label_matcher": "^nginx-plus.*",
     "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "code"]],
     "metric_selectors": [
       "^nginxplus_upstream_server_responses$",
       "^nginxplus_server_zone_responses$"
     ]
   },
   ```

1. Wenn Sie den CloudWatch Agenten noch nicht in diesem Cluster bereitgestellt haben, fahren Sie mit Schritt 8 fort.

   Wenn Sie den CloudWatch Agenten bereits mithilfe von im Amazon ECS-Cluster bereitgestellt haben AWS CloudFormation, können Sie einen Änderungssatz erstellen, indem Sie die folgenden Befehle eingeben:

   ```
   ECS_CLUSTER_NAME=your_cluster_name
   AWS_REGION=your_aws_region
   ECS_NETWORK_MODE=bridge
   CREATE_IAM_ROLES=True
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
       --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_REGION \
       --change-set-name nginx-plus-scraping-support
   ```

1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Überprüfen Sie das neu erstellte Changeset. **nginx-plus-scraping-support** Sie sollten sehen, dass eine Änderung an der **CWAgentSSMParameterConfig-Ressource** vorgenommen wurde. Führen Sie das Changeset aus und starten Sie die CloudWatch Agentenaufgabe neu, indem Sie den folgenden Befehl eingeben:

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 0 \
   --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
   --region $AWS_REGION
   ```

1. Warten Sie etwa 10 Sekunden und geben Sie den folgenden Befehl ein.

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 1 \
   --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
   --region $AWS_REGION
   ```

1. Wenn Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken zum ersten Mal auf dem Cluster installieren, geben Sie die folgenden Befehle ein.

   ```
   ECS_CLUSTER_NAME=your_cluster_name
   AWS_REGION=your_aws_region
   ECS_NETWORK_MODE=bridge
   CREATE_IAM_ROLES=True
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
       --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_REGION
   ```

## Anzeigen Ihrer NGINX-Plus-Metriken und -Protokolle
<a name="ContainerInsights-Prometheus-Setup-nginx-plus-view"></a>

Sie können jetzt die gesammelten NGINX-Plus-Metriken anzeigen.

**So zeigen Sie die Metriken für Ihren NGINX-Beispiel-Workload an**

1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie in der Region, in der Ihr Cluster ausgeführt wird, im linken Navigationsbereich **Metriken** aus. Suchen Sie den **ContainerInsights/Prometheus-Namespace**, um die Metriken zu sehen.

1. Um die CloudWatch Logs-Ereignisse zu sehen, wählen Sie im **Navigationsbereich Protokollgruppen** aus. Die Ereignisse befinden sich in der Protokollgruppe ***your\$1cluster\$1name*/aws/containerinsights/** /prometheus im Protokollstream. *nginx-plus-prometheus-exporter*

# Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Memcached auf Amazon ECS
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs"></a>

Dieses Tutorial bietet eine praktische Einführung in die Prometheus-Metriken einer Memcached-Beispielanwendung auf einem Amazon-ECS-Cluster mit dem EC2-Starttyp. Das Memcached Prometheus-Exporter-Ziel wird vom CloudWatch Agenten automatisch durch die auf ECS-Aufgabendefinitionen basierende Serviceerkennung erkannt.

Memcached ist ein universelles verteiltes Speicherzwischenspeicher-Caching-System. Es wird häufig verwendet, um dynamische datenbankgesteuerte Websites zu beschleunigen, indem Daten und Objekte im RAM zwischengespeichert werden, um die Häufigkeit des Lesens einer externen Datenquelle (z. B. einer Datenbank oder API) zu reduzieren. Weitere Informationen finden Sie unter [Was ist Memcached?](https://www.memcached.org/).

Der [memchached\$1exporter](https://github.com/prometheus/memcached_exporter) (Apache License 2.0) ist einer der offiziellen Prometheus-Exporteure. Standardmäßig dient der memcache\$1exporter auf Port 0.0.0.0:9150 bei `/metrics.`

Die Docker-Images in den folgenden zwei Docker Hub-Repositories werden in diesem Tutorial verwendet: 
+ [ Memcached](https://hub.docker.com/_/memcached?tab=description)
+ [ prom/memcached-exporter](https://hub.docker.com/r/prom/memcached-exporter/)

**Voraussetzung**

Um Metriken aus einem Prometheus-Beispiel-Workload für Amazon ECS zu erfassen, müssen Sie Container Insights im Cluster ausführen. Informationen zur Installation von Container Insights finden Sie unter [Einrichten von Container Insights für Amazon ECS](deploy-container-insights-ECS.md).

**Topics**
+ [Legen Sie die Umgebungsvariablen des EC2-Clusters von Amazon ECS fest](#ContainerInsights-Prometheus-Setup-memcached-ecs-environment)
+ [Installieren der Memcached-Beispiel-Workload](#ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload)
+ [Konfigurieren Sie den CloudWatch Agenten für das Scraping von Memcached Prometheus-Metriken](#ContainerInsights-Prometheus-Setup-memcached-ecs-agent)
+ [Anzeigen Ihrer Memcached-Metriken](#ContainerInsights-Prometheus-ECS-memcached-view)

## Legen Sie die Umgebungsvariablen des EC2-Clusters von Amazon ECS fest
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs-environment"></a>

**Festlegen Umgebungsvariablen des EC2-Clusters von Amazon ECS**

1. Installieren Sie die Amazon ECS-CLI, falls noch nicht geschehen. Weitere Informationen finden Sie unter [Installieren der Amazon-ECS-CLI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html).

1. Legen Sie den neuen Amazon-ECS-Clusternamen und die Region fest. Beispiel:

   ```
   ECS_CLUSTER_NAME=ecs-ec2-memcached-tutorial
   AWS_DEFAULT_REGION=ca-central-1
   ```

1. (Optional) Wenn Sie noch keinen Amazon ECS-Cluster mit dem EC2-Starttyp haben, auf dem Sie den Memcached-Beispiel-Workload und CloudWatch -Agenten installieren möchten, können Sie einen erstellen, indem Sie den folgenden Befehl eingeben.

   ```
   ecs-cli up --capability-iam --size 1 \
   --instance-type t3.medium \
   --cluster $ECS_CLUSTER_NAME \
   --region $AWS_REGION
   ```

   Das erwartete Ergebnis dieses Befehls lautet wie folgt:

   ```
   WARN[0000] You will not be able to SSH into your EC2 instances without a key pair. 
   INFO[0000] Using recommended Amazon Linux 2 AMI with ECS Agent 1.44.4 and Docker version 19.03.6-ce 
   INFO[0001] Created cluster                               cluster=ecs-ec2-memcached-tutorial region=ca-central-1
   INFO[0002] Waiting for your cluster resources to be created... 
   INFO[0002] Cloudformation stack status                   stackStatus=CREATE_IN_PROGRESS
   INFO[0063] Cloudformation stack status                   stackStatus=CREATE_IN_PROGRESS
   INFO[0124] Cloudformation stack status                   stackStatus=CREATE_IN_PROGRESS
   VPC created: vpc-xxxxxxxxxxxxxxxxx
   Security Group created: sg-xxxxxxxxxxxxxxxxx
   Subnet created: subnet-xxxxxxxxxxxxxxxxx
   Subnet created: subnet-xxxxxxxxxxxxxxxxx
   Cluster creation succeeded.
   ```

## Installieren der Memcached-Beispiel-Workload
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload"></a>

**So installieren Sie eine Memcached-Beispiel-Workload, die Prometheus-Metriken verfügbar macht**

1. Laden Sie die CloudFormation Memcached-Vorlage herunter, indem Sie den folgenden Befehl eingeben.

   ```
   curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/memcached/memcached-traffic-sample.yaml
   ```

1. Legen Sie die für Memcached zu erstellenden IAM-Rollennamen fest, indem Sie die folgenden Befehle eingeben.

   ```
   MEMCACHED_ECS_TASK_ROLE_NAME=memcached-prometheus-demo-ecs-task-role-name
   MEMCACHED_ECS_EXECUTION_ROLE_NAME=memcached-prometheus-demo-ecs-execution-role-name
   ```

1. Installieren Sie die Memcached-Beispiel-Workload, indem Sie den folgenden Befehl eingeben. Dieses Beispiel installiert die Workload im `host`-Netzwerkmodus.

   ```
   MEMCACHED_ECS_NETWORK_MODE=host
   
   aws cloudformation create-stack --stack-name Memcached-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MODE \
       --template-body file://memcached-traffic-sample.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=ECSNetworkMode,ParameterValue=$MEMCACHED_ECS_NETWORK_MODE \
                    ParameterKey=TaskRoleName,ParameterValue=$MEMCACHED_ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$MEMCACHED_ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_REGION
   ```

Der CloudFormation Stapel erstellt vier Ressourcen:
+ Eine ECS-Aufgabenrolle
+ Eine ECS-Aufgabenausführungsrolle
+ Eine Memcached-Aufgabendefinition
+ Ein Memcached-Service

In der Memcached-Aufgabendefinition werden zwei Container definiert:
+ Der primäre Container führt eine einfache Memcached-Anwendung aus und öffnet Port 11211 für den Zugriff.
+ Der andere Container führt den Redis-OSS-Exportprozess aus, um die Prometheus-Metriken auf Port 9150 verfügbar zu machen. Dies ist der Container, der vom Agenten entdeckt und gescrapt werden muss. CloudWatch 

## Konfigurieren Sie den CloudWatch Agenten für das Scraping von Memcached Prometheus-Metriken
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs-agent"></a>

**So konfigurieren Sie den CloudWatch Agenten für das Scrapen von Memcached Prometheus-Metriken**

1. Laden Sie die aktuelle Version der `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` herunter, indem Sie einen der folgenden Befehle eingeben.

   ```
   curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
   ```

1. Öffnen Sie die Datei mit einem Texteditor und finden Sie die vollständige CloudWatch Agentenkonfiguration hinter dem Schlüssel im `value` Abschnitt. `resource:CWAgentConfigSSMParameter`

   Fügen Sie dann im `ecs_service_discovery`-Abschnitt die folgende Konfiguration zum `task_definition_list`-Abschnitt hinzu.

   ```
   {
       "sd_job_name": "ecs-memcached",
       "sd_metrics_ports": "9150",
       "sd_task_definition_arn_pattern": ".*:task-definition/memcached-prometheus-demo.*:[0-9]+"
   },
   ```

   Für den `metric_declaration`-Abschnitt lässt die Standardeinstellung keine Memcached-Metriken zu. Fügen Sie den folgenden Abschnitt hinzu, um Memcached-Metriken zuzulassen. Beachten Sie unbedingt das vorhandene Einrückungsmuster.

   ```
   {
     "source_labels": ["container_name"],
     "label_matcher": "memcached-exporter-.*",
     "dimensions": [["ClusterName", "TaskDefinitionFamily"]],
     "metric_selectors": [
       "^memcached_current_(bytes|items|connections)$",
       "^memcached_items_(reclaimed|evicted)_total$",
       "^memcached_(written|read)_bytes_total$",
       "^memcached_limit_bytes$",
       "^memcached_commands_total$"
     ]
   },
   {
     "source_labels": ["container_name"],
     "label_matcher": "memcached-exporter-.*",
     "dimensions": [["ClusterName", "TaskDefinitionFamily","status","command"], ["ClusterName", "TaskDefinitionFamily","command"]],
     "metric_selectors": [
       "^memcached_commands_total$"
     ]
   },
   ```

1. Wenn Sie den CloudWatch Agenten bereits im Amazon ECS-Cluster von bereitgestellt haben CloudFormation, können Sie einen Änderungssatz erstellen, indem Sie die folgenden Befehle eingeben.

   ```
   ECS_NETWORK_MODE=bridge
   CREATE_IAM_ROLES=True
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
       --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_REGION \
       --change-set-name memcached-scraping-support
   ```

1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Überprüfen des neu erstellten Änderungssatzes `memcached-scraping-support`. Sie sollten sehen, dass eine Änderung auf die `CWAgentConfigSSMParameter`-Ressource angewendet wurde. Führen Sie das Changeset aus und starten Sie die CloudWatch Agentenaufgabe neu, indem Sie die folgenden Befehle eingeben.

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 0 \
   --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
   --region $AWS_REGION
   ```

1. Warten Sie etwa 10 Sekunden und geben Sie den folgenden Befehl ein.

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 1 \
   --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
   --region $AWS_REGION
   ```

1. Wenn Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken für den Cluster zum ersten Mal installieren, geben Sie bitte die folgenden Befehle ein:

   ```
   ECS_NETWORK_MODEE=bridge
   CREATE_IAM_ROLES=True
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
       --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_REGION
   ```

## Anzeigen Ihrer Memcached-Metriken
<a name="ContainerInsights-Prometheus-ECS-memcached-view"></a>

Dieses Tutorial sendet die folgenden Metriken an den **ECS/ContainerInsights/Prometheus**Namespace in. CloudWatch Sie können die CloudWatch Konsole verwenden, um die Metriken in diesem Namespace zu sehen.


| Metrikname | Dimensionen | 
| --- | --- | 
|  `memcached_current_items` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_current_connections` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_limit_bytes` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_current_bytes` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_written_bytes_total` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_read_bytes_total` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_items_evicted_total` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_items_reclaimed_total` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `memcached_commands_total` |  `ClusterName`, `TaskDefinitionFamily` `ClusterName`, TaskDefinitionFamily, Befehl `ClusterName`, TaskDefinitionFamily, Status, Befehl  | 

**Anmerkung**  
Die Werte der **command**-Dimension können `delete`, `get`, `cas`, `set`, `decr`, `touch`, `incr`, oder `flush` sein.  
Die Werte der **-Dimension können **, `hit`, `miss`, oder `badval` sein. 

Sie können auch ein CloudWatch Dashboard für Ihre Memcached Prometheus-Metriken erstellen.

**So erstellen Sie ein Dashboard für Memcached-Prometheus-Metriken**

1. Erstellen Sie Umgebungsvariablen und ersetzen Sie die folgenden Werte entsprechend Ihrer Bereitstellung.

   ```
   DASHBOARD_NAME=your_memcached_cw_dashboard_name
   ECS_TASK_DEF_FAMILY=memcached-prometheus-demo-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MOD
   ```

1. Verwenden Sie den folgenden Befehl, um das Dashboard zu erstellen.

   ```
   curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json \
   | sed "s/{{YOUR_AWS_REGION}}/$AWS_REGION/g" \
   | sed "s/{{YOUR_CLUSTER_NAME}}/$ECS_CLUSTER_NAME/g" \
   | sed "s/{{YOUR_TASK_DEF_FAMILY}}/$ECS_TASK_DEF_FAMILY/g" \
   | xargs -0 aws cloudwatch put-dashboard --dashboard-name ${DASHBOARD_NAME} --region $AWS_REGION --dashboard-body
   ```

# Tutorial zum Scraping von Redis-OSS-Prometheus-Metriken auf Amazon ECS Fargate
<a name="ContainerInsights-Prometheus-Setup-redis-ecs"></a>

Dieses Tutorial bietet eine praktische Einführung zum Scraping der Prometheus-Metriken einer Redis-OSS-Beispielanwendung in einem Amazon-ECS-Fargate-Cluster. Das Redis OSS Prometheus-Exportziel wird vom CloudWatch Agenten mit Prometheus-Metrikunterstützung auf der Grundlage der Docker-Labels des Containers automatisch erkannt.

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)

**Voraussetzung**

Um Metriken aus einem Prometheus-Beispiel-Workload für Amazon ECS zu erfassen, müssen Sie Container Insights im Cluster ausführen. Informationen zur Installation von Container Insights finden Sie unter [Einrichten von Container Insights für Amazon ECS](deploy-container-insights-ECS.md).

**Topics**
+ [Legen Sie die Umgebungsvariable des Amazon-ECS-Fargate-Clusters fest](#ContainerInsights-Prometheus-Setup-redis-ecs-variable)
+ [Legen Sie die Netzwerkumgebungsvariablen für den Amazon-ECS-Fargate-Cluster fest](#ContainerInsights-Prometheus-Setup-redis-ecs-variable2)
+ [Installieren der Redis-OSS-Beispiel-Workload](#ContainerInsights-Prometheus-Setup-redis-ecs-install-workload)
+ [Konfigurieren Sie den CloudWatch Agenten für das Scraping von Redis OSS Prometheus-Metriken](#ContainerInsights-Prometheus-Setup-redis-ecs-agent)
+ [Anzeigen Ihrer Redis-OSS-Metriken](#ContainerInsights-Prometheus-Setup-redis-view)

## Legen Sie die Umgebungsvariable des Amazon-ECS-Fargate-Clusters fest
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-variable"></a>

**Festlegen der Umgebungsvariable des Amazon-ECS-Fargate-Clusters**

1. Installieren Sie die Amazon ECS-CLI, falls noch nicht geschehen. Weitere Informationen finden Sie unter [Installieren der Amazon-ECS-CLI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html).

1. Legen Sie den neuen Amazon-ECS-Clusternamen und die Region fest. Beispiel:

   ```
   ECS_CLUSTER_NAME=ecs-fargate-redis-tutorial
   AWS_DEFAULT_REGION=ca-central-1
   ```

1. (Optional) Wenn Sie noch keinen Amazon ECS Fargate-Cluster haben, auf dem Sie den Redis OSS-Beispiel-Workload und CloudWatch -Agenten installieren möchten, können Sie einen erstellen, indem Sie den folgenden Befehl eingeben.

   ```
   ecs-cli up --capability-iam \
   --cluster $ECS_CLUSTER_NAME \
   --launch-type FARGATE \
   --region $AWS_DEFAULT_REGION
   ```

   Das erwartete Ergebnis dieses Befehls lautet wie folgt:

   ```
   INFO[0000] Created cluster   cluster=ecs-fargate-redis-tutorial region=ca-central-1
   INFO[0001] Waiting for your cluster resources to be created...
   INFO[0001] Cloudformation stack status   stackStatus=CREATE_IN_PROGRESS
   VPC created: vpc-xxxxxxxxxxxxxxxxx
   Subnet created: subnet-xxxxxxxxxxxxxxxxx
   Subnet created: subnet-xxxxxxxxxxxxxxxxx
   Cluster creation succeeded.
   ```

## Legen Sie die Netzwerkumgebungsvariablen für den Amazon-ECS-Fargate-Cluster fest
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-variable2"></a>

**Festlegen der Netzwerkumgebungsvariablen für den Amazon-ECS-Fargate-Cluster**

1. Legen Sie die VPC- und Subnetz-ID des Amazon-ECS-Clusters fest. Wenn Sie im vorherigen Verfahren einen neuen Cluster erstellt haben, werden diese Werte im Ergebnis des endgültigen Befehls angezeigt. Verwenden Sie andernfalls den IDs des vorhandenen Clusters, den Sie mit Redis verwenden werden.

   ```
   ECS_CLUSTER_VPC=vpc-xxxxxxxxxxxxxxxxx
   ECS_CLUSTER_SUBNET_1=subnet-xxxxxxxxxxxxxxxxx
   ECS_CLUSTER_SUBNET_2=subnet-xxxxxxxxxxxxxxxxx
   ```

1. In diesem Tutorial werden wir die Redis OSS-Anwendung und den CloudWatch Agenten in der Standardsicherheitsgruppe der VPC des Amazon ECS-Clusters installieren. Die Standardsicherheitsgruppe erlaubt alle Netzwerkverbindungen innerhalb derselben Sicherheitsgruppe, sodass der CloudWatch Agent die auf den Redis OSS-Containern offengelegten Prometheus-Metriken auslesen kann. In einer echten Produktionsumgebung möchten Sie möglicherweise spezielle Sicherheitsgruppen für die Redis OSS-Anwendung und den Redis CloudWatch OSS-Agenten erstellen und benutzerdefinierte Berechtigungen für diese einrichten. 

   Geben Sie den folgenden Befehl ein, um die Standard-Sicherheitsgruppen-ID abzurufen.

   ```
   aws ec2 describe-security-groups \
   --filters Name=vpc-id,Values=$ECS_CLUSTER_VPC  \
   --region $AWS_DEFAULT_REGION
   ```

   Legen Sie dann die Standardsicherheitsgruppenvariable des Fargate-Clusters fest, indem Sie den folgenden Befehl eingeben und ihn durch den Wert *my-default-security-group* ersetzen, den Sie im vorherigen Befehl gefunden haben.

   ```
   ECS_CLUSTER_SECURITY_GROUP=my-default-security-group
   ```

## Installieren der Redis-OSS-Beispiel-Workload
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-install-workload"></a>

**So installieren Sie eine Redis-OSS-Beispiel-Workload, die Prometheus-Metriken verfügbar macht**

1. Laden Sie die Redis CloudFormation OSS-Vorlage herunter, indem Sie den folgenden Befehl eingeben.

   ```
   curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml
   ```

1. Legen Sie die für Redis OSS zu erstellenden IAM-Rollennamen fest, indem Sie die folgenden Befehle eingeben.

   ```
   REDIS_ECS_TASK_ROLE_NAME=redis-prometheus-demo-ecs-task-role-name
   REDIS_ECS_EXECUTION_ROLE_NAME=redis-prometheus-demo-ecs-execution-role-name
   ```

1. Installieren Sie die Redis-OSS-Beispiel-Workload, indem Sie den folgenden Befehl eingeben.

   ```
   aws cloudformation create-stack --stack-name Redis-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-fargate-awsvpc \
       --template-body file://redis-traffic-sample.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
                    ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET_1 \
                    ParameterKey=TaskRoleName,ParameterValue=$REDIS_ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$REDIS_ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region $AWS_DEFAULT_REGION
   ```

Der CloudFormation Stack erstellt vier Ressourcen:
+ Eine ECS-Aufgabenrolle
+ Eine ECS-Aufgabenausführungsrolle
+ Eine Redis-OSS-Aufgabendefinition
+ Ein Redis-OSS-Service

In der Redis-OSS-Aufgabendefinition werden zwei Container definiert:
+ Der primäre Container führt eine einfache Redis-OSS-Anwendung aus und öffnet Port 6379 für den Zugriff.
+ Der andere Container führt den Redis-OSS-Exportprozess aus, um die Prometheus-Metriken auf Port 9121 verfügbar zu machen. Dies ist der Container, der vom Agenten entdeckt und gescrapt werden muss. CloudWatch Das folgende Docker-Label ist so definiert, dass der CloudWatch Agent diesen Container anhand dessen erkennen kann.

  ```
  ECS_PROMETHEUS_EXPORTER_PORT: 9121
  ```

## Konfigurieren Sie den CloudWatch Agenten für das Scraping von Redis OSS Prometheus-Metriken
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-agent"></a>

**So konfigurieren Sie den CloudWatch Agenten für das Scrapen von Redis OSS Prometheus-Metriken**

1. Laden Sie die aktuelle Version der `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` herunter, indem Sie einen der folgenden Befehle eingeben.

   ```
   curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
   ```

1. Öffnen Sie die Datei mit einem Texteditor und finden Sie die vollständige CloudWatch Agentenkonfiguration hinter dem `value` Schlüssel im Abschnitt. `resource:CWAgentConfigSSMParameter`

   Dann wird im hier gezeigten Abschnitt `ecs_service_discovery` die `docker_label`-basierte Serviceerkennung mit den auf `ECS_PROMETHEUS_EXPORTER_PORT` basierenden Standardeinstellungen aktiviert, die der Docker-Bezeichnung entsprechen, das wir in der Redis-OSS-ECS-Aufgabendefinition definiert haben. So müssen wir keine Änderungen in diesem Abschnitt vornehmen:

   ```
   ecs_service_discovery": {
     "sd_frequency": "1m",
     "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
   *  "docker_label": {
     },*
     ...
   ```

   Für den `metric_declaration`-Abschnitt lässt die Standardeinstellung keine Redis-OSS-Metriken zu. Fügen Sie den folgenden Abschnitt hinzu, um Redis-OSS-Metriken zuzulassen. Beachten Sie unbedingt das vorhandene Einrückungsmuster.

   ```
   {
     "source_labels": ["container_name"],
     "label_matcher": "^redis-exporter-.*$",
     "dimensions": [["ClusterName","TaskDefinitionFamily"]],
     "metric_selectors": [
       "^redis_net_(in|out)put_bytes_total$",
       "^redis_(expired|evicted)_keys_total$",
       "^redis_keyspace_(hits|misses)_total$",
       "^redis_memory_used_bytes$",
       "^redis_connected_clients$"
     ]
   },
   {
     "source_labels": ["container_name"],
     "label_matcher": "^redis-exporter-.*$",
     "dimensions": [["ClusterName","TaskDefinitionFamily","cmd"]],
     "metric_selectors": [
       "^redis_commands_total$"
     ]
   },
   {
     "source_labels": ["container_name"],
     "label_matcher": "^redis-exporter-.*$",
     "dimensions": [["ClusterName","TaskDefinitionFamily","db"]],
     "metric_selectors": [
       "^redis_db_keys$"
     ]
   },
   ```

1. Wenn Sie den CloudWatch Agenten bereits im Amazon ECS-Cluster von bereitgestellt haben CloudFormation, können Sie einen Änderungssatz erstellen, indem Sie die folgenden Befehle eingeben.

   ```
   ECS_LAUNCH_TYPE=FARGATE
   CREATE_IAM_ROLES=True
   ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
       --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
                    ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
                    ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region ${AWS_DEFAULT_REGION} \
       --change-set-name redis-scraping-support
   ```

1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Überprüfen des neu erstellten Änderungssatzes `redis-scraping-support`. Sie sollten sehen, dass eine Änderung auf die `CWAgentConfigSSMParameter`-Ressource angewendet wurde. Führen Sie das Changeset aus und starten Sie die CloudWatch Agentenaufgabe neu, indem Sie die folgenden Befehle eingeben.

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 0 \
   --service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
   --region ${AWS_DEFAULT_REGION}
   ```

1. Warten Sie etwa 10 Sekunden und geben Sie den folgenden Befehl ein.

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 1 \
   --service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
   --region ${AWS_DEFAULT_REGION}
   ```

1. Wenn Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken für den Cluster zum ersten Mal installieren, geben Sie bitte die folgenden Befehle ein:

   ```
   ECS_LAUNCH_TYPE=FARGATE
   CREATE_IAM_ROLES=True
   ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
   ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
   ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
   
   aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
       --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
       --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                    ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                    ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
                    ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
                    ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
                    ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                    ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
       --capabilities CAPABILITY_NAMED_IAM \
       --region ${AWS_DEFAULT_REGION}
   ```

## Anzeigen Ihrer Redis-OSS-Metriken
<a name="ContainerInsights-Prometheus-Setup-redis-view"></a>

Dieses Tutorial sendet die folgenden Metriken an den **ECS/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, `TaskDefinitionFamily`  | 
|  `redis_net_output_bytes_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_expired_keys_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_evicted_keys_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_keyspace_hits_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_keyspace_misses_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_memory_used_bytes` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_connected_clients` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_commands_total` |  ` ClusterName`, `TaskDefinitionFamily`, `cmd`  | 
|  `redis_db_keys` |  `ClusterName`, `TaskDefinitionFamily`, `db`  | 

**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
   ECS_TASK_DEF_FAMILY=redis-prometheus-demo-$ECS_CLUSTER_NAME-fargate-awsvpc
   ```

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

# Einrichten und Konfigurieren der Prometheus-Metrikensammlung in Amazon EKS oder Kubernetes-Clustern
<a name="ContainerInsights-Prometheus-install-EKS"></a>

Um Prometheus-Metriken von Clustern zu sammeln, auf denen Amazon EKS oder Kubernetes ausgeführt werden, können Sie den CloudWatch Agenten als Collector oder die AWS Distro for Collector verwenden. OpenTelemetry [Informationen zur Verwendung von AWS Distro for Collector finden Sie unter https://aws-otel.github. OpenTelemetry io/docs/getting-started/container-insights/eks-Prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus).

In den folgenden Abschnitten wird erklärt, wie Sie Prometheus-Metriken mithilfe des CloudWatch Agenten sammeln. Sie erklären, wie der CloudWatch Agent mit Prometheus-Überwachung auf Clustern installiert wird, auf denen Amazon EKS oder Kubernetes ausgeführt wird, und wie der Agent so konfiguriert wird, dass er zusätzliche Ziele scrapt. Sie enthalten auch optionale Tutorials zum Einrichten von Beispiel-Workloads zum Testen mit der Prometheus-Überwachung.

**Topics**
+ [Installieren Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken auf Amazon EKS- und Kubernetes-Clustern](ContainerInsights-Prometheus-Setup.md)

# Installieren Sie den CloudWatch Agenten mit der Erfassung von Prometheus-Metriken auf Amazon EKS- und Kubernetes-Clustern
<a name="ContainerInsights-Prometheus-Setup"></a>

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
<a name="ContainerInsights-Prometheus-Setup-roles"></a>

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
<a name="ContainerInsights-Prometheus-Setup-roles"></a>

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
<a name="ContainerInsights-Prometheus-Setup-install-agent"></a>

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
<a name="ContainerInsights-Prometheus-Setup-install-agent-EKS"></a>

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
<a name="ContainerInsights-Prometheus-Setup-install-agent-EKS-fargate"></a>

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
<a name="ContainerInsights-Prometheus-Setup-install-agent-Kubernetes"></a>

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
<a name="ContainerInsights-Prometheus-Setup-install-agent-verify"></a>

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
<a name="ContainerInsights-Prometheus-Setup-configure"></a>

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 [<scrape\$1config>](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
<a name="ContainerInsights-Prometheus-Setup-config-global"></a>

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) <scrape\$1config>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
<a name="ContainerInsights-Prometheus-Setup-config-scrape"></a>

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
<a name="ContainerInsights-Prometheus-Setup-cw-agent-config2"></a>

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
<a name="ContainerInsights-Prometheus-Setup-new-exporters"></a>

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.
<a name="ContainerInsights-Prometheus-Setup-KPI-dashboard"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-iam"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-install"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-application"></a>

[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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-delete"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh--fargate-iam"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-fargate-install"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-fargate-application"></a>

[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
<a name="ContainerInsights-Prometheus-Sample-Workloads-appmesh-fargate-delete"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-nginx"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-memcached"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-javajmx"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-javajmx-default"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-javajmx-other"></a>

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 [<kubernetes\$1sd\$1config>](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
<a name="ContainerInsights-Prometheus-Sample-Workloads-javajmx-docker"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-javajmx-tomcat"></a>

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<type=OperatingSystem><>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
    name: java_lang_OperatingSystem_$1
    type: GAUGE
  
  - pattern: 'java.lang<type=Threading><>(TotalStartedThreadCount|ThreadCount)'
    name: java_lang_threading_$1
    type: GAUGE
  
  - pattern: 'Catalina<type=GlobalRequestProcessor, name=\"(\w+-\w+)-(\d+)\"><>(\w+)'
    name: catalina_globalrequestprocessor_$3_total
    labels:
      port: "$2"
      protocol: "$1"
    help: Catalina global $3
    type: COUNTER
  
  - pattern: 'Catalina<j2eeType=Servlet, WebModule=//([-a-zA-Z0-9+&@#/%?=~_|!:.,;]*[-a-zA-Z0-9+&@#/%=~_|]), name=([-a-zA-Z0-9+/$%~_-|!.]*), J2EEApplication=none, J2EEServer=none><>(requestCount|maxTime|processingTime|errorCount)'
    name: catalina_servlet_$3_total
    labels:
      module: "$1"
      servlet: "$2"
    help: Catalina servlet $3 total
    type: COUNTER
  
  - pattern: 'Catalina<type=ThreadPool, name="(\w+-\w+)-(\d+)"><>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
    name: catalina_threadpool_$3
    labels:
      port: "$2"
      protocol: "$1"
    help: Catalina threadpool $3
    type: GAUGE
  
  - pattern: 'Catalina<type=Manager, host=([-a-zA-Z0-9+&@#/%?=~_|!:.,;]*[-a-zA-Z0-9+&@#/%=~_|]), context=([-a-zA-Z0-9+/$%~_-|!.]*)><>(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
<a name="ContainerInsights-Prometheus-Sample-Workloads-javajmx-jar"></a>

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<type=OperatingSystem><>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
    name: java_lang_OperatingSystem_$1
    type: GAUGE
  
  - pattern: 'java.lang<type=Threading><>(TotalStartedThreadCount|ThreadCount)'
    name: java_lang_threading_$1
    type: GAUGE
  
  - pattern: 'Catalina<type=GlobalRequestProcessor, name=\"(\w+-\w+)-(\d+)\"><>(\w+)'
    name: catalina_globalrequestprocessor_$3_total
    labels:
      port: "$2"
      protocol: "$1"
    help: Catalina global $3
    type: COUNTER
  
  - pattern: 'Catalina<j2eeType=Servlet, WebModule=//([-a-zA-Z0-9+&@#/%?=~_|!:.,;]*[-a-zA-Z0-9+&@#/%=~_|]), name=([-a-zA-Z0-9+/$%~_-|!.]*), J2EEApplication=none, J2EEServer=none><>(requestCount|maxTime|processingTime|errorCount)'
    name: catalina_servlet_$3_total
    labels:
      module: "$1"
      servlet: "$2"
    help: Catalina servlet $3 total
    type: COUNTER
  
  - pattern: 'Catalina<type=ThreadPool, name="(\w+-\w+)-(\d+)"><>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
    name: catalina_threadpool_$3
    labels:
      port: "$2"
      protocol: "$1"
    help: Catalina threadpool $3
    type: GAUGE
  
  - pattern: 'Catalina<type=Manager, host=([-a-zA-Z0-9+&@#/%?=~_|!:.,;]*[-a-zA-Z0-9+&@#/%=~_|]), context=([-a-zA-Z0-9+/$%~_-|!.]*)><>(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
<a name="ContainerInsights-Prometheus-Sample-Workloads-haproxy"></a>

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
<a name="ContainerInsights-Prometheus-Setup-redis-eks"></a>

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
<a name="ContainerInsights-Prometheus-Setup-redis-eks-view"></a>

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

# Konvertierung des metrischen Prometheus-Typs durch den Agenten CloudWatch
<a name="ContainerInsights-Prometheus-metrics-conversion"></a>

Die Prometheus-Clientbibliotheken bieten vier Kernmetriktypen: 
+ Zähler
+ Messinstrument
+ Zusammenfassung
+ Histogramm

Der CloudWatch Agent unterstützt die Metriktypen Zähler, Messgerät und Zusammenfassung.

 Die Prometheus-Metriken mit dem Metriktyp Histogramm werden vom Agenten gelöscht. CloudWatch Weitere Informationen finden Sie unter [Protokollierung von gelöschten Prometheus-Metriken](ContainerInsights-Prometheus-troubleshooting-EKS.md#ContainerInsights-Prometheus-troubleshooting-droppedmetrics).

**Messinstrumentmetriken**

Eine Prometheus-Messwertmetrik ist eine Metrik, die einen einzelnen numerischen Wert darstellt, der beliebig nach oben und unten gehen kann. Der CloudWatch Agent erfasst Messmetriken und sendet diese Werte direkt aus.

**Zähler-Metriken**

Eine Prometheus-Zählermetrik ist eine kumulative Metrik, die einen einzelnen monotonisch zunehmenden Zähler darstellt, dessen Wert nur erhöht oder auf Null zurückgesetzt werden kann. Der CloudWatch Agent berechnet ein Delta aus dem vorherigen Scrape und sendet den Deltawert als Metrikwert in das Protokollereignis. Der CloudWatch Agent beginnt also, ab dem zweiten Scrape ein Log-Ereignis zu erzeugen und setzt, falls vorhanden, mit nachfolgenden Scrapes fort.

**Zusammenfassende Metriken**

Eine Prometheus-Zusammenfassungsmetrik ist ein komplexer Metriktyp, der durch mehrere Datenpunkte dargestellt wird. Es liefert eine Gesamtzahl der Beobachtungen und eine Summe aller beobachteten Werte. Er berechnet konfigurierbare Quantile über ein Schiebezeitfenster.

Die Summe und Anzahl einer Zusammenfassungsmetrik sind kumulativ, die Quantile jedoch nicht. Das folgende Beispiel veranschaulicht die Varianz von Quantilen.

```
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 7.123e-06
go_gc_duration_seconds{quantile="0.25"} 9.204e-06
go_gc_duration_seconds{quantile="0.5"} 1.1065e-05
go_gc_duration_seconds{quantile="0.75"} 2.8731e-05
go_gc_duration_seconds{quantile="1"} 0.003841496
go_gc_duration_seconds_sum 0.37630427
go_gc_duration_seconds_count 9774
```

Der CloudWatch Agent verarbeitet die Summe und Anzahl einer Übersichtsmetrik genauso wie Zählermetriken, wie im vorherigen Abschnitt beschrieben. Der CloudWatch Agent behält die Quantilwerte so bei, wie sie ursprünglich gemeldet wurden.

# Vom Agenten gesammelte Prometheus-Metriken CloudWatch
<a name="ContainerInsights-Prometheus-metrics"></a>

Der CloudWatch Agent mit Prometheus-Unterstützung sammelt automatisch Metriken von verschiedenen Diensten und Workloads. Die Metriken, die standardmäßig erfasst werden, sind in den folgenden Abschnitten aufgeführt. Sie können den Agenten auch so konfigurieren, dass er weitere Metriken von diesen Services erfasst und Prometheus-Metriken von anderen Anwendungen und Services erfasst. Weitere Informationen zum Erfassen zusätzlicher Metriken finden Sie unter [CloudWatch Agentenkonfiguration für Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config).

**Prometheus-Metriken, die von Amazon EKS- und Kubernetes-Clustern gesammelt wurden, befinden sich im /Prometheus-Namespace. ContainerInsights** Aus Amazon ECS-Clustern gesammelte Prometheus-Metriken befinden sich im **ECS/ContainerInsights/Prometheus**Namespace. 

**Topics**
+ [Prometheus-Metriken für App Mesh](#ContainerInsights-Prometheus-metrics-appmesh)
+ [Prometheus-Metriken für NGINX](#ContainerInsights-Prometheus-metrics-nginx)
+ [Prometheus-Metriken für Memcached](#ContainerInsights-Prometheus-metrics-memcached)
+ [Prometheus-Metriken für Java/JMX](#ContainerInsights-Prometheus-metrics-jmx)
+ [Prometheus-Metriken für HAProxy](#ContainerInsights-Prometheus-metrics-haproxy)

## Prometheus-Metriken für App Mesh
<a name="ContainerInsights-Prometheus-metrics-appmesh"></a>

Die folgenden Metriken werden automatisch von App Mesh erfasst.

**Prometheus-Metriken für App Mesh in Amazon-EKS- und Kubernetes-Clustern**


| Metrikname | Dimensionen | 
| --- | --- | 
|  `envoy_http_downstream_rq_total` |  ClusterName, `Namespace`  | 
|  `envoy_http_downstream_rq_xx` |  ClusterName, `Namespace` ClusterName,, envoy\$1http\$1conn\$1manager\$1prefix, `Namespace` envoy\$1response\$1code\$1class  | 
|  `envoy_cluster_upstream_cx_rx_bytes_total` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_cx_tx_bytes_total` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_membership_healthy` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_membership_total` |  ClusterName, `Namespace`  | 
|  `envoy_server_memory_heap_size` |  ClusterName, `Namespace`  | 
|  `envoy_server_memory_allocated` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_cx_connect_timeout` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_pending_failure_eject` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_pending_overflow` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_timeout` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_try_per_timeout` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_rx_reset` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_cx_destroy_local_with_active_rq` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_cx_destroy_remote_active_rq` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_maintenance_mode` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_flow_control_paused_reading_total` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_flow_control_resumed_reading_total` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_flow_control_backed_up_total` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_flow_control_drained_total` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_retry` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_retry_success` |  ClusterName, `Namespace`  | 
|  `envoy_cluster_upstream_rq_retry_overflow` |  ClusterName, `Namespace`  | 
|  `envoy_server_live` |  ClusterName, `Namespace`  | 
|  `envoy_server_uptime` |  ClusterName, `Namespace`  | 

**Prometheus-Metriken für App Mesh auf Amazon-ECS-Clustern**


| Metrikname | Dimensionen | 
| --- | --- | 
|  `envoy_http_downstream_rq_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_http_downstream_rq_xx` |  ClusterName, `TaskDefinitionFamily` | 
|  `envoy_cluster_upstream_cx_rx_bytes_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_cx_tx_bytes_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_membership_healthy` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_membership_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_server_memory_heap_size` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_server_memory_allocated` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_cx_connect_timeout` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_pending_failure_eject` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_pending_overflow` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_timeout` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_try_per_timeout` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_rx_reset` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_cx_destroy_local_with_active_rq` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_cx_destroy_remote_active_rq` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_maintenance_mode` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_flow_control_paused_reading_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_flow_control_resumed_reading_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_flow_control_backed_up_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_flow_control_drained_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_retry` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_retry_success` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_cluster_upstream_rq_retry_overflow` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_server_live` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_server_uptime` |  ClusterName, `TaskDefinitionFamily`  | 
|  `envoy_http_downstream_rq_xx` |  ClusterName TaskDefinitionFamily, envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class ClusterName, TaskDefinitionFamily, envoy\$1response\$1code\$1class | 

**Anmerkung**  
`TaskDefinitionFamily` ist der Kubernetes-Namespace des Netzes.  
Folgende Werte von `envoy_http_conn_manager_prefix` sind möglich: `ingress`, `egress` oder `admin`.   
Der Wert von `envoy_response_code_class` kann `1` (steht für `1xx`), `2` steht für `2xx`), `3`steht für `3xx`), `4` steht für `4xx`), oder `5` steht für `5xx`) sein. 

## Prometheus-Metriken für NGINX
<a name="ContainerInsights-Prometheus-metrics-nginx"></a>

Die folgenden Metriken werden automatisch von NGINX auf Amazon-EKS- und Kubernetes-Clustern erfasst.


| Metrikname | Dimensionen | 
| --- | --- | 
|  `nginx_ingress_controller_nginx_process_cpu_seconds_total` |  ClusterName, `Namespace`, Service  | 
|  `nginx_ingress_controller_success` |  ClusterName, `Namespace`, Service  | 
|  `nginx_ingress_controller_requests` |  ClusterName, `Namespace`, Service  | 
|  `nginx_ingress_controller_nginx_process_connections` |  ClusterName, `Namespace`, Service  | 
|  `nginx_ingress_controller_nginx_process_connections_total` |  ClusterName, `Namespace`, Service  | 
|  `nginx_ingress_controller_nginx_process_resident_memory_bytes` |  ClusterName, `Namespace`, Service  | 
|  `nginx_ingress_controller_config_last_reload_successful` |  ClusterName, `Namespace`, Service  | 
|  `nginx_ingress_controller_requests` |  ClusterName`Namespace`, Dienst, Status  | 

## Prometheus-Metriken für Memcached
<a name="ContainerInsights-Prometheus-metrics-memcached"></a>

Die folgenden Metriken werden automatisch von Memcached auf Amazon-EKS- und Kubernetes-Clustern erfasst.


| Metrikname | Dimensionen | 
| --- | --- | 
|  `memcached_current_items` |  ClusterName, `Namespace`, Service  | 
|  `memcached_current_connections` |  ClusterName, `Namespace`, Service  | 
|  `memcached_limit_bytes` |  ClusterName, `Namespace`, Service  | 
|  `memcached_current_bytes` |  ClusterName, `Namespace`, Service  | 
|  `memcached_written_bytes_total` |  ClusterName, `Namespace`, Service  | 
|  `memcached_read_bytes_total` |  ClusterName, `Namespace`, Service  | 
|  `memcached_items_evicted_total` |  ClusterName, `Namespace`, Service  | 
|  `memcached_items_reclaimed_total` |  ClusterName, `Namespace`, Service  | 
|  `memcached_commands_total` |  ClusterName, `Namespace`, Service ClusterName`Namespace`, Service, Befehl ClusterName,`Namespace`, Dienst, Status, Befehl  | 

## Prometheus-Metriken für Java/JMX
<a name="ContainerInsights-Prometheus-metrics-jmx"></a>

**Metriken, die auf Amazon-EKS- und Kubernetes-Clustern erfasst werden**

Auf Amazon-EKS- und Kubernetes-Clustern kann Container Insights mit dem JMX-Exporter die folgenden vordefinierten Prometheus-Metriken von Java Virtual Machine (JVM), Java und Tomcat (Catalina) sammeln. Weitere Informationen finden Sie unter [ prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) auf Github.

**Java/JMX auf Amazon-EKS- und Kubernetes-Clustern**


| Metrikname | Dimensionen | 
| --- | --- | 
|  `jvm_classes_loaded` |  `ClusterName`, `Namespace`  | 
|  `jvm_threads_current` |  `ClusterName`, `Namespace`  | 
|  `jvm_threads_daemon` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_totalswapspacesize` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_systemcpuload` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_processcpuload` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_freeswapspacesize` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_totalphysicalmemorysize` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_freephysicalmemorysize` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_openfiledescriptorcount` |  `ClusterName`, `Namespace`  | 
|  `java_lang_operatingsystem_availableprocessors` |  `ClusterName`, `Namespace`  | 
|  `jvm_memory_bytes_used` |  `ClusterName`, `Namespace`, Bereich  | 
|  `jvm_memory_pool_bytes_used` |  `ClusterName`, `Namespace`, Pool  | 

**Anmerkung**  
Die Werte der `area`-Dimension können `heap` oder sein `nonheap`.  
Die Werte der `pool`-Dimension können `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` oder `Metaspace` sein.

**Tomcat/JMX auf Amazon-EKS- und Kubernetes-Clustern**

Zusätzlich zu den Java/JMX Metriken in der vorherigen Tabelle werden auch die folgenden Metriken für den Tomcat-Workload erfasst.


| Metrikname | Dimensionen | 
| --- | --- | 
|  `catalina_manager_activesessions` |  `ClusterName`, `Namespace`  | 
|  `catalina_manager_rejectedsessions` |  `ClusterName`, `Namespace`  | 
|  `catalina_globalrequestprocessor_bytesreceived` |  `ClusterName`, `Namespace`  | 
|  `catalina_globalrequestprocessor_bytessent` |  `ClusterName`, `Namespace`  | 
|  `catalina_globalrequestprocessor_requestcount` |  `ClusterName`, `Namespace`  | 
|  `catalina_globalrequestprocessor_errorcount` |  `ClusterName`, `Namespace`  | 
|  `catalina_globalrequestprocessor_processingtime` |  `ClusterName`, `Namespace`  | 

**Java/JMX auf Amazon-ECS-Clustern**


| Metrikname | Dimensionen | 
| --- | --- | 
|  `jvm_classes_loaded` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `jvm_threads_current` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `jvm_threads_daemon` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_totalswapspacesize` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_systemcpuload` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_processcpuload` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_freeswapspacesize` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_totalphysicalmemorysize` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_freephysicalmemorysize` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_openfiledescriptorcount` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `java_lang_operatingsystem_availableprocessors` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `jvm_memory_bytes_used` |  `ClusterName`, TaskDefinitionFamily, Bereich  | 
|  `jvm_memory_pool_bytes_used` |  `ClusterName` TaskDefinitionFamily, Schwimmbad  | 

**Anmerkung**  
Die Werte der `area`-Dimension können `heap` oder sein `nonheap`.  
Die Werte der `pool`-Dimension können `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` oder `Metaspace` sein.

**Tomcat/JMX auf Amazon-ECS-Clustern**

Zusätzlich zu den Java/JMX Metriken in der vorherigen Tabelle werden die folgenden Metriken auch für den Tomcat-Workload auf Amazon ECS-Clustern erfasst.


| Metrikname | Dimensionen | 
| --- | --- | 
|  `catalina_manager_activesessions` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `catalina_manager_rejectedsessions` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `catalina_globalrequestprocessor_bytesreceived` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `catalina_globalrequestprocessor_bytessent` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `catalina_globalrequestprocessor_requestcount` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `catalina_globalrequestprocessor_errorcount` |  `ClusterName`, `TaskDefinitionFamily`  | 
|  `catalina_globalrequestprocessor_processingtime` |  `ClusterName`, `TaskDefinitionFamily`  | 

## Prometheus-Metriken für HAProxy
<a name="ContainerInsights-Prometheus-metrics-haproxy"></a>

Die folgenden Metriken werden automatisch aus HAProxy Amazon EKS- und Kubernetes-Clustern erfasst.

Die gesammelten Metriken hängen davon ab, welche Version von HAProxy Ingress Sie verwenden. [Weitere Informationen zu HAProxy Ingress und seinen Versionen finden Sie unter haproxy-ingress.](https://artifacthub.io/packages/helm/haproxy-ingress/haproxy-ingress)


| Metrikname | Dimensionen | Verfügbarkeit | 
| --- | --- | --- | 
|  `haproxy_backend_bytes_in_total` |  `ClusterName`, `Namespace`, Service  |  HAProxy Alle Versionen von Ingress | 
|  `haproxy_backend_bytes_out_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_backend_connection_errors_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_backend_connections_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_backend_current_sessions` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_backend_http_responses_total` |  `ClusterName`, `Namespace`, Service, Code, Backend  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_backend_status` |  `ClusterName`, `Namespace`, Service  |  Nur in den Versionen 0.10 oder höher von Ingress HAProxy   | 
|  `haproxy_backend_up` |  `ClusterName`, `Namespace`, Service  |  Nur in Versionen von HAProxy Ingress vor 0.10  | 
|  `haproxy_frontend_bytes_in_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_frontend_bytes_out_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_frontend_connections_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_frontend_current_sessions` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_frontend_http_requests_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_frontend_http_responses_total` |  `ClusterName`, `Namespace`, Service, Code, Frontend  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_frontend_request_errors_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 
|  `haproxy_frontend_requests_denied_total` |  `ClusterName`, `Namespace`, Service  | Alle Versionen von Ingress HAProxy  | 

**Anmerkung**  
Die Werte der `code`-Dimension können `1xx`, `2xx`, `3xx`, `4xx`, `5xx` oder `other` sein.  
Die Werte der `backend`-Dimension können wie folgt sein:  
`http-default-backend`,`http-shared-backend`, oder `httpsback-shared-backend` für HAProxy Ingress-Version 0.0.27 oder früher.
`_default_backend`für HAProxy Ingress-Versionen nach 0.0.27.
Die Werte der `frontend`-Dimension können wie folgt sein:  
`httpfront-default-backend`,`httpfront-shared-frontend`, oder `httpfronts` für HAProxy Ingress-Version 0.0.27 oder früher.
`_front_http`oder `_front_https` für HAProxy Ingress-Versionen nach 0.0.27.

# Anzeigen Ihrer Prometheus-Metriken
<a name="ContainerInsights-Prometheus-viewmetrics"></a>

Sie können all Ihre Prometheus-Metriken überwachen und Alarme ausgeben, einschließlich der kuratierten, voraggregierten Metriken aus App Mesh, NGINX, Java/JMX, Memcached und HAProxy jedem anderen manuell konfigurierten Prometheus-Exporter, den Sie möglicherweise hinzugefügt haben. Weitere Informationen zum Erfassen von Metriken von anderen Prometheus-Exportern finden Sie unter [Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Prometheus-API-Server-Metriken](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).

 CloudWatch In der Konsole bietet Container Insights die folgenden vorgefertigten Berichte: 
+ Für Amazon-EKS- und Kubernetes-Cluster gibt es vordefinierte Berichte für App Mesh, NGINX, HAPROXY, Memcached und Java/JMX.
+ Für Amazon-ECS-Cluster gibt es vordefinierte Berichte für App Mesh und Java/JMX.

Container Insights stellt auch benutzerdefinierte Dashboards für jede der Workloads bereit, aus denen Container Insights kuratierte Metriken sammelt. Sie können diese Dashboards von herunterladen GitHub 

**So zeigen Sie alle Prometheus-Metriken an:**

1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie im Navigationsbereich **Metriken** aus.

1. **Wählen ContainerInsights Sie in der Liste der Namespaces /Prometheus oder. **ECS/ContainerInsights/Prometheus****

1. Wählen Sie einen der Dimensionssätze in der folgenden Liste aus. Markieren Sie dann das Kontrollkästchen neben den Metriken, die Sie anzeigen möchten.

**So zeigen Sie vorgefertigte Berichte zu Ihren Prometheus-Metriken an:**

1.  CloudWatch Öffnen [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)Sie die Konsole unter.

1. Wählen Sie im Navigationsbereich **Performance Monitoring (Leistungsüberwachung)** aus.

1. Wählen Sie im Dropdown-Feld oben auf der Seite eine der Prometheus-Optionen aus.

   Wählen Sie im anderen Dropdown-Feld einen Cluster aus, der angezeigt werden soll.

Wir haben auch benutzerdefinierte Dashboards für NGINX, App Mesh, Memcached und Java/JMX bereitgestellt. HAProxy

**So verwenden Sie ein von Amazon bereitgestelltes benutzerdefiniertes Dashboard:**

1.  CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)Öffnen Sie die Konsole unter.

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 eine der folgenden JSON-Dateien herunter:
   + [Benutzerdefinierte NGINX-Dashboard-Quelle auf Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/nginx-ingress/cw_dashboard_nginx_ingress_controller.json).
   + [Quelle für benutzerdefiniertes App-Mesh-Dashboard auf Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/appmesh/cw_dashboard_awsappmesh.json).
   + [ Memcached benutzerdefinierte Dashboard-Quelle auf Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json)
   + [ HAProxy-Ingress-Quelle für das benutzerdefinierte Dashboard auf Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/haproxy-ingress/cw_dashboard_haproxy_ingress.json)
   + [ Java/JMX benutzerdefinierte Dashboard-Quelle auf Github.](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/javajmx/cw_dashboard_javajmx.json)

1. Ö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_REGION}}` Zeichenketten durch die AWS Region, in der Ihr Cluster läuft. Zum Beispiel **us-west-1**. Stellen Sie sicher, dass keine Leerzeichen vor oder nach dem Text hinzugefügt werden. 
   + Ersetzen Sie alle `{{YOUR_NAMESPACE}}`-Zeichenfolgen durch den genauen Namespace Ihres Workloads.
   + Ersetzen Sie alle `{{YOUR_SERVICE_NAME}}`-Zeichenfolgen durch den genauen Servicenamen Ihres Workloads. Beispiel: **haproxy-haproxy-ingress-controller-metrics**

1. Kopieren Sie den gesamten JSON-Blob und fügen Sie ihn in das Textfeld in der CloudWatch Konsole ein. Dabei wird der Inhalt des Felds ersetzt.

1. Wählen Sie **Update (Aktualisieren)**, **Save dashboard (Dashboard speichern)**.

# Fehlerbehebung für Prometheus-Metriken
<a name="ContainerInsights-Prometheus-troubleshooting"></a>

Dieser Abschnitt enthält Hilfe zur Fehlerbehebung bei der Einrichtung Ihrer Prometheus-Metriken. 

**Topics**
+ [Fehlerbehebung bei Prometheus-Metriken in Amazon ECS](ContainerInsights-Prometheus-troubleshooting-ECS.md)
+ [Fehlerbehebung bei Prometheus-Metriken in Amazon-EKS- und Kubernetes-Clustern](ContainerInsights-Prometheus-troubleshooting-EKS.md)

# Fehlerbehebung bei Prometheus-Metriken in Amazon ECS
<a name="ContainerInsights-Prometheus-troubleshooting-ECS"></a>

Dieser Abschnitt bietet Hilfe bei der Fehlerbehebung bei der Einrichtung von Prometheus-Metriken in Amazon-ECS-Clustern. 

## Ich sehe keine an Logs gesendeten Prometheus-Metriken CloudWatch
<a name="ContainerInsights-Prometheus-troubleshooting-ECS-nometrics"></a>

**Die Prometheus-Metriken sollten als Protokollereignisse in der Protokollgruppe/aufgenommen werden. aws/ecs/containerinsights/cluster-name/Prometheus** Wenn die Protokollgruppe nicht erstellt wurde oder die Prometheus-Metriken nicht an die Protokollgruppe gesendet werden, müssen Sie zunächst überprüfen, ob die Prometheus-Ziele erfolgreich vom Agenten erkannt wurden. CloudWatch Überprüfen Sie als Nächstes die Sicherheitsgruppen und die Berechtigungseinstellungen des Agenten. CloudWatch Die folgenden Schritte führen Sie zum Debuggen.

**Schritt 1: Aktivieren Sie den CloudWatch Agenten-Debugging-Modus**

Ändern Sie zunächst den CloudWatch Agenten in den Debug-Modus, indem Sie Ihrer CloudFormation Vorlagendatei die folgenden fetten Zeilen hinzufügen, `cwagent-ecs-prometheus-metric-for-bridge-host.yaml` oder. `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` Speichern Sie dann die Datei.

```
cwagentconfig.json: |
    {
      "agent": {
        "debug": true
      },
      "logs": {
        "metrics_collected": {
```

Erstellen Sie ein neues CloudFormation Changeset für den vorhandenen Stack. Setzen Sie andere Parameter im Changeset auf dieselben Werte wie in Ihrem vorhandenen Stack. CloudFormation Das folgende Beispiel bezieht sich auf einen CloudWatch Agenten, der in einem Amazon ECS-Cluster unter Verwendung des EC2-Starttyps und des Bridge-Netzwerkmodus installiert ist.

```
ECS_NETWORK_MODE=bridge
 CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
NEW_CHANGESET_NAME=your_selected_ecs_execution_role_name

aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
    --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
    --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                 ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                 ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                 ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                 ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
    --capabilities CAPABILITY_NAMED_IAM \
    --region $AWS_REGION \
    --change-set-name $NEW_CHANGESET_NAME
```

Gehen Sie zur CloudFormation Konsole, um das neue Changeset zu überprüfen,. `$NEW_CHANGESET_NAME` Es sollte eine Änderung an der **CWAgentSSMParameterConfig-Ressource vorgenommen** werden. Führen Sie das Changeset aus und starten Sie die CloudWatch Agententask neu, indem Sie die folgenden Befehle eingeben.

```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service your_service_name_here \
--region $AWS_REGION
```

Warten Sie etwa 10 Sekunden und geben Sie den folgenden Befehl ein.

```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service your_service_name_here \
--region $AWS_REGION
```

**Schritt 2: Prüfen der ECS-Serviceerkennungsprotokolle**

Die ECS-Aufgabendefinition des CloudWatch Agenten aktiviert die Protokolle standardmäßig im folgenden Abschnitt. Die Protokolle werden an CloudWatch Logs in der Protokollgruppe **ecs-cwagent-prometheus/ecs/** gesendet.

```
LogConfiguration:
  LogDriver: awslogs
    Options:
      awslogs-create-group: 'True'
      awslogs-group: "/ecs/ecs-cwagent-prometheus"
      awslogs-region: !Ref AWS::Region
      awslogs-stream-prefix: !Sub 'ecs-${ECSLaunchType}-awsvpc'
```

Filtern Sie die Protokolle nach der Zeichenfolge `ECS_SD_Stats`, um die Metriken im Zusammenhang mit der ECS-Serviceerkennung abzurufen, wie im folgenden Beispiel gezeigt.

```
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeContainerInstances: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeInstancesRequest: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_ListTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: Exporter_DiscoveredTargetCount: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_EC2MetaData: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_ContainerInstance: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: Latency: 43.399783ms
```

Die Bedeutung jeder Metrik für einen bestimmten ECS-Serviceerkennungszyklus lautet wie folgt:
+ **AWSCLI\$1DescribeContainerInstances**— die Anzahl der getätigten `ECS::DescribeContainerInstances` API-Aufrufe.
+ **AWSCLI\$1DescribeInstancesRequest**— die Anzahl der `ECS::DescribeInstancesRequest` getätigten API-Aufrufe.
+ **AWSCLI\$1DescribeTaskDefinition**— die Anzahl der `ECS::DescribeTaskDefinition` getätigten API-Aufrufe.
+ **AWSCLI\$1DescribeTasks**— die Anzahl der `ECS::DescribeTasks` getätigten API-Aufrufe.
+ **AWSCLI\$1ListTasks**— die Anzahl der `ECS::ListTasks` getätigten API-Aufrufe.
+ **ExporterDiscoveredTargetCount**— die Anzahl der Prometheus-Ziele, die entdeckt und erfolgreich in die Zielergebnisdatei im Container exportiert wurden.
+ **LRUCache\$1Get\$1 EC2 MetaData** — die Häufigkeit, mit der Metadaten von Container-Instances aus dem Cache abgerufen wurden.
+ **LRUCache\$1Get\$1 TaskDefinition** — die Häufigkeit, mit der Metadaten der ECS-Aufgabendefinition aus dem Cache abgerufen wurden.
+ **LRUCache\$1Size\$1 ContainerInstance** — die Anzahl der Metadaten einer eindeutigen Container-Instance, die im Speicher zwischengespeichert wurden.
+ **LRUCache\$1Size\$1 TaskDefinition** — die Anzahl der eindeutigen ECS-Aufgabendefinitionen, die im Speicher zwischengespeichert sind.
+ **Latency** – wie lange der Service-Discovery-Zyklus dauert.

Überprüfen Sie den Wert von `ExporterDiscoveredTargetCount`, um zu sehen, ob die erkannten Prometheus-Ziele Ihren Erwartungen entsprechen. Wenn nicht, sind die möglichen Gründe wie folgt:
+ Die Konfiguration der ECS-Serviceerkennung stimmt möglicherweise nicht mit der Einstellung Ihrer Anwendung überein. Für die auf Docker-Labels basierende Diensterkennung ist für Ihre Zielcontainer möglicherweise nicht das erforderliche Docker-Label im CloudWatch Agenten konfiguriert, um sie auto zu erkennen. Für die auf regulären Ausdrücken basierende ARN-Diensterkennung für die ECS-Aufgabendefinition stimmt die Regex-Einstellung im CloudWatch Agenten möglicherweise nicht mit der Aufgabendefinition Ihrer Anwendung überein. 
+ Die ECS-Aufgabenrolle des CloudWatch Agenten ist möglicherweise nicht berechtigt, die Metadaten von ECS-Aufgaben abzurufen. Vergewissern Sie sich, dass dem CloudWatch Agenten die folgenden Nur-Lese-Berechtigungen gewährt wurden:
  + `ec2:DescribeInstances`
  + `ecs:ListTasks`
  + `ecs:DescribeContainerInstances`
  + `ecs:DescribeTasks`
  + `ecs:DescribeTaskDefinition`

**Schritt 3: Überprüfen Sie die Netzwerkverbindung und die ECS-Aufgabenrollenrichtlinie**

Wenn immer noch keine Protokollereignisse an die CloudWatch Log-Zielgruppe Logs gesendet werden, obwohl der Wert von `Exporter_DiscoveredTargetCount` angibt, dass es entdeckte Prometheus-Ziele gibt, kann dies folgende Ursachen haben:
+ Der CloudWatch Agent kann möglicherweise keine Verbindung zu den Prometheus-Zielports herstellen. Überprüfen Sie die Sicherheitsgruppeneinstellung hinter dem CloudWatch Agenten. Die private IP sollte es dem CloudWatch Agenten ermöglichen, eine Verbindung zu den Prometheus-Exporter-Ports herzustellen. 
+ Die ECS-Aufgabenrolle des CloudWatch Agenten verfügt möglicherweise nicht über die verwaltete Richtlinie. **CloudWatchAgentServerPolicy** Die ECS-Aufgabenrolle des CloudWatch Agenten muss über diese Richtlinie verfügen, um die Prometheus-Metriken als Protokollereignisse senden zu können. Wenn Sie die CloudFormation Beispielvorlage verwendet haben, um die IAM-Rollen automatisch zu erstellen, erhalten sowohl die ECS-Aufgabenrolle als auch die ECS-Ausführungsrolle die geringste Berechtigung zur Durchführung der Prometheus-Überwachung. 

# Fehlerbehebung bei Prometheus-Metriken in Amazon-EKS- und Kubernetes-Clustern
<a name="ContainerInsights-Prometheus-troubleshooting-EKS"></a>

Dieser Abschnitt bietet Hilfe bei der Fehlerbehebung bei der Einrichtung von Prometheus-Metriken in Amazon EKS- und Kubernetes-Clustern. 

## Schritte zur Problembehandlung bei Amazon EKS
<a name="ContainerInsights-Prometheus-troubleshooting-general"></a>

Geben Sie den folgenden Befehl ein, um zu bestätigen, dass der CloudWatch Agent ausgeführt wird.

```
kubectl get pod -n amazon-cloudwatch
```

Die Ausgabe sollte eine Zeile mit `cwagent-prometheus-id` in der Spalte `NAME` und `Running` in der Spalte `STATUS column.` sein.

Geben Sie den folgenden Befehl ein, um Details zum laufenden Pod anzuzeigen. *pod-name*Ersetzen Sie ihn durch den vollständigen Namen Ihres Pods, dessen Name mit beginnt`cw-agent-prometheus`.

```
kubectl describe pod pod-name -n amazon-cloudwatch
```

Wenn Sie CloudWatch Container Insights installiert haben, können Sie Logs Insights verwenden, um die CloudWatch Logs von dem CloudWatch Agenten abzufragen, der die Prometheus-Metriken sammelt.

**So fragen Sie die Anwendungsprotokolle ab:**

1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie im Navigationsbereich **CloudWatch Logs Insights** aus.

1. Wählen Sie die Protokollgruppe für die Anwendungsprotokolle, **/aws/containerinsights/ /application *cluster-name***

1. Ersetzen Sie den Suchabfrageausdruck durch die folgende Abfrage und wählen Sie **Run query (Abfrage ausführen)**

   ```
   fields ispresent(kubernetes.pod_name) as haskubernetes_pod_name, stream, kubernetes.pod_name, log | 
   filter haskubernetes_pod_name and kubernetes.pod_name like /cwagent-prometheus
   ```

Sie können auch bestätigen, dass Prometheus-Metriken und -Metadaten als CloudWatch Logs-Ereignisse aufgenommen werden.

**So bestätigen Sie, dass Prometheus-Daten aufgenommen werden:**

1. Öffnen Sie die Konsole unter CloudWatch . [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie im Navigationsbereich **CloudWatch Logs Insights** aus.

1. Wählen Sie **/aws/containerinsights/ /prometheus *cluster-name***

1. Ersetzen Sie den Suchabfrageausdruck durch die folgende Abfrage und wählen Sie **Run query (Abfrage ausführen)**

   ```
   fields @timestamp, @message | sort @timestamp desc | limit 20
   ```

## Protokollierung von gelöschten Prometheus-Metriken
<a name="ContainerInsights-Prometheus-troubleshooting-droppedmetrics"></a>

In dieser Version werden keine Prometheus-Metriken des Histogrammtyps erfasst. Sie können den CloudWatch Agenten verwenden, um zu überprüfen, ob Prometheus-Metriken gelöscht wurden, da es sich um Histogramm-Metriken handelt. Sie können auch eine Liste der ersten 500 Prometheus-Metriken protokollieren, die gelöscht und nicht an sie gesendet wurden, CloudWatch da es sich um Histogramm-Metriken handelt.

Um festzustellen, ob Metriken gelöscht werden, geben Sie den folgenden Befehl ein:

```
kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
```

Wenn Metriken gelöscht werden, werden die folgenden Zeilen in der `/opt/aws/amazon-cloudwatch-agent/logs/amazon-cloudwatch-agent.log`-Datei angezeigt.

```
I! Drop Prometheus metrics with unsupported types. Only Gauge, Counter and Summary are supported.
I! Please enable CWAgent debug mode to view the first 500 dropped metrics
```

Wenn Sie diese Zeilen sehen und wissen möchten, welche Metriken gelöscht werden, führen Sie die folgenden Schritte aus.

**So protokollieren Sie eine Liste der gelöschten Prometheus-Metriken:**

1. Versetzen Sie den CloudWatch Agenten in den Debug-Modus, indem Sie Ihrer OR-Datei die folgenden fetten Zeilen hinzufügen, und `prometheus-eks.yaml` speichern Sie die `prometheus-k8s.yaml` Datei.

   ```
   {
         "agent": {
           "debug": true
         },
   ```

   Dieser Abschnitt der Datei sollte dann wie folgt aussehen:

   ```
   cwagentconfig.json: |
       {
         "agent": {
           "debug": true
         },
         "logs": {
           "metrics_collected": {
   ```

1. Installieren Sie den CloudWatch Agenten erneut, um den Debug-Modus zu aktivieren, indem Sie die folgenden Befehle eingeben:

   ```
   kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
   kubectl apply -f prometheus.yaml
   ```

   Die gelöschten Metriken werden im CloudWatch Agent-Pod protokolliert.

1. Geben Sie den folgenden Befehl ein, um die Protokolle aus dem CloudWatch Agenten-Pod abzurufen:

   ```
   kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
   ```

   Oder, wenn Sie Container Insights Fluentd Logging installiert haben, werden die Protokolle auch in der Logs-Protokollgruppe CloudWatch **/aws/containerinsights/ *cluster\$1name* /application** gespeichert.

   Um diese Protokolle abzufragen, können Sie die Schritte zum Abfragen der Anwendungsprotokolle in [Schritte zur Problembehandlung bei Amazon EKS](#ContainerInsights-Prometheus-troubleshooting-general) befolgen.

## Wo werden die Prometheus-Metriken als CloudWatch Log-Log-Ereignisse aufgenommen?
<a name="ContainerInsights-Prometheus-troubleshooting-metrics_ingested"></a>

Der CloudWatch Agent erstellt einen Protokollstream für jede Prometheus-Scrape-Job-Konfiguration. Beispiel: In den Dateien `prometheus-eks.yaml` und `prometheus-k8s.yaml` führt die Zeile `job_name: 'kubernetes-pod-appmesh-envoy'` das Scraping der App-Mesh-Metriken durch. Das Prometheus-Ziel ist definiert als `kubernetes-pod-appmesh-envoy`. **Daher werden alle App Mesh Prometheus-Metriken als CloudWatch Logs-Ereignisse in den Protokollstream **kubernetes-pod-appmesh-envoy**unter der Protokollgruppe mit dem Namen/aufgenommen. aws/containerinsights/cluster-name/Prometheus**

## Ich sehe keine Amazon EKS- oder Kubernetes Prometheus-Metriken in den Metriken CloudWatch
<a name="ContainerInsights-Prometheus-troubleshooting-no-metrics"></a>

**Stellen Sie zunächst sicher, dass die Prometheus-Metriken als Protokollereignisse in der Protokollgruppe/aufgenommen werden. aws/containerinsights/cluster-name/Prometheus** Verwenden Sie die Informationen in [Wo werden die Prometheus-Metriken als CloudWatch Log-Log-Ereignisse aufgenommen?](#ContainerInsights-Prometheus-troubleshooting-metrics_ingested), um den Zielprotokoll-Stream zu überprüfen. Wenn der Protokoll-Stream nicht erstellt wird oder keine neuen Protokollereignisse im Protokoll-Stream vorhanden sind, überprüfen Sie Folgendes:
+ Überprüfen Sie, ob die Prometheus-Metrik-Exporter-Endpunkte korrekt eingerichtet sind
+ Überprüfen Sie, ob die Prometheus-Scraping-Konfigurationen im `config map: cwagent-prometheus` Abschnitt der CloudWatch Agenten-YAML-Datei korrekt sind. Die Konfiguration sollte die gleiche sein wie in einer Prometheus-Konfigurationsdatei. Weitere Informationen finden Sie unter [ <scrape\$1config>](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) in der Prometheus-Dokumentation.

Wenn die Prometheus-Metriken korrekt als Protokollereignisse aufgenommen wurden, überprüfen Sie, ob die Einstellungen für das eingebettete Metrikformat zu den Protokollereignissen hinzugefügt wurden, um die Metriken zu generieren. CloudWatch 

```
"CloudWatchMetrics":[
   {
      "Metrics":[
         {
            "Name":"envoy_http_downstream_cx_destroy_remote_active_rq"
         }
      ],
      "Dimensions":[
         [
            "ClusterName",
            "Namespace"
         ]
      ],
      "Namespace":"ContainerInsights/Prometheus"
   }
],
```

Weitere Hinweise zum eingebetteten Metrik-Format finden Sie unter [Spezifikation: Eingebettetes Metrikformat](CloudWatch_Embedded_Metric_Format_Specification.md).

Wenn die Protokollereignisse kein eingebettetes metrisches Format enthalten, überprüfen Sie, ob der `metric_declaration` Abschnitt im Abschnitt der YAML-Datei für die `config map: prometheus-cwagentconfig` CloudWatch Agenteninstallation korrekt konfiguriert ist. Weitere Informationen finden Sie unter [Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Prometheus-API-Server-Metriken](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).