Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

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

Um die Unterstützung von Prometheus-Metriken in CloudWatch Container Insights zu testen, können Sie einen oder mehrere der folgenden containerisierten Workloads einrichten. Der CloudWatch Agent mit Prometheus-Unterstützung sammelt automatisch Metriken von jeder dieser Workloads. Informationen zum Anzeigen der Metriken, die standardmäßig erfasst werden, finden Sie unter [Vom Agenten gesammelte Prometheus-Metriken CloudWatch](ContainerInsights-Prometheus-metrics.md).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

**Fehlersuche**

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

```
$ aws configure
```

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

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

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

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

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

JMX Exporter ist ein offizieller Prometheus-Exporter, der JMX mBeans als Prometheus-Metriken erfassen und verfügbar machen kann. Weitere Informationen finden Sie unter [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).

Der CloudWatch Agent mit Prometheus-Unterstützung scannt die Java/JMX Prometheus-Metriken auf der Grundlage der Service Discovery-Konfiguration im Amazon ECS-Cluster. Sie können den JMX Exporter so konfigurieren, dass die Metriken auf einem anderen Port oder metrics\$1path verfügbar gemacht werden. Wenn Sie den Port oder Pfad ändern, aktualisieren Sie den `ecs_service_discovery` Standardabschnitt in der Agentenkonfiguration. CloudWatch 

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

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

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

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

   Im Folgenden wird ein Beispiel gezeigt:

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

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

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

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

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

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

Der CloudWatch Agent mit Prometheus-Unterstützung scannt die NGINX Prometheus-Metriken auf der Grundlage der Service Discovery-Konfiguration im Amazon ECS-Cluster. Sie können den NGINX Prometheus Exporter so konfigurieren, dass die Metriken auf einem anderen Port oder metrics\$1path verfügbar gemacht werden. Wenn Sie den Port oder Pfad ändern, aktualisieren Sie den Abschnitt in der `ecs_service_discovery` Agenten-Konfigurationsdatei. CloudWatch 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Als Nächstes richten Sie die Aufgabendefinition ein.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Der CloudWatch Agent mit Prometheus-Unterstützung scannt die NGINX Plus Prometheus-Metriken auf der Grundlage der Service Discovery-Konfiguration im Amazon ECS-Cluster. Sie können den NGINX Prometheus Exporter so konfigurieren, dass die Metriken auf einem anderen Port oder metrics\$1path verfügbar gemacht werden. Wenn Sie den Port oder Pfad ändern, aktualisieren Sie den Abschnitt in der `ecs_service_discovery` Agenten-Konfigurationsdatei. CloudWatch 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Als Nächstes richten Sie die Aufgabendefinition ein.

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

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

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

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

1. Registrieren Sie die Aufgabendefinition:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

**Voraussetzung**

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

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

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

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

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

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

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

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

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

   Das erwartete Ergebnis dieses Befehls lautet wie folgt:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

Redis OSS (https://redis.io/) ist ein Open Source (BSD lizenziert), In-Memory-Datenstrukturspeicher, der als Datenbank, Cache und Message Broker verwendet wird. Weitere Informationen finden Sie unter [redis](https://redis.io/).

redis\$1exporter (mit MIT-Lizenz lizenziert) wird verwendet, um die Redis-OSS-Prometheus-Metriken auf dem angegebenen Port verfügbar zu machen (Standard: 0.0.0.0:9121). Weitere Informationen finden Sie unter [redis\$1exporter](https://github.com/oliver006/redis_exporter).

Die Docker-Images in den folgenden zwei Docker Hub-Repositories werden in diesem Tutorial verwendet: 
+ [ redis](https://hub.docker.com/_/redis?tab=description)
+ [ redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)

**Voraussetzung**

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

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

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

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

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

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

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

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

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

   Das erwartete Ergebnis dieses Befehls lautet wie folgt:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  ```
  ECS_PROMETHEUS_EXPORTER_PORT: 9121
  ```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


| Metrikname | Dimensionen | 
| --- | --- | 
|  `redis_net_input_bytes_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_net_output_bytes_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_expired_keys_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_evicted_keys_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_keyspace_hits_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_keyspace_misses_total` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_memory_used_bytes` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_connected_clients` |  ClusterName, `TaskDefinitionFamily`  | 
|  `redis_commands_total` |  ` ClusterName`, `TaskDefinitionFamily`, `cmd`  | 
|  `redis_db_keys` |  `ClusterName`, `TaskDefinitionFamily`, `db`  | 

**Anmerkung**  
Die Werte der **cmd**-Dimension können `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` oder `slowlog` sein.  
Die Werte der **Db**-Dimension können `db0` oder `db15` sein. 

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

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

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

   ```
   DASHBOARD_NAME=your_cw_dashboard_name
   ECS_TASK_DEF_FAMILY=redis-prometheus-demo-$ECS_CLUSTER_NAME-fargate-awsvpc
   ```

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

   ```
   curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/redis/cw_dashboard_redis.json \
   | sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
   | sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
   | sed "s/{{YOUR_NAMESPACE}}/${NAMESPACE}/g" \
   ```