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.
# Einrichten und Konfigurieren der Prometheus-Metrikensammlung in Amazon-ECS-Clustern
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
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
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
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
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
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
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
Der CloudWatch Agent mit Prometheus-Überwachung benötigt zwei Konfigurationen, um die Prometheus-Metriken zu erfassen. Er folgt der standardmäßigen Prometheus-Konfiguration, wie in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) in der Prometheus-Dokumentation erläutert. Die andere ist für die Agentenkonfiguration vorgesehen. CloudWatch
Für Amazon-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
Der CloudWatch Agent unterstützt die standardmäßigen Prometheus-Scrape-Konfigurationen, wie[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) in der Prometheus-Dokumentation dokumentiert. Sie können diesen Abschnitt bearbeiten, um die Konfigurationen zu aktualisieren, die sich bereits in dieser Datei befinden, und zusätzliche Prometheus-Scraping-Ziele hinzufügen. Standardmäßig enthält die Beispielkonfigurationsdatei die folgenden globalen Konfigurationszeilen:
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval** – Definiert, wie oft das Scraping von zielen durchgeführt werden soll.
+ **scrape\$1timeout** – Definiert, wie lange gewartet werden soll, bis für eine Scrape-Anforderung eine Zeitüberschreitung eintritt.
Sie können auch verschiedene Werte für diese Einstellungen auf Auftragsebene definieren, um die globalen Konfigurationen zu überschreiben.
### Prometheus-Scraping-Aufträge
Für die YAML-Dateien des CloudWatch Agenten sind bereits einige Standard-Scraping-Jobs konfiguriert. In 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
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
Prometheus bietet Dutzende dynamischer Service-Discovery-Mechanismen, wie in [](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 [](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
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
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
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
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
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
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
Zum Installieren des NGINX-Reverse-Proxy-Beispiel-Workloads führen Sie die folgenden Schritte aus.
### Erstellen der Docker-Images
**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
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
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
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
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
Zum Installieren des NGINX-Reverse-Proxy-Beispiel-Workloads führen Sie die folgenden Schritte aus.
### Erstellen der Docker-Images
**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 “
# 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
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
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
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
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
**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
**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
**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
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
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
**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
**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
**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
**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
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" \
```