

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.

# Lösung für die Überwachung der Amazon EKS-Infrastruktur mit Amazon Managed Grafana
<a name="solution-eks"></a>

Die Überwachung der Amazon Elastic Kubernetes Service Service-Infrastruktur ist eines der häufigsten Szenarien, für die Amazon Managed Grafana verwendet wird. Auf dieser Seite wird eine Vorlage beschrieben, die Ihnen eine Lösung für dieses Szenario bietet. Die Lösung kann mit [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)oder mit [Terraform](https://www.terraform.io/) installiert werden.

Diese Lösung konfiguriert:
+ Ihr Amazon Managed Service for Prometheus-Workspace speichert Metriken aus Ihrem Amazon EKS-Cluster und erstellt einen verwalteten Collector, um die Metriken zu scrapen und in diesen Workspace zu übertragen. Weitere Informationen finden Sie unter [Metriken mit verwalteten Sammlern aufnehmen](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector.html). AWS 
+ Sammeln von Protokollen aus Ihrem Amazon EKS-Cluster mithilfe eines CloudWatch Agenten. Die Protokolle werden in Amazon Managed CloudWatch Grafana gespeichert und von Amazon abgefragt. Weitere Informationen finden Sie unter [Protokollierung für Amazon EKS](https://docs.aws.amazon.com/prescriptive-guidance/latest/implementing-logging-monitoring-cloudwatch/kubernetes-eks-logging.html)
+ Ihr Amazon Managed Grafana-Workspace, um diese Protokolle und Metriken abzurufen und Dashboards und Benachrichtigungen zu erstellen, mit denen Sie Ihren Cluster überwachen können.

Durch die Anwendung dieser Lösung werden Dashboards und Benachrichtigungen erstellt, die:
+ Beurteilen Sie den allgemeinen Zustand des Amazon EKS-Clusters.
+ Zeigen Sie den Zustand und die Leistung der Amazon EKS-Steuerebene an.
+ Zeigen Sie den Zustand und die Leistung der Amazon EKS-Datenebene an.
+ Zeigen Sie Einblicke in Amazon EKS-Workloads in Kubernetes-Namespaces an.
+ Zeigen Sie die Ressourcennutzung in allen Namespaces an, einschließlich CPU-, Arbeitsspeicher-, Festplatten- und Netzwerknutzung.

## Informationen zu dieser Lösung
<a name="solution-eks-about"></a>

Diese Lösung konfiguriert einen Amazon Managed Grafana-Workspace, um Metriken für Ihren Amazon EKS-Cluster bereitzustellen. Die Metriken werden verwendet, um Dashboards und Benachrichtigungen zu generieren.

Die Metriken helfen Ihnen dabei, Amazon EKS-Cluster effektiver zu betreiben, indem sie Einblicke in den Zustand und die Leistung der Kubernetes-Steuerungs- und Datenebene bieten. Sie können Ihren Amazon EKS-Cluster von der Knotenebene über die Pods bis hin zur Kubernetes-Ebene verstehen, einschließlich einer detaillierten Überwachung der Ressourcennutzung.

Die Lösung bietet sowohl vorausschauende als auch korrektive Funktionen:
+ Zu den **vorausschauenden Funktionen gehören**:
  + Managen Sie die Ressourceneffizienz, indem Sie Entscheidungen zur Terminplanung treffen. Um beispielsweise Ihren internen Benutzern des Amazon EKS-Clusters Leistung und Zuverlässigkeit SLAs zu bieten, können Sie ihren Workloads auf der Grundlage der Nachverfolgung der historischen Nutzung genügend CPU- und Speicherressourcen zuweisen.
  + Nutzungsprognosen: Basierend auf der aktuellen Auslastung Ihrer Amazon EKS-Cluster-Ressourcen wie Knoten, [Persistent Volumes, die von Amazon EBS unterstützt](https://docs.aws.amazon.com/eks/latest/userguide/ebs-csi.html) werden, oder [Application Load Balancers](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) können Sie vorausschauend planen, z. B. für ein neues Produkt oder Projekt mit ähnlichen Anforderungen.
  + Erkennen Sie potenzielle Probleme frühzeitig: Indem Sie beispielsweise Trends beim Ressourcenverbrauch auf Kubernetes-Namespace-Ebene analysieren, können Sie die saisonale Abhängigkeit der Workload-Nutzung nachvollziehen.
+ **Zu den Korrekturmöglichkeiten gehören:**
  + Verkürzen Sie die mittlere Zeit bis zur Erkennung (MTTD) von Problemen auf Infrastruktur- und Kubernetes-Workload-Ebene. Wenn Sie sich beispielsweise das Dashboard zur Fehlerbehebung ansehen, können Sie Hypothesen darüber, was schief gelaufen ist, schnell testen und sie beseitigen.
  + Ermitteln Sie, wo im Stapel ein Problem auftritt. Beispielsweise wird die Amazon EKS-Kontrollebene vollständig von verwaltet, AWS und bestimmte Operationen wie das Aktualisieren einer Kubernetes-Bereitstellung können fehlschlagen, wenn der API-Server überlastet ist oder die Konnektivität beeinträchtigt ist.

Die folgende Abbildung zeigt ein Beispiel für den Dashboard-Ordner für die Lösung.

![\[Ein Bild zeigt ein Beispiel für einen Grafana-Dashboard-Ordner, der mit dieser Lösung erstellt wurde.\]](http://docs.aws.amazon.com/de_de/grafana/latest/userguide/images/eks-solution-dashboard-folder.png)


Sie können ein Dashboard auswählen, um weitere Details anzuzeigen. Wenn Sie beispielsweise die Computing-Ressourcen für Workloads anzeigen, wird ein Dashboard angezeigt, wie das in der folgenden Abbildung gezeigte.

![\[Ein Bild, das ein Beispiel für ein Grafana-Dashboard zeigt, das die mit dieser Lösung erstellte CPU-Auslastung zeigt.\]](http://docs.aws.amazon.com/de_de/grafana/latest/userguide/images/eks-solution-dashboard-resource-usage.png)


Die Metriken werden mit einem Scrape-Intervall von 1 Minute gescrapt. Die Dashboards zeigen Metriken, die auf der jeweiligen Metrik auf 1 Minute, 5 Minuten oder mehr zusammengefasst sind.

Protokolle werden auch in Dashboards angezeigt, sodass Sie Protokolle abfragen und analysieren können, um die Hauptursachen von Problemen zu finden. Die folgende Abbildung zeigt ein Protokoll-Dashboard.

![\[Ein Bild zeigt ein Beispiel für ein Grafana-Dashboard mit Protokollen, das mit dieser Lösung erstellt wurde.\]](http://docs.aws.amazon.com/de_de/grafana/latest/userguide/images/eks-solution-dashboard-logs.png)


Eine Liste der von dieser Lösung erfassten Metriken finden Sie unter[Liste der erfassten Metriken](#solution-eks-metrics).

Eine Liste der von der Lösung erstellten Warnungen finden Sie unter[Liste der erstellten Alarme](#solution-eks-alerts).

## Kosten
<a name="solution-eks-costs"></a>

Diese Lösung erstellt und verwendet Ressourcen in Ihrem Workspace. Ihnen wird die Standardnutzung der erstellten Ressourcen in Rechnung gestellt, einschließlich:
+ Zugriff auf Amazon Managed Grafana-Workspace durch Benutzer. Weitere Informationen zur Preisgestaltung finden Sie unter [Amazon Managed Grafana-Preise](https://aws.amazon.com/grafana/pricing/).
+ Erfassung und Speicherung von Metriken durch Amazon Managed Service für Prometheus, einschließlich Nutzung des agentenlosen Sammlers Amazon Managed Service for Prometheus und Metrikanalyse (Verarbeitung von Abfrageproben). Die Anzahl der von dieser Lösung verwendeten Metriken hängt von der Konfiguration und Nutzung des Amazon EKS-Clusters ab.

  Sie können die Aufnahme- und Speichermetriken in Amazon Managed Service for Prometheus unter Weitere Informationen finden Sie unter CloudWatch [CloudWatchMetriken](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-CW-usage-metrics.html) im *Amazon Managed Service for* Prometheus User Guide.

  Sie können die Kosten mit dem Preisrechner auf der Preisseite von [Amazon Managed Service für Prometheus](https://aws.amazon.com/prometheus/pricing/) abschätzen. Die Anzahl der Metriken hängt von der Anzahl der Knoten in Ihrem Cluster und den Metriken ab, die Ihre Anwendungen erzeugen.
+ CloudWatch Protokolliert Aufnahme, Speicherung und Analyse. Standardmäßig ist die Aufbewahrung von Protokollen so eingestellt, dass sie niemals abläuft. Sie können dies anpassen in CloudWatch. Weitere Informationen zur Preisgestaltung finden Sie unter [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/).
+ Netzwerkkosten. Möglicherweise fallen AWS Standardnetzwerkgebühren für zonenübergreifenden, regionalen oder anderen Datenverkehr an.

Mithilfe der Preisrechner, die auf der Preisseite für jedes Produkt verfügbar sind, können Sie sich ein Bild über die potenziellen Kosten Ihrer Lösung machen. Die folgenden Informationen können Ihnen helfen, die Grundkosten für die Lösung zu ermitteln, die in derselben Availability Zone wie der Amazon EKS-Cluster ausgeführt wird.


| Produkt | Metrik für den Rechner | Wert | 
| --- | --- | --- | 
| Amazon Managed Service für Prometheus | Aktive Serie | 8000 (Basis) 15.000 (pro Knoten) | 
|  | Durchschnittliches Erfassungsintervall | 60 (Sekunden) | 
| Amazon Managed Service für Prometheus (verwalteter Sammler) | Anzahl der Sammler | 1 | 
|  | Anzahl der Proben | 15 (Basis) 150 (pro Knoten) | 
|  | Anzahl der Regeln | 161 | 
|  | Durchschnittliches Extraktionsintervall für Regeln | 60 (Sekunden) | 
| Amazon Managed Grafana | Anzahl der aktiven Editoren/Administratoren | 1 (oder mehr, basierend auf Ihren Benutzern) | 
| CloudWatch (Protokolle) | Standardprotokolle: Aufgenommene Daten | 24,5 GB (Basis) 0,5 GB (pro Knoten) | 
|  | Protokoll Storage/Archival (Standard- und Verkaufs-Protokolle) | Ja, um Protokolle zu speichern: Es wird davon ausgegangen, dass sie 1 Monat aufbewahrt werden | 
|  | Erwartete Protokolle: Gescannte Daten | Jede Log Insights-Abfrage von Grafana scannt alle Protokollinhalte der Gruppe über den angegebenen Zeitraum. | 

Diese Zahlen sind die Basiszahlen für eine Lösung, auf der EKS ohne zusätzliche Software ausgeführt wird. Auf diese Weise erhalten Sie eine Schätzung der Grundkosten. Außerdem werden die Kosten für die Netzwerknutzung nicht berücksichtigt, die je nachdem, ob sich der Amazon Managed Grafana-Workspace, der Amazon Managed Service for Prometheus Workspace und der Amazon EKS-Cluster in derselben Availability Zone befinden AWS-Region, und VPN variieren.

**Anmerkung**  
Wenn ein Element in dieser Tabelle einen `(base)` Wert und einen Wert pro Ressource enthält (z. B.`(per node)`), sollten Sie den Basiswert zum Wert pro Ressource multiplizieren mit der Anzahl, die Sie für diese Ressource haben, addieren. Geben Sie beispielsweise für **Durchschnittliche aktive Zeitreihe** eine Zahl ein, die ist`8000 + the number of nodes in your cluster * 15,000`. Wenn Sie 2 Knoten haben, würden Sie eingeben`38,000`, was ist`8000 + ( 2 * 15,000 )`.

## Voraussetzungen
<a name="solution-eks-prerequisites"></a>

Für diese Lösung müssen Sie Folgendes getan haben, bevor Sie die Lösung verwenden können.

1. Sie müssen über **einen Amazon Elastic Kubernetes Service Service-Cluster verfügen oder einen solchen erstellen**, den Sie überwachen möchten, und der Cluster muss mindestens einen Knoten haben. Für den Cluster muss der Zugriff auf den API-Serverendpunkt so eingerichtet sein, dass er privaten Zugriff beinhaltet (er kann auch öffentlichen Zugriff zulassen).

   Der [Authentifizierungsmodus](https://docs.aws.amazon.com/eks/latest/userguide/grant-k8s-access.html#set-cam) muss API-Zugriff beinhalten (er kann entweder auf `API` oder eingestellt werden`API_AND_CONFIG_MAP`). Dadurch kann die Lösungsbereitstellung Zugriffseinträge verwenden.

   Folgendes sollte im Cluster installiert sein (standardmäßig wahr, wenn Sie den Cluster über die Konsole erstellen, muss aber hinzugefügt werden, wenn Sie den Cluster mit der AWS API oder erstellen AWS CLI): AWS CNI, CoreDNS und Kube-Proxy. AddOns

   *Speichern Sie den Clusternamen, um ihn später anzugeben*. Dies finden Sie in den Cluster-Details in der Amazon EKS-Konsole.
**Anmerkung**  
Einzelheiten zum Erstellen eines Amazon EKS-Clusters finden Sie unter [Erste Schritte mit Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html).

1. Sie müssen **einen Amazon Managed Service for Prometheus Workspace in derselben Umgebung AWS-Konto wie Ihr Amazon EKS-Cluster erstellen**. Einzelheiten finden Sie unter [Einen Workspace erstellen](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-create-workspace.html) im *Amazon Managed Service for Prometheus Benutzerhandbuch*.

   *Speichern Sie den Workspace-ARN von Amazon Managed Service for Prometheus, um ihn später anzugeben.*

1. Sie müssen **einen Amazon Managed Grafana-Workspace mit Grafana-Version 9 oder neuer erstellen**, genau AWS-Region wie Ihr Amazon EKS-Cluster. Einzelheiten zum Erstellen eines neuen Workspace finden Sie unter. [Erstellen Sie einen Amazon Managed Grafana-Arbeitsbereich](AMG-create-workspace.md)

   Die Workspace-Rolle muss über Berechtigungen für den Zugriff auf Amazon Managed Service für Prometheus und Amazon verfügen. CloudWatch APIs Der einfachste Weg, dies zu tun, besteht darin, vom Service [verwaltete Berechtigungen](AMG-manage-permissions.md) zu verwenden und Amazon Managed Service für Prometheus und auszuwählen. CloudWatch Sie können die [AmazonGrafanaCloudWatchAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonGrafanaCloudWatchAccess)Richtlinien [AmazonPrometheusQueryAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html#AmazonPrometheusQueryAccess)und auch manuell zu Ihrer Workspace-IAM-Rolle hinzufügen.

   *Speichern Sie die Amazon Managed Grafana-Workspace-ID und den Endpunkt, um sie später anzugeben.* Die ID ist im Formular`g-123example`. Die ID und der Endpunkt befinden sich in der Amazon Managed Grafana-Konsole. Der Endpunkt ist die URL für den Workspace und enthält die ID. Beispiel, `https://g-123example.grafana-workspace.<region>.amazonaws.com/`.

1. Wenn Sie die Lösung mit Terraform bereitstellen, müssen Sie einen **Amazon S3 S3-Bucket** erstellen, auf den von Ihrem Konto aus zugegriffen werden kann. Dies wird verwendet, um Terraform-Statusdateien für die Bereitstellung zu speichern.

   *Speichern Sie die Amazon S3 S3-Bucket-ID, um sie später anzugeben.*

1. Um die Warnregeln von Amazon Managed Service for Prometheus einzusehen, müssen Sie [Grafana-Benachrichtigungen für den Amazon Managed Grafana-Arbeitsbereich](v10-alerting-use-grafana-alerts.md) aktivieren.

   Darüber hinaus muss Amazon Managed Grafana über die folgenden Berechtigungen für Ihre Prometheus-Ressourcen verfügen. Sie müssen sie entweder zu den vom Service verwalteten oder den vom Kunden verwalteten Richtlinien hinzufügen, die unter [Amazon Managed Grafana-Berechtigungen und Richtlinien für AWS Datenquellen](AMG-manage-permissions.md) beschrieben sind.
   + `aps:ListRules`
   + `aps:ListAlertManagerSilences`
   + `aps:ListAlertManagerAlerts`
   + `aps:GetAlertManagerStatus`
   + `aps:ListAlertManagerAlertGroups`
   + `aps:PutAlertManagerSilences`
   + `aps:DeleteAlertManagerSilence`

**Anmerkung**  
Die Einrichtung der Lösung ist zwar nicht unbedingt erforderlich, Sie müssen jedoch die Benutzerauthentifizierung in Ihrem Amazon Managed Grafana-Arbeitsbereich einrichten, bevor Benutzer auf die erstellten Dashboards zugreifen können. Weitere Informationen finden Sie unter [Authentifizieren Sie Benutzer in Amazon Managed Grafana-Arbeitsbereichen](authentication-in-AMG.md).

## Verwenden Sie diese Lösung
<a name="solution-eks-use"></a>

Diese Lösung konfiguriert die AWS Infrastruktur so, dass sie Berichts- und Überwachungsmetriken aus einem Amazon EKS-Cluster unterstützt. Sie können sie entweder mit [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)oder mit [Terraform](https://www.terraform.io/) installieren.

------
#### [ Using AWS CDK ]

Diese Lösung wird Ihnen unter anderem als Anwendung zur Verfügung gestellt. AWS CDK Sie stellen Informationen zu den Ressourcen bereit, die Sie verwenden möchten, und die Lösung erstellt den Scraper, die Protokolle und die Dashboards für Sie.

**Anmerkung**  
Bei den hier beschriebenen Schritten wird davon ausgegangen, dass Sie über eine Umgebung verfügen AWS CLI, in der sowohl [Node.js](https://nodeja.org/) als auch [NPM](https://docs.npmjs.com/) installiert sind. AWS CDK Sie werden `make` und verwenden`brew`, um Build und andere gängige Aktionen zu vereinfachen.

**Um diese Lösung zur Überwachung eines Amazon EKS-Clusters zu verwenden mit AWS CDK**

1. Stellen Sie sicher, dass Sie alle [erforderlichen](#solution-eks-prerequisites) Schritte abgeschlossen haben.

1. Laden Sie alle Dateien für die Lösung von Amazon S3 herunter. Die Dateien befinden sich unter`s3://aws-observability-solutions/EKS/OSS/CDK/v3.0.0/iac`, und Sie können sie mit dem folgenden Amazon S3 S3-Befehl herunterladen. Führen Sie diesen Befehl in einem Ordner in Ihrer Befehlszeilenumgebung aus.

   ```
   aws s3 sync s3://aws-observability-solutions/EKS/OSS/CDK/v3.0.0/iac/ .
   ```

   Sie müssen diese Dateien nicht ändern.

1. Führen Sie in Ihrer Befehlszeilenumgebung (aus dem Ordner, in den Sie die Lösungsdateien heruntergeladen haben) die folgenden Befehle aus.

   Richten Sie die benötigten Umgebungsvariablen ein. Ersetzen Sie*REGION*, *AMG\$1ENDPOINT**EKS\$1CLUSTER*, und *AMP\$1ARN* durch Ihren AWS-Region Amazon Managed Grafana-Workspace-Endpunkt (im Formular`http://g-123example.grafana-workspace.us-east-1.amazonaws.com`), den Amazon EKS-Clusternamen und den Amazon Managed Service for Prometheus Workspace-ARN.

   ```
   export AWS_REGION=REGION
   export AMG_ENDPOINT=AMG_ENDPOINT
   export EKS_CLUSTER_NAME=EKS_CLUSTER
   export AMP_WS_ARN=AMP_ARN
   ```

1. Sie müssen ein Dienstkonto-Token mit ADMIN-Zugriff erstellen, um Grafana HTTP APIs aufzurufen. Details hierzu finden Sie unter [Verwenden Sie Dienstkonten, um sich mit dem Grafana-HTTP zu authentifizieren APIs](service-accounts.md). Sie können das AWS CLI mit den folgenden Befehlen verwenden, um das Token zu erstellen. Sie müssen das durch die *GRAFANA\$1ID* ID Ihres Grafana-Workspace ersetzen (sie wird im Formular angegeben`g-123example`). Dieser Schlüssel läuft nach 7.200 Sekunden oder 2 Stunden ab. Sie können die Uhrzeit (`seconds-to-live`) bei Bedarf ändern. Die Bereitstellung dauert weniger als eine Stunde.

   ```
   GRAFANA_SA_ID=$(aws grafana create-workspace-service-account \
     --workspace-id GRAFANA_ID \
     --grafana-role ADMIN \
     --name grafana-operator-key \
     --query 'id' \
     --output text)
     
   # creates a new token for calling APIs
   export AMG_API_KEY=$(aws grafana create-workspace-service-account-token \
     --workspace-id $managed_grafana_workspace_id \
     --name "grafana-operator-key-$(date +%s)" \
     --seconds-to-live 7200 \
     --service-account-id $GRAFANA_SA_ID \
     --query 'serviceAccountToken.key' \
     --output text)
   ```

   Stellen Sie den API-Schlüssel für die zur Verfügung, AWS CDK indem Sie ihn AWS Systems Manager mit dem folgenden Befehl hinzufügen. *AWS\$1REGION*Ersetzen Sie es durch die Region, in der Ihre Lösung ausgeführt werden soll (im Formular`us-east-1`).

   ```
   aws ssm put-parameter --name "/observability-aws-solution-eks-infra/grafana-api-key" \
       --type "SecureString" \
       --value $AMG_API_KEY \
       --region AWS_REGION \
       --overwrite
   ```

1. Führen Sie den folgenden `make` Befehl aus, der alle anderen Abhängigkeiten für das Projekt installiert.

   ```
   make deps
   ```

1. Führen Sie abschließend das AWS CDK Projekt aus:

   ```
   make build && make pattern aws-observability-solution-eks-infra-$EKS_CLUSTER_NAME deploy
   ```

1. [Optional] Nach Abschluss der Stack-Erstellung können Sie dieselbe Umgebung verwenden, um weitere Instances des Stacks für andere Amazon EKS-Cluster in derselben Region zu erstellen, sofern Sie die jeweils anderen Voraussetzungen erfüllen (einschließlich separater Amazon Managed Grafana- und Amazon Managed Service for Prometheus-Workspaces). Sie müssen die `export` Befehle mit den neuen Parametern neu definieren.

Wenn die Stack-Erstellung abgeschlossen ist, wird Ihr Amazon Managed Grafana-Workspace mit einem Dashboard gefüllt, das Metriken für Ihren Amazon EKS-Cluster anzeigt. Es dauert einige Minuten, bis die Metriken angezeigt werden, da der Scraper mit der Erfassung von Metriken beginnt.

------
#### [ Using Terraform ]

Diese Lösung wird Ihnen unter anderem als Terraform-Lösung zur Verfügung gestellt. Sie geben Informationen zu den Ressourcen, die Sie verwenden möchten, und die Lösung erstellt den Scraper, die Protokolle und die Dashboards für Sie.

**Um diese Lösung zur Überwachung eines Amazon EKS-Clusters mit Terraform zu verwenden**

1. Stellen Sie sicher, dass Sie alle [erforderlichen](#solution-eks-prerequisites) Schritte abgeschlossen haben.

1. Laden Sie alle Dateien für die Lösung von Amazon S3 herunter. Die Dateien befinden sich unter`s3://aws-observability-solutions/EKS/OSS/Terraform/v3.0.0/`, und Sie können sie mit dem folgenden Amazon S3 S3-Befehl herunterladen. Führen Sie diesen Befehl in einem Ordner in Ihrer Befehlszeilenumgebung aus und wechseln Sie dann in das Verzeichnis, von dem aus Sie die Bereitstellung vornehmen möchten.

   ```
   aws s3 sync s3://aws-observability-solutions/EKS/OSS/Terraform/v3.0.0/ .
   cd eks-monitoring
   ```

   Sie müssen diese Dateien nicht ändern.

1. Führen Sie in Ihrer Befehlszeilenumgebung (aus dem Ordner, in den Sie die Lösungsdateien heruntergeladen haben) die folgenden Befehle aus.

   Richten Sie die benötigten Umgebungsvariablen ein. Ersetzen Sie*REGION*, *AMG\$1ENDPOINT**EKS\$1CLUSTER*, *AMP\$1ARN* und durch den Ort*S3\$1ID*, AWS-Region an dem Sie neue Ressourcen bereitstellen möchten (z. B.`us-east-1`), den Amazon Managed Grafana-Workspace-Endpunkt (im Formular`http://g-123example.grafana-workspace.us-east-1.amazonaws.com`), den Amazon EKS-Clusternamen, den Amazon Managed Service for Prometheus Workspace-ARN und die Amazon S3 S3-Bucket-ID.

   ```
   export TF_VAR_aws_region=REGION
   export TF_VAR_amg_endpoint=AMG_ENDPOINT
   export TF_VAR_eks_cluster_name=EKS_CLUSTER
   export TF_VAR_amp_ws_arn=AMP_ARN
   export TF_VAR_s3_bucket_id=S3_ID
   ```

1. Sie müssen ein Dienstkonto-Token mit ADMIN-Zugriff erstellen, um Grafana HTTP APIs aufzurufen. Details hierzu finden Sie unter [Verwenden Sie Dienstkonten, um sich mit dem Grafana-HTTP zu authentifizieren APIs](service-accounts.md). Sie können das AWS CLI mit den folgenden Befehlen verwenden, um das Token zu erstellen. Sie müssen das durch die *GRAFANA\$1ID* ID Ihres Grafana-Workspace ersetzen (sie wird im Formular angegeben`g-123example`). Dieser Schlüssel läuft nach 7.200 Sekunden oder 2 Stunden ab. Sie können die Uhrzeit (`seconds-to-live`) bei Bedarf ändern. Die Bereitstellung dauert weniger als eine Stunde.

   ```
   GRAFANA_SA_ID=$(aws grafana create-workspace-service-account \
     --workspace-id GRAFANA_ID \
     --grafana-role ADMIN \
     --name grafana-operator-key \
     --query 'id' \
     --output text)
     
   # creates a new token for running Terraform
   export TF_VAR_grafana_api_key=$(aws grafana create-workspace-service-account-token \
     --workspace-id $managed_grafana_workspace_id \
     --name "grafana-operator-key-$(date +%s)" \
     --seconds-to-live 7200 \
     --service-account-id $GRAFANA_SA_ID \
     --query 'serviceAccountToken.key' \
     --output text)
   ```
**Anmerkung**  
Der erste Schritt oben, das Erstellen eines Dienstkontos für den Workspace, ist nicht erforderlich, wenn Sie bereits über ein Dienstkonto verfügen. In diesem Fall ersetze das *\$1GRAFANA\$1SA\$1ID* durch die ID deines Dienstkontos.

1. Führen Sie den folgenden `terraform` Befehl aus, um Terraform mit der Lösung zu initialisieren.

   ```
   terraform init -reconfigure \
   -backend-config="bucket=${TF_VAR_s3_bucket_id}" \
   -backend-config="region=${TF_VAR_aws_region}" \
   -backend-config="key=state/${TF_VAR_eks_cluster_name}/terraform.tfstate"
   ```

1. Stellen Sie abschließend das Terraform-Projekt bereit:

   ```
   terraform apply
   ```

Wenn die Lösungserstellung abgeschlossen ist, wird Ihr Amazon Managed Grafana-Workspace mit einem Dashboard gefüllt, das Metriken für Ihren Amazon EKS-Cluster anzeigt. Es dauert einige Minuten, bis die Metriken angezeigt werden, da der Scraper mit der Erfassung von Metriken beginnt.

------

## Liste der erfassten Metriken
<a name="solution-eks-metrics"></a>

Diese Lösung erstellt einen Scraper, der Metriken aus Ihrem Amazon EKS-Cluster sammelt. Diese Metriken werden in Amazon Managed Service for Prometheus gespeichert und dann in Amazon Managed Grafana-Dashboards angezeigt. Standardmäßig sammelt der Scraper alle [Promethus-kompatiblen Metriken, die vom Cluster verfügbar](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-compatible-metrics.html) gemacht werden. Durch die Installation von Software in Ihrem Cluster, die mehr Metriken erzeugt, werden die gesammelten Metriken erhöht. Wenn Sie möchten, können Sie die Anzahl der Metriken reduzieren, indem Sie [den Scraper mit einer Konfiguration aktualisieren, die die Metriken filtert](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html#AMP-collector-configuration).

Die folgenden Metriken werden mit dieser Lösung in einer Amazon EKS-Cluster-Basiskonfiguration ohne Installation zusätzlicher Software verfolgt.


| Metrik | Beschreibung/Zweck | 
| --- | --- | 
|  `aggregator_unavailable_apiservice`  |   APIServices Welche Messgeräte sind als nicht verfügbar markiert, aufgeschlüsselt nach APIService Namen.  | 
|  `apiserver_admission_webhook_admission_duration_seconds_bucket`  |  Histogramm der Webhook-Latenz bei der Zulassung in Sekunden, identifiziert anhand des Namens und aufgeschlüsselt nach Vorgang, API-Ressource und Typ (validieren oder zulassen).  | 
|  `apiserver_current_inflight_requests`  |  Maximale Anzahl der aktuell verwendeten Inflight-Anfragen für diesen Apiserver pro Anforderungsart in letzter Sekunde.  | 
|  `apiserver_envelope_encryption_dek_cache_fill_percent`  |  Prozent der Cache-Steckplätze, die derzeit im Cache belegt sind. DEKs  | 
|  `apiserver_flowcontrol_current_executing_requests`  |  Anzahl der Anfragen in der ersten Ausführungsphase (für eine WATCH) oder einer beliebigen Ausführungsphase (für eine Nicht-WATCH) Ausführungsphase im API-Subsystem Priority and Fairness.  | 
|  `apiserver_flowcontrol_rejected_requests_total`  |  Anzahl der Anfragen in der ersten (für eine WATCH) oder einer beliebigen Ausführungsphase (für eine Nicht-WATCH) Ausführungsphase im API-Subsystem Priority and Fairness, die abgelehnt wurden.  | 
|  `apiserver_flowcontrol_request_concurrency_limit`  |  Nominale Anzahl von Ausführungsplätzen, die für jede Prioritätsstufe konfiguriert sind.  | 
|  `apiserver_flowcontrol_request_execution_seconds_bucket`  |  Das gestaffelte Histogramm der Dauer der Anfangsphase (für eine WATCH) oder einer beliebigen Phase (für eine Nicht-WATCH) Phase der Anforderungsausführung im API-Subsystem Priority and Fairness.  | 
|  `apiserver_flowcontrol_request_queue_length_after_enqueue_count`  |  Die Anzahl der Anfangsphasen (für eine WATCH) oder einer beliebigen Phase (für eine Nicht-WATCH) Phase der Anforderungsausführung im API-Subsystem Priority and Fairness.  | 
|  `apiserver_request`  |  Weist auf eine API-Serveranfrage hin.  | 
|  `apiserver_requested_deprecated_apis`  |  Anzeige der veralteten Versionen APIs , die angefordert wurden, aufgeschlüsselt nach API-Gruppe, Version, Ressource, Unterressource und removed\$1release.  | 
|  `apiserver_request_duration_seconds`  |  Verteilung der Antwortlatenz in Sekunden für jedes Verb, jeden Probelauf, jede Gruppe, Version, Ressource, Unterressource, jeden Bereich und jede Komponente.  | 
|  `apiserver_request_duration_seconds_bucket`  |  Das kombinierte Histogramm der Verteilung der Antwortlatenz in Sekunden für jedes Verb, jeden Probelaufwert, jede Gruppe, Version, Ressource, Unterressource, jeden Bereich und jede Komponente.  | 
|  `apiserver_request_slo_duration_seconds`  |  Die Verteilung der Antwortlatenz nach Service Level Objective (SLO) in Sekunden für jedes Verb, jeden Probelauf, jede Gruppe, Version, Ressource, Unterressource, jeden Bereich und jede Komponente.  | 
|  `apiserver_request_terminations_total`  |  Anzahl der Anfragen, die Apiserver aus Notwehr beendet hat.  | 
|  `apiserver_request_total`  |  Zähler der Apiserver-Anfragen, aufgeschlüsselt nach Verb, Probelaufwert, Gruppe, Version, Ressource, Bereich, Komponente und HTTP-Antwortcode.  | 
|  `container_cpu_usage_seconds_total`  |  Kumulierte verbrauchte CPU-Zeit.  | 
|  `container_fs_reads_bytes_total`  |  Kumulative Anzahl der gelesenen Byte.  | 
|  `container_fs_reads_total`  |  Gesamtzahl der abgeschlossenen Lesevorgänge.  | 
|  `container_fs_writes_bytes_total`  |  Kumulierte Anzahl der geschriebenen Byte.  | 
|  `container_fs_writes_total`  |  Kumulierte Anzahl der abgeschlossenen Schreibvorgänge.  | 
|  `container_memory_cache`  |  Gesamter Seitencache-Speicher.  | 
|  `container_memory_rss`  |  Größe von RSS.  | 
|  `container_memory_swap`  |  Nutzung von Container-Swaps.  | 
|  `container_memory_working_set_bytes`  |  Aktueller Arbeitssatz.  | 
|  `container_network_receive_bytes_total`  |  Kumulierte Anzahl der empfangenen Byte.  | 
|  `container_network_receive_packets_dropped_total`  |  Kumulierte Anzahl der Pakete, die beim Empfang verloren gegangen sind.  | 
|  `container_network_receive_packets_total`  |  Kumulierte Anzahl der empfangenen Pakete.  | 
|  `container_network_transmit_bytes_total`  |  Kumulierte Anzahl der übertragenen Byte.  | 
|  `container_network_transmit_packets_dropped_total`  |  Kumulierte Anzahl von Paketen, die bei der Übertragung verloren gegangen sind.  | 
|  `container_network_transmit_packets_total`  |  Kumulierte Anzahl der übertragenen Pakete.  | 
|  `etcd_request_duration_seconds_bucket`  |  Das gebündelte Histogramm der etcd-Anforderungslatenz in Sekunden für jeden Vorgang und Objekttyp.  | 
|  `go_goroutines`  |  Anzahl der Goroutinen, die derzeit existieren.  | 
|  `go_threads`  |  Anzahl der erstellten Betriebssystem-Threads.  | 
|  `kubelet_cgroup_manager_duration_seconds_bucket`  |  Das gestaffelte Histogramm der Dauer in Sekunden für Cgroup Manager-Operationen. Aufgeschlüsselt nach Methode.  | 
|  `kubelet_cgroup_manager_duration_seconds_count`  |  Dauer in Sekunden für Gruppenmanager-Operationen. Aufgeschlüsselt nach Methode.  | 
|  `kubelet_node_config_error`  |  Diese Metrik ist wahr (1), wenn auf dem Knoten ein konfigurationsbedingter Fehler auftritt, andernfalls falsch (0).  | 
|  `kubelet_node_name`  |  Der Name des Knotens. Die Anzahl ist immer 1.  | 
|  `kubelet_pleg_relist_duration_seconds_bucket`  |  Das gestaffelte Histogramm der Dauer in Sekunden für das Wiedereinstellen von Pods in PLEG.  | 
|  `kubelet_pleg_relist_duration_seconds_count`  |  Die Anzahl der Dauer in Sekunden für das Wiedereinstellen von Pods in PLEG.  | 
|  `kubelet_pleg_relist_interval_seconds_bucket`  |  Das gestaffelte Histogramm des Intervalls in Sekunden zwischen dem Wiedereinstellen in PLEG.  | 
|  `kubelet_pod_start_duration_seconds_count`  |  Die Anzahl der Zeiträume in Sekunden zwischen dem ersten Erkennen eines Pods durch Kubelet und dem Starten des Pods.  | 
|  `kubelet_pod_worker_duration_seconds_bucket`  |  Das zusammengefasste Histogramm der Dauer in Sekunden für die Synchronisierung eines einzelnen Pods. Aufgeschlüsselt nach Vorgangstyp: Erstellen, Aktualisieren oder Synchronisieren.  | 
|  `kubelet_pod_worker_duration_seconds_count`  |  Die Anzahl der für die Synchronisierung eines einzelnen Pods erforderlichen Dauer in Sekunden. Aufgeschlüsselt nach Vorgangstyp: Erstellen, Aktualisieren oder Synchronisieren.  | 
|  `kubelet_running_containers`  |  Anzahl der aktuell laufenden Container.  | 
|  `kubelet_running_pods`  |  Anzahl der Pods, auf denen eine Pod-Sandbox läuft.  | 
|  `kubelet_runtime_operations_duration_seconds_bucket`  |  Das gestaffelte Histogramm der Dauer von Laufzeitvorgängen in Sekunden. Aufgeschlüsselt nach Vorgangstyp.  | 
|  `kubelet_runtime_operations_errors_total`  |  Kumulierte Anzahl von Laufzeitvorgangsfehlern nach Vorgangstyp.  | 
|  `kubelet_runtime_operations_total`  |  Kumulierte Anzahl von Laufzeitvorgängen nach Vorgangstyp.  | 
|  `kube_node_status_allocatable`  |  Die Menge der Ressourcen, die Pods zugewiesen werden können (nachdem einige Ressourcen für System-Daemons reserviert wurden).  | 
|  `kube_node_status_capacity`  |  Die Gesamtmenge der für einen Knoten verfügbaren Ressourcen.  | 
|  `kube_pod_container_resource_limits (CPU)`  |  Die Anzahl der von einem Container angeforderten Limit-Ressourcen.  | 
|  `kube_pod_container_resource_limits (Memory)`  |  Die Anzahl der von einem Container angeforderten Limitressourcen.  | 
|  `kube_pod_container_resource_requests (CPU)`  |  Die Anzahl der von einem Container angeforderten Anforderungsressourcen.  | 
|  `kube_pod_container_resource_requests (Memory)`  |  Die Anzahl der von einem Container angeforderten Anforderungsressourcen.  | 
|  `kube_pod_owner`  |  Informationen über den Besitzer des Pods.  | 
|  `kube_resourcequota`  |  Ressourcenkontingente in Kubernetes setzen Nutzungsbeschränkungen für Ressourcen wie CPU, Arbeitsspeicher und Speicher innerhalb von Namespaces durch.  | 
|  `node_cpu`  |  Die CPU-Nutzungsmetriken für einen Knoten, einschließlich der Nutzung pro Kern und der Gesamtnutzung.  | 
|  `node_cpu_seconds_total`  |  Sekunden, die in jedem Modus CPUs verbracht wurden.  | 
|  `node_disk_io_time_seconds`  |  Die kumulierte Zeit, die ein Knoten für die Ausführung von I/O Vorgängen auf der Festplatte aufgewendet hat.  | 
|  `node_disk_io_time_seconds_total`  |  Die Gesamtzeit, die der Knoten für die Ausführung von I/O Vorgängen auf der Festplatte aufgewendet hat.  | 
|  `node_disk_read_bytes_total`  |  Die Gesamtzahl der vom Knoten von der Festplatte gelesenen Byte.  | 
|  `node_disk_written_bytes_total`  |  Die Gesamtzahl der vom Knoten auf die Festplatte geschriebenen Byte.  | 
|  `node_filesystem_avail_bytes`  |  Die Menge des verfügbaren Speicherplatzes in Byte im Dateisystem eines Knotens in einem Kubernetes-Cluster.  | 
|  `node_filesystem_size_bytes`  |  Die Gesamtgröße des Dateisystems auf dem Knoten.  | 
|  `node_load1`  |  Der 1-Minuten-Durchschnitt der CPU-Auslastung eines Knotens.  | 
|  `node_load15`  |  Der 15-minütige Lastdurchschnitt der CPU-Auslastung eines Knotens.  | 
|  `node_load5`  |  Der 5-Minuten-Durchschnitt der CPU-Auslastung eines Knotens.  | 
|  `node_memory_Buffers_bytes`  |  Die Speichermenge, die vom Betriebssystem des Knotens für das Puffer-Caching verwendet wird.  | 
|  `node_memory_Cached_bytes,`  |  Die Speichermenge, die vom Betriebssystem des Knotens für das Festplatten-Caching verwendet wird.  | 
|  `node_memory_MemAvailable_bytes`  |  Die Menge an Arbeitsspeicher, die von Anwendungen und Caches verwendet werden kann.  | 
|  `node_memory_MemFree_bytes`  |  Die Menge an freiem Speicher, der auf dem Knoten verfügbar ist.  | 
|  `node_memory_MemTotal_bytes`  |  Die Gesamtmenge des auf dem Knoten verfügbaren physischen Speichers.  | 
|  `node_network_receive_bytes_total`  |  Die Gesamtzahl der Byte, die der Knoten über das Netzwerk empfangen hat.  | 
|  `node_network_transmit_bytes_total`  |  Die Gesamtzahl der vom Knoten über das Netzwerk übertragenen Byte.  | 
|  `process_cpu_seconds_total`  |  Die gesamte CPU-Zeit, die Benutzer und das System in Sekunden aufgewendet haben.  | 
|  `process_resident_memory_bytes`  |  Größe des residenten Speichers in Byte.  | 
|  `rest_client_requests_total`  |  Anzahl der HTTP-Anfragen, partitioniert nach Statuscode, Methode und Host.  | 
|  `rest_client_request_duration_seconds_bucket`  |  Das kurzgefasste Histogramm der Anforderungslatenz in Sekunden. Aufgeschlüsselt nach Verb und Host.  | 
|  `storage_operation_duration_seconds_bucket`  |  Das kombinierte Histogramm der Dauer von Speichervorgängen.  | 
|  `storage_operation_duration_seconds_count`  |  Die Anzahl der Dauer von Speichervorgängen.  | 
|  `storage_operation_errors_total`  |  Kumulierte Anzahl von Fehlern bei Speichervorgängen.  | 
|  `up`  |  Eine Metrik, die angibt, ob das überwachte Ziel (z. B. der Knoten) betriebsbereit ist.  | 
|  `volume_manager_total_volumes`  |  Die Gesamtzahl der vom Volume Manager verwalteten Volumes.  | 
|  `workqueue_adds_total`  |  Gesamtzahl der von der Workqueue bearbeiteten Hinzufügungen.  | 
|  `workqueue_depth`  |  Aktuelle Tiefe der Arbeitswarteschlange.  | 
|  `workqueue_queue_duration_seconds_bucket`  |  Das kombinierte Histogramm, das angibt, wie lange (in Sekunden) ein Element in der Arbeitswarteschlange verbleibt, bevor es angefordert wird.  | 
|  `workqueue_work_duration_seconds_bucket`  |  Das Buckethistogramm, das angibt, wie lange in Sekunden die Bearbeitung eines Elements aus der Arbeitswarteschlange dauert.  | 

## Liste der erstellten Alarme
<a name="solution-eks-alerts"></a>

In den folgenden Tabellen sind die Warnungen aufgeführt, die mit dieser Lösung erstellt wurden. Die Benachrichtigungen werden als Regeln in Amazon Managed Service für Prometheus erstellt und in Ihrem Amazon Managed Grafana-Arbeitsbereich angezeigt.

Sie können die Regeln ändern, einschließlich des Hinzufügens oder Löschens von Regeln, indem Sie [die Regelkonfigurationsdatei in Ihrem Amazon Managed Service for Prometheus-Workspace bearbeiten](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-rules-edit.html).

Bei diesen beiden Alerts handelt es sich um spezielle Alerts, die etwas anders behandelt werden als typische Alerts. Anstatt Sie auf ein Problem aufmerksam zu machen, geben sie Ihnen Informationen, die zur Überwachung des Systems verwendet werden. Die Beschreibung enthält Einzelheiten zur Verwendung dieser Benachrichtigungen.


| Warnung | Beschreibung und Verwendung | 
| --- | --- | 
| `Watchdog` | Mit dieser Warnung soll sichergestellt werden, dass die gesamte Warnungspipeline funktionsfähig ist. Diese Warnung wird immer ausgelöst, daher sollte sie immer im Alertmanager und immer gegen einen Empfänger ausgelöst werden. Sie können dies in Ihren Benachrichtigungsmechanismus integrieren, um eine Benachrichtigung zu senden, wenn dieser Alarm *nicht* ausgelöst wird. Sie könnten die **DeadMansSnitch**Integration beispielsweise in verwenden PagerDuty. | 
| `InfoInhibitor` | Dies ist eine Warnung, die verwendet wird, um Informationswarnungen zu verhindern. Warnmeldungen auf Informationsebene können für sich genommen sehr laut sein, aber sie sind relevant, wenn sie mit anderen Warnmeldungen kombiniert werden. Diese Warnung wird ausgelöst, wenn eine `severity=info` Warnung eingeht, und wird nicht mehr ausgelöst, wenn eine weitere Warnung mit dem Schweregrad `warning` oder für denselben `critical` Namespace ausgelöst wird. Diese Warnung sollte an einen Null-Empfänger weitergeleitet und so konfiguriert werden, dass Alerts mit blockiert werden. `severity=info` | 

Die folgenden Warnmeldungen geben Ihnen Informationen oder Warnungen zu Ihrem System.


| Warnung | Schweregrad | Description | 
| --- | --- | --- | 
|  `NodeNetworkInterfaceFlapping`  | warning |  Die Netzwerkschnittstelle ändert häufig ihren Status  | 
|  `NodeFilesystemSpaceFillingUp`  | warning |  Es wird prognostiziert, dass im Dateisystem innerhalb der nächsten 24 Stunden nicht mehr genügend Speicherplatz zur Verfügung steht.  | 
|  `NodeFilesystemSpaceFillingUp`  | critical |  Es wird prognostiziert, dass dem Dateisystem innerhalb der nächsten 4 Stunden der Speicherplatz ausgeht.  | 
|  `NodeFilesystemAlmostOutOfSpace`  | warning |  Im Dateisystem sind weniger als 5% Speicherplatz übrig.  | 
|  `NodeFilesystemAlmostOutOfSpace`  | critical |  Im Dateisystem sind weniger als 3% Speicherplatz übrig.  | 
|  `NodeFilesystemFilesFillingUp`  | warning |  Es wird prognostiziert, dass dem Dateisystem innerhalb der nächsten 24 Stunden die Inodes ausgehen werden.  | 
|  `NodeFilesystemFilesFillingUp`  | critical |  Es wird prognostiziert, dass dem Dateisystem innerhalb der nächsten 4 Stunden die Inodes ausgehen werden.  | 
|  `NodeFilesystemAlmostOutOfFiles`  | warning |  Im Dateisystem sind weniger als 5% Inodes übrig.  | 
|  `NodeFilesystemAlmostOutOfFiles`  | critical |  Das Dateisystem hat noch weniger als 3% Inodes übrig.  | 
|  `NodeNetworkReceiveErrs`  | warning |  Die Netzwerkschnittstelle meldet viele Empfangsfehler.  | 
|  `NodeNetworkTransmitErrs`  | warning |  Die Netzwerkschnittstelle meldet viele Übertragungsfehler.  | 
|  `NodeHighNumberConntrackEntriesUsed`  | warning |  Die Anzahl der Conntrack-Einträge nähert sich dem Limit.  | 
|  `NodeTextFileCollectorScrapeError`  | warning |  Der Node Exporter Exporter-Textdatei-Collector konnte nicht gescrapt werden.  | 
|  `NodeClockSkewDetected`  | warning |  Eine Zeitversetzung wurde festgestellt.  | 
|  `NodeClockNotSynchronizzing`  | warning |  Die Uhr wird nicht synchronisiert.  | 
|  `NodeRAIDDegraded`  | critical |  Das RAID-Array ist heruntergestuft  | 
|  `NodeRAIDDiskFailure`  | warning |  Gerät im RAID-Array ausgefallen  | 
|  `NodeFileDescriptorLimit`  | warning |  Der Kernel wird voraussichtlich bald das Limit für Dateideskriptoren erschöpfen.  | 
|  `NodeFileDescriptorLimit`  | critical |  Es wird vorausgesagt, dass der Kernel das Limit für Dateideskriptoren bald erschöpft.  | 
|  `KubeNodeNotReady`  | warning |  Der Knoten ist nicht bereit.  | 
|  `KubeNodeUnreachable`  | warning |  Der Knoten ist nicht erreichbar.  | 
|  `KubeletTooManyPods`  | info |  Kubelet ist voll ausgelastet.  | 
|  `KubeNodeReadinessFlapping`  | warning |  Der Bereitschaftsstatus des Knotens schwankt.  | 
|  `KubeletPlegDurationHigh`  | warning |  Das Wiederauflisten des Kubelet Pod Lifecycle Event Generator dauert zu lange.  | 
|  `KubeletPodStartUpLatencyHigh`  | warning |  Die Startlatenz des Kubelet Pod ist zu hoch.  | 
|  `KubeletClientCertificateExpiration`  | warning |  Das Kubelet-Client-Zertifikat läuft bald ab.  | 
|  `KubeletClientCertificateExpiration`  | critical |  Das Kubelet-Client-Zertifikat läuft bald ab.  | 
|  `KubeletServerCertificateExpiration`  | warning |  Das Kubelet-Serverzertifikat läuft bald ab.  | 
|  `KubeletServerCertificateExpiration`  | critical |  Das Kubelet-Serverzertifikat läuft bald ab.  | 
|  `KubeletClientCertificateRenewalErrors`  | warning |  Kubelet konnte sein Client-Zertifikat nicht erneuern.  | 
|  `KubeletServerCertificateRenewalErrors`  | warning |  Kubelet konnte sein Serverzertifikat nicht erneuern.  | 
|  `KubeletDown`  | critical |  Target ist aus Prometheus Target Discovery verschwunden.  | 
|  `KubeVersionMismatch`  | warning |  Verschiedene semantische Versionen von Kubernetes-Komponenten werden ausgeführt.  | 
|  `KubeClientErrors`  | warning |  Beim Kubernetes-API-Serverclient treten Fehler auf.  | 
|  `KubeClientCertificateExpiration`  | warning |  Das Client-Zertifikat läuft bald ab.  | 
|  `KubeClientCertificateExpiration`  | critical |  Das Client-Zertifikat läuft bald ab.  | 
|  `KubeAggregatedAPIErrors`  | warning |  Die aggregierte Kubernetes-API hat Fehler gemeldet.  | 
|  `KubeAggregatedAPIDown`  | warning |  Die aggregierte Kubernetes-API ist ausgefallen.  | 
|  `KubeAPIDown`  | critical |  Target ist aus Prometheus Target Discovery verschwunden.  | 
|  `KubeAPITerminatedRequests`  | warning |  Der Kubernetes-Apiserver hat \$1\$1\$1value \$1 humanizePercentage\$1\$1 seiner eingehenden Anfragen beendet.  | 
|  `KubePersistentVolumeFillingUp`  | critical |  Das persistente Volumen füllt sich.  | 
|  `KubePersistentVolumeFillingUp`  | warning |  Persistent Volume füllt sich.  | 
|  `KubePersistentVolumeInodesFillingUp`  | critical |  Persistent Volume Inodes füllt sich.  | 
|  `KubePersistentVolumeInodesFillingUp`  | warning |  Persistent Volume Inodes füllen sich.  | 
|  `KubePersistentVolumeErrors`  | critical |  Persistent Volume hat Probleme mit der Bereitstellung.  | 
|  `KubeCPUOvercommit`  | warning |  Der Cluster hat zu viele CPU-Ressourcenanforderungen zugewiesen.  | 
|  `KubeMemoryOvercommit`  | warning |  Der Cluster hat zu viele Speicherressourcenanforderungen zugewiesen.  | 
|  `KubeCPUQuotaOvercommit`  | warning |  Der Cluster hat zu viele CPU-Ressourcenanforderungen zugewiesen.  | 
|  `KubeMemoryQuotaOvercommit`  | warning |  Der Cluster hat zu viele Speicherressourcenanforderungen zugewiesen.  | 
|  `KubeQuotaAlmostFull`  | info |  Das Namespace-Kontingent wird voll sein.  | 
|  `KubeQuotaFullyUsed`  | info |  Das Namespace-Kontingent ist vollständig ausgeschöpft.  | 
|  `KubeQuotaExceeded`  | warning |  Das Namespace-Kontingent hat die Grenzwerte überschritten.  | 
|  `CPUThrottlingHigh`  | info |  Bei Prozessen kommt es zu einer erhöhten CPU-Drosselung.  | 
|  `KubePodCrashLooping`  | warning |  Der Pod stürzt in einer Schleife ab.  | 
|  `KubePodNotReady`  | warning |  Der Pod befindet sich seit mehr als 15 Minuten in einem nicht betriebsbereiten Zustand.  | 
|  `KubeDeploymentGenerationMismatch`  | warning |  Die Generierung der Bereitstellung stimmt aufgrund eines möglichen Rollbacks nicht überein  | 
|  `KubeDeploymentReplicasMismatch`  | warning |  Die Bereitstellung entsprach nicht der erwarteten Anzahl von Replikaten.  | 
|  `KubeStatefulSetReplicasMismatch`  | warning |  StatefulSet hat nicht die erwartete Anzahl von Replikaten erreicht.  | 
|  `KubeStatefulSetGenerationMismatch`  | warning |  StatefulSet Generationenkonflikt aufgrund eines möglichen Rollbacks  | 
|  `KubeStatefulSetUpdateNotRolledOut`  | warning |  StatefulSet Das Update wurde nicht eingeführt.  | 
|  `KubeDaemonSetRolloutStuck`  | warning |  DaemonSet Der Rollout steckt fest.  | 
|  `KubeContainerWaiting`  | warning |  Der Pod-Container wartet länger als 1 Stunde  | 
|  `KubeDaemonSetNotScheduled`  | warning |  DaemonSet Pods sind nicht geplant.  | 
|  `KubeDaemonSetMisScheduled`  | warning |  DaemonSet Pods sind falsch geplant.  | 
|  `KubeJobNotCompleted`  | warning |  Job wurde nicht rechtzeitig abgeschlossen  | 
|  `KubeJobFailed`  | warning |  Der Job konnte nicht abgeschlossen werden.  | 
|  `KubeHpaReplicasMismatch`  | warning |  HPA hat die gewünschte Anzahl von Replikaten nicht gefunden.  | 
|  `KubeHpaMaxedOut`  | warning |  HPA wird mit der maximalen Anzahl von Replikaten ausgeführt  | 
|  `KubeStateMetricsListErrors`  | critical |  kube-state-metrics treten Fehler bei Listenoperationen auf.  | 
|  `KubeStateMetricsWatchErrors`  | critical |  kube-state-metrics treten Fehler bei der Bedienung der Uhr auf.  | 
|  `KubeStateMetricsShardingMismatch`  | critical |  kube-state-metrics Sharding ist falsch konfiguriert.  | 
|  `KubeStateMetricsShardsMissing`  | critical |  kube-state-metrics Shards fehlen.  | 
|  `KubeAPIErrorBudgetBurn`  | critical |  Der API-Server verbraucht zu viel Fehlerbudget.  | 
|  `KubeAPIErrorBudgetBurn`  | critical |  Der API-Server verbraucht zu viel Fehlerbudget.  | 
|  `KubeAPIErrorBudgetBurn`  | warning |  Der API-Server verbraucht zu viel Fehlerbudget.  | 
|  `KubeAPIErrorBudgetBurn`  | warning |  Der API-Server verbraucht zu viel Fehlerbudget.  | 
|  `TargetDown`  | warning |  Ein oder mehrere Ziele sind ausgefallen.  | 
|  `etcdInsufficientMembers`  | critical |  Etcd-Cluster hat nicht genügend Mitglieder.  | 
|  `etcdHighNumberOfLeaderChanges`  | warning |  Etcd-Cluster, hohe Anzahl von Führungswechsel.  | 
|  `etcdNoLeader`  | critical |  Der Etcd-Cluster hat keinen Anführer.  | 
|  `etcdHighNumberOfFailedGRPCRequests`  | warning |  Etcd-Cluster mit hoher Anzahl fehlgeschlagener gRPC-Anfragen.  | 
|  `etcdGRPCRequestsSlow`  | critical |  Etcd-Cluster-gRPC-Anfragen sind langsam.  | 
|  `etcdMemberCommunicationSlow`  | warning |  Die Kommunikation der Etcd-Clustermitglieder ist langsam.  | 
|  `etcdHighNumberOfFailedProposals`  | warning |  Etcd-Cluster mit hoher Anzahl fehlgeschlagener Vorschläge.  | 
|  `etcdHighFsyncDurations`  | warning |  Etcd-Cluster mit hoher Fsync-Dauer.  | 
|  `etcdHighCommitDurations`  | warning |  Der Etcd-Cluster hat eine höhere Commit-Dauer als erwartet.  | 
|  `etcdHighNumberOfFailedHTTPRequests`  | warning |  Der Etcd-Cluster hat HTTP-Anfragen nicht bestanden.  | 
|  `etcdHighNumberOfFailedHTTPRequests`  | critical |  Der Etcd-Cluster hat eine hohe Anzahl fehlgeschlagener HTTP-Anfragen.  | 
|  `etcdHTTPRequestsSlow`  | warning |  Etcd-Cluster-HTTP-Anfragen sind langsam.  | 
|  `HostClockNotSynchronizing`  | warning |  Die Host-Uhr wird nicht synchronisiert.  | 
|  `HostOomKillDetected`  | warning |  Host-OOM-Kill erkannt.  | 

## Fehlerbehebung
<a name="solution-eks-troubleshooting"></a>

Es gibt einige Dinge, die dazu führen können, dass die Einrichtung des Projekts fehlschlägt. Stellen Sie sicher, dass Sie Folgendes überprüfen.
+ Sie müssen alle [Voraussetzungen erfüllen](#solution-eks-prerequisites), bevor Sie die Lösung installieren können.
+ Der Cluster muss mindestens einen Knoten enthalten, bevor Sie versuchen können, die Lösung zu erstellen oder auf die Metriken zuzugreifen.
+ In Ihrem Amazon EKS-Cluster müssen die `AWS CNI` `CoreDNS` und `kube-proxy` Add-Ons installiert sein. Wenn sie nicht installiert sind, funktioniert die Lösung nicht richtig. Sie werden standardmäßig installiert, wenn der Cluster über die Konsole erstellt wird. Möglicherweise müssen Sie sie installieren, wenn der Cluster über ein AWS SDK erstellt wurde.
+ Bei der Installation der Amazon EKS-Pods wurde das Zeitlimit überschritten. Dies kann passieren, wenn nicht genügend Knotenkapazität verfügbar ist. Es gibt mehrere Ursachen für diese Probleme, darunter:
  + Der Amazon EKS-Cluster wurde mit Fargate statt mit Amazon EC2 initialisiert. Für dieses Projekt ist Amazon EC2 erforderlich.
  + Die Knoten sind [beschädigt und](https://docs.aws.amazon.com/eks/latest/userguide/node-taints-managed-node-groups.html) daher nicht verfügbar.

    Sie können sie verwenden`kubectl describe node NODENAME | grep Taints`, um die Makel zu überprüfen. Dann `kubectl taint node NODENAME TAINT_NAME-` um die Flecken zu entfernen. Stellen Sie sicher, dass Sie `-` nach dem Namen des Makels den Namen angeben.
  + Die Knoten haben die Kapazitätsgrenze erreicht. In diesem Fall können Sie einen neuen Knoten erstellen oder die Kapazität erhöhen.
+ Sie sehen in Grafana keine Dashboards: Sie verwenden die falsche Grafana-Workspace-ID.

  Führen Sie den folgenden Befehl aus, um Informationen über Grafana zu erhalten:

  ```
  kubectl describe grafanas external-grafana -n grafana-operator
  ```

  Sie können die Ergebnisse auf die richtige Workspace-URL überprüfen. Wenn es sich nicht um die erwartete handelt, führen Sie die Bereitstellung erneut mit der richtigen Workspace-ID durch.

  ```
  Spec:
    External:
      API Key:
        Key:   GF_SECURITY_ADMIN_APIKEY
        Name:  grafana-admin-credentials
      URL:     https://g-123example.grafana-workspace.aws-region.amazonaws.com
  Status:
    Admin URL:  https://g-123example.grafana-workspace.aws-region.amazonaws.com
    Dashboards:
      ...
  ```
+ In Grafana werden keine Dashboards angezeigt: Sie verwenden einen abgelaufenen API-Schlüssel.

  Um nach diesem Fall zu suchen, müssen Sie den Grafana-Operator aufrufen und die Protokolle auf Fehler überprüfen. Rufen Sie den Namen des Grafana-Operators mit diesem Befehl ab:

  ```
  kubectl get pods -n grafana-operator
  ```

  Dadurch wird der Name des Operators zurückgegeben, zum Beispiel:

  ```
  NAME                               READY   STATUS    RESTARTS   AGE
  grafana-operator-1234abcd5678ef90   1/1     Running   0          1h2m
  ```

  Verwenden Sie den Operatornamen im folgenden Befehl:

  ```
  kubectl logs grafana-operator-1234abcd5678ef90 -n grafana-operator
  ```

  Fehlermeldungen wie die folgenden weisen auf einen abgelaufenen API-Schlüssel hin:

  ```
  ERROR   error reconciling datasource    {"controller": "grafanadatasource", "controllerGroup": "grafana.integreatly.org", "controllerKind": "GrafanaDatasource", "GrafanaDatasource": {"name":"grafanadatasource-sample-amp","namespace":"grafana-operator"}, "namespace": "grafana-operator", "name": "grafanadatasource-sample-amp", "reconcileID": "72cfd60c-a255-44a1-bfbd-88b0cbc4f90c", "datasource": "grafanadatasource-sample-amp", "grafana": "external-grafana", "error": "status: 401, body: {\"message\":\"Expired API key\"}\n"}
  github.com/grafana-operator/grafana-operator/controllers.(*GrafanaDatasourceReconciler).Reconcile
  ```

  Erstellen Sie in diesem Fall einen neuen API-Schlüssel und stellen Sie die Lösung erneut bereit. Wenn das Problem weiterhin besteht, können Sie vor der erneuten Bereitstellung die Synchronisation mithilfe des folgenden Befehls erzwingen:

  ```
  kubectl delete externalsecret/external-secrets-sm -n grafana-operator
  ```
+ *CDK-Installationen* — Fehlender SSM-Parameter. Wenn Sie einen Fehler wie den folgenden sehen, führen Sie ihn aus `cdk bootstrap` und versuchen Sie es erneut.

  ```
  Deployment failed: Error: aws-observability-solution-eks-infra-$EKS_CLUSTER_NAME: SSM 
  parameter /cdk-bootstrap/xxxxxxx/version not found. Has the environment been 
  bootstrapped? Please run 'cdk bootstrap' (see https://docs.aws.amazon.com/cdk/latest/
  guide/bootstrapping.html)
  ```
+ Die Bereitstellung kann fehlschlagen, wenn der OIDC-Anbieter bereits vorhanden ist. Es wird ein Fehler wie der folgende angezeigt (in diesem Fall bei CDK-Installationen):

  ```
  | CREATE_FAILED | Custom::AWSCDKOpenIdConnectProvider | OIDCProvider/Resource/Default
  Received response status [FAILED] from custom resource. Message returned: 
  EntityAlreadyExistsException: Provider with url https://oidc.eks.REGION.amazonaws.com/id/PROVIDER ID already exists.
  ```

  Gehen Sie in diesem Fall zum IAM-Portal, löschen Sie den OIDC-Anbieter und versuchen Sie es erneut.
+ *Terraform-Installationen — Es wird* eine Fehlermeldung angezeigt, die und enthält. `cluster-secretstore-sm failed to create kubernetes rest client for update of resource` `failed to create kubernetes rest client for update of resource`

  Dieser Fehler weist normalerweise darauf hin, dass der External Secrets Operator in Ihrem Kubernetes-Cluster nicht installiert oder aktiviert ist. Dieser wird als Teil der Lösungsbereitstellung installiert, ist aber manchmal nicht bereit, wenn die Lösung ihn benötigt.

  Sie können mit dem folgenden Befehl überprüfen, ob sie installiert ist:

  ```
  kubectl get deployments -n external-secrets
  ```

  Wenn es installiert ist, kann es einige Zeit dauern, bis der Bediener vollständig einsatzbereit ist. Sie können den Status der benötigten benutzerdefinierten Ressourcendefinitionen (CRDs) überprüfen, indem Sie den folgenden Befehl ausführen:

  ```
  kubectl get crds|grep external-secrets
  ```

  Dieser Befehl sollte den Operator auflisten, der sich auf die externen Geheimnisse CRDs bezieht, einschließlich `clustersecretstores.external-secrets.io` und`externalsecrets.external-secrets.io`. Wenn sie nicht aufgeführt sind, warten Sie ein paar Minuten und überprüfen Sie es erneut.

  Sobald sie registriert CRDs sind, können Sie sie `terraform apply` erneut ausführen, um die Lösung bereitzustellen.