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. # AWS Distro for OpenTelemetry als Collector verwenden In diesem Abschnitt wird beschrieben, wie Sie den AWS Distro for OpenTelemetry (ADOT) Collector so konfigurieren, dass er aus einer mit Prometheus instrumentierten Anwendung scrapt und die Metriken an Amazon Managed Service for Prometheus sendet. [Weitere Informationen zum ADOT Collector finden Sie unter Distro for.AWS OpenTelemetry](https://aws.amazon.com/otel/) In den folgenden Themen werden drei verschiedene Möglichkeiten beschrieben, ADOT als Collector für Ihre Metriken einzurichten, je nachdem, ob Ihre Metriken von Amazon EKS, Amazon ECS oder einer Amazon EC2 EC2-Instance stammen. **Topics** + [Richten Sie die Erfassung von Metriken mit AWS Distro for OpenTelemetry auf einem Amazon Elastic Kubernetes Service Service-Cluster ein](AMP-onboard-ingest-metrics-OpenTelemetry.md) + [Richten Sie mithilfe von AWS Distro for Open Telemetry die Erfassung von Metriken aus Amazon ECS ein](AMP-onboard-ingest-metrics-OpenTelemetry-ECS.md) + [Einrichten der Erfassung von Metriken aus einer Amazon-EC2-Instance mithilfe von Remote-Write](AMP-onboard-ingest-metrics-remote-write-EC2.md) # Richten Sie die Erfassung von Metriken mit AWS Distro for OpenTelemetry auf einem Amazon Elastic Kubernetes Service Service-Cluster ein Sie können den Collector AWS Distro for OpenTelemetry (ADOT) verwenden, um Metriken aus einer mit Prometheus instrumentierten Anwendung zu extrahieren und die Metriken an Amazon Managed Service for Prometheus zu senden. **Anmerkung** [Weitere Informationen zum ADOT-Collector finden Sie unter Distro for.AWS OpenTelemetry](https://aws.amazon.com/otel/) Weitere Informationen zu mit Prometheus instrumentierten Anwendungen finden Sie unter. [Was sind Prometheus-kompatible Metriken?](prom-compatible-metrics.md) Das Sammeln von Prometheus-Metriken mit ADOT umfasst drei OpenTelemetry Komponenten: den Prometheus Receiver, den Prometheus Remote Write Exporter und die Sigv4 Authentication Extension. Sie können den Prometheus-Empfänger mithilfe Ihrer vorhandenen Prometheus-Konfiguration konfigurieren, um die Serviceerkennung und das Metrik-Scraping durchzuführen. Der Prometheus Receiver erfasst Metriken im Prometheus-Expositionsformat. Alle Anwendungen oder Endpunkte, die Sie scrapen möchten, sollten mit der Prometheus-Client-Bibliothek konfiguriert werden. Der Prometheus Receiver unterstützt alle Prometheus-Konfigurationen zum Scraping und Umetikettieren, die in der Prometheus-Dokumentation unter [Konfiguration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) beschrieben sind. Sie können diese Konfigurationen direkt in Ihre ADOT Kollektor-Konfigurationen einfügen. Der Prometheus Remote Write Exporter verwendet den `remote_write`-Endpunkt, um die gesammelten Metriken an Ihren Management-Portal-Workspace zu senden. Die HTTP-Anfragen zum Export von Daten werden mit Sigv4, dem AWS Protokoll für sichere Authentifizierung, mit der AWS Sigv4 Authentication Extension signiert. Weitere Informationen finden Sie unter [Signatur Version 4-Signierungsprozess](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html). Der Kollektor erkennt automatisch Prometheus-Metriken-Endpunkte auf Amazon EKS und verwendet die Konfiguration unter [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config). Die folgende Demo ist ein Beispiel für diese Konfiguration auf einem Cluster, auf dem Amazon Elastic Kubernetes Service oder selbstverwaltetes Kubernetes ausgeführt wird. Um diese Schritte ausführen zu können, benötigen Sie AWS Anmeldeinformationen aus einer der möglichen Optionen in der Kette der AWS Standardanmeldedaten. Weitere Informationen finden Sie unter [Konfiguration des AWS SDK for Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html). In dieser Demo wird eine Beispiel-App genutzt, die für Integrationstests des Prozesses verwendet wird. Die Beispiel-App stellt Metriken am `/metrics`-Endpunkt bereit, wie die Prometheus-Client-Bibliothek. ## Voraussetzungen Bevor Sie mit den folgenden Schritten zur Einrichtung der Datenerfassung beginnen, müssen Sie Ihre IAM-Rolle für das Servicekonto und die Vertrauensrichtlinie einrichten. **So richten Sie die IAM-Rolle für das Servicekonto und die Vertrauensrichtlinie ein** 1. Erstellen Sie die IAM-Rolle für das Servicekonto, indem Sie die Schritte unter [Einrichten von Servicerollen für die Erfassung von Metriken aus Amazon-EKS-Clustern](set-up-irsa.md#set-up-irsa-ingest) befolgen. Der ADOT Kollektor verwendet diese Rolle, wenn er Metriken erfasst und exportiert. 1. Bearbeiten Sie als Nächstes die Vertrauensrichtlinie. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/home) die IAM-Konsole. 1. Wählen Sie im linken Navigationsbereich **Rollen** aus und suchen Sie nach den Rollen **amp-iamproxy-ingest-role**, die Sie in Schritt 1 erstellt haben. 1. Wählen Sie die Registerkarte **Vertrauensbeziehungen** und dann **Vertrauensbeziehung bearbeiten** aus. 1. Ersetzen Sie in der JSON-Vertrauenbeziehungsrichtlinie `aws-amp` durch `adot-col` und wählen Sie dann **Vertrauensrichtlinie aktualisieren** aus. Das Ergebnis Ihrer Vertrauensbeziehungsrichtlinie sollte wie folgt aussehen: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE" }, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": { "StringEquals": { "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account", "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com" } } } ] } ``` ------ 1. Wählen Sie die Registerkarte **Berechtigungen** und stellen Sie sicher, dass die folgende Berechtigungsrichtlinie an die Rolle angehängt ist. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "aps:RemoteWrite", "aps:GetSeries", "aps:GetLabels", "aps:GetMetricMetadata" ], "Resource": "*" } ] } ``` ------ ## Erfassung der Prometheus-Metriken aktivieren **Anmerkung** Wenn Sie einen Namespace in Amazon EKS erstellen, sind `alertmanager` und Node Exporter standardmäßig deaktiviert. **So aktivieren Sie die Prometheus-Erfassung auf einem Amazon-EKS- oder Kubernetes-Cluster** 1. Forken und klonen Sie die Beispiel-App aus dem Repository unter [aws-otel-community](https://github.com/aws-observability/aws-otel-community). Führen Sie anschließend folgende Befehle aus. ``` cd ./sample-apps/prometheus-sample-app docker build . -t prometheus-sample-app:latest ``` 1. Push dieses Image in eine Registry wie Amazon ECR oder DockerHub. 1. Stellen Sie die Beispiel-App im Cluster bereit, indem Sie diese Kubernetes-Konfiguration kopieren und anwenden. Ändern Sie das Bild in das Bild, das Sie gerade übertragen haben, indem Sie `{{PUBLIC_SAMPLE_APP_IMAGE}}` in der `prometheus-sample-app.yaml` Datei ersetzen. ``` curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-sample-app.yaml -o prometheus-sample-app.yaml kubectl apply -f prometheus-sample-app.yaml ``` 1. Geben Sie den folgenden Befehl ein, um zu überprüfen, ob die Beispiel-App gestartet wurde. In der Ausgabe des Befehls sehen Sie `prometheus-sample-app` in der `NAME` Spalte. ``` kubectl get all -n aoc-prometheus-pipeline-demo ``` 1. Starten Sie eine Standard-Instance des ADOT Kollektors. Geben Sie dazu zunächst den folgenden Befehl ein, um die Kubernetes-Konfiguration für ADOT Kollektor abzurufen. ``` curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-daemonset.yaml -o prometheus-daemonset.yaml ``` Bearbeiten Sie dann die Vorlagendatei und ersetzen Sie den **remote\$1write**-Endpunkt für Ihren Workspace in Amazon Managed Service für Prometheus durch `YOUR_ENDPOINT` und Ihre Region durch `YOUR_REGION`. Verwenden Sie den **remote\$1write**-Endpunkt, der in der Konsole von Amazon Managed Service für Prometheus angezeigt wird, wenn Sie sich Ihre Workspace-Details ansehen. Sie müssen außerdem `YOUR_ACCOUNT_ID` im Bereich Dienstkonto der Kubernetes-Konfiguration Ihre AWS Konto-ID ändern. In diesem Beispiel verwendet die ADOT Kollektor-Konfiguration eine Anmerkung (`scrape=true`), um anzugeben, welche Zielendpunkte gescrapt werden sollen. Auf diese Weise kann der ADOT Kollektor den Endpunkt der Beispiel-App von den Endpunkten des Kube-Systems in Ihrem Cluster unterscheiden. Sie können dies aus den Konfigurationen der Umetikettierung entfernen, wenn Sie eine andere Beispiel-App entfernen möchten. 1. Geben Sie den folgenden Befehl ein, um den ADOT Kollektor bereitzustellen. ``` kubectl apply -f prometheus-daemonset.yaml ``` 1. Geben Sie den folgenden Befehl ein, um zu überprüfen, ob der ADOT Kollektor gestartet wurde. Suchen Sie nach `adot-col` in der `NAMESPACE` Spalte. ``` kubectl get pods -n adot-col ``` 1. Stellen Sie mithilfe des Protokoll-Exporters sicher, dass die Pipeline funktioniert. Unsere Beispielvorlage ist bereits in den Protokoll-Exporter integriert. Geben Sie die folgenden Befehle ein. ``` kubectl get pods -A kubectl logs -n adot-col name_of_your_adot_collector_pod ``` Einige der aus der Beispiel-App gewonnenen Metriken sehen wie im folgenden Beispiel aus. ``` Resource labels: -> service.name: STRING(kubernetes-service-endpoints) -> host.name: STRING(192.168.16.238) -> port: STRING(8080) -> scheme: STRING(http) InstrumentationLibraryMetrics #0 Metric #0 Descriptor: -> Name: test_gauge0 -> Description: This is my gauge -> Unit: -> DataType: DoubleGauge DoubleDataPoints #0 StartTime: 0 Timestamp: 1606511460471000000 Value: 0.000000 ``` 1. Um zu testen, ob Amazon Managed Service für Prometheus die Messwerte erhalten hat, verwenden Sie `awscurl`. [Mit diesem Tool können Sie HTTP-Anfragen über die Befehlszeile mit AWS Sigv4-Authentifizierung senden. Sie müssen also lokal über AWS Anmeldeinformationen mit den richtigen Berechtigungen für Abfragen von Amazon Managed Service for Prometheus verfügen. Anweisungen zur Installation finden Sie unter awscurl`awscurl`.](https://github.com/okigan/awscurl) Ersetzen Sie `AMP_REGION` im folgenden Befehl und `AMP_ENDPOINT` durch die Informationen für Ihren . ``` awscurl --service="aps" --region="AMP_REGION" "https://AMP_ENDPOINT/api/v1/query?query=adot_test_gauge0" {"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"adot_test_gauge0"},"value":[1606512592.493,"16.87214000011479"]}]}} ``` Wenn Sie als Antwort eine Metrik erhalten, bedeutet das, dass Ihre Pipeline-Einrichtung erfolgreich war und die Metrik erfolgreich von der Beispiel-App an Amazon Managed Service für Prometheus weitergegeben wurde. **Bereinigen** Geben Sie die folgenden Befehle ein, um diese Demo zu bereinigen. ``` kubectl delete namespace aoc-prometheus-pipeline-demo kubectl delete namespace adot-col ``` ## Erweiterte Konfiguration Der Prometheus Receiver unterstützt alle Prometheus-Konfigurationen zum Scraping und Umetikettieren, die in der Prometheus-Dokumentation unter [Konfiguration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) beschrieben sind. Sie können diese Konfigurationen direkt in Ihre ADOT Kollektor-Konfigurationen einfügen. Die Konfiguration für den Prometheus Receiver umfasst Ihre Serviceerkennung, Scraping-Konfigurationen und Umetikettierungs-Konfigurationen. Die Konfiguration des Empfängers sieht wie folgt aus. ``` receivers: prometheus: config: [[Your Prometheus configuration]] ``` Folgendes ist ein Konfigurationsbeispiel: ``` receivers: prometheus: config: global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: kubernetes-service-endpoints sample_limit: 10000 kubernetes_sd_configs: - role: endpoints tls_config: ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt insecure_skip_verify: true bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token ``` Wenn Sie über eine bestehende Prometheus-Konfiguration verfügen, müssen Sie die `$` Zeichen durch `$$` ersetzen, um zu vermeiden, dass die Werte durch Umgebungsvariablen ersetzt werden. \$1 Dies ist besonders wichtig für den Ersatzwert der relabel\$1configurations. Wenn Sie beispielsweise mit der folgenden relabel\$1configuration beginnen: ``` relabel_configs: - source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path] regex: (.+);(.+);(.+) replacement: ${1}://${2}${3} target_label: __param_target ``` Es würde wie folgt werden: ``` relabel_configs: - source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path] regex: (.+);(.+);(.+) replacement: $${1}://${2}${3} target_label: __param_target ``` **Prometheus Remote Write Exporter und SigV4-Authentifizierungserweiterung** Die Konfiguration für den Prometheus Remote Write Exporter und die SigV4-Authentifizierungserweiterung ist einfacher als für den Prometheus-Empfänger. In dieser Phase der Pipeline wurden die Metriken bereits erfasst und wir sind bereit, diese Daten in Amazon Managed Service für Prometheus zu exportieren. Die Mindestanforderung für eine erfolgreiche Konfiguration für die Kommunikation mit Amazon Managed Service für Prometheus ist im folgenden Beispiel dargestellt. ``` extensions: sigv4auth: service: "aps" region: "user-region" exporters: prometheusremotewrite: endpoint: "https://aws-managed-prometheus-endpoint/api/v1/remote_write" auth: authenticator: "sigv4auth" ``` Diese Konfiguration sendet eine HTTPS-Anfrage, die von AWS Sigv4 mithilfe von AWS Anmeldeinformationen aus der standardmäßigen Anmeldeinformationskette signiert wurde. AWS Weitere Informationen finden Sie unter [Konfigurieren der AWS SDK für Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html). Sie müssen den Service als `aps` angeben. Unabhängig von der Bereitstellungsmethode muss der ADOT-Collector Zugriff auf eine der aufgelisteten Optionen in der Kette der AWS Standardanmeldedaten haben. Die Sigv4-Authentifizierungserweiterung hängt von der ab AWS SDK für Go und verwendet sie, um Anmeldeinformationen abzurufen und sich zu authentifizieren. Sie müssen sicherstellen, dass diese Anmeldeinformationen über Remote-Write-Berechtigungen für Amazon Managed Service für Prometheus verfügen. # Richten Sie mithilfe von AWS Distro for Open Telemetry die Erfassung von Metriken aus Amazon ECS ein In diesem Abschnitt wird erklärt, wie Sie Metriken von Amazon Elastic Container Service (Amazon ECS) sammeln und sie mithilfe von AWS Distro for Open Telemetry (ADOT) in Amazon Managed Service for Prometheus aufnehmen. Außerdem wird beschrieben, wie Sie Ihre Metriken in Amazon Managed Grafana anzeigen können. ## Voraussetzungen **Wichtig** Bevor Sie beginnen, benötigen Sie eine Amazon-ECS-Umgebung auf einem AWS Fargate -Cluster mit Standardeinstellungen, einen Workspace in Amazon Managed Service für Prometheus und einen Workspace in Amazon Managed Grafana. Wir gehen davon aus, dass Sie mit Container-Workloads, Amazon Managed Service für Prometheus und Amazon Managed Grafana vertraut sind. Weitere Informationen finden Sie unter den folgenden Links: + Informationen zum Erstellen einer Amazon ECS-Umgebung auf einem Fargate-Cluster mit Standardeinstellungen finden Sie unter [Erstellen eines Clusters](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) im *Amazon ECS-Entwicklerhandbuch*. + Informationen zum Erstellen eines Workspace in Amazon Managed Service für Prometheus finden Sie unter [Einen Workspace erstellen](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html) im *Benutzerhandbuch von Amazon Managed Service für Prometheus*. + Informationen zum Erstellen eines Workspace in Amazon Managed Grafana-finden Sie unter [Einen Workspace erstellen](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-create-workspace.html) im *Benutzerhandbuch von Amazon Managed Grafana*. ## Schritt 1: Definieren Sie ein benutzerdefiniertes ADOT-Collector-Container-Image Verwenden Sie die folgende Konfigurationsdatei als Vorlage, um Ihr eigenes ADOT-Kollektor-Container-Image zu definieren. Ersetzen Sie *my-remote-URL* und *my-region* durch Ihre `region` Werte `endpoint` und. Speichern Sie die Konfiguration in einer Datei namens *adot-config.yaml*. **Anmerkung** Diese Konfiguration verwendet die `sigv4auth` Erweiterung zur Authentifizierung von Aufrufen an Amazon Managed Service für Prometheus. Weitere Informationen zur Konfiguration `sigv4auth` finden Sie unter [Authenticator — Sigv4 on](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/sigv4authextension). GitHub ``` receivers: prometheus: config: global: scrape_interval: 15s scrape_timeout: 10s scrape_configs: - job_name: "prometheus" static_configs: - targets: [ 0.0.0.0:9090 ] awsecscontainermetrics: collection_interval: 10s processors: filter: metrics: include: match_type: strict metric_names: - ecs.task.memory.utilized - ecs.task.memory.reserved - ecs.task.cpu.utilized - ecs.task.cpu.reserved - ecs.task.network.rate.rx - ecs.task.network.rate.tx - ecs.task.storage.read_bytes - ecs.task.storage.write_bytes exporters: prometheusremotewrite: endpoint: my-remote-URL auth: authenticator: sigv4auth logging: loglevel: info extensions: health_check: pprof: endpoint: :1888 zpages: endpoint: :55679 sigv4auth: region: my-region service: aps service: extensions: [pprof, zpages, health_check, sigv4auth] pipelines: metrics: receivers: [prometheus] exporters: [logging, prometheusremotewrite] metrics/ecs: receivers: [awsecscontainermetrics] processors: [filter] exporters: [logging, prometheusremotewrite] ``` ## Schritt 2: Übertragen Sie Ihr ADOT-Collector-Container-Image in ein Amazon ECR-Repository Verwenden Sie ein Dockerfile, um Ihr Container-Image zu erstellen und in ein Repository von Amazon Elastic Container Registry (ECR) zu pushen. 1. Erstellen Sie das Dockerfile, um Ihr Container-Image zu kopieren und dem OTEL Docker-Image hinzuzufügen. ``` FROM public.ecr.aws/aws-observability/aws-otel-collector:latest COPY adot-config.yaml /etc/ecs/otel-config.yaml CMD ["--config=/etc/ecs/otel-config.yaml"] ``` 1. Erstellen Sie ein Amazon-ECR-Repository. ``` # create repo: COLLECTOR_REPOSITORY=$(aws ecr create-repository --repository aws-otel-collector \ --query repository.repositoryUri --output text) ``` 1. Erstellen Sie Ihr Container-Image. ``` # build ADOT collector image: docker build -t $COLLECTOR_REPOSITORY:ecs . ``` **Anmerkung** Dies setzt voraus, dass Sie Ihren Container in derselben Umgebung erstellen, in der er ausgeführt werden soll. Wenn nicht, müssen Sie den `--platform` Parameter möglicherweise beim Erstellen des Images verwenden. 1. Melden Sie sich im Amazon-ECR-Repository an. Ersetzen Sie es *my-region* durch Ihren Wert`region`. ``` # sign in to repo: aws ecr get-login-password --region my-region | \ docker login --username AWS --password-stdin $COLLECTOR_REPOSITORY ``` 1. Pushen Sie Ihr Container-Image. ``` # push ADOT collector image: docker push $COLLECTOR_REPOSITORY:ecs ``` ## Schritt 3: Erstellen Sie eine Amazon ECS-Aufgabendefinition, um Amazon Managed Service for Prometheus zu scrapen Erstellen Sie eine Amazon-ECS-Aufgabendefinition zum Scrapen von Amazon Managed Service für Prometheus. Ihre Aufgabendefinition sollte einen Container mit dem Namen `adot-collector` und einen Container mit dem Namen `prometheus` enthalten. `prometheus` generiert Metriken und `adot-collector` Scrapes`prometheus`. **Anmerkung** Amazon Managed Service für Prometheus wird als Service ausgeführt und sammelt Metriken aus Containern. In diesem Fall führen die Container Prometheus lokal im Agentenmodus aus, wodurch die lokalen Metriken an Amazon Managed Service für Prometheus gesendet werden. **Beispiel: Aufgabendefinition** Im Folgenden finden Sie ein Beispiel dafür, wie Ihre Aufgabendefinition aussehen kann. Sie können dieses Beispiel als Vorlage verwenden, um Ihre eigene Aufgabendefinition zu erstellen. Ersetzen Sie den `image`-Wert von `adot-collector` durch Ihre Repository-URL und Ihr Bild-Tag (`$COLLECTOR_REPOSITORY:ecs`). Ersetzen Sie die `region`-Werte von `adot-collector` und `prometheus` durch Ihre `region`-Werte. ``` { "family": "adot-prom", "networkMode": "awsvpc", "containerDefinitions": [ { "name": "adot-collector", "image": "account_id.dkr.ecr.region.amazonaws.com/image-tag", "essential": true, "logConfiguration": { "logDriver": "awslogs", "options": { "awslogs-group": "/ecs/ecs-adot-collector", "awslogs-region": "my-region", "awslogs-stream-prefix": "ecs", "awslogs-create-group": "True" } } }, { "name": "prometheus", "image": "prom/prometheus:main", "logConfiguration": { "logDriver": "awslogs", "options": { "awslogs-group": "/ecs/ecs-prom", "awslogs-region": "my-region", "awslogs-stream-prefix": "ecs", "awslogs-create-group": "True" } } } ], "requiresCompatibilities": [ "FARGATE" ], "cpu": "1024" } ``` ## Schritt 4: Erteilen Sie Ihrer Aufgabe Berechtigungen für den Zugriff auf Amazon Managed Service for Prometheus Um die gesammelten Metriken an Amazon Managed Service for Prometheus zu senden, muss Ihre Amazon ECS-Aufgabe über die richtigen Berechtigungen verfügen, um die AWS API-Operationen für Sie aufzurufen. Sie müssen eine IAM-Rolle für Ihre Aufgaben erstellen und die `AmazonPrometheusRemoteWriteAccess`-Richtlinie anhängen. Weitere Informationen zum Erstellen dieser Rolle und Anhängen der Richtlinie finden Sie unter [Eine IAM-Rolle und Richtlinie für Ihre Aufgaben erstellen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#create_task_iam_policy_and_role). Nachdem Sie `AmazonPrometheusRemoteWriteAccess` zu Ihrer IAM-Rolle hinzufügen und diese Rolle für Ihre Aufgaben verwendet haben, kann Amazon ECS Ihre gescrapten Metriken an Amazon Managed Service für Prometheus senden. ## Schritt 5: Visualisieren Sie Ihre Kennzahlen in Amazon Managed Grafana **Wichtig** Bevor Sie beginnen, müssen Sie eine Fargate-Aufgabe in Ihrer Amazon-ECS-Aufgabendefinition ausführen. Andernfalls kann Amazon Managed Service für Prometheus Ihre Metriken nicht verarbeiten. 1. Wählen Sie im Navigationsbereich Ihres Amazon Managed Grafana-Arbeitsbereichs unter dem AWS Symbol **Datenquellen** aus. 1. Wählen Sie auf der Registerkarte **Datenquellen** unter **Service** die Option **Amazon Managed Service für Prometheus** und Ihre **Standardregion** aus. 1. Wählen Sie **Datenquelle hinzufügen** aus. 1. Verwenden Sie die Präfixe `ecs` und `prometheus`, um Ihre Metriken abzufragen und anzuzeigen. # Einrichten der Erfassung von Metriken aus einer Amazon-EC2-Instance mithilfe von Remote-Write In diesem Abschnitt wird erläutert, wie Sie einen Prometheus-Server mit Remote-Write in einer Instance von Amazon Elastic Compute Cloud (Amazon EC2) ausführen. Es wird erklärt, wie Sie Metriken aus einer in Go geschriebenen Demo-Anwendung sammeln und sie an einen Workspace in Amazon Managed Service für Prometheus senden. ## Voraussetzungen **Wichtig** Bevor Sie beginnen, müssen Sie Prometheus v2.26 oder höher installiert haben. Wir gehen davon aus, dass Sie mit Prometheus, Amazon EC2 und Amazon Managed Service für Prometheus vertraut sind. Informationen zur Installation von Prometheus finden Sie unter [Erste Schritte](https://prometheus.io/docs/prometheus/latest/getting_started/) auf der Prometheus-Website. Wenn Sie mit Amazon EC2 oder Amazon Managed Service für Prometheus nicht vertraut sind, empfehlen wir Ihnen, zunächst die folgenden Abschnitte zu lesen: + [Was ist Amazon Elastic Compute Cloud?](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) + [Was ist Amazon Managed Service für Prometheus?](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html) ## Erstellen Sie eine IAM-Rolle für Amazon EC2 Um Metriken zu streamen, müssen Sie zunächst eine IAM-Rolle mit der AWS verwalteten Richtlinie erstellen. **AmazonPrometheusRemoteWriteAccess** Anschließend können Sie eine Instance mit der Rolle starten und Metriken in Ihren Workspace in Amazon Managed Service für Prometheus streamen. 1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole. 1. Wählen Sie im Navigationsbereich **Roles (Rollen)** und dann **Create role (Rolle erstellen)** aus. 1. Wählen Sie als Typ der vertrauenswürdigen Entität **AWS -Service** aus. Wählen Sie für den Anwendungsfall **EC2** aus. Wählen Sie **Weiter: Berechtigungen** aus. 1. Geben Sie im Suchfeld **AmazonPrometheusRemoteWriteAccess** ein. Wählen Sie als **Richtlinienname **AmazonPrometheusRemoteWriteAccess****die Option **Richtlinie anhängen** aus. Wählen Sie **Weiter: Tags** aus. 1. (Optional) Erstellen Sie IAM-Tags für Ihre IAM-Rolle. Wählen Sie **Weiter: Prüfen** aus. 1. Geben Sie einen Namen für die neue Rolle ein. Wählen Sie **Richtlinie erstellen** aus. ## Starten Sie eine Amazon-EC2-Instance Befolgen Sie die Anweisungen unter [Eine Instance starten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) im *Amazon EC2-Benutzerhandbuch für Linux-Instances*, um eine Amazon-EC2-Instance zu starten. ## Setzen Sie die Demo-App ein Nachdem Sie Ihre IAM-Rolle erstellt und eine EC2-Instance mit der Rolle gestartet haben, können Sie eine Demo-Anwendung ausführen, um zu sehen, wie sie funktioniert. **Um eine Demo-Anwendung auszuführen und Metriken zu testen** 1. Verwenden Sie die folgende Vorlage, um eine Go-Datei mit dem Namen `main.go` zu erstellen. ``` package main import ( "github.com/prometheus/client_golang/prometheus/promhttp" "net/http" ) func main() { http.Handle("/metrics", promhttp.Handler()) http.ListenAndServe(":8000", nil) } ``` 1. Führen Sie den folgenden Befehl aus, um die richtigen Abhängigkeiten zu installieren. ``` sudo yum update -y sudo yum install -y golang go get github.com/prometheus/client_golang/prometheus/promhttp ``` 1. Setzen Sie die Demo-App ein. ``` go run main.go ``` Die Demo-App sollte auf Port 8000 laufen und alle offengelegten Prometheus-Metriken anzeigen. Das ist ein Beispiel dieser Metriken. ``` curl -s http://localhost:8000/metrics ... process_max_fds 4096# HELP process_open_fds Number of open file descriptors.# TYPE process_open_fds gauge process_open_fds 10# HELP process_resident_memory_bytes Resident memory size in bytes.# TYPE process_resident_memory_bytes gauge process_resident_memory_bytes 1.0657792e+07# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.# TYPE process_start_time_seconds gauge process_start_time_seconds 1.61131955899e+09# HELP process_virtual_memory_bytes Virtual memory size in bytes.# TYPE process_virtual_memory_bytes gauge process_virtual_memory_bytes 7.77281536e+08# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.# TYPE process_virtual_memory_max_bytes gauge process_virtual_memory_max_bytes -1# HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.# TYPE promhttp_metric_handler_requests_in_flight gauge promhttp_metric_handler_requests_in_flight 1# HELP promhttp_metric_handler_requests_total Total number of scrapes by HTTP status code.# TYPE promhttp_metric_handler_requests_total counter promhttp_metric_handler_requests_total{code="200"} 1 promhttp_metric_handler_requests_total{code="500"} 0 promhttp_metric_handler_requests_total{code="503"} 0 ``` ## Erstellen eines Workspace in Amazon Managed Service für Prometheus Um einen Workspace in Amazon Managed Service für Prometheus zu erstellen, folgen Sie den Anweisungen unter [Einen Workspace erstellen](AMP-create-workspace.md). ## Setzen Sie einen Prometheus-Server ein 1. Verwenden Sie die folgende YAML-Beispieldatei als Vorlage, um eine neue Datei mit dem Namen `prometheus.yaml` zu erstellen. *my-region*Ersetzen Sie für `url` durch Ihren Regionswert und *my-workspace-id* durch die Workspace-ID, die Amazon Managed Service for Prometheus für Sie generiert hat. Ersetzen Sie für `region` durch den *my-region* Wert für Ihre Region. **Beispiel: YAML-Datei** ``` global: scrape_interval: 15s external_labels: monitor: 'prometheus' scrape_configs: - job_name: 'prometheus' static_configs: - targets: ['localhost:8000'] remote_write: - url: https://aps-workspaces.my-region.amazonaws.com/workspaces/my-workspace-id/api/v1/remote_write queue_config: max_samples_per_send: 1000 max_shards: 200 capacity: 2500 sigv4: region: my-region ``` 1. Führen Sie den Prometheus-Server aus, um die Metriken der Demo-App an Ihren Workspace in Amazon Managed Service für Prometheus zu senden. ``` prometheus --config.file=prometheus.yaml ``` Der Prometheus-Server sollte jetzt die Metriken der Demo-App an Ihren Workspace in Amazon Managed Service für Prometheus senden.