

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 sulla memoria e sulla vCPU per AWS Batch su Amazon EKS
<a name="memory-cpu-batch-eks"></a>

In AWS Batch Amazon EKS, puoi specificare le risorse rese disponibili per un container. Ad esempio, puoi specificare `limits` valori `requests` per vCPU e risorse di memoria.

Di seguito sono riportati i vincoli per specificare le risorse vCPU:
+ È necessario specificare almeno una vCPU `requests` o un `limits` valore.
+ Un'unità vCPU equivale a un core fisico o virtuale. 
+ Il valore della vCPU deve essere immesso in numeri interi o con incrementi di 0,25. 
+ Il valore vCPU valido più piccolo è 0,25.
+ Se vengono specificati entrambi, il `requests` valore deve essere minore o uguale al `limits` valore. In questo modo, è possibile configurare configurazioni vCPU sia soft che hard.
+ I valori di vCPU non possono essere specificati nel formato MilliCPU. Ad esempio, `100m` non è un valore valido.
+ AWS Batch utilizza il `requests` valore per scalare 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 di memoria:
+ È necessario specificare almeno una memoria `requests` o `limits` un valore.
+ I valori di memoria devono essere espressi 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 viene specificato un `requests` 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 sulla definizione dei job di Amazon EKS configura le condivisioni soft vCPU. Ciò consente ad AWS Batch Amazon EKS di utilizzare tutta la capacità della vCPU per il tipo di istanza. Tuttavia, se sono in esecuzione altri job, al job viene assegnato un massimo di `2` vCPU. 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 AWS Batch definizione del job di Amazon EKS ha un `request` valore di `1` e assegna un massimo di `4` vCPU al job.

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

Quanto segue AWS Batch sulla definizione del job di Amazon EKS imposta un valore di 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 job AWS Batch su Amazon EKS in un pod Amazon EKS, AWS Batch copia il `limits` valore nel valore. `requests` Questo è se non è specificato un `requests` valore. Quando invii la precedente definizione di lavoro di esempio, 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
      ...
```

## Prenotazioni di CPU e memoria del nodo
<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/al2/templates/al2/runtime/bootstrap.sh) Quando dimensionate la vCPU e le risorse di memoria, considerate gli esempi che seguono.

**Nota**  
Se nessuna istanza è in esecuzione, le prenotazioni di vCPU e memoria possono inizialmente influire sulla logica di AWS Batch scalabilità e sul processo decisionale. Dopo l'esecuzione delle istanze, AWS Batch modifica 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 vCPU 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 vCPU è 70 m. Viene calcolato nel modo seguente: * (1\*60) \+ (1\*10) = 70 m. *
+ Il valore di prenotazione della CPU per un'`c5.24xlarge`istanza con 96 vCPU è 310 m. Viene calcolato nel modo seguente: (1\*60) \+ (1\*10) \+ (2\*5) \+ (92\*2.5) = 310 m.

In questo esempio, sono disponibili 1930 unità vCPU millicore (calcolate 2000-70) per eseguire job su un'istanza. `c5.large` Supponiamo che il lavoro richieda `2` (2\*1000 m) unità vCPU, che non rientri in una singola istanza. `c5.large` Tuttavia, un lavoro che richiede `1.75` unità 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 è 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 \* numero massimo di pod supportati dal tipo di istanza) \+ 255). * Per informazioni sul numero massimo di pod supportati da un tipo di istanza, vedi instance-info.jsonl [https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/instance-info.jsonl](https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/instance-info.jsonl) 
+ 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\_capacity\_in\_MiB}}) - (11 \* ()) - 255 - ({{maximum\_number\_of\_pods}})). {{`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 \* 29) -255 -100) = 7074 MiB. * In questo esempio, un MiB processo 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 lo usiDaemonSets, considera quanto segue:
+ Se nessuna istanza AWS Batch su 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 modifica 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 di DaemonSets quelli assegnati ai AWS Batch job il più basso possibile.