Prometheus-Scrape-Konfiguration CloudWatch Agentenkonfiguration für Prometheus Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Prometheus Server-Metriken API

Scraping zusätzlicher Prometheus-Quellen und Importieren dieser Metriken

Der CloudWatch Agent mit Prometheus-Überwachung benötigt zwei Konfigurationen, um die Prometheus-Metriken zu erfassen. Er folgt der standardmäßigen Prometheus-Konfiguration, wie in <scrape_config> in der Prometheus-Dokumentation erläutert. Die andere ist für die Agentenkonfiguration vorgesehen. CloudWatch

Für EKS Amazon-Cluster sind die Konfigurationen in prometheus-eks.yaml (für den EC2 Starttyp) oder prometheus-eks-fargate.yaml (für den Fargate-Starttyp) als zwei Konfigurationszuordnungen definiert:

Der name: prometheus-config-Abschnitt enthält die Einstellungen für Prometheus-Scraping.
Der name: prometheus-cwagentconfig Abschnitt enthält die Konfiguration für den CloudWatch Agenten. In diesem Abschnitt können Sie konfigurieren, wie die Prometheus-Metriken von erfasst werden. CloudWatch Sie geben beispielsweise an, in welche Metriken importiert werden sollen CloudWatch, und definieren deren Dimensionen.

Für Kubernetes-Cluster, die auf EC2 Amazon-Instances ausgeführt werden, sind die Konfigurationen in der prometheus-k8s.yaml YAML Datei als zwei Konfigurationszuordnungen definiert:

Der name: prometheus-config-Abschnitt enthält die Einstellungen für Prometheus-Scraping.
Der name: prometheus-cwagentconfig Abschnitt enthält die Konfiguration für den CloudWatch Agenten.

Um zusätzliche Prometheus-Metrikquellen zu scrapen und diese Metriken zu importieren CloudWatch, ändern Sie sowohl die Prometheus-Scrape-Konfiguration als auch die Agentenkonfiguration und stellen dann den CloudWatch Agenten mit der aktualisierten Konfiguration erneut bereit.

VPCAnforderungen an Sicherheitsgruppen

Die Eingangsregeln der Sicherheitsgruppen für die Prometheus-Workloads müssen die Prometheus-Ports für den CloudWatch Agenten öffnen, damit er die Prometheus-Metriken über die private IP scrapen kann.

Die Ausgangsregeln der Sicherheitsgruppe für den CloudWatch Agenten müssen es dem CloudWatch Agenten ermöglichen, über eine private IP eine Verbindung zum Port der Prometheus-Workloads herzustellen.

Prometheus-Scrape-Konfiguration

Der CloudWatch Agent unterstützt die standardmäßigen Prometheus-Scrape-Konfigurationen, wiehttps://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config <scrape_config>in der Prometheus-Dokumentation dokumentiert. Sie können diesen Abschnitt bearbeiten, um die Konfigurationen zu aktualisieren, die sich bereits in dieser Datei befinden, und zusätzliche Prometheus-Scraping-Ziele hinzufügen. Standardmäßig enthält die Beispielkonfigurationsdatei die folgenden globalen Konfigurationszeilen:


global:
  scrape_interval: 1m
  scrape_timeout: 10s

scrape_interval – Definiert, wie oft das Scraping von zielen durchgeführt werden soll.
scrape_timeout – Definiert, wie lange gewartet werden soll, bis für eine Scrape-Anforderung eine Zeitüberschreitung eintritt.

Sie können auch verschiedene Werte für diese Einstellungen auf Auftragsebene definieren, um die globalen Konfigurationen zu überschreiben.

Prometheus-Scraping-Aufträge

Für die CloudWatch YAML Agentendateien sind bereits einige Standard-Scraping-Jobs konfiguriert. In prometheus-eks.yaml werden beispielsweise die Standard-Scraping-Aufträge in den job_name-Zeilen im Abschnitt scrape_configs konfiguriert. In dieser Datei werden im folgenden kubernetes-pod-jmx Standardabschnitt Export-Metriken erfasst. JMX


   - job_name: 'kubernetes-pod-jmx'
      sample_limit: 10000
      metrics_path: /metrics
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__address__]
        action: keep
        regex: '.*:9404$'
      - action: labelmap
        regex: __meta_kubernetes_pod_label_(.+)
      - action: replace
        source_labels:
        - __meta_kubernetes_namespace
        target_label: Namespace
      - source_labels: [__meta_kubernetes_pod_name]
        action: replace
        target_label: pod_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_container_name
        target_label: container_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_controller_name
        target_label: pod_controller_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_controller_kind
        target_label: pod_controller_kind
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_phase
        target_label: pod_phase

Jedes dieser Standardziele wird gelöscht, und die Metriken werden im eingebetteten Metrikformat CloudWatch in Protokollereignissen gesendet. Weitere Informationen finden Sie unter Einbetten von Metriken in Protokollen.

Protokollereignisse von Amazon EKS - und Kubernetes-Clustern werden im Verzeichnis /aws/containerinsights/ gespeichert cluster_name CloudWatch /prometheus-Protokollgruppe in Logs. Protokollereignisse von ECS Amazon-Clustern werden im Verzeichnis /aws/ecs/containerinsights/ gespeichertcluster_name/prometheus-Protokollgruppe.

Jeder Scraping-Auftrag ist in einem anderen Protokoll-Stream in dieser Protokollgruppe enthalten. Beispielsweise ist der Prometheus-Scraping-Auftrag kubernetes-pod-appmesh-envoy für App Mesh definiert. Alle App Mesh Prometheus-Metriken von Amazon EKS - und Kubernetes-Clustern werden an den Log-Stream mit dem Namen /aws/containerinsights/ gesendet cluster_namekubernetes-pod-appmesh-envoy>prometheus//.

Um ein neues Scraping-Ziel hinzuzufügen, fügen Sie dem Abschnitt der Datei einen neuen job_name Abschnitt hinzu und starten den scrape_configs Agenten neu. YAML Ein Beispiel für diesen Prozess finden Sie unter Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Prometheus Server-Metriken API.

CloudWatch Agentenkonfiguration für Prometheus

Die CloudWatch Agentenkonfigurationsdatei enthält einen prometheus Abschnitt metrics_collected für die Prometheus-Scraping-Konfiguration. Es sind folgende Konfigurationsoptionen enthalten:

Clustername – Gibt den Clusternamen an, der als Bezeichnung im Protokollereignis hinzugefügt werden soll. Dies ist ein optionales Feld. Wenn Sie es weglassen, kann der Agent den Amazon EKS - oder Kubernetes-Clusternamen erkennen.
log_group_name – Gibt den Namen der Protokollgruppe für die Prometheus-Scrape-Metriken an. Dies ist ein optionales Feld. Wenn Sie ihn weglassen, wird /aws/containerinsights/ verwendet CloudWatch cluster_name/prometheus für Logs von Amazon EKS - und Kubernetes-Clustern.
prometheus_config_path – gibt den Pfad der Prometheus-Scrape-Konfigurationsdatei an. Wenn der Wert dieses Felds mit env: beginnt, wird der Inhalt der Prometheus-Scrape-Konfigurationsdatei aus der Umgebungsvariablen des Containers abgerufen. Ändern Sie dieses Feld nicht.
ecs_service_discovery — ist der Abschnitt, in dem die Konfiguration für Amazon ECS Prometheus Service Discovery angegeben wird. Weitere Informationen finden Sie unter Ausführlicher Leitfaden für Autodiscovery auf Amazon-Clustern ECS.

Der Abschnitt ecs_service_discovery kann die folgenden Felder enthalten:
- sd_frequency ist die Häufigkeit, mit der die Prometheus-Exporteure entdeckt werden. Geben Sie eine Zahl und ein Einheitensuffix an. Zum Beispiel 1m für einmal pro Minute oder 30s für einmal pro 30 Sekunden. Gültige Einheitensuffixe sind ns, us, ms, s, m und h.
  
  Dies ist ein optionales Feld. Der Standardwert ist 60 Sekunden (1 Minute).
- sd_target_clusterist der ECS Amazon-Zielclustername für die automatische Erkennung. Dies ist ein optionales Feld. Der Standard ist der Name des ECS Amazon-Clusters, auf dem der CloudWatch Agent installiert ist.
- sd_cluster_regionist die Region des ECS Amazon-Zielclusters. Dies ist ein optionales Feld. Die Standardeinstellung ist die Region des ECS Amazon-Clusters, in der der CloudWatch Agent installiert ist.
- sd_result_fileist der Pfad der YAML Datei für die Prometheus-Zielergebnisse. Die Prometheus-Scrape-Konfiguration bezieht sich auf diese Datei.
- docker_label ist ein optionaler Abschnitt, mit dem Sie die Konfiguration für die Docker-Beschriftungs-basierte Service-Discovery angeben können. Wenn Sie diesen Abschnitt auslassen, wird die Docker-Bezeichnungs-basierte Erkennung nicht verwendet. Dieser Abschnitt kann die folgenden Felder enthalten:
  - sd_port_label ist der Docker-Bezeichnungsname des Containers, der den Container-Port für Prometheus Metriken angibt. Der Standardwert ist ECS_PROMETHEUS_EXPORTER_PORT. Wenn der Container dieses Docker-Label nicht hat, überspringt der CloudWatch Agent es.
  - sd_metrics_path_label ist der Docker-Bezeichnungsname des Containers, der den Pfad für Prometheus Metriken angibt. Der Standardwert ist ECS_PROMETHEUS_METRICS_PATH. Wenn der Container nicht über diese Docker-Bezeichnung verfügt, nimmt der Agent den Standardpfad /metrics an.
  - sd_job_name_label ist der Docker-Bezeichnungsname des Containers, der den Container-Scraping-Auftrag-Namen für Prometheus angibt. Der Standardwert ist job. Wenn der Container dieses Docker-Label nicht hat, verwendet der CloudWatch Agent den Jobnamen in der Prometheus-Scrape-Konfiguration.
- task_definition_list ist ein optionaler Abschnitt, den Sie verwenden können, um die Konfiguration der aufgabendefinitionsbasierten Serviceerkennung anzugeben. Wenn Sie diesen Abschnitt auslassen, wird die aufgabendefinitionsbasierte Erkennung nicht verwendet. Dieser Abschnitt kann die folgenden Felder enthalten:
  - sd_task_definition_arn_patternist das Muster, das verwendet werden soll, um die zu ECS ermittelnden Amazon-Aufgabendefinitionen anzugeben. Dies ist ein regulärer Ausdruck.
  - sd_metrics_portslistet die containerPort für die Prometheus-Metriken auf. Trennen Sie die durch containerPorts Semikolons.
  - sd_container_name_patterngibt die Namen der ECS Amazon-Aufgabencontainer an. Dies ist ein regulärer Ausdruck.
  - sd_metrics_path gibt den Prometheus-Metrikpfad an. Wenn Sie dies weglassen, übernimmt der Agent den Standardpfad /metrics
  - sd_job_name gibt den Namen des Prometheus -Scrape-Auftrags an. Wenn Sie dieses Feld weglassen, verwendet der CloudWatch Agent den Jobnamen in der Prometheus-Scrape-Konfiguration.
metric_declaration – sind Abschnitte, die das Array von Protokollen mit eingebettetem Metrikformat angeben, das generiert werden soll. Für jede Prometheus-Quelle, aus der der CloudWatch Agent standardmäßig importiert, gibt es metric_declaration Abschnitte. Diese Abschnitte enthalten jeweils die folgenden Felder:
- label_matcher ist ein regulärer Ausdruck, der den Wert der in source_labels aufgelisteten Beschriftungen überprüft. Die übereinstimmenden Metriken werden für die Aufnahme in das eingebettete Metrikformat aktiviert, an das gesendet wird. CloudWatch
  
  Wenn in source_labels mehrere Bezeichnungen angegeben sind, empfehlen wir, keine ^- oder $-Zeichen im regulären Ausdruck für label_matcher zu verwenden.
- source_labels gibt den Wert der Beschriftungen an, die von der label_matcher-Zeile überprüft werden.
- label_separator gibt das Trennzeichen an, das in der Zeile label_matcherverwendet werden soll, wenn mehrere source_labels angegeben werden. Der Standardwert ist ;. Sie können diesen Standardwert in der Zeile label_matcher im folgenden Beispiel sehen.
- metric_selectorsist ein regulärer Ausdruck, der die Metriken angibt, die gesammelt und an sie gesendet werden sollen CloudWatch.
- dimensionsist die Liste der Bezeichnungen, die als CloudWatch Dimensionen für jede ausgewählte Metrik verwendet werden sollen.

Sehen Sie sich das folgende metric_declaration-Beispiel an.


"metric_declaration": [
  {
     "source_labels":[ "Service", "Namespace"],
     "label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system",
     "dimensions":[
        ["Service", "Namespace"]
     ],
     "metric_selectors":[
        "^coredns_dns_request_type_count_total$"
     ]
  }
]

In diesem Beispiel wird ein eingebetteter Metrikformatabschnitt konfiguriert, der als Protokollereignis gesendet wird, wenn die folgenden Bedingungen erfüllt sind:

Der Wert von Service enthält entweder node-exporter oder kube-dns.
Der Wert von Namespace ist kube-system.
Die Prometheus-Metrik coredns_dns_request_type_count_total enthält sowohl Service-als auch Namespace-Beschriftungen.

Das Protokollereignis, das gesendet wird, enthält den folgenden hervorgehobenen Abschnitt:


{
   "CloudWatchMetrics":[
      {
         "Metrics":[
            {
               "Name":"coredns_dns_request_type_count_total"
            }
         ],
         "Dimensions":[
            [
               "Namespace",
               "Service"
            ]
         ],
         "Namespace":"ContainerInsights/Prometheus"
      }
   ],
   "Namespace":"kube-system",
   "Service":"kube-dns",
   "coredns_dns_request_type_count_total":2562,
   "eks_amazonaws_com_component":"kube-dns",
   "instance":"192.168.61.254:9153",
   "job":"kubernetes-service-endpoints",
   ...
}

Tutorial zum Hinzufügen eines neuen Prometheus-Scrape-Ziels: Prometheus Server-Metriken API

Der API Kubernetes-Server stellt standardmäßig Prometheus-Metriken auf Endpunkten bereit. Das offizielle Beispiel für die Kubernetes API Server-Scraping-Konfiguration ist auf Github verfügbar.

Das folgende Tutorial zeigt, wie Sie die folgenden Schritte ausführen, um mit dem Import von API Kubernetes Server-Metriken zu beginnen: CloudWatch

Hinzufügen der Prometheus-Scraping-Konfiguration für Kubernetes Server zur API Agentendatei. CloudWatch YAML
Konfiguration der Metrikdefinitionen im eingebetteten Metrikformat in der Agentendatei. CloudWatch YAML
(Optional) Erstellen eines CloudWatch Dashboards für die Kubernetes API Server-Metriken.

Anmerkung

Der API Kubernetes-Server stellt Messwerte, Zähler, Histogramme und Übersichtsmetriken bereit. In dieser Version der Prometheus-Metrikunterstützung werden nur die Metriken mit den Typen Messgerät, Zähler und Zusammenfassung CloudWatch importiert.

Um mit der Erfassung von Kubernetes API Server Prometheus-Metriken zu beginnen in CloudWatch

Laden Sie die aktuelle Version der prometheus-eks.yaml-, prometheus-eks-fargate.yaml- oder prometheus-k8s.yaml-Datei herunter, indem Sie einen der folgenden Befehle eingeben.

Geben Sie für einen EKS Amazon-Cluster mit dem EC2 Starttyp den folgenden Befehl ein:


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml

Geben Sie für einen EKS Amazon-Cluster mit dem Starttyp Fargate den folgenden Befehl ein:


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml

Geben Sie für einen Kubernetes-Cluster, der auf einer EC2 Amazon-Instance ausgeführt wird, den folgenden Befehl ein:


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml

Öffnen Sie die Datei mit einem Texteditor, suchen Sie den Abschnitt prometheus-config und fügen Sie den folgenden Abschnitt in diesem Abschnitt hinzu. Speichern Sie dann die Änderungen:


    # Scrape config for API servers
    - job_name: 'kubernetes-apiservers'
      kubernetes_sd_configs:
        - role: endpoints
          namespaces:
            names:
              - default
      scheme: https
      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
      relabel_configs:
      - source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
        action: keep
        regex: kubernetes;https
      - action: replace
        source_labels:
        - __meta_kubernetes_namespace
        target_label: Namespace
      - action: replace
        source_labels:
        - __meta_kubernetes_service_name
        target_label: Service

Solange Sie die YAML Datei noch im Texteditor geöffnet haben, suchen Sie den cwagentconfig.json Abschnitt. Fügen Sie den folgenden Unterabschnitt hinzu und speichern Sie die Änderungen. In diesem Abschnitt werden die API Server-Metriken in die Zulassungsliste für CloudWatch Agenten aufgenommen. Drei Typen von API Server-Metriken werden der Zulassungsliste hinzugefügt:

etcd-Objektanzahl
APIController-Messwerte für die Serverregistrierung
APIMetriken für Serveranfragen


{"source_labels": ["job", "resource"],
  "label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)",
  "dimensions": [["ClusterName","Service","resource"]],
  "metric_selectors": [
  "^etcd_object_counts$"
  ]
},
{"source_labels": ["job", "name"],
   "label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$",
   "dimensions": [["ClusterName","Service","name"]],
   "metric_selectors": [
   "^workqueue_depth$",
   "^workqueue_adds_total$",
   "^workqueue_retries_total$"
  ]
},
{"source_labels": ["job","code"],
  "label_matcher": "^kubernetes-apiservers;2[0-9]{2}$",
  "dimensions": [["ClusterName","Service","code"]],
  "metric_selectors": [
   "^apiserver_request_total$"
  ]
},
{"source_labels": ["job"],
  "label_matcher": "^kubernetes-apiservers",
  "dimensions": [["ClusterName","Service"]],
  "metric_selectors": [
  "^apiserver_request_total$"
  ]
},

Wenn Sie den CloudWatch Agenten mit Prometheus-Unterstützung bereits im Cluster bereitgestellt haben, müssen Sie ihn löschen, indem Sie den folgenden Befehl eingeben:
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
Stellen Sie den CloudWatch Agenten mit Ihrer aktualisierten Konfiguration bereit, indem Sie einen der folgenden Befehle eingeben. Geben Sie für einen EKS Amazon-Cluster mit dem EC2 Starttyp Folgendes ein:
```
kubectl apply -f prometheus-eks.yaml
```
Geben Sie für einen EKS Amazon-Cluster mit dem Starttyp Fargate den folgenden Befehl ein. Ersetzen MyCluster and region mit Werten, die Ihrer Bereitstellung entsprechen.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Geben Sie für einen Kubernetes-Cluster den folgenden Befehl ein. Ersetzen MyCluster and region mit Werten, die zu Ihrer Bereitstellung passen.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```

Sobald Sie dies getan haben, sollten Sie einen neuen Protokollstream mit dem Namen kubernetes-apiservers im Verzeichnis /aws/containerinsights/ sehen cluster_name/prometheus-Protokollgruppe. Dieser Protokoll-Stream sollte Protokollereignisse mit einer Definition des eingebetteten Metrikformats wie folgt einschließen:


{
   "CloudWatchMetrics":[
      {
         "Metrics":[
            {
               "Name":"apiserver_request_total"
            }
         ],
         "Dimensions":[
            [
               "ClusterName",
               "Service"
            ]
         ],
         "Namespace":"ContainerInsights/Prometheus"
      }
   ],
   "ClusterName":"my-cluster-name",
   "Namespace":"default",
   "Service":"kubernetes",
   "Timestamp":"1592267020339",
   "Version":"0",
   "apiserver_request_count":0,
   "apiserver_request_total":0,
   "code":"0",
   "component":"apiserver",
   "contentType":"application/json",
   "instance":"192.0.2.0:443",
   "job":"kubernetes-apiservers",
   "prom_metric_type":"counter",
   "resource":"pods",
   "scope":"namespace",
   "verb":"WATCH",
   "version":"v1"
}

Sie können Ihre Metriken in der CloudWatch Konsole im ContainerInsights/Prometheus-Namespace anzeigen. Sie können optional auch ein CloudWatch Dashboard für Ihre Prometheus API Kubernetes Server-Metriken erstellen.

(Optional) Erstellen eines Dashboards für Kubernetes Server-Metriken API

Um Kubernetes API Server-Metriken in Ihrem Dashboard zu sehen, müssen Sie zuerst die Schritte in den vorherigen Abschnitten ausgeführt haben, um mit der Erfassung dieser Metriken zu beginnen. CloudWatch

Um ein Dashboard für API Kubernetes Server-Metriken zu erstellen

Öffnen Sie die CloudWatch Konsole unter. https://console.aws.amazon.com/cloudwatch/
Vergewissern Sie sich, dass Sie die richtige AWS Region ausgewählt haben.
Wählen Sie im Navigationsbereich Dashboards aus.
Klicken Sie auf Create Dashboard (Dashboard erstellen). Geben Sie einen Namen für das neue Dashboard ein und wählen Sie Create dashboard (Dashboard erstellen).
Wählen Sie unter Add to this dashboard (Zu diesem Dashboard hinzufügen) die Option Cancel (Abbrechen).
Wählen Sie Actions (Aktionen), View/edit source (Quelle anzeigen/bearbeiten).
Laden Sie die folgende JSON Datei herunter: APIKubernetes-Dashboard-Quelle.
Öffnen Sie die JSON Datei, die Sie heruntergeladen haben, mit einem Texteditor und nehmen Sie die folgenden Änderungen vor:
- Ersetzen Sie alle {{YOUR_CLUSTER_NAME}}-Zeichenfolgen durch den genauen Namen Ihres Clusters. Stellen Sie sicher, dass keine Leerzeichen vor oder nach dem Text hinzugefügt werden.
- Ersetzen Sie alle {{YOUR_AWS_REGION}}-Zeichenfolgen durch den Namen der Region, in der die Metriken erfasst werden. Zum Beispiel us-west-2. Stellen Sie sicher, dass keine Leerzeichen vor oder nach dem Text hinzugefügt werden.
Kopieren Sie den gesamten JSON Blob und fügen Sie ihn in das Textfeld in der CloudWatch Konsole ein, wodurch der Inhalt ersetzt wird, der sich bereits im Feld befindet.
Wählen Sie Update (Aktualisieren), Save dashboard (Dashboard speichern).

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

Auf Amazon EKS - und Kubernetes-Clustern einrichten

(Optional) Richten Sie containerisierte EKS Amazon-Beispiel-Workloads für Prometheus-Metriktests ein