

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 vCPU für AWS Batch auf 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 unsere `limits` Werte für vCPU `requests` - und Speicherressourcen angeben.

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 im MilliCPU-Format 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) stehen.
+ 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 AWS Batch Amazon EKS-Jobdefinition 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 an `2` vCPUs 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 Jobdefinition in AWS Batch Amazon EKS hat den `request` Wert von `1` und weist dem Job ein Maximum an `4` vCPUs 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 Jobdefinition AWS Batch auf Amazon EKS legt einen `limits` vCPU-Wert von 1 GB `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"
                       }
                   }
               }
           ]
       }
   }
}
```

Bei der AWS Batch Übersetzung eines AWS Batch Amazon EKS-Jobs in einen Amazon EKS-Pod wird der Wert in den `limits` `requests` Wert AWS Batch kopiert. Dies ist der Fall, wenn kein `requests` Wert angegeben ist. Wenn Sie die vorhergehende 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/al2/templates/al2/runtime/bootstrap.sh). Beachten Sie bei der Dimensionierung Ihrer vCPU- und Speicherressourcen die folgenden Beispiele.

**Anmerkung**  
Wenn keine Instanzen 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 werden.

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

Der CPU-Reservierungswert wird in Millikernen anhand der Gesamtzahl der vCPUs berechnet, die für die Instance verfügbar sind.


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

Bei Verwendung der vorstehenden Werte gilt Folgendes:
+ Der CPU-Reservierungswert für eine `c5.large` Instanz mit 2 vCPUs beträgt 70 m. Dies wird auf folgende Weise berechnet: * (1\*60) \+ (1\*10) = 70 m. *
+ Der CPU-Reservierungswert für eine `c5.24xlarge` Instanz mit 96 vCPUs beträgt 310 m. Dies wird auf folgende Weise berechnet: (1\*60) \+ (1\*10) \+ (2\*5) \+ (92\*2,5) = 310 m.

In diesem Beispiel stehen 1930 (berechnete 2000-70) Millicore-vCPU-Einheiten zur Verfügung, um Jobs auf einer Instance auszuführen. `c5.large` Angenommen, Ihr Job erfordert `2` (2\*1000 m) vCPU-Einheiten, der Job passt nicht auf eine einzelne Instance. `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 Speicherreservierungswert wird wie folgt in Mebibyte berechnet:
+ Die Instanzkapazität in Mebibyte. Eine 8-GB-Instanz ist beispielsweise 7.748. MiB
+ Der `kubeReserved` Wert. Der `kubeReserved` Wert ist die Speichermenge, die für Systemdaemons reserviert werden soll. Der `kubeReserved` Wert wird auf folgende Weise berechnet: * ((11 \* maximale Anzahl von Pods, die vom Instanztyp unterstützt werden) \+ 255). * Informationen zur maximalen Anzahl von Pods, die von einem Instanztyp unterstützt werden, finden Sie unter [ instance-info.jsonl ](https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/instance-info.jsonl) 
+ `HardEvictionLimit`Der Wert. Wenn der verfügbare Speicher unter den `HardEvictionLimit` Wert fällt, versucht die Instanz, Pods zu löschen.

Die Formel zur Berechnung des zuweisbaren Speichers lautet wie folgt: ({{instance\_capacity\_in\_MiB}}) - (11 \* ({{maximum\_number\_of\_pods}})) - 255 - ()). {{`HardEvictionLimit` value.}}

 Eine `c5.large` Instance 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 auf folgende Weise berechnet: * (7748 - (11 \* 29) -255 -100) = 7074 MiB. * In diesem Beispiel passt ein MiB 8.192-Job nicht in 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 keine AWS Batch Amazon EKS-Instances ausgeführt werden, DaemonSets kann sich dies zunächst auf die AWS Batch Skalierungslogik und die Entscheidungsfindung auswirken. AWS Batch weist zunächst 0,5 vCPU-Einheiten und 500 MiB für den erwarteten Wert zu. DaemonSets AWS Batch Passt die anfänglichen Zuweisungen an, nachdem die Instanzen ausgeführt werden.
+ Wenn a vCPU- oder Speichergrenzwerte DaemonSet definiert, stehen bei AWS Batch Amazon EKS-Jobs weniger Ressourcen zur Verfügung. Wir empfehlen, die Anzahl der Jobs, die AWS Batch Jobs zugewiesen werdenDaemonSets, so gering wie möglich zu halten.