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