

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Considerazioni su AWS Batch memoria e vCPU per Amazon EKS
<a name="memory-cpu-batch-eks"></a>

In AWS Batch Amazon EKS, puoi specificare le risorse messe a disposizione di un contenitore. Ad esempio, è possibile specificare `requests` o `limits` valori per vCPU e risorse di memoria.

Di seguito sono riportati i vincoli per specificare le risorse vCPU:
+ È necessario specificare almeno una vCPU `requests` o `limits` un valore.
+ Un'unità vCPU equivale a un core fisico o virtuale. 
+ Il valore vCPU deve essere immesso in numeri interi o in incrementi di 0,25. 
+ Il valore vCPU più piccolo valido è 0,25.
+ Se vengono specificati entrambi, il `requests` valore deve essere inferiore o uguale al `limits` valore. In questo modo, è possibile configurare configurazioni vCPU sia soft che hard.
+ I valori vCPU non possono essere specificati nel formato MilliCPU. Ad esempio, `100m` non è un valore valido.
+ AWS Batch utilizza il `requests` valore per ridimensionare le decisioni. Se non `requests` viene specificato un valore, il `limits` valore viene copiato nel `requests` valore.

Di seguito sono riportati i vincoli per specificare le risorse di memoria:
+ È necessario specificare almeno una memoria `requests` o un `limits` valore.
+ I valori di memoria devono essere in mebibytes (MiBs).
+ Se vengono specificati entrambi, il `requests` valore deve essere uguale al `limits` valore.
+ AWS Batch utilizza il `requests` valore per ridimensionare le decisioni. Se non viene specificato un `requests` valore, il `limits` valore viene copiato nel `requests` valore.

Di seguito sono riportati i vincoli per specificare le risorse GPU:
+ Se vengono specificati entrambi, il `requests` valore deve essere uguale al valore. `limits`
+ AWS Batch utilizza il `requests` valore per ridimensionare le decisioni. Se non `requests` viene specificato un valore, il `limits` valore viene copiato nel `requests` valore.

## Esempio: definizioni delle mansioni
<a name="memory-cpu-batch-eks-example-job-definition"></a>

Quanto segue AWS Batch su Amazon EKS Job Definition configura le condivisioni soft vCPU. Ciò consente ad AWS Batch Amazon EKS di utilizzare tutta la capacità vCPU per il tipo di istanza. Tuttavia, se ci sono altri job in esecuzione, al job viene assegnato un massimo di `2` v. CPUs La memoria è limitata a 2 GB.

```
{
   "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 seguente definizione di processo AWS Batch su Amazon EKS ha un `request` valore `1` e assegna un massimo di `4` v CPUs al lavoro.

```
{
   "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 seguente definizione del processo AWS Batch su Amazon EKS imposta un valore vCPU `1` e un `limits` valore di memoria `limits` di 1 GB.

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

Quando AWS Batch traduce un lavoro AWS Batch su Amazon EKS in un pod Amazon EKS, AWS Batch copia il `limits` valore nel `requests` valore. Questo è se non viene specificato un `requests` valore. Quando inviate la definizione di lavoro di esempio precedente, il contenitore `spec` è il seguente.

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

## Nodo, CPU e prenotazioni di memoria
<a name="memory-cpu-batch-eks-node-cpu-memory-reservations"></a>

AWS Batch si basa sulla logica predefinita del `bootstrap.sh` file per le prenotazioni di vCPU e memoria. [Per ulteriori informazioni sul `bootstrap.sh` file, vedere bootstrap.sh.](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh) Per quanto riguarda le dimensioni della vCPU e delle risorse di memoria, considera gli esempi seguenti.

**Nota**  
Se nessuna istanza è in esecuzione, le prenotazioni di vCPU e memoria possono inizialmente AWS Batch influire sulla logica di scalabilità e sul processo decisionale. Dopo l'esecuzione delle istanze, AWS Batch regola le allocazioni iniziali.

## Esempio: prenotazione della CPU del nodo
<a name="memory-cpu-batch-eks-node-cpu-reservations"></a>

Il valore di prenotazione della CPU viene calcolato in millicore utilizzando il numero totale di v CPUs disponibili per l'istanza.


| Numero vCPU | Percentuale riservata | 
| --- | --- | 
| 1 | 6% | 
| 2 | 1% | 
| 3-4 | 0,5% | 
| 4 e versioni successive | 0,25% | 

Utilizzando i valori precedenti, è vero quanto segue:
+ Il valore di prenotazione della CPU per un'`c5.large`istanza con 2 v CPUs è 70 m. Viene calcolato nel modo seguente: *(1\$160) \$1 (1\$110)* = 70 m.
+ Il valore di riserva della CPU per un'`c5.24xlarge`istanza con 96 v CPUs è 310 m. Viene calcolato nel modo seguente: (1\$160) \$1 (1\$110) \$1 (2\$15) \$1 (92\$12,5) = 310 m.

In questo esempio, sono disponibili 1930 unità vCPU millicore (calcolate 2000-70) per eseguire processi su un'istanza. `c5.large` Supponiamo che il processo richieda `2` (2\$11000 m) unità vCPU, il processo non si adatta a una singola istanza. `c5.large` Tuttavia, un lavoro che richiede unità `1.75` vCPU è adatto.

## Esempio: prenotazione della memoria del nodo
<a name="memory-cpu-batch-eks-node-memory-reservations"></a>

Il valore di prenotazione della memoria viene calcolato in mebibyte utilizzando quanto segue:
+ La capacità dell'istanza in mebibyte. Ad esempio, un'istanza da 8 GB è pari a 7.748. MiB
+ Il `kubeReserved` valore. Il `kubeReserved` valore è la quantità di memoria da riservare ai demoni di sistema. Il `kubeReserved` valore viene calcolato nel modo seguente: *((11 \$1 numero massimo di pod supportato dal tipo di istanza) \$1 255)*. [Per informazioni sul numero massimo di pod supportato da un tipo di istanza, consulta .txt eni-max-pods](https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/eni-max-pods.txt) 
+ Il valore. `HardEvictionLimit` Quando la memoria disponibile scende al di sotto del `HardEvictionLimit` valore, l'istanza tenta di eliminare i pod.

La formula per calcolare la memoria allocabile è la seguente: (*instance\$1capacity\$1in\$1MiB*) - (11 \$1 ()) - 255 - (*maximum\$1number\$1of\$1pods*)). *`HardEvictionLimit` value.*

 Un'`c5.large`istanza supporta fino a 29 pod. Per un'`c5.large`istanza da 8 GB con un `HardEvictionLimit` valore di 100 MiB, la memoria allocabile è 7074. MiB Viene calcolato nel modo seguente: *(7748 - (11 \$1 29) -255 -100) = 7074* MiB. In questo esempio, un MiB job di 8.192 non rientra in questa istanza anche se si tratta di un'istanza 8 (). gibibyte GiB

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

Quando si utilizzaDaemonSets, si consideri quanto segue:
+ Se nessuna istanza di AWS Batch Amazon EKS è in esecuzione, DaemonSets può inizialmente influire sulla logica di AWS Batch scalabilità e sul processo decisionale. AWS Batch inizialmente alloca 0,5 unità vCPU e 500 MiB come previsto. DaemonSets Dopo l'esecuzione delle istanze, AWS Batch regola le allocazioni iniziali.
+ Se a DaemonSet definisce limiti di vCPU o memoria, AWS Batch su Amazon EKS i job hanno meno risorse. Ti consigliamo di mantenere il numero DaemonSets di AWS Batch lavori assegnati al più basso possibile.