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.

# Amazon Managed Service für Prometheus mit AWS Controllern für Kubernetes verwalten
<a name="integrating-ack"></a>

Amazon Managed Service für Prometheus ist in [AWS Controllers für Kubernetes (ACK)](https://aws-controllers-k8s.github.io/community/docs/community/overview/) integriert und unterstützt die Verwaltung Ihrer Workspace-, Alert Manager- und Ruler-Ressourcen in Amazon EKS. Sie können benutzerdefinierte Ressourcendefinitionen (CRDs) von AWS Controllers for Kubernetes und native Kubernetes-Objekte verwenden, ohne Ressourcen außerhalb Ihres Clusters definieren zu müssen.

In diesem Abschnitt wird beschrieben, wie Sie AWS Controller für Kubernetes und Amazon Managed Service for Prometheus in einem vorhandenen Amazon EKS-Cluster einrichten.

Sie können auch die Blogbeiträge zur [Einführung von AWS Controllern für Kubernetes](https://aws.amazon.com/blogs/containers/aws-controllers-for-kubernetes-ack/) und zur [Einführung des ACK-Controllers für Amazon Managed Service for Prometheus](https://aws.amazon.com/blogs/mt/introducing-the-ack-controller-for-amazon-managed-service-for-prometheus/) lesen.

## Voraussetzungen
<a name="ack-prereqs"></a>

Bevor Sie mit der Integration von AWS Controllern für Kubernetes und Amazon Managed Service for Prometheus in Ihren Amazon EKS-Cluster beginnen, müssen Sie die folgenden Voraussetzungen erfüllen.
+ Sie benötigen ein [vorhandenes Konto AWS-Konto und die erforderlichen Berechtigungen](AMP-setting-up.md), um Amazon Managed Service for Prometheus- und IAM-Rollen programmgesteuert zu erstellen.
+ Sie müssen über einen vorhandenen [Amazon-EKS-Cluster](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) mit aktiviertem OpenID Connect (OIDC) verfügen.

  Wenn Sie OIDC nicht aktiviert haben, können Sie es mit dem folgenden Befehl aktivieren. Denken Sie daran, das *YOUR\$1CLUSTER\$1NAME* und durch die richtigen Werte für *AWS\$1REGION* Ihr Konto zu ersetzen.

  ```
  eksctl utils associate-iam-oidc-provider \
      --cluster ${YOUR_CLUSTER_NAME} --region ${AWS_REGION} \
      --approve
  ```

  Weitere Informationen zur Verwendung von OIDC mit Amazon EKS finden Sie unter [OIDC-Identitätsanbieter-Authentifizierung](https://docs.aws.amazon.com/eks/latest/userguide/authenticate-oidc-identity-provider.html) und [Erstellen eines IAM-OIDC-Anbieters](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) im *Amazon-EKS-Benutzerhandbuch*. 
+ Sie müssen den [Amazon-EBS-CSI-Treiber in Ihrem Amazon-EKS-Cluster installiert](https://docs.aws.amazon.com/eks/latest/userguide/ebs-csi.html) haben.
+ Sie müssen [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installiert haben. Das AWS CLI wird verwendet, um AWS Funktionen von der Befehlszeile aus aufzurufen.
+ [Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html), der Paketmanager für Kubernetes, muss installiert sein.
+ [Metriken der Steuerebene mit Prometheus](https://docs.aws.amazon.com/eks/latest/userguide/prometheus.html) müssen in Ihrem Amazon-EKS-Cluster eingerichtet werden.
+ Sie müssen ein [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/)-Thema haben, zu dem Sie Benachrichtigungen von Ihrem neuen Workspace aus senden möchten. Vergewissern Sie sich, dass Sie [Amazon Managed Service für Prometheus die Erlaubnis erteilt haben, Nachrichten zu diesem Thema zu senden](AMP-alertmanager-receiver-AMPpermission.md).

Wenn Ihr Amazon-EKS-Cluster entsprechend konfiguriert ist, sollten Sie in der Lage sein, Metriken zu sehen, die für Prometheus formatiert sind, indem Sie `kubectl get --raw /metrics` aufrufen. Jetzt sind Sie bereit, einen AWS Controllers for Kubernetes Service Controller zu installieren und ihn zur Bereitstellung von Amazon Managed Service for Prometheus-Ressourcen zu verwenden.

## Bereitstellung eines Workspace mit Controllern für Kubernetes AWS
<a name="ack-deploy-workspace"></a>

Um einen neuen Amazon Managed Service for Prometheus Workspace bereitzustellen, installieren Sie einen AWS Controller für Controller für Kubernetes und verwenden diesen dann, um den Workspace zu erstellen.

**Um einen neuen Amazon Managed Service für Prometheus Workspace mit AWS Controllern für Kubernetes bereitzustellen**

1. Verwenden Sie die folgenden Befehle, um Helm zur Installation des Service Controllers von Amazon Managed Service für Prometheus zu verwenden. Weitere Informationen finden [Sie unter Installieren eines ACK-Controllers in der Dokumentation zu AWS Controllern](https://aws-controllers-k8s.github.io/community/docs/user-docs/install/) für Kubernetes unter. GitHub Verwenden Sie den richtigen *region* für Ihr System, z. B. `us-east-1`

   ```
   export SERVICE=prometheusservice
   export RELEASE_VERSION=`curl -sL https://api.github.com/repos/aws-controllers-k8s/$SERVICE-controller/releases/latest | jq -r '.tag_name | ltrimstr("v")'`
   export ACK_SYSTEM_NAMESPACE=ack-system
   export AWS_REGION=region
   
   aws ecr-public get-login-password --region us-east-1 | helm registry login --username AWS --password-stdin public.ecr.aws
   helm install --create-namespace -n $ACK_SYSTEM_NAMESPACE ack-$SERVICE-controller \
     oci://public.ecr.aws/aws-controllers-k8s/$SERVICE-chart --version=$RELEASE_VERSION --set=aws.region=$AWS_REGION
   ```

   Nach einigen Augenblicken sollten Sie eine Reaktion ähnlich der folgenden erhalten, die auf einen Erfolg hinweist.

   ```
   You are now able to create Amazon Managed Service for Prometheus (AMP) resources!
   The controller is running in "cluster" mode.
   The controller is configured to manage AWS resources in region: "us-east-1"
   ```

   Sie können optional mit dem folgenden Befehl überprüfen, ob der AWS Controller für Kubernetes Controller erfolgreich installiert wurde.

   ```
   helm list --namespace $ACK_SYSTEM_NAMESPACE -o yaml
   ```

   Dadurch werden Informationen über den Controller zurückgegeben`ack-prometheusservice-controller`, einschließlich des `status: deployed`.

1. Erstellen Sie eine Datei mit dem Namen `workspace.yaml` und folgendem Text. Dies wird als Konfiguration für den Workspace verwendet, den Sie erstellen.

   ```
   apiVersion: prometheusservice.services.k8s.aws/v1alpha1
   kind: Workspace
   metadata:
     name: my-amp-workspace
   spec:
     alias: my-amp-workspace
     tags:
       ClusterName: EKS-demo
   ```

1. Führen Sie den folgenden Befehl aus, um Ihren Workspace zu erstellen (dieser Befehl hängt von den Systemvariablen ab, die Sie in Schritt 1 eingerichtet haben).

   ```
   kubectl apply -f workspace.yaml -n $ACK_SYSTEM_NAMESPACE
   ```

   Innerhalb weniger Augenblicke sollten Sie in der Lage sein, einen neuen Workspace zu sehen, der `my-amp-workspace` in Ihrem Konto aufgerufen wird.

   Führen Sie den folgenden Befehl aus, um die Details und den Status Ihres Workspace einschließlich der *Workspace-ID* anzuzeigen. Alternativ können Sie den neuen Workspace in der [Konsole für Amazon Managed Service für Prometheus](https://console.aws.amazon.com/prometheus) anzeigen.

   ```
   kubectl describe workspace my-amp-workspace -n $ACK_SYSTEM_NAMESPACE
   ```
**Anmerkung**  
Sie können auch [einen vorhandenen Workspace verwenden](https://aws-controllers-k8s.github.io/community/docs/user-docs/adopted-resource/), anstatt einen neuen zu erstellen.

1. Erstellen Sie zwei neue Yaml-Dateien als Konfiguration für die Rulegroups AlertManager , die Sie als Nächstes mit der folgenden Konfiguration erstellen werden.

   Speichern Sie diese Konfiguration unter `rulegroup.yaml`. Ersetzen Sie es *WORKSPACE-ID* durch die Workspace-ID aus dem vorherigen Schritt.

   ```
   apiVersion: prometheusservice.services.k8s.aws/v1alpha1
   kind: RuleGroupsNamespace
   metadata:
     name: default-rule
   spec:
     workspaceID: WORKSPACE-ID
     name: default-rule
     configuration: |
       groups:
       - name: example
         rules:
         - alert: HostHighCpuLoad
           expr: 100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100) > 60
           for: 5m
           labels:
             severity: warning
             event_type: scale_up
           annotations:
             summary: Host high CPU load (instance {{ $labels.instance }})
             description: "CPU load is > 60%\n  VALUE = {{ $value }}\n  LABELS = {{ $labels }}"
         - alert: HostLowCpuLoad
           expr: 100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100) < 30
           for: 5m
           labels:
             severity: warning
             event_type: scale_down
           annotations:
             summary: Host low CPU load (instance {{ $labels.instance }})
             description: "CPU load is < 30%\n  VALUE = {{ $value }}\n  LABELS = {{ $labels }}"
   ```

   Speichern Sie die folgende Konfiguration als `alertmanager.yaml`. Ersetze es *WORKSPACE-ID* durch die Workspace-ID aus dem vorherigen Schritt. *TOPIC-ARN*Ersetzen Sie es durch den ARN für das Amazon SNS SNS-Thema, an das Sie Benachrichtigungen senden möchten, und *REGION* durch das, das AWS-Region Sie verwenden. Denken Sie daran, dass Amazon Managed Service für Prometheus [über Berechtigungen für das Amazon-SNS-Thema verfügen muss](AMP-alertmanager-receiver-AMPpermission.md).

   ```
   apiVersion: prometheusservice.services.k8s.aws/v1alpha1
   kind: AlertManagerDefinition
   metadata:
     name: alert-manager
   spec:
     workspaceID: WORKSPACE-ID
     configuration: |
       alertmanager_config: |
         route:
            receiver: default_receiver
         receivers:
           - name: default_receiver
             sns_configs:
             - topic_arn: TOPIC-ARN
               sigv4:
                 region: REGION
               message: |
                 alert_type: {{ .CommonLabels.alertname }}
                 event_type: {{ .CommonLabels.event_type }}
   ```
**Anmerkung**  
Weitere Informationen zu den Formaten dieser Konfigurationsdateien finden Sie unter [RuleGroupsNamespaceData](https://docs.aws.amazon.com/prometheus/latest/APIReference/yaml-RuleGroupsNamespaceData.html) und [AlertManagerDefinitionData](https://docs.aws.amazon.com/prometheus/latest/APIReference/yaml-AlertManagerDefinitionData.html).

1. Führen Sie die folgenden Befehle aus, um Ihre Regelgruppen- und Alert-Manager-Konfiguration zu erstellen (dieser Befehl hängt von den Systemvariablen ab, die Sie in Schritt 1 eingerichtet haben).

   ```
   kubectl apply -f rulegroup.yaml -n $ACK_SYSTEM_NAMESPACE
   kubectl apply -f alertmanager.yaml -n $ACK_SYSTEM_NAMESPACE
   ```

   Die Änderungen werden innerhalb von einigen Augenblicken verfügbar sein.
**Anmerkung**  
Um eine Ressource zu aktualisieren, anstatt sie zu erstellen, aktualisieren Sie einfach die Yaml-Datei und führen den Befehl `kubectl apply` erneut aus.  
Um eine Ressource zu löschen, führen Sie den folgenden Befehl aus. *ResourceType*Ersetzen Sie durch den Ressourcentyp, den Sie löschen möchten `Workspace``AlertManagerDefinition`, oder`RuleGroupNamespace`. *ResourceName*Ersetzen Sie durch den Namen der zu löschenden Ressource.  

   ```
   kubectl delete ResourceType ResourceName -n $ACK_SYSTEM_NAMESPACE
   ```

Damit ist die Bereitstellung des neuen Workspace abgeschlossen. Im nächsten Abschnitt wird beschrieben, wie Sie Ihren Cluster so konfigurieren, dass Metriken an diesen Workspace gesendet werden.

## Den Amazon-EKS-Cluster für das Schreiben im Workspace in Amazon Managed Service für Prometheus konfigurieren
<a name="ack-configure-workspace"></a>

In diesem Abschnitt wird beschrieben, wie Sie mithilfe des Befehls „Helm“ den in Ihrem Amazon-EKS-Cluster ausgeführten Prometheus-Service so konfigurieren, dass er Remote-Write-Metriken in den Workspace von Managed Service für Prometheus schreibt, den Sie im vorherigen Abschnitt erstellt haben.

Für dieses Verfahren benötigen Sie den Namen der IAM-Rolle, die Sie für die Erfassung von Metriken erstellt haben. Wenn Sie dies noch nicht getan haben, finden Sie weitere Informationen und Anweisungen unter [Einrichten von Servicerollen für die Erfassung von Metriken aus Amazon-EKS-Clustern](set-up-irsa.md#set-up-irsa-ingest). Wenn Sie diese Anweisungen befolgen, wird die IAM-Rolle `amp-iamproxy-ingest-role` genannt.

**So konfigurieren Sie Ihren Amazon-EKS-Cluster für Remote-Write**

1. Verwenden Sie den folgenden Befehl, um `prometheusEndpoint` für Ihren Workspace zu erhalten. Ersetze es *WORKSPACE-ID* durch die Workspace-ID aus dem vorherigen Abschnitt.

   ```
   aws amp describe-workspace --workspace-id WORKSPACE-ID
   ```

   prometheusEndpunkt ist in den Rückgabeergebnissen enthalten und ist wie folgt formatiert:

   ```
   https://aps-workspaces.us-west-2.amazonaws.com/workspaces/ws-a1b2c3d4-a123-b456-c789-ac1234567890/
   ```

   Speichern Sie diese URL zur Verwendung in den nächsten Schritten.

1. Erstellen Sie eine Datei mit folgendem Text und nennen Sie sie `prometheus-config.yaml`. Ersetze es *account* durch deine Konto-ID, *workspaceURL/* durch die URL, die du gerade gefunden hast, und *region* durch die AWS-Region für dein System passende URL.

   ```
   serviceAccounts:
           server:
               name: "amp-iamproxy-ingest-service-account"
               annotations:
                   eks.amazonaws.com/role-arn: "arn:aws:iam::account:role/amp-iamproxy-ingest-role"
   server:
       remoteWrite:
           - url: workspaceURL/api/v1/remote_write
             sigv4:
               region: region
             queue_config:
               max_samples_per_send: 1000
               max_shards: 200
               capacity: 2500
   ```

1. Suchen Sie die Namen des Prometheus-Charts und -Namespaces sowie die Chart-Version mit dem folgenden Helm-Befehl.

   ```
   helm ls --all-namespaces
   ```

   Basierend auf den bisherigen Schritten sollten sowohl das Prometheus-Chart als auch der Namespace `prometheus` genannt werden, während es sich bei der Chart-Version um handeln `15.2.0` könnte.

1. Führen Sie den folgenden Befehl aus, und verwenden Sie dabei das *PrometheusChartName**PrometheusNamespace*, *PrometheusChartVersion* und, aus dem vorherigen Schritt.

   ```
   helm upgrade PrometheusChartName prometheus-community/prometheus -n PrometheusNamespace -f prometheus-config.yaml --version PrometheusChartVersion
   ```

   Nach einigen Minuten wird eine Nachricht angezeigt, dass die Aktualisierung erfolgreich war.

1. Überprüfen Sie optional, ob die Metriken erfolgreich gesendet wurden, indem Sie den Endpunkt von Amazon Managed Service für Prometheus über `awscurl` abfragen. *Region*Ersetzen Sie es durch AWS-Region die, die Sie verwenden, und *workspaceURL/* durch die URL, die Sie in Schritt 1 gefunden haben.

   ```
   awscurl --service="aps" --region="Region" "workspaceURL/api/v1/query?query=node_cpu_seconds_total"
   ```

Sie haben jetzt einen Workspace für Amazon Managed Service für Prometheus erstellt und von Ihrem Amazon-EKS-Cluster aus eine Verbindung zu ihm hergestellt, wobei YAML-Dateien als Konfiguration verwendet wurden. Diese Dateien, die als benutzerdefinierte Ressourcendefinitionen (CRDs) bezeichnet werden, befinden sich in Ihrem Amazon EKS-Cluster. Sie können den AWS Controller Controllers for Kubernetes verwenden, um all Ihre Amazon Managed Service for Prometheus-Ressourcen direkt vom Cluster aus zu verwalten.