

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.

# Überlegungen zu Arbeitsspeicher und vCPUs für AWS Batch Amazon EKS
<a name="memory-cpu-batch-eks"></a>

In AWS Batch Amazon EKS können Sie die Ressourcen angeben, die einem Container zur Verfügung gestellt werden. Sie können beispielsweise `limits` OR-Werte für vCPU- und Speicherressourcen angeben`requests`.

Die folgenden Einschränkungen gelten für die Angabe von vCPU-Ressourcen:
+ Es muss mindestens eine vCPU `requests` oder ein `limits` Wert angegeben werden.
+ Eine vCPU-Einheit entspricht einem physischen oder virtuellen Kern. 
+ Der vCPU-Wert muss in ganzen Zahlen oder in Schritten von 0,25 eingegeben werden. 
+ Der kleinste gültige vCPU-Wert ist 0,25.
+ Wenn beide angegeben sind, muss der `requests` Wert kleiner oder gleich dem `limits` Wert sein. Auf diese Weise können Sie sowohl weiche als auch harte vCPU-Konfigurationen konfigurieren.
+ vCPU-Werte können nicht in MilliCPU-Form angegeben werden. `100m`Ist beispielsweise kein gültiger Wert.
+ AWS Batch verwendet den `requests` Wert für Skalierungsentscheidungen. Wenn kein `requests` Wert angegeben ist, wird der `limits` Wert in den `requests` Wert kopiert.

Die folgenden Einschränkungen gelten für die Angabe von Speicherressourcen:
+ Es muss mindestens ein Speicher `requests` oder `limits` Wert angegeben werden.
+ Speicherwerte müssen in mebibytes (MiBs) angegeben werden.
+ Wenn beide angegeben sind, muss der `requests` Wert dem `limits` Wert entsprechen.
+ AWS Batch verwendet den `requests` Wert für Skalierungsentscheidungen. Wenn kein `requests` Wert angegeben ist, wird der `limits` Wert in den `requests` Wert kopiert.

Die folgenden Einschränkungen gelten für die Angabe von GPU-Ressourcen:
+ Wenn beide angegeben sind, muss der `requests` Wert dem `limits` Wert entsprechen.
+ AWS Batch verwendet den `requests` Wert für Skalierungsentscheidungen. Wenn kein `requests` Wert angegeben ist, wird der `limits` Wert in den `requests` Wert kopiert.

## Beispiel: Jobdefinitionen
<a name="memory-cpu-batch-eks-example-job-definition"></a>

Mit der folgenden Jobdefinition in AWS Batch Amazon EKS werden Soft-vCPU-Shares konfiguriert. Dadurch kann AWS Batch Amazon EKS die gesamte vCPU-Kapazität für den Instance-Typ nutzen. Wenn jedoch andere Jobs ausgeführt werden, wird dem Job ein Maximum von `2` v CPUs zugewiesen. Der Arbeitsspeicher ist auf 2 GB begrenzt.

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "requests": {
                           "cpu": "2",
                           "memory": "2048Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Die folgende Auftragsdefinition in AWS Batch Amazon EKS hat einen `request` Wert von `1` und weist dem Auftrag ein Maximum von `4` v CPUs zu.

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "requests": {
                           "cpu": "1"
                       },
                       "limits": {
                           "cpu": "4",
                           "memory": "2048Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Die folgende Auftragsdefinition in AWS Batch Amazon EKS legt einen `limits` vCPU-Wert von `1` und einen `limits` Speicherwert von 1 GB fest.

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "limits": {
                           "cpu": "1",
                           "memory": "1024Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Wenn ein Job AWS Batch auf Amazon EKS in einen Amazon EKS-Pod AWS Batch übersetzt wird, wird der `limits` Wert in den `requests` Wert AWS Batch kopiert. Dies ist der Fall, wenn kein `requests` Wert angegeben ist. Wenn Sie die obige Beispiel-Jobdefinition einreichen, sieht der Pod wie `spec` folgt aus.

```
apiVersion: v1
kind: Pod
...
spec:
  ...
  containers:
    - command:
        - sleep
        - 60
      image: public.ecr.aws/amazonlinux/amazonlinux:2
      resources:
        limits:
          cpu: 1
          memory: 1024Mi
        requests:
          cpu: 1
          memory: 1024Mi
      ...
```

## CPU- und Speicherreservierungen für Knoten
<a name="memory-cpu-batch-eks-node-cpu-memory-reservations"></a>

AWS Batch stützt sich auf die Standardlogik der `bootstrap.sh` Datei für vCPU- und Speicherreservierungen. Weitere Informationen zur `bootstrap.sh` Datei finden Sie unter [bootstrap.sh](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh). Beachten Sie bei der Dimensionierung Ihrer vCPU- und Speicherressourcen die folgenden Beispiele.

**Anmerkung**  
Wenn keine Instances ausgeführt werden, können sich vCPU- und Speicherreservierungen zunächst auf die AWS Batch Skalierungslogik und die Entscheidungsfindung auswirken. AWS Batch Passt die anfänglichen Zuweisungen an, nachdem die Instanzen ausgeführt wurden.

## Beispiel: CPU-Reservierung eines Knotens
<a name="memory-cpu-batch-eks-node-cpu-reservations"></a>

Der CPU-Reservierungswert wird in Millikernen berechnet, wobei die Gesamtzahl der V verwendet wirdCPUs , die für die Instanz verfügbar sind.


| vCPU-Nummer | Prozentsatz reserviert | 
| --- | --- | 
| 1 | 6% | 
| 2 | 1% | 
| 3-4 | 0.5% | 
| 4 und höher | 0,25% | 

Unter Verwendung der vorherigen Werte ist Folgendes wahr:
+ Der CPU-Reservierungswert für eine `c5.large` Instance mit 2 v CPUs ist 70 m. Dies wird auf folgende Weise berechnet: *(1\$160) \$1 (1\$110)* = 70 m.
+ Der CPU-Reservierungswert für eine `c5.24xlarge` Instanz mit 96 v beträgt 310 m. CPUs Dies wird auf folgende Weise berechnet: (1\$160) \$1 (1\$110) \$1 (2\$15) \$1 (92\$12,5) = 310 m.

In diesem Beispiel stehen 1930 (berechnete 2000-70) Millicore-vCPU-Einheiten zur Ausführung von Jobs auf einer Instance zur Verfügung. `c5.large` Angenommen, Ihr Job erfordert `2` (2\$11000 m) vCPU-Einheiten, der Job passt nicht auf eine einzelne Instanz. `c5.large` Ein Job, der `1.75` vCPU-Einheiten erfordert, passt jedoch.

## Beispiel: Speicherreservierung für Knoten
<a name="memory-cpu-batch-eks-node-memory-reservations"></a>

Der Wert für die Speicherreservierung wird wie folgt in Mebibyte berechnet:
+ Die Instanzkapazität in Mebibyte. Eine 8-GB-Instance ist beispielsweise 7.748. MiB
+ Der `kubeReserved` Wert. Der `kubeReserved` Wert ist die Speichermenge, die für System-Daemons reserviert werden soll. Der `kubeReserved` Wert wird auf folgende Weise berechnet: *((11 \$1 maximale Anzahl von Pods, die vom Instance-Typ unterstützt wird) \$1 255)*. Informationen zur maximalen Anzahl von Pods, die von einem Instance-Typ unterstützt werden, finden Sie unter [eni-max-pods.txt](https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/eni-max-pods.txt) 
+ Der `HardEvictionLimit` Wert. Wenn der verfügbare Speicher unter den `HardEvictionLimit` Wert fällt, versucht die Instance, Pods zu entfernen.

Die Formel zur Berechnung des zuweisbaren Speichers lautet wie folgt: (*instance\$1capacity\$1in\$1MiB*) - (11 \$1 (*maximum\$1number\$1of\$1pods*)) - 255 - ()). *`HardEvictionLimit` value.*

 Eine `c5.large` Instanz unterstützt bis zu 29 Pods. Für eine `c5.large` 8-GB-Instance mit einem `HardEvictionLimit` Wert von 100 MiB beträgt der zuweisbare Speicher 7074. MiB Dies wird wie folgt berechnet: *(7748 - (11 \$1 29) -255 -100) =* 7074 MiB. In diesem Beispiel passt ein 8.192 MiB Job nicht auf diese Instanz, obwohl es sich um eine 8 () -Instanz handelt. gibibyte GiB

## DaemonSets
<a name="memory-cpu-batch-eks-reservations-daemonset-scaling"></a>

Beachten Sie bei der Verwendung DaemonSets Folgendes:
+ Wenn AWS Batch auf Amazon EKS keine Instances ausgeführt werden, DaemonSets kann dies zunächst Auswirkungen auf die AWS Batch Skalierungslogik und die Entscheidungsfindung haben. AWS Batch weist zunächst 0,5 vCPU-Einheiten und 500 MiB für die erwarteten Werte zu. DaemonSets AWS Batch Passt die anfänglichen Zuweisungen an, nachdem die Instanzen ausgeführt wurden.
+ Wenn a vCPU- oder Speicherlimits DaemonSet definiert, haben Jobs AWS Batch auf Amazon EKS weniger Ressourcen. Wir empfehlen, die Anzahl der Aufträge, die AWS Batch Jobs zugewiesen sindDaemonSets, so gering wie möglich zu halten.