

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.

# Speicherverwaltung für Rechenressourcen
<a name="memory-management"></a>

Wenn der Amazon ECS-Container-Agent eine Rechenressource in einer Rechenumgebung registriert, muss der Agent ermitteln, wie viel Speicher die Rechenressource zur Verfügung hat, um sie für Ihre Jobs zu reservieren. Aufgrund des Mehraufwands des Plattformspeichers und des vom Systemkernel belegten Speichers unterscheidet sich diese Zahl von der installierten Speichermenge für EC2 Amazon-Instances. Eine `m4.large`-Instance beispielsweise besitzt 8 GiB installierten Speicher. Dies entspricht jedoch nicht immer genau 8192 MiB Arbeitsspeicher, der für Jobs verfügbar ist, wenn die Rechenressource registriert wird.

Angenommen, Sie geben 8192 MiB für den Job an und für keine Ihrer Rechenressourcen stehen 8192 MiB oder mehr Arbeitsspeicher zur Verfügung, um diese Anforderung zu erfüllen. Dann kann der Job nicht in Ihrer Computerumgebung platziert werden. Wenn Sie eine verwaltete Rechenumgebung verwenden, AWS Batch müssen Sie einen größeren Instanztyp starten, um der Anfrage gerecht zu werden.

Das AWS Batch Standard-Rechenressourcen-AMI reserviert außerdem 32 MiB Speicher für den Amazon ECS-Container-Agenten und andere kritische Systemprozesse. Dieser Speicher ist für die Auftragszuweisung nicht verfügbar. Weitere Informationen finden Sie unter [Systemspeicher reservieren](ecs-reserved-memory.md).

Der Amazon-ECS-Container-Agent verwendet die Docker-Funktion `ReadMemInfo()` für die Abfrage des gesamten für das Betriebssystem verfügbaren Arbeitsspeichers. Linux stellt Befehlszeilenprogramme zur Verfügung, mit denen der Gesamtspeicher ermittelt werden kann.

**Example – Bestimmung des Gesamtspeichers für Linux**  
Der **free** Befehl gibt den Gesamtspeicher zurück, der vom Betriebssystem erkannt wird.  

```
$ free -b
```
Im Folgenden finden Sie eine Beispielausgabe für eine `m4.large` Instance, auf der das Amazon ECS-optimierte Amazon Linux AMI ausgeführt wird.  

```
             total       used       free     shared    buffers     cached
Mem:    8373026816  348180480 8024846336      90112   25534464  205418496
-/+ buffers/cache:  117227520 8255799296
```
Diese Instance verfügt über einen Gesamtspeicher von 8373026816 Byte. Das bedeutet, dass 7985 MiB für Aufgaben zur Verfügung stehen.

**Topics**
+ [Systemspeicher reservieren](ecs-reserved-memory.md)
+ [Tutorial: Rechenressourcenspeicher anzeigen](viewing-memory.md)
+ [Überlegungen zu Arbeitsspeicher und vCPUs für AWS Batch Amazon EKS](memory-cpu-batch-eks.md)

# Systemspeicher reservieren
<a name="ecs-reserved-memory"></a>

Wenn Sie mit Ihren Jobs den gesamten Arbeitsspeicher einer Rechenressource belegen, ist es möglich, dass Ihre Jobs mit kritischen Systemprozessen in Bezug auf den Arbeitsspeicher zu kämpfen haben und möglicherweise zu einem Systemausfall führen. Der Amazon ECS-Container-Agent stellt eine Konfigurationsvariable bereit, die aufgerufen wird`ECS_RESERVED_MEMORY`. Sie können diese Konfigurationsvariable verwenden, um eine bestimmte Anzahl von MiB Speicher aus dem Pool zu entfernen, der Ihren Jobs zugewiesen ist. Damit wird dieser Arbeitsspeicher für wichtige Systemprozesse reserviert.

Das AWS Batch Standard-Rechenressourcen-AMI reserviert 32 MiB Arbeitsspeicher für den Amazon ECS-Container-Agenten und andere kritische Systemprozesse. Wir empfehlen, einen Speicherpuffer von 5% für den Amazon ECS-Container-Agenten und andere kritische Systemprozesse zu reservieren.

# Tutorial: Rechenressourcenspeicher anzeigen
<a name="viewing-memory"></a>

Sie können in der Amazon ECS-Konsole oder bei der [DescribeContainerInstances](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html)API-Operation sehen, mit wie viel Speicher sich eine Rechenressource registriert. Wenn Sie versuchen, Ihre Ressourcennutzung zu maximieren, indem Sie Ihren Jobs so viel Speicher wie möglich für einen bestimmten Instance-Typ zur Verfügung stellen, können Sie den für diese Rechenressource verfügbaren Speicher beobachten und Ihren Jobs dann so viel Speicher zuweisen.

**Um den Arbeitsspeicher der Rechenressource anzuzeigen**

1. Öffnen Sie die Konsole auf [https://console.aws.amazon.com/ecs/Version](https://console.aws.amazon.com/ecs/v2) 2.

1. Wählen Sie **Cluster** und dann den Cluster aus, der Ihre anzuzeigenden Rechenressourcen hostet.

   Der Cluster-Name für Ihre Computing-Umgebung beginnt mit dem Namen Ihrer Computing-Umgebung.

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

1. Wählen Sie unter **Container-Instances** die Container-Instance aus.

1. Im Abschnitt **Ressourcen und Netzwerke** wird der registrierte und verfügbare Speicher für die Rechenressource angezeigt.

   Der Speicherwert für die **Gesamtkapazität** ist der Wert, den die Rechenressource bei Amazon ECS registriert hat, als sie zum ersten Mal gestartet wurde, und der Wert für **verfügbaren** Speicher ist der Wert, der noch keinen Aufträgen zugewiesen wurde.

# Ü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.