

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.

# Richtlinien zur automatischen Skalierung für die Bereitstellung Ihres HyperPod Inferenzmodells
<a name="sagemaker-hyperpod-model-deployment-autoscaling"></a>

Die folgenden Informationen enthalten praktische Beispiele und Konfigurationen für die Implementierung von Autoscaling-Richtlinien in Bereitstellungen des SageMaker HyperPod Amazon-Inferenzmodells. 

Sie erfahren, wie Sie die automatische Skalierung mithilfe der in Ihren Bereitstellungs-YAML-Dateien integrierten `autoScalingSpec` konfigurieren und eigenständige KEDA–`ScaledObject`Konfigurationen für erweiterte Skalierungsszenarien erstellen. Die Beispiele behandeln Skalierungsauslöser auf der Grundlage von CloudWatch Metriken, Amazon SQS SQS-Warteschlangenlängen, Prometheus-Abfragen und Kennzahlen zur Ressourcennutzung wie CPU und Arbeitsspeicher. 

## Verwendung von YAML bei der Bereitstellung autoScalingSpec
<a name="sagemaker-hyperpod-model-deployment-autoscaling-yaml"></a>

Der Amazon SageMaker HyperPod Inference Operator bietet integrierte Autoscaling-Funktionen für Modellbereitstellungen, die Metriken von Amazon Managed Prometheus (AMP) CloudWatch und Amazon Managed Prometheus (AMP) verwenden. Das folgende YAML-Implementierungsbeispiel enthält einen `autoScalingSpec` Abschnitt, der die Konfigurationswerte für die Skalierung Ihrer Modellbereitstellung definiert.

```
apiVersion: inference.sagemaker.aws.amazon.com/v1
kind: JumpStartModel
metadata:
  name: deepseek-sample624
  namespace: ns-team-a
spec:
  sageMakerEndpoint:
    name: deepsek7bsme624
  model:
    modelHubName: SageMakerPublicHub
    modelId: deepseek-llm-r1-distill-qwen-1-5b
    modelVersion: 2.0.4
  server:
    instanceType: ml.g5.8xlarge
  metrics:
    enabled: true
  environmentVariables:
    - name: SAMPLE_ENV_VAR
      value: "sample_value"
  maxDeployTimeInSeconds: 1800
  tlsConfig:
    tlsCertificateOutputS3Uri: "s3://{USER}-tls-bucket-{REGION}/certificates"
  autoScalingSpec:
    minReplicaCount: 0
    maxReplicaCount: 5
    pollingInterval: 15
    initialCooldownPeriod: 60
    cooldownPeriod: 120
    scaleDownStabilizationTime: 60
    scaleUpStabilizationTime: 0
    cloudWatchTrigger:
        name: "SageMaker-Invocations"
        namespace: "AWS/SageMaker"
        useCachedMetrics: false
        metricName: "Invocations"
        targetValue: 10.5
        activationTargetValue: 5.0
        minValue: 0.0
        metricCollectionStartTime: 300
        metricCollectionPeriod: 30
        metricStat: "Sum"
        metricType: "Average"
        dimensions:
          - name: "EndpointName"
            value: "deepsek7bsme624"
          - name: "VariantName"
            value: "AllTraffic"
    prometheusTrigger: 
        name: "Prometheus-Trigger"
        useCachedMetrics: false
        serverAddress: http://<prometheus-host>:9090
        query: sum(rate(http_requests_total{deployment="my-deployment"}[2m]))
        targetValue: 10.0
        activationTargetValue: 5.0
        namespace: "namespace"
        customHeaders: "X-Client-Id=cid"
        metricType: "Value"
```

### Erläuterung der Felder, die bei der Bereitstellung von YAML verwendet werden
<a name="sagemaker-hyperpod-model-deployment-autoscaling-fields"></a>

`minReplicaCount` (Optional, Ganzzahl)  
Gibt die Mindestanzahl der Modellbereitstellungsreplikate an, die im Cluster verwaltet werden sollen. Bei Down-Scale-Down-Ereignissen wird die Bereitstellung auf diese Mindestanzahl von Pods herunterskaliert. Der Wert muss gleich oder größer 0 sein. Standard: 1

`maxReplicaCount` (Optional, Ganzzahl)  
Gibt die maximale Anzahl von Modellbereitstellungsreplikaten an, die im Cluster verwaltet werden sollen. Der Wert muss gleich oder größer `minReplicaCount` sein. Bei Skalierungsereignissen wird die Bereitstellung auf diese maximale Anzahl von Pods skaliert. Standard: 5.

`pollingInterval` (Optional, Ganzzahl)  
Das Zeitintervall in Sekunden für die Abfrage von Metriken. Minimum: 0. Standard: 30 Sekunden.

`cooldownPeriod` (Optional, Ganzzahl)  
Das Zeitintervall in Sekunden, in dem gewartet werden soll, bevor während eines Scale-Down-Ereignisses von 1 auf 0 Pods herunterskaliert wird. Gilt nur, wenn `minReplicaCount` auf 0 gesetzt ist. Minimum: 0. Standard: 300 Sekunden.

`initialCooldownPeriod` (Optional, Ganzzahl)  
Das Zeitintervall in Sekunden, in dem gewartet werden soll, bevor bei der ersten Bereitstellung von 1 auf 0 Pods herunterskaliert wird. Gilt nur, wenn `minReplicaCount` auf 0 gesetzt ist. Minimum: 0. Standard: 300 Sekunden.

`scaleDownStabilizationTime` (Optional, Ganzzahl)  
Das Stabilisierungszeitfenster in Sekunden, nachdem ein Scale-Down-Trigger aktiviert wurde, bevor das Herunterskalieren erfolgt. Minimum: 0. Standard: 300 Sekunden.

`scaleUpStabilizationTime` (Optional, Ganzzahl)  
Das Stabilisierungszeitfenster in Sekunden nach der Aktivierung eines Scale-Up-Triggers, bevor das Hochskalieren erfolgt. Minimum: 0. Standard: 0 Sekunden.

`cloudWatchTrigger`  
Die Triggerkonfiguration für CloudWatch Metriken, die bei Entscheidungen zur automatischen Skalierung verwendet werden. Die folgenden Felder sind verfügbar in `cloudWatchTrigger`:  
+ `name`(Optional, Zeichenfolge) — Name für den CloudWatch Trigger. Falls nicht angegeben, wird das Standardformat verwendet: < model-deployment-name >-scaled-object-cloudwatch-trigger.
+ `useCachedMetrics`(Optional, Boolean) – Legt fest, ob von KEDA abgefragte Metriken zwischengespeichert werden sollen. KEDA fragt Metriken mithilfe des PollingInterval ab, während der Horizontal Pod Autoscaler (HPA) alle 15 Sekunden Metriken von KEDA anfordert. Wenn dieser Wert auf true gesetzt ist, werden abgefragte Metriken zwischengespeichert und zur Bearbeitung von HPA-Anfragen verwendet. Standard: true
+ `namespace`(Erforderlich, Zeichenfolge) — Der CloudWatch Namespace für die abzufragende Metrik.
+ `metricName`(Erforderlich, Zeichenfolge) — Der Name der CloudWatch Metrik.
+ `dimensions`(Optional, Liste) – Die Liste der Dimensionen für die Metrik. Jede Dimension umfasst einen Namen (Dimensionsname – Zeichenfolge) und einen Wert (Dimensionswert – Zeichenfolge).
+ `targetValue`(Erforderlich, Float) — Der Zielwert für die CloudWatch Metrik, die bei Autoscaling-Entscheidungen verwendet wird.
+ `activationTargetValue`(Optional, Float) — Der Zielwert für die CloudWatch Metrik, die bei der Skalierung von 0 auf 1 Pod verwendet wird. Gilt nur, wenn `minReplicaCount` auf 0 gesetzt ist. Standard: 0
+ `minValue`(Optional, Float) — Der Wert, der verwendet werden soll, wenn die CloudWatch Abfrage keine Daten zurückgibt. Standard: 0
+ `metricCollectionStartTime`(Optional, Integer) — Die Startzeit für die Metrikabfrage, berechnet als metricCollectionStart T-Zeit. Muss größer als oder gleich sein metricCollectionPeriod. Standard: 300 Sekunden.
+ `metricCollectionPeriod`(Optional, Integer) – Die Dauer der Metrikabfrage in Sekunden. Muss ein von CloudWatch -unterstützter Wert sein (1, 5, 10, 30 oder ein Vielfaches von 60). Standard: 300 Sekunden.
+ `metricStat`(Optional, Zeichenfolge) — Der Statistiktyp für die CloudWatch Abfrage. Standard: `Average`.
+ `metricType`(Optional, Zeichenfolge) – Definiert, wie die Metrik für Skalierungsberechnungen verwendet wird. Standard: `Average`. Zulässige Werte: `Average`, `Value`.
  + **Durchschnitt**: Gewünschte Replikate = ceil (metrischer Wert)/(TargetValue)
  + **Wert**: Gewünschte Replikate = (aktuelle Replikate) × ceil (metrischer Wert)/(TargetValue)

`prometheusTrigger`  
Die Triggerkonfiguration für Amazon Managed Prometheus (AMP) -Metriken, die bei Entscheidungen zur automatischen Skalierung verwendet werden. Die folgenden Felder sind verfügbar in `prometheusTrigger`:  
+ `name`(Optional, Zeichenfolge) — Name für den CloudWatch Trigger. Falls nicht angegeben, wird das Standardformat verwendet: < model-deployment-name >-scaled-object-cloudwatch-trigger.
+ `useCachedMetrics`(Optional, Boolean) – Legt fest, ob von KEDA abgefragte Metriken zwischengespeichert werden sollen. KEDA fragt Metriken mithilfe des PollingInterval ab, während der Horizontal Pod Autoscaler (HPA) alle 15 Sekunden Metriken von KEDA anfordert. Wenn dieser Wert auf true gesetzt ist, werden abgefragte Metriken zwischengespeichert und zur Bearbeitung von HPA-Anfragen verwendet. Standard: true
+ `serverAddress`(Erforderlich, Zeichenfolge) – Die Adresse des AMP-Servers. Muss das Format verwenden: <https://aps-workspaces.<region>.amazonaws.com/workspaces/<workspace\$1id>
+ `query`(Erforderlich, Zeichenfolge) – Die für die Metrik verwendete PromQL-Abfrage. Muss einen Skalarwert zurückgeben.
+ `targetValue`(Erforderlich, Float) — Der Zielwert für die CloudWatch Metrik, die bei Autoscaling-Entscheidungen verwendet wird.
+ `activationTargetValue`(Optional, Float) — Der Zielwert für die CloudWatch Metrik, die bei der Skalierung von 0 auf 1 Pod verwendet wird. Gilt nur, wenn `minReplicaCount` auf 0 gesetzt ist. Standard: 0
+ `namespace`(Optional, String) – Der Namespace, der für Namespace-Abfragen verwendet werden soll. Standard: leere Zeichenfolge (`""`).
+ `customHeaders`(Optional, Zeichenfolge) – Benutzerdefinierte Header, die bei der Abfrage des Prometheus-Endpunkts berücksichtigt werden sollen. Standard: leere Zeichenfolge ("").
+ `metricType`(Optional, Zeichenfolge) – Definiert, wie die Metrik für Skalierungsberechnungen verwendet wird. Standard: `Average`. Zulässige Werte: `Average`, `Value`.
  + **Durchschnitt**: Gewünschte Replikate = ceil (metrischer Wert)/(TargetValue)
  + **Wert**: Gewünschte Replikate = (aktuelle Replikate) × ceil (metrischer Wert)/(TargetValue)

## Verwendung von ScaledObject KEDA-Yaml-Definitionen über kubectl
<a name="sagemaker-hyperpod-model-deployment-autoscaling-kubectl"></a>

Zusätzlich zur Konfiguration von Autoscaling über den autoScalingSpec Abschnitt in Ihrer YAML-Bereitstellung können Sie eigenständige KEDA-YAML-Definitionen mit kubectl erstellen und anwenden. `ScaledObject`

Dieser Ansatz bietet mehr Flexibilität für komplexe Skalierungsszenarien und ermöglicht es Ihnen, Autoscaling-Richtlinien unabhängig von Ihren Modellbereitstellungen zu verwalten. `ScaledObject`KEDA-Konfigurationen unterstützen eine [Vielzahl von Skalierungsauslösern](https://keda.sh/docs/2.17/scalers/), darunter CloudWatch Metriken, Amazon SQS SQS-Warteschlangenlängen, Prometheus-Abfragen und ressourcenbasierte Metriken wie CPU- und Speicherauslastung. Sie können diese Konfigurationen auf bestehende Modellbereitstellungen anwenden, indem Sie im Abschnitt der Spezifikation auf den Namen der Bereitstellung verweisen. scaleTargetRef ScaledObject 

**Anmerkung**  
Stellen Sie sicher, dass die während der Installation des HyperPod Inference-Operators bereitgestellte Keda-Operatorrolle über ausreichende Berechtigungen verfügt, um die in den skalierten Objekt-Triggern definierten Metriken abzufragen.

### CloudWatch Metriken
<a name="sagemaker-hyperpod-model-deployment-autoscaling-kubectl-cw"></a>

Die folgende KEDA-Yaml-Richtlinie verwendet CloudWatch Metriken als Auslöser für die automatische Skalierung in einer Kubernetes-Bereitstellung. Die Richtlinie fragt die Anzahl der Aufrufe für einen Sagemaker-Endpunkt ab und skaliert die Anzahl der Bereitstellungs-Pods. [Die vollständige Liste der von KEDA for `aws-cloudwatch` Trigger unterstützten Parameter finden Sie unter https://keda. sh/docs/2.17/scalers/aws-cloudwatch/](https://keda.sh/docs/2.17/scalers/aws-cloudwatch/).

```
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: invocations-scaledobject # name of the scaled object that will be created by this
  namespace: ns-team-a # namespace that this scaled object targets
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: $DEPLOYMENT_NAME # name of the model deployment
  minReplicaCount: 1 # minimum number of pods to be maintained
  maxReplicaCount: 4 # maximum number of pods to scale to
  pollingInterval: 10
  triggers:
  - type: aws-cloudwatch
    metadata:
      namespace: AWS/SageMaker
      metricName: Invocations
      targetMetricValue: "1"
      minMetricValue: "1"
      awsRegion: "us-west-2"
      dimensionName: EndpointName;VariantName
      dimensionValue: $ENDPOINT_NAME;$VARIANT_NAME
      metricStatPeriod: "30" # seconds
      metricStat: "Sum"
      identityOwner: operator
```

### Amazon-SQS-Metriken
<a name="sagemaker-hyperpod-model-deployment-autoscaling-kubectl-sqs"></a>

Die folgende KEDA-Yaml-Richtlinie verwendet Amazon-SQS-Metriken als Auslöser für die automatische Skalierung einer Kubernetes-Bereitstellung. Die Richtlinie fragt die Anzahl der Aufrufe für einen Sagemaker-Endpunkt ab und skaliert die Anzahl der Bereitstellungs-Pods. [Die vollständige Liste der von KEDA für `aws-cloudwatch` Trigger unterstützten Parameter finden Sie unter https://keda. sh/docs/2.17/scalers/aws-sqs/](https://keda.sh/docs/2.17/scalers/aws-sqs/).

```
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: invocations-scaledobject # name of the scaled object that will be created by this
  namespace: ns-team-a # namespace that this scaled object targets
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: $DEPLOYMENT_NAME # name of the model deployment
  minReplicaCount: 1 # minimum number of pods to be maintained
  maxReplicaCount: 4 # maximum number of pods to scale to
  pollingInterval: 10
  triggers:
  - type: aws-sqs-queue
    metadata:
      queueURL: https://sqs.eu-west-1.amazonaws.com/account_id/QueueName
      queueLength: "5"  # Default: "5"
      awsRegion: "us-west-1"
      scaleOnInFlight: true
      identityOwner: operator
```

### Prometheus-Metriken
<a name="sagemaker-hyperpod-model-deployment-autoscaling-kubectl-prometheus"></a>

Die folgende KEDA-Yaml-Richtlinie verwendet Prometheus-Metriken als Auslöser für die automatische Skalierung in einer Kubernetes-Bereitstellung. Die Richtlinie fragt die Anzahl der Aufrufe für einen Sagemaker-Endpunkt ab und skaliert die Anzahl der Bereitstellungs-Pods. [Die vollständige Liste der von KEDA für `aws-cloudwatch` Trigger unterstützten Parameter finden Sie unter https://keda. sh/docs/2.17/scalers/prometheus](https://keda.sh/docs/2.17/scalers/prometheus/)/.

```
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: invocations-scaledobject # name of the scaled object that will be created by this
  namespace: ns-team-a # namespace that this scaled object targets
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: $DEPLOYMENT_NAME # name of the model deployment
  minReplicaCount: 1 # minimum number of pods to be maintained
  maxReplicaCount: 4 # maximum number of pods to scale to
  pollingInterval: 10
  triggers:
  - type: prometheus
    metadata:
      serverAddress: http://<prometheus-host>:9090
      query: avg(rate(http_requests_total{deployment="$DEPLOYMENT_NAME"}[2m])) # Note: query must return a vector/scalar single element response
      threshold: '100.50'
      namespace: example-namespace  # for namespaced queries, eg. Thanos
      customHeaders: X-Client-Id=cid,X-Tenant-Id=tid,X-Organization-Id=oid # Optional. Custom headers to include in query. In case of auth header, use the custom authentication or relevant authModes.
      unsafeSsl: "false" #  Default is `false`, Used for skipping certificate check when having self-signed certs for Prometheus endpoint    
      timeout: 1000 # Custom timeout for the HTTP client used in this scaler
      identityOwner: operator
```

### CPU-Metriken
<a name="sagemaker-hyperpod-model-deployment-autoscaling-kubectl-cpu"></a>

Die folgende KEDA-Yaml-Richtlinie verwendet die CPU-Metrik als Auslöser für die automatische Skalierung in einer Kubernetes-Bereitstellung. Die Richtlinie fragt die Anzahl der Aufrufe für einen Sagemaker-Endpunkt ab und skaliert die Anzahl der Bereitstellungs-Pods. Die vollständige Liste der von KEDA für `aws-cloudwatch` Trigger unterstützten Parameter finden Sie unter [https://keda. sh/docs/2.17/scalers/prometheus](https://keda.sh/docs/2.17/scalers/prometheus/)/.

```
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: invocations-scaledobject # name of the scaled object that will be created by this
  namespace: ns-team-a # namespace that this scaled object targets
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: $DEPLOYMENT_NAME # name of the model deployment
  minReplicaCount: 1 # minimum number of pods to be maintained
  maxReplicaCount: 4 # maximum number of pods to scale to
  pollingInterval: 10
  triggers:
  - type: cpu
    metricType: Utilization # Allowed types are 'Utilization' or 'AverageValue'
    metadata:
        value: "60"
        containerName: "" # Optional. You can use this to target a specific container
```

### Speichermetriken
<a name="sagemaker-hyperpod-model-deployment-autoscaling-kubectl-memory"></a>

Die folgende KEDA-Yaml-Richtlinie verwendet die Prometheus-Metrikabfrage als Auslöser für die automatische Skalierung in einer Kubernetes-Bereitstellung. Die Richtlinie fragt die Anzahl der Aufrufe für einen Sagemaker-Endpunkt ab und skaliert die Anzahl der Bereitstellungs-Pods. Die vollständige Liste der von KEDA für `aws-cloudwatch` Trigger unterstützten Parameter finden Sie unter [https://keda. sh/docs/2.17/scalers/prometheus](https://keda.sh/docs/2.17/scalers/prometheus/)/.

```
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: invocations-scaledobject # name of the scaled object that will be created by this
  namespace: ns-team-a # namespace that this scaled object targets
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: $DEPLOYMENT_NAME # name of the model deployment
  minReplicaCount: 1 # minimum number of pods to be maintained
  maxReplicaCount: 4 # maximum number of pods to scale to
  pollingInterval: 10
  triggers:
  - type: memory
    metricType: Utilization # Allowed types are 'Utilization' or 'AverageValue'
    metadata:
        value: "60"
        containerName: "" # Optional. You can use this to target a specific container in a pod
```

## Beispiel für eine Prometheus-Richtlinie zum Herunterskalieren auf 0 Pods
<a name="sagemaker-hyperpod-model-deployment-autoscaling-kubectl-sample"></a>

Die folgende KEDA-Yaml-Richtlinie verwendet die Prometheus-Metrikabfrage als Auslöser für die automatische Skalierung in einer Kubernetes-Bereitstellung. Diese Richtlinie verwendet einen `minReplicaCount` von 0, wodurch KEDA die Bereitstellung auf 0 Pods reduzieren kann. Wenn auf 0 gesetzt `minReplicaCount` ist, müssen Sie ein Aktivierungskriterium angeben, um den ersten Pod aufzurufen, nachdem die Pods auf 0 herunterskaliert wurden. Für den Prometheus-Trigger wird dieser Wert von `activationThreshold` bereitgestellt. Für die SQS-Warteschlange stammt er von `activationQueueLength`.

**Anmerkung**  
Stellen Sie bei Verwendung `minReplicaCount` von 0 sicher, dass die Aktivierung nicht von einer Metrik abhängt, die von den Pods generiert wird. Wenn die Pods auf 0 herunterskaliert werden, wird diese Metrik nie generiert und die Pods werden nicht wieder hochskaliert.

```
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: invocations-scaledobject # name of the scaled object that will be created by this
  namespace: ns-team-a # namespace that this scaled object targets
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: $DEPLOYMENT_NAME # name of the model deployment
  minReplicaCount: 0 # minimum number of pods to be maintained
  maxReplicaCount: 4 # maximum number of pods to scale to
  pollingInterval: 10
  cooldownPeriod:  30
  initialCooldownPeriod:  180 # time before scaling down the pods after initial deployment
  triggers:
  - type: prometheus
    metadata:
      serverAddress: http://<prometheus-host>:9090
      query: sum(rate(http_requests_total{deployment="my-deployment"}[2m])) # Note: query must return a vector/scalar single element response
      threshold: '100.50'
      activationThreshold: '5.5' # Required if minReplicaCount is 0 for initial scaling
      namespace: example-namespace
      timeout: 1000
      identityOwner: operator
```

**Anmerkung**  
Die CPU- und Speicher-Trigger können nur dann auf 0 skaliert werden, wenn Sie mindestens einen zusätzlichen Skalierer definieren, der nicht CPU oder Speicher ist (z. B. SQS \$1 CPU oder Prometheus \$1 CPU). 