Voraussetzungen Erfassung der Prometheus-Metriken aktivieren Erweiterte Konfiguration

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

Weitere Informationen zu mit Prometheus instrumentierten Anwendungen finden Sie unter. Was sind Prometheus-kompatible Metriken?

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

Der Kollektor erkennt automatisch Prometheus-Metriken-Endpunkte auf Amazon EKS und verwendet die Konfiguration unter <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. 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

Erstellen Sie die IAM-Rolle für das Servicekonto, indem Sie die Schritte unter Richten Sie Servicerollen für die Erfassung von Metriken aus Amazon EKS-Clustern ein befolgen.

Der ADOT Kollektor verwendet diese Rolle, wenn er Metriken erfasst und exportiert.
Bearbeiten Sie als Nächstes die Vertrauensrichtlinie. Öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.
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.
Wählen Sie die Registerkarte Vertrauensbeziehungen und dann Vertrauensbeziehung bearbeiten aus.

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:


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::account-id:oidc-provider/oidc.eks.region.amazonaws.com/id/openid"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.region.amazonaws.com/id/openid:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account"
        }
      }
    }
  ]
}

Wählen Sie die Registerkarte Berechtigungen und stellen Sie sicher, dass die folgende Berechtigungsrichtlinie an die Rolle angehängt ist.


{
    "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

Forken und klonen Sie die Beispiel-App aus dem Repository unter aws-otel-community.

Führen Sie anschließend folgende Befehle aus.
```
cd ./sample-apps/prometheus-sample-app
docker build . -t prometheus-sample-app:latest
```
Push dieses Image in eine Registry wie Amazon ECR oder DockerHub.
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
```
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
```
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_write-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_write-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.
Geben Sie den folgenden Befehl ein, um den ADOT Kollektor bereitzustellen.
```
kubectl apply -f prometheus-daemonset.yaml
```
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
```

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

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

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 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. * Dies ist besonders wichtig für den Ersatzwert der relabel_configurations. Wenn Sie beispielsweise mit der folgenden relabel_configuration 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 for Go. 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 for 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.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

ADOT-Kollektoren

Aufnahme aus Amazon ECS