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)
+ [MIG-Konfiguration wird aktualisiert](#sagemaker-hyperpod-eks-gpu-partitioning-setup-update)
+ [Überprüfung der MIG-Konfiguration](#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
+ Geeignete 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 GPU Operator
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-install"></a>

`{$AWS_REGION}`Ersetzen Sie durch Ihre Cluster-Region (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>

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

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

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

### Das alte Geräte-Plugin entfernen
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-remove"></a>

Deaktiviere das bestehende 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>

Stellen Sie sicher, dass die Knoten GPU-Kapazität anzeigen. Es sollte angezeigt werden: nvidia. com/gpu: 8 (oder deine tatsächliche GPU-Anzahl).

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

## 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 verhindern. Folgen Sie diesen Schritten, um die Arbeitslasten sicher von den Knoten abzuleiten, die neu konfiguriert werden.

### Schritt 1: Identifizieren Sie 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 die Namen der einzelnen Knoten für die folgenden Schritte.

### Schritt 2: Sperren Sie jeden Knoten ab und entleeren Sie ihn
<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:

#### Den Knoten abkoppeln
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-drain-cordon"></a>

Das Sperren 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 aus dem Knoten entfernen
<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 zu erhalten:

```
# 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 das Entwässern auch dann, wenn DaemonSet Schoten vorhanden sind
+ `--delete-emptydir-data`- Löscht Pods mithilfe von EmptyDir-Volumes (für eine erfolgreiche Entleerung erforderlich)
+ `--force`- Erzwingt das Löschen von Pods, die nicht von einem Controller verwaltet werden (mit Vorsicht verwenden)
+ `--grace-period=300`— Gibt den Pods 5 Minuten Zeit, um ordnungsgemäß zu beenden

**Wichtig**  
Je nach Anzahl der Pods und deren Nachfrist kann der Vorgang mehrere Minuten in Anspruch nehmen
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 (mit Ausnahme von 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äß geleert ist, sollte dieser Befehl keine Ergebnisse zurückgeben (oder nur die Kopfzeile anzeigen). Falls Pods immer noch laufen, untersuche, warum sie nicht entfernt wurden, und lösche sie gegebenenfalls manuell.

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

Bevor Sie mit dem MIG-Update fortfahren, vergewissern Sie sich, dass alle Knoten abgesperrt sind:

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

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

### Aktualisieren Sie das MIG-Profil auf dem vorhandenen Cluster
<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, dass er die Knoten entleeren muss, bevor er erneut versucht, die MIG-Partitionierung durchzuführen.

## Überprüfung der MIG-Konfiguration
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-verify"></a>

Überprüfen Sie nach der Clustererstellung oder -aktualisierung 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 Cluster ** > ** Cluster-Management ** > HyperPod Cluster ** erstellen **

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

1. Wählen Sie ** Benutzerdefiniertes Setup ** und vergewissern Sie sich, dass ** 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ü aus

1. Klicken Sie auf Instanzgruppe ** hinzufügen ** und schließen Sie die restliche Cluster-Konfiguration ab

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

### Aktualisierung der MIG-Konfiguration auf dem vorhandenen Cluster
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-console-update"></a>

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

1. Wählen Sie Ihren vorhandenen Cluster aus und klicken Sie ** bei der Instanzgruppe, die Sie ändern möchten, auf ** Bearbeiten

1. Aktivieren ** Sie ** unter Erweiterte Konfiguration die Option GPU-Partition verwenden**, ** falls nicht bereits aktiviert, und wählen Sie eine andere ** MIG-Konfiguration ** aus dem Drop-down-Menü aus

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