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.

# GPU-Partitionen bei Amazon einrichten SageMaker HyperPod
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup"></a>

**Topics**
+ [Voraussetzungen](#sagemaker-hyperpod-eks-gpu-partitioning-setup-prerequisites)
+ [Einen Cluster mit MIG-Konfiguration erstellen](#sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster)
+ [Hinzufügen eines GPU-Operators zu einem vorhandenen Cluster](#sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator)
+ [Die MIG-Konfiguration wird aktualisiert](#sagemaker-hyperpod-eks-gpu-partitioning-setup-update)
+ [Die MIG-Konfiguration wird überprüft](#sagemaker-hyperpod-eks-gpu-partitioning-setup-verify)
+ [Allgemeine Befehle zum Debuggen der MIG-Konfiguration](#sagemaker-hyperpod-eks-gpu-partitioning-setup-debug-commands)
+ [Verwenden der SageMaker AI-Konsole](#sagemaker-hyperpod-eks-gpu-partitioning-setup-console)

## Voraussetzungen
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-prerequisites"></a>
+ HyperPod Amazon EKS-Cluster mit unterstützten GPU-Instances
+ NVIDIA GPU Operator ist installiert
+ Entsprechende IAM-Berechtigungen für die Clusterverwaltung

## Einen Cluster mit MIG-Konfiguration erstellen
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster"></a>

### Verwenden AWS CLI
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster-cli"></a>

```
aws sagemaker create-cluster \
  --cluster-name my-mig-cluster \
  --orchestrator 'Eks={ClusterArn=arn:aws:eks:region:account:cluster/cluster-name}' \
  --instance-groups '{
    "InstanceGroupName": "gpu-group",
    "InstanceType": "ml.p4d.24xlarge",
    "InstanceCount": 1,
    "LifeCycleConfig": {
       "SourceS3Uri": "s3://my-bucket",
       "OnCreate": "on_create_script.sh"
    },
    "KubernetesConfig": {
       "Labels": {
          "nvidia.com/mig.config": "all-1g.5gb"
       }
    },
    "ExecutionRole": "arn:aws:iam::account:role/execution-role",
    "ThreadsPerCore": 1
  }' \
  --vpc-config '{
     "SecurityGroupIds": ["sg-12345"],
     "Subnets": ["subnet-12345"]
  }' \
  --node-provisioning-mode Continuous
```

### Verwenden CloudFormation
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster-cfn"></a>

```
{
  "ClusterName": "my-mig-cluster",
  "InstanceGroups": [
    {
      "InstanceGroupName": "gpu-group",
      "InstanceType": "ml.p4d.24xlarge",
      "InstanceCount": 1,
      "KubernetesConfig": {
        "Labels": {
          "nvidia.com/mig.config": "all-2g.10gb"
        }
      },
      "ExecutionRole": "arn:aws:iam::account:role/execution-role"
    }
  ],
  "Orchestrator": {
    "Eks": {
      "ClusterArn": "arn:aws:eks:region:account:cluster/cluster-name"
    }
  },
  "NodeProvisioningMode": "Continuous"
}
```

## Hinzufügen eines GPU-Operators zu einem vorhandenen Cluster
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator"></a>

### Installieren Sie den GPU Operator
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-install"></a>

`{$AWS_REGION}`Ersetzen Sie es durch Ihre Clusterregion (z. B. us-east-1, us-west-2).

```
helm install gpuo helm_chart/HyperPodHelmChart/charts/gpu-operator \
-f helm_chart/HyperPodHelmChart/charts/gpu-operator/regional-values/values-{$AWS_REGION}.yaml \
-n kube-system
```

### Überprüfen Sie die Installation (warten Sie 2-3 Minuten)
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-verify"></a>

Überprüfen Sie, ob alle GPU-Operator-Pods laufen:

```
kubectl get pods -n kube-system | grep -E "(gpu-operator|nvidia-)"
```

**Erwartete Pods:**
+ gpu-operator-\$1 — 1 Instanz (Cluster-Controller)
+ nvidia-device-plugin-daemonset-\$1 - 1 pro GPU-Knoten (alle GPU-Instanzen)
+ nvidia-mig-manager-\$1 - 1 pro MIG-fähigem Knoten (A100/H100)

### Entfernen Sie das alte Geräte-Plug-In
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-remove"></a>

Deaktiviere das vorhandene nvidia-device-plugin:

```
helm upgrade dependencies helm_chart/HyperPodHelmChart \
--set nvidia-device-plugin.devicePlugin.enabled=false \
-n kube-system
```

### Überprüfen Sie die GPU-Ressourcen
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-verify-gpu"></a>

Bestätigen Sie, dass die Knoten GPU-Kapazität anzeigen. Es sollte Folgendes anzeigen: nvidia.com/gpu: 8 (oder deine tatsächliche GPU-Anzahl).

```
kubectl describe nodes | grep "nvidia.com/gpu"
```

## Die MIG-Konfiguration wird aktualisiert
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update"></a>

**Knoten vor MIG-Updates vorbereiten**  
Bevor Sie die MIG-Konfigurationen in Ihrer Instanzgruppe aktualisieren, müssen Sie die Knoten vorbereiten, um eine Unterbrechung der Arbeitslast zu vermeiden. Gehen Sie wie folgt vor, um Workloads sicher von den Knoten abzuleiten, die neu konfiguriert werden.

### Schritt 1: Identifizieren Sie die Knoten in der Instanzgruppe
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-identify"></a>

Identifizieren Sie zunächst alle Knoten, die zu der Instanzgruppe gehören, die Sie aktualisieren möchten:

```
# List all nodes in the instance group
kubectl get nodes -l sagemaker.amazonaws.com/instance-group-name=INSTANCE_GROUP_NAME

# Example:
kubectl get nodes -l sagemaker.amazonaws.com/instance-group-name=p4d-group
```

Dieser Befehl gibt eine Liste aller Knoten in der angegebenen Instanzgruppe zurück. Notieren Sie sich jeden Knotennamen für die folgenden Schritte.

### Schritt 2: Sperren und Entleeren Sie jeden Knoten
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-drain"></a>

Führen Sie für jeden in Schritt 1 identifizierten Knoten die folgenden Aktionen aus:

#### Sperren Sie den Knoten ab
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-drain-cordon"></a>

Durch das Absperren wird verhindert, dass neue Pods auf dem Knoten geplant werden:

```
# Cordon a single node
kubectl cordon NODE_NAME

# Example:
kubectl cordon hyperpod-i-014a41a7001adca60
```

#### Workload-Pods vom Knoten entleeren
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-drain-evict"></a>

Entleeren Sie den Knoten, um alle Workload-Pods zu entfernen und gleichzeitig die System-Pods beizubehalten:

```
# Drain the node (ignore DaemonSets and evict pods)
kubectl drain NODE_NAME \
  --ignore-daemonsets \
  --delete-emptydir-data \
  --force \
  --grace-period=300

# Example:
kubectl drain hyperpod-i-014a41a7001adca60 \
  --ignore-daemonsets \
  --delete-emptydir-data \
  --force \
  --grace-period=300
```

**Erläuterung der Befehlsoptionen:**
+ `--ignore-daemonsets`- Ermöglicht es, den Entleerungsvorgang auch dann fortzusetzen, wenn DaemonSet Pods vorhanden sind
+ `--delete-emptydir-data`— Löscht Pods mithilfe von EmptyDir-Volumes (erforderlich, damit das Entleeren erfolgreich ist)
+ `--force`- Erzwingt das Löschen von Pods, die nicht von einem Controller verwaltet werden (mit Vorsicht verwenden)
+ `--grace-period=300`- Gibt Pods 5 Minuten Zeit, um sie ordnungsgemäß zu beenden

**Wichtig**  
Der Entleerungsvorgang kann je nach Anzahl der Pods und deren Übergangsfristen mehrere Minuten dauern
System-Pods in den folgenden Namespaces werden weiterhin ausgeführt:`kube-system`,`cert-manager`,`kubeflow`,`hyperpod-inference-system`,`kube-public`,,`mpi-operator`,`gpu-operator`, `aws-hyperpod``jupyter-k8s-system`, und `hyperpod-observability` `kueue-system` `keda`
DaemonSet Pods bleiben auf dem Knoten (sie werden vom Design her ignoriert)

### Schritt 3: Stellen Sie sicher, dass keine Workload-Pods ausgeführt werden
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-verify"></a>

Stellen Sie nach dem Entleeren sicher, dass keine Workload-Pods auf den Knoten verbleiben (außer System-Namespaces):

```
# Check for any remaining pods outside system namespaces
kubectl get pods --all-namespaces --field-selector spec.nodeName=NODE_NAME \
  | grep -v "kube-system" \
  | grep -v "cert-manager" \
  | grep -v "kubeflow" \
  | grep -v "hyperpod-inference-system" \
  | grep -v "kube-public" \
  | grep -v "mpi-operator" \
  | grep -v "gpu-operator" \
  | grep -v "aws-hyperpod" \
  | grep -v "jupyter-k8s-system" \
  | grep -v "hyperpod-observability" \
  | grep -v "kueue-system" \
  | grep -v "keda"

# Example:
kubectl get pods --all-namespaces --field-selector spec.nodeName=hyperpod-i-014a41a7001adca60 \
  | grep -v "kube-system" \
  | grep -v "cert-manager" \
  | grep -v "kubeflow" \
  | grep -v "hyperpod-inference-system" \
  | grep -v "kube-public" \
  | grep -v "mpi-operator" \
  | grep -v "gpu-operator" \
  | grep -v "aws-hyperpod" \
  | grep -v "jupyter-k8s-system" \
  | grep -v "hyperpod-observability" \
  | grep -v "kueue-system" \
  | grep -v "keda"
```

**Erwartete Ausgabe:** Wenn der Knoten ordnungsgemäß entleert wurde, sollte dieser Befehl keine Ergebnisse zurückgeben (oder nur die Kopfzeile anzeigen). Falls noch Pods laufen, untersuchen Sie, warum sie nicht entfernt wurden, und löschen Sie sie gegebenenfalls manuell.

### Schritt 4: Überprüfen Sie den Bereitschaftsstatus des Knotens
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-readiness"></a>

Bevor Sie mit dem MIG-Update fortfahren, stellen Sie sicher, dass alle Knoten gesperrt sind:

```
# Check node status - should show "SchedulingDisabled"
kubectl get nodes -l sagemaker.amazonaws.com/instance-group-name=INSTANCE_GROUP_NAME
```

Die Knoten sollten `SchedulingDisabled` in der STATUS-Spalte angezeigt werden, was bedeutet, dass sie gesperrt und bereit für das MIG-Update sind.

### MIG-Profil auf vorhandenem Cluster aktualisieren
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-change"></a>

Sie können MIG-Profile auf vorhandenen Clustern ändern:

```
aws sagemaker update-cluster \
  --cluster-name my-mig-cluster \
  --instance-groups '{
    "InstanceGroupName": "gpu-group",
    "InstanceType": "ml.p4d.24xlarge",
    "InstanceCount": 1,
    "KubernetesConfig": {
       "Labels": {
          "nvidia.com/mig.config": "all-3g.20gb"
       }
    },
    "ExecutionRole": "arn:aws:iam::account:role/execution-role"
  }'
```

**Anmerkung**  
Wenn Jobs bereits auf einem Knoten ausgeführt werden, schlägt die MIG-Partitionierung fehl. Der Benutzer erhält eine Fehlermeldung mit der Aufforderung, die Knoten zu entleeren, bevor er erneut versucht, die MIG-Partitionierung durchzuführen.

## Die MIG-Konfiguration wird überprüft
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-verify"></a>

Überprüfen Sie nach der Erstellung oder Aktualisierung des Clusters die MIG-Konfiguration:

```
# Update kubeconfig
aws eks update-kubeconfig --name your-eks-cluster --region us-east-2

# Check MIG labels
kubectl get node NODE_NAME -o=jsonpath='{.metadata.labels}' | grep mig

# Check available MIG resources
kubectl describe node NODE_NAME | grep -A 10 "Allocatable:"
```

## Allgemeine Befehle zum Debuggen der MIG-Konfiguration
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-debug-commands"></a>

Verwenden Sie die folgenden Befehle, um Fehler bei der MIG-Konfiguration in Ihrem Cluster zu beheben und zu überprüfen:

```
# Check GPU Operator status
kubectl get pods -n gpu-operator-resources

# View MIG configuration
kubectl exec -n gpu-operator-resources nvidia-driver-XXXXX -- nvidia-smi mig -lgi

# Check device plugin configuration
kubectl logs -n gpu-operator-resources nvidia-device-plugin-XXXXX

# Monitor node events
kubectl get events --field-selector involvedObject.name=NODE_NAME
```

**Anmerkung**  
Ersetzen Sie `nvidia-driver-XXXXX` und `nvidia-device-plugin-XXXXX` durch die tatsächlichen Pod-Namen aus Ihrem Cluster und `NODE_NAME` durch den Namen Ihres Knotens.

## Verwenden der SageMaker AI-Konsole
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-console"></a>

### Einen neuen Cluster mit MIG erstellen
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-console-create"></a>

1. Navigieren Sie zu **Amazon SageMaker AI** > **HyperPod Clusters** **> Cluster Management** > ** HyperPod Cluster erstellen**

1. Wählen Sie **Orchestriert von EKS**

1. Wählen Sie **Benutzerdefiniertes Setup** und stellen Sie sicher, dass der **GPU-Operator** standardmäßig aktiviert ist

1. Klicken Sie im Abschnitt **Instanzgruppen** auf **Gruppe hinzufügen**

1. Konfigurieren Sie die Instanzgruppe und navigieren Sie zu **Erweiterte Konfiguration**, um die Option **GPU-Partition verwenden** zu aktivieren, und wählen Sie die gewünschte **MIG-Konfiguration aus dem Drop-down-Menü**

1. Klicken Sie auf **Instanzgruppe hinzufügen** und schließen Sie die verbleibende Clusterkonfiguration ab

1. Klicken Sie auf **Senden**, um den Cluster zu erstellen

### Die MIG-Konfiguration auf einem vorhandenen Cluster wird aktualisiert
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-console-update"></a>

1. Navigieren Sie zu **Amazon SageMaker AI** > **HyperPod Clusters** **> Cluster Management**

1. Wählen Sie Ihren vorhandenen Cluster aus und klicken Sie in der Instance-Gruppe, die Sie ändern möchten, auf **Bearbeiten**

1. Aktivieren **Sie in der **erweiterten Konfiguration** die Option GPU-Partition verwenden**, falls nicht bereits aktiviert, und wählen Sie im Dropdownmenü eine andere **MIG-Konfiguration** aus

1. **Klicken Sie auf Änderungen speichern**