

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

# Gestione della memoria delle risorse di calcolo
<a name="memory-management"></a>

Quando l'agente container Amazon ECS registra una risorsa di calcolo in un ambiente di elaborazione, deve determinare la quantità di memoria disponibile per la risorsa di elaborazione da riservare per i tuoi lavori. A causa del sovraccarico di memoria della piattaforma e della memoria occupata dal kernel di sistema, questo numero è diverso dalla quantità di memoria installata per le istanze Amazon EC2 . Ad esempio, un'istanza `m4.large` dispone di 8 GiB di memoria installata. Tuttavia, ciò non sempre si traduce in esattamente 8192 MiB di memoria disponibili per i lavori quando la risorsa di elaborazione viene registrata.

Si supponga di specificare 8192 MiB per il job e che nessuna delle risorse di elaborazione disponga di 8192 MiB o più di memoria disponibile per soddisfare questo requisito. Quindi, il lavoro non può essere inserito nel tuo ambiente di elaborazione. Se utilizzi un ambiente di elaborazione gestito, AWS Batch devi avviare un tipo di istanza più grande per soddisfare la richiesta.

L'AMI di risorse di AWS Batch calcolo predefinita riserva inoltre 32 MiB di memoria per l'agente container Amazon ECS e altri processi di sistema critici. Questa memoria non è disponibile per l'allocazione dei lavori. Per ulteriori informazioni, consulta [Memoria di sistema di riserva](ecs-reserved-memory.md).

L'agente del container di Amazon ECS utilizza la funzione Docker `ReadMemInfo()` per eseguire una query sulla memoria totale disponibile per il sistema operativo. Linux fornisce utilità da riga di comando per determinare la memoria totale.

**Example - Determinare la memoria totale in Linux**  
Il **free** comando restituisce la memoria totale riconosciuta dal sistema operativo.  

```
$ free -b
```
Di seguito è riportato un esempio di output per un'`m4.large`istanza che esegue l'AMI Amazon Linux ottimizzata per Amazon ECS.  

```
             total       used       free     shared    buffers     cached
Mem:    8373026816  348180480 8024846336      90112   25534464  205418496
-/+ buffers/cache:  117227520 8255799296
```
Questa istanza ha 8373026816 byte di memoria totale. Ciò significa che sono disponibili 7985 MiB per le attività.

**Topics**
+ [

# Memoria di sistema di riserva
](ecs-reserved-memory.md)
+ [

# Tutorial: Visualizza la memoria delle risorse di calcolo
](viewing-memory.md)
+ [

# Considerazioni su AWS Batch memoria e vCPU per Amazon EKS
](memory-cpu-batch-eks.md)

# Memoria di sistema di riserva
<a name="ecs-reserved-memory"></a>

Se si occupa tutta la memoria di una risorsa di elaborazione con i propri lavori, è possibile che tali processi abbiano a che fare con processi di sistema critici per la memoria e che possano causare un errore di sistema. L'agente container Amazon ECS fornisce una variabile di configurazione `ECS_RESERVED_MEMORY` denominata. Puoi usare questa variabile di configurazione per rimuovere un numero specifico di MiB di memoria dal pool allocato ai tuoi lavori. In questo modo si riserva la memoria per i processi di sistema critici.

L'AMI della risorsa di AWS Batch calcolo predefinita riserva 32 MiB di memoria per l'agente container Amazon ECS e altri processi di sistema critici. Consigliamo di riservare un buffer di memoria del 5% per l'agente container Amazon ECS e altri processi di sistema critici.

# Tutorial: Visualizza la memoria delle risorse di calcolo
<a name="viewing-memory"></a>

Puoi visualizzare la quantità di memoria con cui viene registrata una risorsa di calcolo nella console Amazon ECS o con il funzionamento dell'[DescribeContainerInstances](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html)API. Se stai cercando di massimizzare l'utilizzo delle risorse fornendo ai tuoi job quanta più memoria possibile per un particolare tipo di istanza, puoi osservare la memoria disponibile per quella risorsa di elaborazione e quindi assegnare ai job quella quantità di memoria.

**Per visualizzare la memoria delle risorse di calcolo**

1. Apri la console alla [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Scegli **Cluster**, quindi scegli il cluster che ospita le risorse di elaborazione da visualizzare.

   Il nome del cluster dell'ambiente di calcolo inizia con il nome dell'ambiente di calcolo.

1. **Scegli Infrastruttura.**

1. In **Istanze di container**, scegli l'istanza del contenitore.

1. La sezione **Risorse e reti** mostra la memoria registrata e disponibile per la risorsa di calcolo.

   Il valore di memoria **della capacità totale** è quello che la risorsa di elaborazione ha registrato con Amazon ECS al momento del primo avvio, mentre il valore di memoria **disponibile** è quello che non è già stato allocato ai lavori.

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