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.

# SageMaker HyperPod Überwachung der Cluster-Ressourcen
Überwachung der Clusterressourcen

Um eine umfassende Beobachtbarkeit Ihrer SageMaker HyperPod Cluster-Ressourcen und Softwarekomponenten zu erreichen, integrieren Sie den Cluster in [Amazon Managed Service for Prometheus](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html) und [Amazon](https://docs.aws.amazon.com/grafana/latest/userguide/what-is-Amazon-Managed-Service-Grafana.html) Managed Grafana. Die Integration mit Amazon Managed Service for Prometheus ermöglicht den Export von Metriken zu Ihren HyperPod Cluster-Ressourcen und bietet so Einblicke in deren Leistung, Auslastung und Zustand. Die Integration mit Amazon Managed Grafana ermöglicht die Visualisierung dieser Metriken über verschiedene Grafana-Dashboards, die eine intuitive Oberfläche für die Überwachung und Analyse des Clusterverhaltens bieten. Durch die Nutzung dieser Services erhalten Sie eine zentralisierte und einheitliche Ansicht Ihres HyperPod Clusters, was die proaktive Überwachung, Fehlerbehebung und Optimierung Ihrer verteilten Trainingsworkloads erleichtert.

**Tipp**  
[Praktische Beispiele und Lösungen finden Sie auch im SageMaker HyperPod Workshop.](https://catalog.workshops.aws/sagemaker-hyperpod)

![\[Ein Überblick über die Konfiguration SageMaker HyperPod mit Amazon Managed Service für Prometheus und Amazon Managed Grafana.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hyperpod-observability-architecture.png)


Abbildung: Dieses Architekturdiagramm zeigt einen Überblick über die Konfiguration SageMaker HyperPod mit Amazon Managed Service für Prometheus und Amazon Managed Grafana.

Fahren Sie mit den folgenden Themen fort, um die Cluster-Observability einzurichten. SageMaker HyperPod 

**Topics**
+ [

# Voraussetzungen für die SageMaker HyperPod Cluster-Observability
](sagemaker-hyperpod-cluster-observability-slurm-prerequisites.md)
+ [

# Installation von Metrics Exporter-Paketen auf Ihrem Cluster HyperPod
](sagemaker-hyperpod-cluster-observability-slurm-install-exporters.md)
+ [

# Validierung des Prometheus-Setups auf dem Hauptknoten eines Clusters HyperPod
](sagemaker-hyperpod-cluster-observability-slurm-validate-prometheus-setup.md)
+ [

# Einrichten eines Workspaces von Amazon Managed Grafana
](sagemaker-hyperpod-cluster-observability-slurm-managed-grafana-ws.md)
+ [

# Referenz zu exportierten Metriken
](sagemaker-hyperpod-cluster-observability-slurm-exported-metrics-reference.md)
+ [

# Amazon SageMaker HyperPod Slurm-Metriken
](smcluster-slurm-metrics.md)

# Voraussetzungen für die SageMaker HyperPod Cluster-Observability
Voraussetzungen

Bevor Sie mit den Schritten unter [Installation von Metrics Exporter-Paketen auf Ihrem Cluster HyperPod](sagemaker-hyperpod-cluster-observability-slurm-install-exporters.md) fortfahren, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind.

## IAM Identity Center aktivieren


Um Observability für Ihren SageMaker HyperPod Cluster zu aktivieren, müssen Sie zuerst IAM Identity Center aktivieren. Dies ist eine Voraussetzung für die Bereitstellung eines CloudFormation Stacks, der den Amazon Managed Grafana-Workspace und Amazon Managed Service für Prometheus einrichtet. Beide Services benötigen außerdem das IAM Identity Center für die Authentifizierung und Autorisierung, um den sicheren Benutzerzugriff und die Verwaltung der Überwachungsinfrastruktur zu gewährleisten.

Eine ausführliche Anleitung zur Aktivierung von IAM Identity Center finden Sie im Abschnitt [Aktivierung von IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/get-set-up-for-idc.html) im *Benutzerhandbuch für AWS IAM Identity Center*. 

Nachdem Sie IAM Identity Center erfolgreich aktiviert haben, richten Sie ein Benutzerkonto ein, das während der folgenden Konfigurationsschritte als Administratorbenutzer dient.

## Erstellen und implementieren Sie einen Stack für CloudFormation Observability SageMaker HyperPod


Erstellen und implementieren Sie mithilfe von Amazon Managed Service for Prometheus und Amazon Managed Grafana einen CloudFormation Stack für SageMaker HyperPod Observability, um HyperPod Cluster-Metriken in Echtzeit zu überwachen. Beachten Sie, dass Sie vor der Bereitstellung des Stacks auch Ihr [IAM Identity Center](https://console.aws.amazon.com/singlesignon) aktivieren sollten.

Verwenden Sie das CloudFormation Beispielskript [https://github.com/aws-samples/awsome-distributed-training/blob/main/4.validation_and_observability/4.prometheus-grafana/cluster-observability.yaml](https://github.com/aws-samples/awsome-distributed-training/blob/main/4.validation_and_observability/4.prometheus-grafana/cluster-observability.yaml), das Ihnen hilft, Amazon VPC-Subnetze, Amazon FSx for Lustre-Dateisysteme, Amazon S3 S3-Buckets und IAM-Rollen einzurichten, die für die Erstellung eines Cluster-Observability-Stacks erforderlich sind. HyperPod 

# Installation von Metrics Exporter-Paketen auf Ihrem Cluster HyperPod
Installieren von Metrik-Exporter-Paketen

Zu den vom SageMaker HyperPod Team bereitgestellten [Lebenszyklusskripten für die Basiskonfiguration](sagemaker-hyperpod-lifecycle-best-practices-slurm-slurm-base-config.md) gehört auch die Installation verschiedener Metrik-Export-Pakete. Um den Installationsschritt zu aktivieren, müssen Sie lediglich den Parameter `enable_observability=True` in der Datei [https://github.com/aws-samples/awsome-distributed-training/blob/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/config.py](https://github.com/aws-samples/awsome-distributed-training/blob/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/config.py) festlegen. Die Lebenszyklusskripte dienen dazu, Ihren Cluster mit den folgenden Metrik-Exporter-Paketen (Open Source) zu booten.


|  |  |  | 
| --- |--- |--- |
| Name | Zielknoten für die Skriptbereitstellung | Beschreibung des Exporters | 
| [Slurm-Exporteur für Prometheus](https://github.com/vpenso/prometheus-slurm-exporter) | Hauptknoten (Controller) |  Exportiert die Buchhaltungsmetriken von Slurm  | 
|  [Knoten-Exporter von Elastic Fabric Adapter (EFA)](https://github.com/aws-samples/awsome-distributed-training/tree/main/4.validation_and_observability/3.efa-node-exporter)  |  Rechenknoten  |  Exportiert Metriken aus Clusterknoten und EFA. Das Paket ist eine Vergabelung des [Prometheus-Knoten-Exporters](https://github.com/prometheus/node_exporter).  | 
|  [Exporter für NVIDIA Data Center GPU Management (DCGM)](https://github.com/NVIDIA/dcgm-exporter)  | Rechenknoten |  Exportiert NVIDIA DCGM-Metriken zum Zustand und zur Leistung von NVIDIA. GPUs  | 

Mit `enable_observability=True` in der Datei [https://github.com/aws-samples/awsome-distributed-training/blob/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/config.py](https://github.com/aws-samples/awsome-distributed-training/blob/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/config.py) wird der folgende Installationsschritt im [https://github.com/aws-samples/awsome-distributed-training/blob/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/lifecycle_script.py](https://github.com/aws-samples/awsome-distributed-training/blob/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/lifecycle_script.py)-Skript aktiviert. 

```
# Install metric exporting software and Prometheus for observability
if Config.enable_observability:
    if node_type == SlurmNodeType.COMPUTE_NODE:
        ExecuteBashScript("./utils/install_docker.sh").run()
        ExecuteBashScript("./utils/install_dcgm_exporter.sh").run()
        ExecuteBashScript("./utils/install_efa_node_exporter.sh").run()

    if node_type == SlurmNodeType.HEAD_NODE:
        wait_for_scontrol()
        ExecuteBashScript("./utils/install_docker.sh").run()
        ExecuteBashScript("./utils/install_slurm_exporter.sh").run()
        ExecuteBashScript("./utils/install_prometheus.sh").run()
```

Auf den Rechenknoten installiert das Skript den NVIDIA Data Center GPU Management (DCGM)-Exporter und den Elastic Fabric Adapter (EFA)-Knoten-Exporter. Der DCGM-Exporter ist ein Exporter für Prometheus, der Metriken von NVIDIA sammelt und so die Überwachung der GPU-Nutzung GPUs, Leistung und Integrität ermöglicht. Der EFA-Knoten-Exporter hingegen erfasst Metriken zur EFA-Netzwerkschnittstelle, die für eine Kommunikation mit geringer Latenz und hoher Bandbreite in HPC-Clustern unerlässlich ist.

Auf dem Hauptknoten installiert das Skript den Slurm-Exporter für Prometheus und die [Open-Source-Software Prometheus](https://prometheus.io/docs/introduction/overview/). Der Slurm-Exporter stellt Prometheus Metriken zu Slurm-Aufträgen, Partitionen und Knotenstatus zur Verfügung.

Beachten Sie, dass die Lebenszyklusskripte so konzipiert sind, dass sie alle Exportpakete als Docker-Container installieren. Daher sollte das Docker-Paket auch sowohl auf dem Haupt- als auch auf dem Compute-Knoten installiert werden. *Die Skripte für diese Komponenten befinden sich praktischerweise im [https://github.com/aws-samples/awsome-distributed-training/tree/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/utils](https://github.com/aws-samples/awsome-distributed-training/tree/main/1.architectures/5.sagemaker-hyperpod/LifecycleScripts/base-config/utils)Ordner des Awsome Distributed Training Repositorys. GitHub *

Nachdem Sie Ihren HyperPod Cluster erfolgreich mit den Exportpaketen installiert haben, fahren Sie mit dem nächsten Thema fort, um die Einrichtung von Amazon Managed Service für Prometheus und Amazon Managed Grafana abzuschließen.

# Validierung des Prometheus-Setups auf dem Hauptknoten eines Clusters HyperPod
Validieren des Prometheus-Einrichtung

Nachdem Sie Ihren HyperPod Cluster erfolgreich mit den Exporter-Paketen installiert haben, überprüfen Sie, ob Prometheus auf dem Hauptknoten Ihres Clusters ordnungsgemäß eingerichtet ist. HyperPod 

1. Stellen Sie eine Verbindung mit dem Hauptknoten Ihres Clusters her. Anweisungen zum Zugriff auf einen Knoten finden Sie unter [Zugriff auf Ihre SageMaker HyperPod Clusterknoten](sagemaker-hyperpod-run-jobs-slurm-access-nodes.md).

1. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die vom Lebenszyklusskript erstellte Prometheus-Konfigurations- und Servicedatei `install_prometheus.sh` auf dem Controller-Knoten ausgeführt wird. Die Ausgabe sollte den Status „Aktiv“ als **active (running)** anzeigen.

   ```
   $ sudo systemctl status prometheus
   • prometheus service - Prometheus Exporter
   Loaded: loaded (/etc/systemd/system/prometheus.service; enabled; preset:disabled)
   Active: active (running) since DAY YYYY-MM-DD HH:MM:SS UTC; Ss ago
   Main PID: 12345 (prometheus)
   Tasks: 7 (limit: 9281)
   Memory: 35M
   CPU: 234ms
   CGroup: /system.slice/prometheus.service
           -12345 /usr/bin/prometheus--config.file=/etc/prometheus/prometheus.yml
   ```

1. Überprüfen Sie die Prometheus-Konfigurationsdatei wie folgt. Die Ausgabe muss in etwa wie folgt aussehen, wobei drei Exporter mit den richtigen IP-Adressen der Rechenknoten konfiguriert sind.

   ```
   $ cat /etc/prometheus/prometheus.yml
   global:
     scrape_interval: 15s
     evaluation_interval: 15s
     scrape_timeout: 15s
   
   scrape_configs:
     - job_name: 'slurm_exporter'
       static_configs:
         - targets:
             - 'localhost:8080'
     - job_name: 'dcgm_exporter'
       static_configs:
         - targets:
             - '<ComputeNodeIP>:9400'
             - '<ComputeNodeIP>:9400'
     - job_name: 'efa_node_exporter'
       static_configs:
         - targets:
             - '<ComputeNodeIP>:9100'
             - '<ComputeNodeIP>:9100'
   
   remote_write:
     - url: <AMPReoteWriteURL>
       queue_config:
         max_samples_per_send: 1000
         max_shards: 200
         capacity: 2500
       sigv4:
         region: <Region>
   ```

1. Um zu testen, ob Prometheus die Slurm-, DCGM- und EFA-Metriken ordnungsgemäß exportiert, führen Sie den folgenden `curl`-Befehl für Prometheus auf dem Port `:9090` des Hauptknotens aus.

   ```
   $ curl -s http://localhost:9090/metrics | grep -E 'slurm|dcgm|efa'
   ```

   Nachdem die Metriken über die Remote-Write-Konfiguration von Prometheus vom Controller-Knoten zu Amazon Managed Service für Prometheus Workspace exportiert wurden, können Sie mit dem nächsten Thema fortfahren, um die Dashboards von Amazon Managed Grafana für die Anzeige der Metriken einzurichten.

# Einrichten eines Workspaces von Amazon Managed Grafana
Einrichten eines Grafana-Workspaces

Erstellen Sie einen neuen Workspace von Amazon Managed Grafana oder aktualisieren Sie einen bestehenden mit Amazon Managed Service für Prometheus als Datenquelle.

**Topics**
+ [

## Erstellen Sie einen Grafana-Workspace und legen Sie Amazon Managed Service für Prometheus als Datenquelle fest.
](#sagemaker-hyperpod-cluster-observability-slurm-managed-grafana-ws-create)
+ [

## Öffnen des Grafana-Workspaces und Beenden der Einrichtung der Datenquelle
](#sagemaker-hyperpod-cluster-observability-slurm-managed-grafana-ws-connect-data-source)
+ [

## Importieren von Open-Source-Dashboards von Grafana
](#sagemaker-hyperpod-cluster-observability-slurm-managed-grafana-ws-import-dashboards)

## Erstellen Sie einen Grafana-Workspace und legen Sie Amazon Managed Service für Prometheus als Datenquelle fest.


Um Metriken aus Amazon Managed Service für Prometheus zu visualisieren, erstellen Sie einen Workspace von Amazon Managed Grafana und richten Sie ihn so ein, dass Amazon Managed Service für Prometheus als Datenquelle verwendet wird.

1. Um einen Grafana-Workspace zu erstellen, befolgen Sie die Anweisungen unter [Erstellen eines Workspace](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-create-workspace.html#creating-workspace) im *Benutzerhandbuch für Amazon Managed Service für Prometheus*.

   1. Wählen Sie in Schritt 13 Amazon Managed Service für Prometheus als Datenquelle aus.

   1. In Schritt 17 können Sie den Admin-Benutzer und auch andere Benutzer in Ihrem IAM Identity Center hinzufügen.

Weitere Informationen finden Sie auch in den folgenden Ressourcen.
+ [Einrichten von Amazon Managed Grafana für die Verwendung mit Amazon Managed Service für Prometheus](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-amg.html) im *Benutzerhandbuch für Amazon Managed Service für Prometheus*
+ [Verwenden Sie die AWS Datenquellenkonfiguration, um Amazon Managed Service for Prometheus als Datenquelle im *Amazon Managed Grafana-Benutzerhandbuch* hinzuzufügen](https://docs.aws.amazon.com/grafana/latest/userguide/AMP-adding-AWS-config.html)

## Öffnen des Grafana-Workspaces und Beenden der Einrichtung der Datenquelle


Nachdem Sie erfolgreich einen Workspace von Amazon Managed Grafana erstellt oder aktualisiert haben, wählen Sie die Workspace-URL aus, um den Workspace zu öffnen. Sie werden aufgefordert, einen Benutzernamen und das Passwort des Benutzers einzugeben, den Sie im IAM Identity Center eingerichtet haben. Sie sollten sich mit dem Admin-Benutzer anmelden, um die Einrichtung des Workspaces abzuschließen.

1. Wählen Sie auf der Workspace-**Startseite** **Apps**, **-Datenquellen** und **Datenquellen** aus.

1. Wählen Sie auf der Seite **Datenquellen** die Registerkarte **Datenquellen** aus.

1. Wählen Sie für **Service** Amazon Managed Service für Prometheus aus.

1. Wählen **Sie im Abschnitt Datenquellen durchsuchen und bereitstellen** die AWS Region aus, in der Sie einen Amazon Managed Service for Prometheus Workspace bereitgestellt haben.

1. Wählen Sie aus der Liste der Datenquellen in der ausgewählten Region die für Amazon Managed Service für Prometheus aus. Stellen Sie sicher, dass Sie die Ressourcen-ID und den Ressourcenalias des Amazon Managed Service for Prometheus Workspace überprüfen, den Sie für den HyperPod Observability Stack eingerichtet haben.

## Importieren von Open-Source-Dashboards von Grafana


Nachdem Sie Ihren Workspace von Amazon Managed Grafana mit Amazon Managed Service für Prometheus als Datenquelle erfolgreich eingerichtet haben, beginnen Sie mit der Erfassung von Metriken für Prometheus. Sie sollten dann die verschiedenen Dashboards mit Diagrammen, Informationen und mehr sehen. Die Open-Source-Software Grafana bietet verschiedene Dashboards, die Sie in Amazon Managed Grafana importieren können.

**So importieren Sie Open-Source-Dashboards von Grafana in Amazon Managed Grafana**

1. Wählen Sie auf der **Startseite** Ihres Workspaces von Amazon Managed Grafana die Option **Dashboards** aus.

1. Wählen Sie die Dropdown-Menüschaltfläche mit dem Benutzeroberflächen-Text **Neu** und dann **Importieren** aus.

1. Fügen Sie die URL in das [Slurm-Dashboard](https://grafana.com/grafana/dashboards/4323-slurm-dashboard/) ein.

   ```
   https://grafana.com/grafana/dashboards/4323-slurm-dashboard/
   ```

1. Wählen Sie **Laden** aus.

1. Wiederholen Sie die vorherigen Schritte zum Importieren der folgenden Dashboards.

   1. [Knoten-Exporter –vollständiges Dashboard](https://grafana.com/grafana/dashboards/1860-node-exporter-full/)

      ```
      https://grafana.com/grafana/dashboards/1860-node-exporter-full/
      ```

   1. [Exporter-Dashboard von NVIDIA DCGM](https://grafana.com/grafana/dashboards/12239-nvidia-dcgm-exporter-dashboard/)

      ```
      https://grafana.com/grafana/dashboards/12239-nvidia-dcgm-exporter-dashboard/
      ```

   1. [Dashboard von EFA-Metriken](https://grafana.com/grafana/dashboards/20579-efa-metrics-dev/)

      ```
      https://grafana.com/grafana/dashboards/20579-efa-metrics-dev/
      ```

   1. [FSx für das Lustre Metrics Dashboard](https://grafana.com/grafana/dashboards/20906-fsx-lustre/)

      ```
      https://grafana.com/grafana/dashboards/20906-fsx-lustre/
      ```

# Referenz zu exportierten Metriken
Referenz zu exportierten Metriken

Die folgenden Abschnitte enthalten umfassende Listen von Metriken, die SageMaker HyperPod nach erfolgreicher Konfiguration des CloudFormation Stacks für Observability aus Amazon Managed Service for SageMaker HyperPod Prometheus exportiert wurden. Sie können mit der Überwachung dieser in den Dashboards von Amazon Managed Grafana visualisierten Metriken beginnen.

## Slurm-Exporter-Dashboard


Stellt visualisierte Informationen zu Slurm-Clustern bereit. SageMaker HyperPod

**Arten von Metriken**
+ **Cluster-Übersicht:** Anzeige der Gesamtzahl der Knoten, Aufträgen und ihrer Status.
+ **Auftragsmetriken:** Visualisierung der Anzahl und des Status von Aufträgen im Zeitverlauf.
+ **Knotenmetriken:** Anzeige des Knotenstatus, der Zuweisung und der verfügbaren Ressourcen.
+ **Partitionsmetriken:** Überwachung partitionsspezifischer Metriken wie CPU-, Arbeitsspeicher- und GPU-Auslastung.
+ **Auftragseffizienz:** Berechnung der Auftragseffizienz auf der Grundlage der eingesetzten Ressourcen.

**Liste der Metriken**


| Metrikname | Description | 
| --- | --- | 
| slurm\$1job\$1count | Die Gesamtzahl der Aufträge im Slurm-Cluster | 
| slurm\$1job\$1state\$1count | Anzahl der Aufträge in jedem Status (z. B. wird ausgeführt, ausstehend, abgeschlossen) | 
| slurm\$1node\$1count  | Die Gesamtzahl der Knoten im Slurm-Cluster | 
| slurm\$1node\$1state\$1count  | Anzahl der Knoten in jedem Status (z. B. inaktiv, alloc, mix) | 
| slurm\$1partition\$1node\$1count  | Anzahl der Knoten in jeder Partition | 
| slurm\$1partition\$1job\$1count  | Anzahl der Aufträge in jeder Partition | 
| slurm\$1partition\$1alloc\$1cpus  | Gesamtzahl der CPUs in jeder Partition zugewiesenen | 
| slurm\$1partition\$1free\$1cpus  | Gesamtzahl der CPUs in jeder Partition verfügbaren | 
| slurm\$1partition\$1alloc\$1memory  | Insgesamt zugewiesener Speicher in jeder Partition | 
| slurm\$1partition\$1free\$1memory  | Insgesamt verfügbarer Speicher in jeder Partition | 
| slurm\$1partition\$1alloc\$1gpus  | Gesamtzahl der GPUs in jeder Partition zugewiesenen | 
| slurm\$1partition\$1free\$1gpus  | Insgesamt GPUs in jeder Partition verfügbar | 

## Knoten-Exporter-Dashboard


Stellt visualisierte Informationen zu Systemmetriken bereit, die vom [Prometheus-Knotenexporter von den Clusterknoten](https://github.com/prometheus/node_exporter) gesammelt wurden. HyperPod 

**Arten von Metriken**
+ **Systemübersicht:** Anzeige der durchschnittlichen CPU-Last und der Speicherauslastung.
+ **Speichermetriken:** Visualisierung der Speicherauslastung, einschließlich Gesamtspeicher, freiem Speicher und Auslagerungsbereich.
+ **Festplattennutzung:** Überwachung der Festplattenauslastung und -verfügbarkeit.
+ **Netzwerkverkehr:** Anzeige der im Laufe der Zeit empfangenen und übertragenen Netzwerkbytes.
+ **Dateisystem-Metriken:** Analyse der Nutzung und Verfügbarkeit des Dateisystems.
+ ** I/O Festplatten-Metriken:** Visualisierung der Lese- und Schreibaktivitäten auf der Festplatte.

**Liste der Metriken**

Eine vollständige Liste der exportierten Metriken finden Sie in den Repositorys [Node Exporter](https://github.com/prometheus/node_exporter?tab=readme-ov-file#enabled-by-default) und [ GitHub procfs](https://github.com/prometheus/procfs?tab=readme-ov-file). Die folgende Tabelle zeigt einen Teil der Metriken, die Einblicke in die Nutzung der Systemressourcen wie CPU-Auslastung, Speicherverbrauch, Festplattenspeicher und Netzwerkaktivität geben.


| Metrikname | Description | 
| --- | --- | 
|  node\$1load1  | Durchschnittliche Auslastung 1 Minute | 
|  node\$1load5  | Durchschnittliche Auslastung 5 Minuten | 
|  node\$1load15  | Durchschnittliche Auslastung 15 Minuten | 
|  node\$1memory\$1MemTotal  | Gesamtsystemspeicher | 
|  node\$1memory\$1MemFree  | Freier Systemspeicher | 
|  node\$1memory\$1MemAvailable  | Verfügbarer Speicher für die Zuweisung zu Prozessen | 
|  node\$1memory\$1Buffers  | Speicher, der vom Kernel für die Pufferung verwendet wird | 
|  node\$1memory\$1Cached  | Speicher, der vom Kernel für das Zwischenspeichern von Dateisystemdaten verwendet wird | 
|  node\$1memory\$1SwapTotal  | Verfügbarer Auslagerungsbereich | 
|  node\$1memory\$1SwapFree  | Kostenloser Auslagerungsbereich | 
|  node\$1memory\$1SwapCached  | Einmal ausgelagerter Speicher wird wieder eingelagert, befindet sich aber weiterhin im Swap | 
|  node\$1filesystem\$1avail\$1bytes  | Verfügbarer Festplattenspeicher in Byte | 
|  node\$1filesystem\$1size\$1bytes  | Gesamter Festplattenspeicher in Byte | 
|  node\$1filesystem\$1free\$1bytes  | Freier Festplattenspeicher in Byte | 
|  node\$1network\$1receive\$1bytes  | Empfangene Netzwerk-Byte | 
|  node\$1network\$1transmit\$1bytes  | Übertragene Netzwerk-Byte | 
|  node\$1disk\$1read\$1bytes  | Gelesene Festplatten-Byte | 
|  node\$1disk\$1written\$1bytes  | Geschriebene Festplatten-Byte | 

## Exporter-Dashboard von NVIDIA DCGM


Bietet visualisierte Informationen zu NVIDIA-GPU-Metriken, die vom [NVIDIA-DCGM-Exporter](https://github.com/NVIDIA/dcgm-exporter) erfasst wurden.

**Arten von Metriken**
+ **GPU-Übersicht:** Anzeige der GPU-Auslastung, der Temperaturen, des Stromverbrauchs und der Speicherauslastung. 
+ **Temperaturmetriken:** Visualisierung der GPU-Temperaturen im Zeitverlauf. 
+ **Stromverbrauch:** Überwachung des GPU-Stromverbrauchs und der Trends beim Stromverbrauch. 
+ **Speicherauslastung:** Analyse der GPU-Speichernutzung, einschließlich belegtem, freiem Speicher und Gesamtspeicher. 
+ **Lüftergeschwindigkeit:** Anzeige der Geschwindigkeiten und Variationen der GPU-Lüfter. 
+ **ECC-Fehler:** Verfolgung von ECC-Fehlern und ausstehenden Fehlern im GPU-Speicher.

**Liste der Metriken**

Die folgende Tabelle enthält eine Liste der Metriken, die Einblicke in den Zustand und die Leistung der NVIDIA-GPU bieten, darunter Taktfrequenzen, Temperaturen, Stromverbrauch, Speicherauslastung, Lüftergeschwindigkeiten und Fehlermetriken.


| Metrikname | Description | 
| --- | --- | 
|  DCGM\$1FI\$1DEV\$1SM\$1CLOCK  | SM-Taktfrequenz (in MHz) | 
|  DCGM\$1FI\$1DEV\$1MEM\$1CLOCK  | Speichertaktfrequenz (in MHz) | 
|  DCGM\$1FI\$1DEV\$1MEMORY\$1TEMP  | Speichertemperatur (in C) | 
|  DCGM\$1FI\$1DEV\$1GPU\$1TEMP  | GPU-Temperatur (in C) | 
|  DCGM\$1FI\$1DEV\$1POWER\$1USAGE  | Leistungsaufnahme (in W) | 
|  DCGM\$1FI\$1DEV\$1TOTAL\$1ENERGY\$1CONSUMPTION  | Gesamtenergieverbrauch seit dem Start (in mJ) | 
|  DCGM\$1FI\$1DEV\$1PCIE\$1REPLAY\$1COUNTER  | Gesamtzahl der PCIe Wiederholungen | 
|  DCGM\$1FI\$1DEV\$1MEM\$1COPY\$1UTIL  | Speichernutzung (in %) | 
|  DCGM\$1FI\$1DEV\$1ENC\$1UTIL  | Encoder-Nutzung (in%) | 
|  DCGM\$1FI\$1DEV\$1DEC\$1UTIL  | Decoder-Nutzung (in%) | 
|  DCGM\$1FI\$1DEV\$1XID\$1ERRORS  | Wert des letzten aufgetretenen XID-Fehlers | 
|  DCGM\$1FI\$1DEV\$1FB\$1FREE  | Freier Frame-Pufferspeicher (in MiB) | 
|  DCGM\$1FI\$1DEV\$1FB\$1USED  | Verwendeter Frame-Pufferspeicher (in MiB) | 
|  DCGM\$1FI\$1DEV\$1NVLINK\$1BANDWIDTH\$1TOTAL  | Gesamtzahl der NVLink Bandbreitenzähler für alle Lanes | 
|  DCGM\$1FI\$1DEV\$1VGPU\$1LICENSE\$1STATUS  | Status der vGPU-Lizenz | 
|  DCGM\$1FI\$1DEV\$1UNCORRECTABLE\$1REMAPPED\$1ROWS  | Anzahl der neu zugewiesenen Zeilen für nicht behebbare Fehler | 
|  DCGM\$1FI\$1DEV\$1CORRECTABLE\$1REMAPPED\$1ROWS  | Anzahl der neu zugewiesenen Zeilen für behebbare Fehler | 
|  DCGM\$1FI\$1DEV\$1ROW\$1REMAP\$1FAILURE  | Ob die Neuzuweisung von Zeilen fehlgeschlagen ist | 

## Dashboard für EFA-Metriken


Stellt visualisierte Informationen zu den Metriken von [Amazon Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) bereit, die auf P-Instances installiert sind und vom [EFA-Knoten-Exporter](https://github.com/aws-samples/awsome-distributed-training/blob/main/4.validation_and_observability/3.efa-node-exporter/README.md) erfasst wurden.

**Arten von Metriken**
+ **EFA-Fehlermetriken:** Visualisierung von Fehlern wie Zuweisungsfehler, Befehlsfehler und Speicherzuordnungsfehler.
+ **EFA-Netzwerkverkehr:** Überwachung empfangener und übertragener Byte, Pakete und Arbeitsanfragen.
+ **EFA-RDMA-Leistung:** Analyse von RDMA-Lese- und Schreibvorgängen, einschließlich übertragener Byte und Fehlerraten.
+ **Lebensdauer von EFA-Ports:** Anzeige der Lebensdauer von EFA-Ports im Zeitverlauf.
+ **EFA-Keep-Alive-Pakete:** Verfolgung der Anzahl der empfangenen Keep-Alive-Pakete.

**Liste der Metriken**

Die folgende Tabelle enthält eine Liste der Metriken, die Einblicke in verschiedene Aspekte des EFA-Betriebs bieten, darunter Fehler, ausgeführte Befehle, Netzwerkverkehr und Ressourcenauslastung.


| Metrikname | Description | 
| --- | --- | 
|  node\$1amazonefa\$1info  | Nicht numerische Daten von/sys/class/infiniband/, Wert ist immer 1. | 
|  node\$1amazonefa\$1lifespan  | Lebensdauer des Ports | 
|  node\$1amazonefa\$1rdma\$1read\$1bytes  | Anzahl der mit RDMA gelesenen Byte | 
|  node\$1amazonefa\$1rdma\$1read\$1resp\$1bytes  | Anzahl der mit RDMA gelesenen Antwort-Byte | 
|  node\$1amazonefa\$1rdma\$1read\$1wr\$1err  | Anzahl der Lese- und Schreibfehler mit RDMA | 
|  node\$1amazonefa\$1rdma\$1read\$1wrs  | Anzahl der mit RDMA gelesenen rs | 
|  node\$1amazonefa\$1rdma\$1write\$1bytes  | Anzahl der mit RDMA geschriebenen Byte | 
|  node\$1amazonefa\$1rdma\$1write\$1recv\$1bytes  | Anzahl der mit RDMA geschriebenen und empfangenen Byte | 
|  node\$1amazonefa\$1rdma\$1write\$1wr\$1err  | Anzahl der mit Fehler geschriebenen Byte RDMA | 
|  node\$1amazonefa\$1rdma\$1write\$1wrs  | Anzahl der geschriebenen Byte wrs RDMA | 
|  node\$1amazonefa\$1recv\$1bytes  | Anzahl der empfangenen Bytes | 
|  node\$1amazonefa\$1recv\$1wrs  | Anzahl der empfangenen Bytes wrs | 
|  node\$1amazonefa\$1rx\$1bytes  | Anzahl der empfangenen Bytes | 
|  node\$1amazonefa\$1rx\$1drops  | Anzahl der verworfenen Pakete | 
|  node\$1amazonefa\$1rx\$1pkts  | Anzahl der empfangenen Pakete | 
|  node\$1amazonefa\$1send\$1bytes  | Anzahl der gesendeten Byte | 
|  node\$1amazonefa\$1send\$1wrs  | Anzahl der gesendeten wrs | 
|  node\$1amazonefa\$1tx\$1bytes  | Anzahl der übertragenen Bytes | 
|  node\$1amazonefa\$1tx\$1pkts  | Anzahl der übertragenen Pakete | 

## FSx für das Lustre-Metrik-Dashboard


[Bietet visualisierte Informationen zu den [von Amazon FSx für das Lustre-Dateisystem gesammelten Metriken](https://docs.aws.amazon.com/fsx/latest/LustreGuide/monitoring-cloudwatch.html). CloudWatch](https://docs.aws.amazon.com/fsx/latest/LustreGuide/monitoring-cloudwatch.html)

**Anmerkung**  
Das Grafana FSx for Lustre-Dashboard verwendet Amazon CloudWatch als Datenquelle, was sich von den anderen Dashboards unterscheidet, die Sie für die Verwendung von Amazon Managed Service für Prometheus konfiguriert haben. Um eine genaue Überwachung und Visualisierung von Metriken zu gewährleisten, die sich auf Ihr FSx for Lustre-Dateisystem beziehen, konfigurieren Sie das FSx for Lustre-Dashboard so, dass Amazon CloudWatch als Datenquelle verwendet wird, und geben Sie an, AWS-Region wo Ihr FSx for Lustre-Dateisystem bereitgestellt wird.

**Arten von Metriken**
+ **DataReadBytes:** Die Anzahl der Byte für Lesevorgänge im Dateisystem.
+ **DataWriteBytes:** Die Anzahl der Byte für Schreiboperationen im Dateisystem.
+ **DataReadOperations:** Die Anzahl der Lesevorgänge.
+ **DataWriteOperations:** Die Anzahl der Schreiboperationen.
+ **MetadataOperations:** Die Anzahl der Metadatenoperationen.
+ **FreeDataStorageCapacity:** Die Menge der verfügbaren Speicherkapazität.

# Amazon SageMaker HyperPod Slurm-Metriken
Slurm-Metriken

Amazon SageMaker HyperPod bietet eine Reihe von CloudWatch Amazon-Metriken, mit denen Sie den Zustand und die Leistung Ihrer HyperPod Cluster überwachen können. Diese Metriken werden vom Slurm-Workload-Manager erfasst, der auf Ihren HyperPod Clustern ausgeführt wird, und sind im `/aws/sagemaker/Clusters` CloudWatch Namespace verfügbar.

## Metriken auf Clusterebene


Die folgenden Metriken auf Clusterebene sind verfügbar für. HyperPod Diese Metriken verwenden die `ClusterId` Dimension, um den spezifischen HyperPod Cluster zu identifizieren.


| CloudWatch Name der Metrik | Hinweise | Metrikname „Amazon EKS Container Insights“ | 
| --- | --- | --- | 
| cluster\$1node\$1count | Gesamtzahl der Knoten im Cluster | cluster\$1node\$1count | 
| cluster\$1idle\$1node\$1count | Anzahl der inaktiven Knoten im Cluster | – | 
| cluster\$1failed\$1node\$1count | Anzahl der ausgefallenen Knoten im Cluster | cluster\$1failed\$1node\$1count | 
| cluster\$1cpu\$1count | Gesamtzahl der CPU-Kerne im Cluster | node\$1cpu\$1limit | 
| cluster\$1idle\$1cpu\$1count | Anzahl der CPU-Kerne im Cluster | – | 
| cluster\$1gpu\$1count | Summe GPUs im Cluster | node\$1gpu\$1limit | 
| cluster\$1idle\$1gpu\$1count | Anzahl der inaktiven GPUs Benutzer im Cluster | – | 
| cluster\$1running\$1task\$1count | Gesamtzahl der laufenden Slurm-Aufträge im Cluster | – | 
| cluster\$1pending\$1task\$1count | Gesamtzahl der ausstehenden Slurm-Aufträge im Cluster | – | 
| cluster\$1preempted\$1task\$1count | Gesamtzahl der unterbrochenen Slurm-Aufträge im Cluster | – | 
| cluster\$1avg\$1task\$1wait\$1time | Durchschnittliche Wartezeit für Slurm-Aufträge im Cluster | – | 
| cluster\$1max\$1task\$1wait\$1time | Maximale Wartezeit für Slurm-Aufträge im Cluster | – | 

## Metriken auf Instance-Ebene


Die folgenden Metriken auf Instanzebene sind verfügbar für. HyperPod Diese Metriken verwenden die `ClusterId` Dimension auch, um den spezifischen HyperPod Cluster zu identifizieren.


| CloudWatch Name der Metrik | Hinweise | Metrikname „Amazon EKS Container Insights“ | 
| --- | --- | --- | 
| node\$1gpu\$1utilization | Durchschnittliche GPU-Auslastung über alle Instances | node\$1gpu\$1utilization | 
| node\$1gpu\$1memory\$1utilization | Durchschnittliche GPU-Speicherauslastung über alle Instances | node\$1gpu\$1memory\$1utilization | 
| node\$1cpu\$1utilization | Durchschnittliche CPU-Auslastung über alle Instances hinweg | node\$1cpu\$1utilization | 
| node\$1memory\$1utilization | Durchschnittliche Speicherauslastung über alle Instances hinweg | node\$1memory\$1utilization |