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.

# Autoscaling auf EKS SageMaker HyperPod
<a name="sagemaker-hyperpod-eks-autoscaling"></a>

Amazon SageMaker HyperPod bietet eine verwaltete, auf Karpenter basierende Node-Autoscaling-Lösung für Cluster, die mit EKS-Orchestrierung erstellt wurden. [Karpenter ist ein](https://karpenter.sh/) Open-Source-Kubernetes-Node-Lifecycle-Manager, der entwickelt wurde und die Clusterskalierung und Kosteneffizienz optimiert. AWS Im Gegensatz zu selbstverwalteten Karpenter-Deployments entfällt bei SageMaker HyperPod der verwalteten Implementierung der betriebliche Aufwand für die Installation, Konfiguration und Wartung von Karpenter Controllern und bietet gleichzeitig integrierte Stabilität und Fehlertoleranz. Diese verwaltete Autoscaling-Lösung basiert auf HyperPod den Funktionen zur [kontinuierlichen Bereitstellung](sagemaker-hyperpod-scaling-eks.md) und ermöglicht Ihnen eine effiziente Skalierung der Rechenressourcen für Schulungs- und Inferenz-Workloads mit automatischer Fehlerbehandlung und Wiederherstellung. 

Sie zahlen nur das, was Sie nutzen. Sie sind dafür verantwortlich, für alle Recheninstanzen zu bezahlen, die automatisch durch Autoscaling gemäß den Standardpreisen bereitgestellt werden. SageMaker HyperPod Detaillierte Preisinformationen finden Sie unter [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).

Wenn Sie die Karpenter-basierte Autoskalierung mit aktivieren HyperPod, haben Sie Zugriff auf:
+ **Service-Managed Lifecycle** — HyperPod kümmert sich um die Installation, Updates und Wartung von Karpenter, wodurch der betriebliche Aufwand entfällt.
+ **Just-in-Time-Bereitstellung** – Karpenter beobachtet Ihre ausstehenden Pods und stellt die benötigte Rechenleistung für Ihre Workloads aus einem On-Demand-Pool bereit.
+ Auf **Null skalieren** – Skalieren Sie auf null Knoten herunter, ohne eine dedizierte Controller-Infrastruktur aufrechtzuerhalten.
+ **Auswahl von Knoten unter Berücksichtigung des Workloads** – Karpenter wählt die optimalen Instance-Typen basierend auf Pod-Anforderungen, Verfügbarkeitszonen und Preisen aus, um die Kosten zu minimieren.
+ **Automatische Knotenkonsolidierung** – Karpenter bewertet Cluster regelmäßig im Hinblick auf Optimierungsmöglichkeiten und verlagert die Workloads, um nicht ausgelastete Knoten zu eliminieren.
+ **Integrierte Ausfallsicherheit** — Nutzt die integrierten HyperPod Mechanismen für Fehlertoleranz und Knotenwiederherstellung.

In den folgenden Themen wird erklärt, wie HyperPod Autoscaling mit Karpenter aktiviert wird.

**Topics**
+ [Voraussetzungen](#sagemaker-hyperpod-eks-autoscaling-prereqs)
+ [Erstellen Sie mit Karpenter eine IAM-Rolle für HyperPod Autoscaling](sagemaker-hyperpod-eks-autoscaling-iam.md)
+ [Erstellen und konfigurieren Sie einen HyperPod Cluster mit Karpenter Autoscaling](sagemaker-hyperpod-eks-autoscaling-cluster.md)
+ [Erstellen Sie ein NodeClass](sagemaker-hyperpod-eks-autoscaling-nodeclass.md)
+ [Erstellen Sie eine NodePool](sagemaker-hyperpod-eks-autoscaling-nodepool.md)
+ [Stellen Sie einen Workload bereit](sagemaker-hyperpod-eks-autoscaling-workload.md)

## Voraussetzungen
<a name="sagemaker-hyperpod-eks-autoscaling-prereqs"></a>
+ Kontinuierliches Provisioning ist auf Ihrem Cluster aktiviert. HyperPod Aktivieren Sie die kontinuierliche Bereitstellung, indem Sie `Continuous` bei der Erstellung Ihres SageMaker HyperPod Clusters `--node-provisioning-mode` auf einstellen. Weitere Informationen finden Sie unter [Kontinuierliche Bereitstellung für erweiterte Cluster-Operationen auf Amazon EKS](sagemaker-hyperpod-scaling-eks.md).
+ Health Monitoring Agent Version 1.0.742.0\$11.0.241.0 oder höher ist installiert. Für den Betrieb und die Überwachung des HyperPod Clusters erforderlich. Der Agent muss konfiguriert werden, bevor die automatische Skalierung von Karpenter aktiviert wird, um die ordnungsgemäße Berichterstattung über den Clusterstatus und die Verwaltung des Knotenlebenszyklus sicherzustellen. Weitere Informationen finden Sie unter [System zur Gesundheitsüberwachung](sagemaker-hyperpod-eks-resiliency-health-monitoring-agent.md).
+ Nur wenn auf Ihrem Amazon EKS-Cluster Karpenter ausgeführt wird, müssen Karpenter `NodePool` und die `NodeClaim` Versionen v1 sein.
+ `NodeRecovery`auf automatisch eingestellt. Weitere Informationen finden Sie unter [Automatische Wiederherstellung von Knoten](sagemaker-hyperpod-eks-resiliency-node-recovery.md).

# Erstellen Sie mit Karpenter eine IAM-Rolle für HyperPod Autoscaling
<a name="sagemaker-hyperpod-eks-autoscaling-iam"></a>

In den folgenden Schritten erstellen Sie eine IAM-Rolle, mit der Sie Kubernetes-Knoten in Ihrem Cluster durch SageMaker HyperPod Karpenter-basiertes Autoscaling verwalten können. Diese Rolle bietet die erforderlichen Berechtigungen für das automatische Hinzufügen und Entfernen von HyperPod Clusterknoten je nach Arbeitslastanforderung.

**Öffnen Sie die IAM-Konsole.**

1. Melden Sie sich unter console.aws.amazon.com bei der IAM-Konsole an AWS-Managementkonsole und öffnen Sie sie.

1. Wählen Sie im Navigationsbereich **Rollen** aus.

1. Wählen Sie **Create role** (Rolle erstellen) aus.

**Konfigurieren der Vertrauensrichtlinie**

1. Für **Trusted entity type** (Vertrauenstyp der Entität), wählen Sie **Custom trust policy** (Benutzerdefinierte Vertrauensrichtlinie).

1. Ersetzen Sie im Editor **für benutzerdefinierte Vertrauensrichtlinien** die Standardrichtlinie durch die folgende Richtlinie:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": [
                       "hyperpod.sagemaker.amazonaws.com"
                   ]
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

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

**Erstellen Sie die Berechtigungsrichtlinie und fügen Sie sie an**

Da bestimmte Berechtigungen SageMaker HyperPod erforderlich sind, die in AWS verwalteten Richtlinien nicht verfügbar sind, müssen Sie eine benutzerdefinierte Richtlinie erstellen.

1. Wählen Sie **Richtlinie erstellen** aus. Dies öffnet eine neue Registerkarte im Browser.

1. Wählen Sie den Tab **JSON**.

1. Ersetzen Sie die Standardrichtlinie durch die folgende:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "sagemaker:BatchAddClusterNodes",
                   "sagemaker:BatchDeleteClusterNodes"
               ],
               "Resource": "arn:aws:sagemaker:*:*:cluster/*",
               "Condition": {
                   "StringEquals": {
                       "aws:ResourceAccount": "${aws:PrincipalAccount}"
                   }
               }
           },
           {
               "Effect": "Allow",
               "Action": [
                   "kms:CreateGrant",
                   "kms:DescribeKey"
               ],
               "Resource": "arn:aws:kms:*:*:key/*",
               "Condition": {
                   "StringLike": {
                       "kms:ViaService": "sagemaker.*.amazonaws.com"
                   },
                   "Bool": {
                       "kms:GrantIsForAWSResource": "true"
                   },
                   "ForAllValues:StringEquals": {
                       "kms:GrantOperations": [
                           "CreateGrant",
                           "Decrypt",
                           "DescribeKey",
                           "GenerateDataKeyWithoutPlaintext",
                           "ReEncryptTo",
                           "ReEncryptFrom",
                           "RetireGrant"
                       ]
                   }
               }
           }
       ]
   }
   ```

------

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

1. Geben Sie unter **Policy name** (Richtlinienname) **SageMakerHyperPodKarpenterPolicy** ein.

1. (Optional) Geben Sie im Feld **Beschreibung** eine Beschreibung für die Richtlinie ein.

1. Wählen Sie **Richtlinie erstellen** aus.

1. Kehren Sie zur Registerkarte Rollenerstellung zurück und aktualisieren Sie die Richtlinienliste.

1. Suchen Sie nach der **SageMakerHyperPodKarpenterPolicy**, die Sie gerade erstellt haben, und wählen Sie sie aus.

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

**Benennen Sie die Rolle und erstellen Sie sie**

1. Geben Sie für **Rollenname** den Namen `SageMakerHyperPodKarpenterRole` ein.

1. (Optional) Geben Sie unter **Beschreibung** eine Beschreibung für die neue Rolle ein.

1. Überprüfen Sie im Abschnitt **Schritt 1: Vertrauenswürdige Entitäten auswählen** sicher, dass die Vertrauensrichtlinie die richtigen Dienstprinzipale anzeigt.

1. Vergewissern Sie sich im Abschnitt **Schritt 2: Berechtigungen hinzufügen**, dass der Anhang angehängt `SageMakerHyperPodKarpenterPolicy` ist.

1. Wählen Sie **Rolle erstellen** aus.

**Notieren Sie sich den Rollen-ARN.**

Nachdem die Rolle erfolgreich erstellt wurde:

1. Wählen Sie in der **Rollenliste** den Rollennamen `SageMakerHyperPodKarpenterRole` aus.

1. Kopieren Sie den **Rollen-ARN** aus dem Abschnitt **Zusammenfassung**. Sie benötigen diesen ARN, wenn Sie Ihren HyperPod Cluster erstellen.

Die Rollen-ARN folgt diesem Format: `arn:aws:iam::ACCOUNT-ID:role/SageMakerHyperPodKarpenterRole`.

# Erstellen und konfigurieren Sie einen HyperPod Cluster mit Karpenter Autoscaling
<a name="sagemaker-hyperpod-eks-autoscaling-cluster"></a>

In den folgenden Schritten erstellen Sie einen SageMaker HyperPod Cluster mit aktiviertem Continuous Provisioning und konfigurieren ihn für die Verwendung von Karpenter-basiertem Autoscaling.

**Erstellen Sie einen Cluster HyperPod**

1. Laden Sie Ihre Umgebungskonfiguration und extrahieren Sie Werte aus CloudFormation Stacks.

   ```
   source .env
   SUBNET1=$(cfn-output $VPC_STACK_NAME PrivateSubnet1)
   SUBNET2=$(cfn-output $VPC_STACK_NAME PrivateSubnet2)
   SUBNET3=$(cfn-output $VPC_STACK_NAME PrivateSubnet3)
   SECURITY_GROUP=$(cfn-output $VPC_STACK_NAME NoIngressSecurityGroup)
   EKS_CLUSTER_ARN=$(cfn-output $EKS_STACK_NAME ClusterArn)
   EXECUTION_ROLE=$(cfn-output $SAGEMAKER_STACK_NAME ExecutionRole)
   SERVICE_ROLE=$(cfn-output $SAGEMAKER_STACK_NAME ServiceRole)
   BUCKET_NAME=$(cfn-output $SAGEMAKER_STACK_NAME Bucket)
   HP_CLUSTER_NAME="hyperpod-eks-test-$(date +%s)"
   EKS_CLUSTER_NAME=$(cfn-output $EKS_STACK_NAME ClusterName)
   HP_CLUSTER_ROLE=$(cfn-output $SAGEMAKER_STACK_NAME ClusterRole)
   ```

1. Laden Sie das Knoteninitialisierungsskript in Ihren Amazon-S3-Bucket hoch.

   ```
   aws s3 cp lifecyclescripts/on_create_noop.sh s3://$BUCKET_NAME
   ```

1. Erstellen Sie eine Cluster-Konfigurationsdatei mit Ihren Umgebungsvariablen.

   ```
   cat > cluster_config.json << EOF
   {
       "ClusterName": "$HP_CLUSTER_NAME",
       "InstanceGroups": [
           {
               "InstanceCount": 1,
               "InstanceGroupName": "system",
               "InstanceType": "ml.c5.xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE"
           },
           {
               "InstanceCount": 0,
               "InstanceGroupName": "auto-c5-az1",
               "InstanceType": "ml.c5.xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE"
           },
           {
               "InstanceCount": 0,
               "InstanceGroupName": "auto-c5-4xaz2",
               "InstanceType": "ml.c5.4xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE",
               "OverrideVpcConfig": {
                   "SecurityGroupIds": [
                       "$SECURITY_GROUP"
                   ],
                   "Subnets": [
                       "$SUBNET2"
                   ]
               }
           },
           {
               "InstanceCount": 0,
               "InstanceGroupName": "auto-g5-az3",
               "InstanceType": "ml.g5.xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE",
               "OverrideVpcConfig": {
                   "SecurityGroupIds": [
                       "$SECURITY_GROUP"
                   ],
                   "Subnets": [
                       "$SUBNET3"
                   ]
               }
           }
       ],
       "VpcConfig": {
           "SecurityGroupIds": [
               "$SECURITY_GROUP"
           ],
           "Subnets": [
               "$SUBNET1"
           ]
       },
       "Orchestrator": {
           "Eks": {
               "ClusterArn": "$EKS_CLUSTER_ARN"
           }
       },
       "ClusterRole": "$HP_CLUSTER_ROLE",
       "AutoScaling": {
           "Mode": "Enable",
           "AutoScalerType": "Karpenter"
       },
       "NodeProvisioningMode": "Continuous"
   }
   EOF
   ```

1. Führen Sie den folgenden Befehl aus, um Ihren HyperPod Cluster zu erstellen.

   ```
   aws sagemaker create-cluster --cli-input-json file://./cluster_config.json
   ```

1. Der Prozess der Clustererstellung dauert ungefähr 20 Minuten. Überwachen Sie den Clusterstatus, bis ClusterStatus sowohl als auch AutoScaling .Status angezeigt InService werden.

1. Speichern Sie den Cluster-ARN für nachfolgende Operationen.

   ```
   HP_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME \
      --output text --query ClusterArn)
   ```

**Aktivieren von Carpenter Autoscaling**

1. Führen Sie den folgenden Befehl aus, um die Karpenter-basierte Autoskalierung auf jedem bereits vorhandenen Cluster zu aktivieren, der über den kontinuierlichen Knotenbereitstellungsmodus verfügt.

   ```
   aws sagemaker update-cluster \
       --cluster-name $HP_CLUSTER_NAME \
       --auto-scaling Mode=Enable,AutoScalerType=Karpenter \
       --cluster-role $HP_CLUSTER_ROLE
   ```

1. Stellen Sie sicher, dass Karpenter erfolgreich aktiviert wurde:

   ```
   aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --query 'AutoScaling'
   ```

1. Erwartete Ausgabe:

   ```
   {
       "Mode": "Enable",
       "AutoScalerType": "Karpenter",
       "Status": "InService"
   }
   ```

Warten Sie`Status`, bis das angezeigt wird, `InService` bevor Sie mit der Konfiguration von NodeClass und NodePool fortfahren.

# Erstellen Sie ein NodeClass
<a name="sagemaker-hyperpod-eks-autoscaling-nodeclass"></a>

**Wichtig**  
Sie müssen mit 0 Knoten in Ihrer Instance-Gruppe beginnen und Karpenter die automatische Skalierung übernehmen lassen. Wenn Sie mit mehr als 0 Knoten beginnen, skaliert Karpenter diese auf 0 herunter.

Eine Knotenklasse (`NodeClass`) definiert Einstellungen auf Infrastrukturebene, die für Knotengruppen in Ihrem Amazon EKS-Cluster gelten, einschließlich Netzwerkkonfiguration, Speichereinstellungen und Ressourcen-Tagging. A `HyperPodNodeClass` ist ein benutzerdefinierter Code`NodeClass`, der vorab erstellten Instanzgruppen zugeordnet wird. Dabei werden Einschränkungen definiert SageMaker HyperPod, welche Instanztypen und Availability Zones für die automatische Skalierung von Karpenter unterstützt werden.

**Überlegungen zur Erstellung einer Knotenklasse**
+ Sie können bis zu 10 Instance-Gruppen in einer angeben`NodeClass`.
+ Bei Verwendung der GPU-Partitionierung mit MIG (Multi-Instance-GPU) kann Karpenter automatisch Knoten mit MIG-fähigen Instanzgruppen bereitstellen. Stellen Sie sicher, dass Ihre Instanzgruppen von MIG unterstützte Instanztypen (ml.p4d.24xlarge, ml.p5.48xlarge oder ml.p5e/p5en.48xlarge) enthalten, und konfigurieren Sie die entsprechenden MIG-Labels während der Clustererstellung. Weitere Informationen zur Konfiguration [Verwenden von GPU-Partitionen in Amazon SageMaker HyperPod](sagemaker-hyperpod-eks-gpu-partitioning.md) der GPU-Partitionierung finden Sie unter.
+ Wenn benutzerdefinierte Labels auf Instanzgruppen angewendet werden, können Sie sie bei der Statusabfrage im `desiredLabels` Feld einsehen. `HyperpodNodeClass` Dazu gehören MIG-Konfigurationsbezeichnungen wie`nvidia.com/mig.config`. Wenn eingehende Jobs MIG-Ressourcen anfordern, skaliert Karpenter automatisch die Instanzen mit den entsprechenden MIG-Bezeichnungen.
+ Wenn Sie sich dafür entscheiden, eine Instanzgruppe zu löschen, empfehlen wir, sie aus Ihrer zu entfernen, `NodeClass` bevor Sie sie aus Ihrem HyperPod Cluster löschen. Wenn eine Instance-Gruppe gelöscht wird, während sie in einem `NodeClass` verwendet wird, wird die `NodeClass` als nicht `Ready` für die Bereitstellung markiert und für nachfolgende Skalierungsvorgänge nicht verwendet, bis die Instance-Gruppe aus `NodeClass` entfernt wird.
+ Wenn Sie Instance-Gruppen aus einer entfernen`NodeClass`, erkennt Karpenter eine Abweichung auf den Knoten, die von Karpenter in der Instance-Gruppe (n) verwaltet wurden, und unterbricht die Knoten auf der Grundlage Ihrer Budgetkontrollen für Störungen.
+ Die von der Instance-Gruppe verwendeten Subnetze sollten derselben AZ angehören. Subnetze werden entweder mit `OverrideVpcConfig` auf Instance-Gruppenebene oder Clusterebene spezifiziert. `VpcConfig` wird standardmäßig verwendet.
+ Derzeit wird nur On-Demand-Kapazität unterstützt. Instance-Gruppen mit Trainingsplan oder reservierter Kapazität werden nicht unterstützt.
+ Instance-Gruppen mit `DeepHealthChecks (DHC)` werden nicht unterstützt. Das liegt daran, dass die Fertigstellung eines DHC etwa 60 bis 90 Minuten in Anspruch nimmt und die Pods während dieser Zeit im Status „Ausstehend“ verbleiben, was zu einer Überprovisionierung führen kann.

In den folgenden Schritten wird erklärt, wie eine erstellt wird`NodeClass`.

1. Erstellen Sie eine YAML-Datei (z. B. nodeclass.yaml) mit Ihrer `NodeClass`-Konfiguration.

1. Wenden Sie die Konfiguration mit kubectl auf Ihren Cluster an.

1. Verweisen Sie `NodeClass` in Ihrer `NodePool` Konfiguration auf.

1. Im Folgenden finden Sie ein Beispiel`NodeClass`, das die Instance-Typen ml.c5.xlarge und ml.c5.4xlarge verwendet:

   ```
   apiVersion: karpenter.sagemaker.amazonaws.com/v1
   kind: HyperpodNodeClass
   metadata:
     name: sample-nc
   spec:
     instanceGroups:
       # name of InstanceGroup in HyperPod cluster. InstanceGroup needs to pre-created
       # MaxItems: 10
       - auto-c5-xaz1
       - auto-c5-4xaz2
   ```

1. Wenden Sie die Konfiguration an:

   ```
   kubectl apply -f nodeclass.yaml
   ```

1. Überwachen Sie den NodeClass Status, um sicherzustellen, dass die Bedingung Bereit im Status auf True gesetzt ist:

   ```
   kubectl get hyperpodnodeclass sample-nc -o yaml
   ```

   ```
   apiVersion: karpenter.sagemaker.amazonaws.com/v1
   kind: HyperpodNodeClass
   metadata:
     creationTimestamp: "<timestamp>"
     name: sample-nc
     uid: <resource-uid>
   spec:
     instanceGroups:
     - auto-c5-az1
     - auto-c5-4xaz2
   status:
     conditions:
     // true when all IGs in the spec are present in SageMaker cluster, false otherwise
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 3
       reason: InstanceGroupReady
       status: "True"
       type: InstanceGroupReady
     // true if subnets of IGs are discoverable, false otherwise
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 3
       reason: SubnetsReady
       status: "True"
       type: SubnetsReady
     // true when all dependent resources are Ready [InstanceGroup, Subnets]
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 3
       reason: Ready
       status: "True"
       type: Ready
     instanceGroups:
     - desiredLabels:
       - key: <custom_label_key>
         value: <custom_label_value>
       - key: nvidia.com/mig.config
         value: all-1g.5gb
       instanceTypes:
       - ml.c5.xlarge
       name: auto-c5-az1
       subnets:
       - id: <subnet-id>
         zone: <availability-zone-a>
         zoneId: <zone-id-a>
     - instanceTypes:
       - ml.c5.4xlarge
       name: auto-c5-4xaz2
       subnets:
       - id: <subnet-id>
         zone: <availability-zone-b>
         zoneId: <zone-id-b>
   ```

# Erstellen Sie eine NodePool
<a name="sagemaker-hyperpod-eks-autoscaling-nodepool"></a>

Das `NodePool` legt Einschränkungen für die Knoten fest, die von Karpenter erstellt werden können, und für die Pods, die auf diesen Knoten ausgeführt werden können. `NodePool`Sie können so konfiguriert werden, dass sie Dinge tun wie:
+ Beschränken Sie die Knotenerstellung auf bestimmte Zonen, Instance-Typen und Computerarchitekturen.
+ Definieren Sie Labels oder Taints, um die Anzahl der Pods zu begrenzen, die auf den von Karpenter erstellten Knoten ausgeführt werden können.

**Anmerkung**  
HyperPod Der Anbieter unterstützt eine begrenzte Anzahl bekannter Kubernetes- und Karpenteranforderungen, die im Folgenden erläutert werden. 

In den folgenden Schritten wird erklärt, wie eine erstellt wird`NodePool`.

1. Erstellen Sie eine YAML-Datei mit dem Namen nodepool.yaml und Ihrer gewünschten `NodePool`-Konfiguration.

1. Sie können die folgende Beispielkonfiguration verwenden.

   Suchen Sie nach `Ready` unter`Conditions`, um anzuzeigen, dass alle abhängigen Ressourcen ordnungsgemäß funktionieren.

   ```
   apiVersion: karpenter.sh/v1
   kind: NodePool
   metadata:
    name: sample-np
   spec:
    template:
      spec:
        nodeClassRef:
         group: karpenter.sagemaker.amazonaws.com
         kind: HyperpodNodeClass
         name: multiazc5
        expireAfter: Never
        requirements:
           - key: node.kubernetes.io/instance-type
             operator: Exists
   ```

1. Wenden Sie den `NodePool` auf Ihren Cluster an:

   ```
   kubectl apply -f nodepool.yaml
   ```

1. Überwachen Sie den `NodePool` Status, um sicherzustellen, dass der `Ready` Zustand im Status auf Folgendes gesetzt ist`True`:

   ```
   kubectl get nodepool sample-np -oyaml
   ```

   ```
   apiVersion: karpenter.sh/v1
   kind: NodePool
   metadata:
     name: <nodepool-name>
     uid: <resource-uid>
     ...
   spec:
     disruption:
       budgets:
       - nodes: 90%
       consolidateAfter: 0s
       consolidationPolicy: WhenEmptyOrUnderutilized
     template:
       spec:
         expireAfter: 720h
         nodeClassRef:
           group: karpenter.sagemaker.amazonaws.com
           kind: HyperpodNodeClass
           name: <nodeclass-name>
         requirements:
         - key: node.kubernetes.io/instance-type
           operator: Exists
   status:
     conditions:
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 2
       reason: ValidationSucceeded
       status: "True"
       type: ValidationSucceeded
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 2
       reason: NodeClassReady
       status: "True"
       type: NodeClassReady
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 2
       reason: Ready
       status: "True"
       type: Ready
   ```

**Unterstützte Labels für Karpenter Provider HyperPod**

Dies sind die optionalen Einschränkungen und Anforderungen, die Sie in Ihrer `NodePool`-Konfiguration festlegen können.


|  Art der Anforderung  |  Zweck  |  Verwenden Sie Werte Case/Supported   |  Empfehlung  | 
| --- | --- | --- | --- | 
|  Instance-Typen (`node.kubernetes.io/instance-type`)  |  Steuert, SageMaker aus welchen Instanztypen Karpenter wählen kann  |  Anstatt sich nur auf ml.c5.xlarge zu beschränken, lassen Sie Karpenter aus allen verfügbaren Typen in Ihren Instance-Gruppen auswählen  |  Lassen Sie diesen Wert undefiniert oder verwenden Sie den Exists-Operator, um Karpenter maximale Flexibilität bei der Auswahl kostengünstiger Instance-Typen zu bieten  | 
|  Availability Zones (`topology.kubernetes.io/zone`)  |  Steuert, AWS in welchen Verfügbarkeitszonen Knoten erstellt werden können  |  Spezifische Zonennamen wie us-east-1c. Verwenden Sie diese Option, wenn Pods aus Latenz- oder Compliance-Gründen in bestimmten Zonen ausgeführt werden müssen  | – | 
|  Architektur (`kubernetes.io/arch`)  |  Spezifiziert die CPU-Architektur  |  Nur amd64 (derzeit keine ARM-Unterstützung)  |  –  | 

# Stellen Sie einen Workload bereit
<a name="sagemaker-hyperpod-eks-autoscaling-workload"></a>

Die folgenden Beispiele zeigen, wie HyperPod Autoscaling mit Karpenter automatisch Knoten als Reaktion auf Workload-Anforderungen bereitstellt. Diese Beispiele zeigen das grundlegende Skalierungsverhalten und die Verteilungsmuster für mehrere Verfügbarkeitszonen.

**Stellen Sie einen einfachen Workload bereit**

1. Die folgende Kubernetes-Bereitstellung umfasst Pods, die 1 CPU und 256 MB Arbeitsspeicher pro Replikat oder Pod anfordern. In diesem Szenario sind die Pods noch nicht hochgefahren.

   ```
   kubectl apply -f https://raw.githubusercontent.com/aws/karpenter-provider-aws/refs/heads/main/examples/workloads/inflate.yaml
   ```

1. Führen Sie zum Test des Scale-Up-Prozesses den folgenden Befehl aus. Karpenter wird dem Cluster neue Knoten hinzufügen.

   ```
   kubectl scale deployment inflate --replicas 10
   ```

1. Führen Sie zum Test des Herunterskalierungsprozesses den folgenden Befehl aus. Karpenter wird Knoten aus dem Cluster entfernen.

   ```
   kubectl scale deployment inflate --replicas 0
   ```

**Stellen Sie einen Workload für mehrere bereit AZs**

1. Führen Sie den folgenden Befehl aus, um eine Workload bereitzustellen, die eine Kubernetes-Bereitstellung ausführt, bei der die Pods in der Bereitstellung gleichmäßig auf verschiedene Availability Zones verteilt werden müssen, mit einer maximalen Abweichung von 1.

   ```
   kubectl apply -f https://raw.githubusercontent.com/aws/karpenter-provider-aws/refs/heads/main/examples/workloads/spread-zone.yaml
   ```

1. Führen Sie den folgenden Befehl aus, um die Anzahl der Pods anzupassen:

   ```
   kubectl scale deployment zone-spread --replicas 15
   ```

   Karpenter fügt dem Cluster neue Knoten hinzu, wobei sich mindestens ein Knoten in einer anderen Availability Zone befindet.

Weitere Beispiele finden Sie unter [Karpenter-Beispiel-Workloads](https://github.com/aws/karpenter-provider-aws/tree/main/examples/workloads) auf. GitHub