

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Considérations relatives à la mémoire et au vCPU pour AWS Batch Amazon EKS
<a name="memory-cpu-batch-eks"></a>

 AWS Batch Sur Amazon EKS, vous pouvez spécifier les ressources mises à la disposition d'un conteneur. Par exemple, vous pouvez spécifier `requests` des `limits` valeurs pour le vCPU et les ressources de mémoire.

Les contraintes suivantes s'appliquent à la spécification des ressources vCPU :
+ Au moins un vCPU `requests` ou une `limits` valeur doivent être spécifiés.
+ Une unité vCPU est équivalente à un cœur physique ou virtuel. 
+ La valeur du vCPU doit être saisie en nombres entiers ou par incréments de 0,25. 
+ La plus petite valeur de vCPU valide est 0,25.
+ Si les deux sont spécifiés, la `requests` valeur doit être inférieure ou égale à la `limits` valeur. De cette façon, vous pouvez configurer des configurations de vCPU souples et matérielles.
+ Les valeurs du vCPU ne peuvent pas être spécifiées sous forme MilliCPU. Par exemple, `100m` n'est pas une valeur valide.
+ AWS Batch utilise la `requests` valeur pour dimensionner les décisions. Si aucune `requests` valeur n'est spécifiée, elle est copiée dans la `requests` valeur. `limits`

Les contraintes suivantes s'appliquent à la spécification des ressources de mémoire :
+ Au moins une mémoire `requests` ou une `limits` valeur doit être spécifiée.
+ Les valeurs de mémoire doivent être comprises mebibytes entre (MiBs).
+ Si les deux sont spécifiés, la `requests` valeur doit être égale à la `limits` valeur.
+ AWS Batch utilise la `requests` valeur pour dimensionner les décisions. Si aucune `requests` valeur n'est spécifiée, elle est copiée dans la `requests` valeur. `limits`

Les contraintes suivantes s'appliquent à la spécification des ressources GPU :
+ Si les deux sont spécifiés, la `requests` valeur doit être égale à la `limits` valeur.
+ AWS Batch utilise la `requests` valeur pour dimensionner les décisions. Si aucune `requests` valeur n'est spécifiée, elle est copiée dans la `requests` valeur. `limits`

## Exemple : définitions de tâches
<a name="memory-cpu-batch-eks-example-job-definition"></a>

La section suivante de AWS Batch la définition de tâche Amazon EKS configure les partages de vCPU souples. Cela permet AWS Batch à Amazon EKS d'utiliser toute la capacité du vCPU pour le type d'instance. Toutefois, si d'autres tâches sont en cours d'exécution, une valeur maximale de `2` v est attribuée à la tâcheCPUs. La mémoire est limitée à 2 Go.

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

La définition de tâche suivante AWS Batch sur Amazon EKS a une `request` valeur de `1` et alloue un maximum de `4` v CPUs à la tâche.

```
{
   "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"
                       }
                   }
               }
           ]
       }
   }
}
```

La définition AWS Batch de tâche Amazon EKS ci-dessous définit une valeur de vCPU `1` et une `limits` valeur de mémoire `limits` de 1 Go.

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

Lorsque vous AWS Batch traduisez une tâche AWS Batch sur Amazon EKS en un module Amazon EKS, AWS Batch copie la `limits` valeur dans la `requests` valeur. C'est le cas si `requests` aucune valeur n'est spécifiée. Lorsque vous soumettez l'exemple de définition de tâche précédent, le module `spec` est le suivant.

```
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
      ...
```

## Réservations de processeur et de mémoire pour les nœuds
<a name="memory-cpu-batch-eks-node-cpu-memory-reservations"></a>

AWS Batch repose sur la logique par défaut du `bootstrap.sh` fichier pour les réservations de vCPU et de mémoire. Pour plus d'informations sur le `bootstrap.sh` fichier, consultez le fichier [bootstrap.sh](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh). Lorsque vous dimensionnez vos ressources de vCPU et de mémoire, considérez les exemples suivants.

**Note**  
Si aucune instance n'est en cours d'exécution, les réservations de vCPU et de mémoire peuvent initialement affecter la logique de AWS Batch dimensionnement et la prise de décision. Une fois les instances en cours d'exécution, AWS Batch ajuste les allocations initiales.

## Exemple : réservation du processeur d'un nœud
<a name="memory-cpu-batch-eks-node-cpu-reservations"></a>

La valeur de réservation du processeur est calculée en millicores en utilisant le nombre total de v CPUs disponibles pour l'instance.


| Numéro de vCPU | Pourcentage réservé | 
| --- | --- | 
| 1 | 6 % | 
| 2 | 1 % | 
| 3-4 | 0.5% | 
| 4 et plus | 0,25 % | 

Sur la base des valeurs précédentes, ce qui suit est vrai :
+ La valeur de réservation du processeur pour une `c5.large` instance de 2 V CPUs est de 70 m. Ceci est calculé de la manière suivante : *(1\$160) \$1 (1\$110)* = 70 m.
+ La valeur de réservation du processeur pour une `c5.24xlarge` instance de 96 v CPUs est de 310 m. Ceci est calculé de la manière suivante : (1\$160) \$1 (1\$110) \$1 (2\$15) \$1 (92\$12,5) = 310 m.

Dans cet exemple, 1930 unités de vCPU millicore (calculées entre 2000 et 70) sont disponibles pour exécuter des tâches sur une instance. `c5.large` Supposons que votre tâche nécessite `2` (2 x 1 000 m) unités de vCPU, mais qu'elle ne convient pas à une seule instance. `c5.large` Cependant, une tâche qui nécessite des unités de `1.75` vCPU convient.

## Exemple : réservation de mémoire d'un nœud
<a name="memory-cpu-batch-eks-node-memory-reservations"></a>

La valeur de réservation de mémoire est calculée en mégaoctets à l'aide des méthodes suivantes :
+ Capacité de l'instance en mégaoctets. Par exemple, une instance de 8 Go vaut 7 748MiB.
+ La `kubeReserved` valeur. La `kubeReserved` valeur est la quantité de mémoire à réserver aux démons du système. La `kubeReserved` valeur est calculée de la manière suivante : *(((11 \$1 nombre maximum de pods pris en charge par le type d'instance) \$1 255)*. Pour plus d'informations sur le nombre maximal de pods pris en charge par un type d'instance, consultez [eni-max-pods.txt](https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/eni-max-pods.txt) 
+ La `HardEvictionLimit` valeur. Lorsque la mémoire disponible tombe en dessous de `HardEvictionLimit` cette valeur, l'instance tente d'expulser les pods.

La formule pour calculer la mémoire allouable est la suivante : (*instance\$1capacity\$1in\$1MiB*) - (11 \$1 (*maximum\$1number\$1of\$1pods*)) - 255 - (*`HardEvictionLimit` value.*)).

 Une `c5.large` instance prend en charge jusqu'à 29 pods. Pour une `c5.large` instance de 8 Go d'une `HardEvictionLimit` valeur de 100 Mo, la mémoire allouable est de 7074. MiB Ceci est calculé de la manière suivante : *(7748 - (11 \$1 29) -255 -100) = 7074* MiB. Dans cet exemple, une MiB tâche de 8 192 ne convient pas à cette instance même s'il s'agit d'une instance 8 gibibyte (GiB).

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

Lorsque vous l'utilisezDaemonSets, tenez compte des points suivants :
+ Si aucune AWS Batch instance Amazon EKS n'est en cours d'exécution, cela DaemonSets peut initialement affecter la logique de AWS Batch dimensionnement et la prise de décision. AWS Batch alloue initialement 0,5 unité de vCPU et 500 MiB comme prévu. DaemonSets Une fois les instances en cours d'exécution, AWS Batch ajuste les allocations initiales.
+ Si a DaemonSet définit des limites de vCPU ou de mémoire, les tâches AWS Batch Amazon EKS disposent de moins de ressources. Nous vous recommandons de limiter autant DaemonSets que possible le nombre de AWS Batch tâches assignées aux tâches.