Implementare un carico di lavoro accelerato - Amazon EKS

View a markdown version of this page

Implementare un carico di lavoro accelerato - Amazon EKS
PrerequisitiFase 1: Implementare un carico di lavoro GPUFase 2: ConvalidaFase 3: Clean-upEsempio di riferimento NodePools

Contribuisci a migliorare questa pagina

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

Per contribuire a questa guida per l'utente, scegli il GitHub link Modifica questa pagina su che si trova nel riquadro destro di ogni pagina.

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

Implementare un carico di lavoro accelerato

Questo tutorial dimostra come Amazon EKS Auto Mode semplifica l'avvio di carichi di lavoro con accelerazione hardware. Amazon EKS Auto Mode semplifica le operazioni che vanno oltre il cluster stesso automatizzando i componenti chiave dell'infrastruttura fornendo funzionalità di calcolo, rete, bilanciamento del carico, storage e gestione delle identità e degli accessi pronte all'uso.

Amazon EKS Auto Mode include i driver e i plug-in di dispositivo necessari per determinati tipi di istanze, come i driver NVIDIA e Neuron. AWS Non è necessario installare o aggiornare questi componenti.

modalità automatica di EKS gestisce automaticamente i driver per questi acceleratori:

Nota

La modalità automatica di EKS include il plug-in di dispositivo NVIDIA per Kubernetes. Questo plug-in viene eseguito automaticamente e non è visibile come daemon impostato nel cluster.

Supporto di reti avanzate:

La modalità automatica di Amazon EKS elimina la difficoltà della gestione dei driver dell’acceleratore e dei plug-in di dispositivo.

Puoi anche trarre vantaggio dai risparmi sui costi ridimensionando il cluster fino a zero. Puoi configurare modalità automatica di EKS per terminare le istanze quando non è in esecuzione alcun carico di lavoro. Ciò è utile per i carichi di lavoro di inferenza basati su batch.

Di seguito viene fornito un esempio di come avviare carichi di lavoro accelerati con la modalità automatica di Amazon EKS.

Prerequisiti

  • Un cluster Kubernetes con la modalità automatica di Amazon EKS configurata.

  • Una classe del nodo default EKS creata quando i pool di nodi gestiti da general-purpose o system sono abilitati.

Fase 1: Implementare un carico di lavoro GPU

In questo esempio, creerai un file NodePool per carichi di lavoro basati su NVIDIA che richiede 45 GB di memoria GPU. Con la modalità automatica di EKS, utilizzi i vincoli di pianificazione di Kubernetes per definire i requisiti delle istanze.

Per implementare Amazon EKS Auto Mode NodePool e l'esempioworkload, esamina quanto segue e la definizione del Pod NodePool e salva con nome e: nodepool-gpu.yaml pod.yaml

nodepool-gpu.yaml 

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: gpu
spec:
  disruption:
    budgets:
    - nodes: 10%
    consolidateAfter: 1h
    consolidationPolicy: WhenEmpty
  template:
    metadata: {}
    spec:
      nodeClassRef:
        group: eks.amazonaws.com
        kind: NodeClass
        name: default
      requirements:
        - key: "karpenter.sh/capacity-type"
          operator: In
          values: ["on-demand"]
        - key: "kubernetes.io/arch"
          operator: In
          values: ["amd64"]
        - key: "eks.amazonaws.com/instance-family"
          operator: In
          values:
          - g6e
          - g6
      taints:
        - key: nvidia.com/gpu
          effect: NoSchedule
      terminationGracePeriod: 24h0m0s

pod.yaml 

apiVersion: v1
kind: Pod
metadata:
  name: nvidia-smi
spec:
  nodeSelector:
    eks.amazonaws.com/compute-type: auto
  restartPolicy: OnFailure
  containers:
  - name: nvidia-smi
    image: public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
    args:
    - "nvidia-smi"
    resources:
      requests:
        memory: "30Gi"
        cpu: "3500m"
        nvidia.com/gpu: 1
      limits:
        memory: "30Gi"
        nvidia.com/gpu: 1
  tolerations:
  - key: nvidia.com/gpu
    effect: NoSchedule
    operator: Exists

Il selettore eks.amazonaws.com/compute-type: auto richiede che il carico di lavoro sia implementato su un nodo della modalità automatica di Amazon EKS. NodePool Inoltre, imposta un limite che consente di programmare solo pod con tolleranze per le GPU NVIDIA.

Applica il carico di lavoro NodePool and al tuo cluster.

kubectl apply -f nodepool-gpu.yaml
kubectl apply -f pod.yaml

Verrà visualizzato l’output seguente:

nodepool.karpenter.sh/gpu created
pod/nvidia-smi created

Attendi qualche secondo e controlla i nodi del cluster. Ora dovresti vedere un nuovo nodo fornito nel cluster della modalità automatica di Amazon EKS:

> kubectl get nodes

NAME        TYPE          CAPACITY    ZONE         NODE                  READY   AGE
gpu-dnknr   g6e.2xlarge   on-demand   us-west-2b   i-02315c7d7643cdee6   True    76s

Fase 2: Convalida

Puoi vedere Amazon EKS Auto Mode avviato a g6e.2xlarge anziché a g6.2xlarge poiché il carico di lavoro richiedeva un'istanza con un L40SGPU, in base ai seguenti vincoli di pianificazione Kubernetes:

...
  nodeSelector:
    eks.amazonaws.com/instance-gpu-name: l40s
...
    requests:
        memory: "30Gi"
        cpu: "3500m"
        nvidia.com/gpu: 1
      limits:
        memory: "30Gi"
        nvidia.com/gpu: 1

Ora, esamina i log del contenitore eseguendo il seguente comando:

kubectl logs nvidia-smi

Output di esempio:

+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 535.230.02             Driver Version: 535.230.02   CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  NVIDIA L40S                    On  | 00000000:30:00.0 Off |                    0 |
| N/A   27C    P8              23W / 350W |      0MiB / 46068MiB |      0%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+

+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|  No running processes found                                                           |
+---------------------------------------------------------------------------------------+

Puoi vedere che il container ha rilevato che è in esecuzione su un’istanza con una GPU NVIDIA e che non hai dovuto installare alcun driver di dispositivo, poiché questa è gestita dalla modalità automatica di Amazon EKS.

Fase 3: Clean-up

Per rimuovere tutti gli oggetti creati, usa kubectl per eliminare la distribuzione di esempio e NodePool quindi il nodo viene terminato:

kubectl delete -f nodepool-gpu.yaml
kubectl delete -f pod.yaml

Esempio di riferimento NodePools

Crea una NVIDIA NodePool

Quanto segue NodePool definisce:

  • Solo istanze di avvio della famiglia g6e e g6

  • Consolidare i nodi quando sono vuoti per 1 ora

    • Il valore di 1 ora per consolidateAfter supporta carichi di lavoro intensi e riduce l'abbandono dei nodi. Puoi eseguire l’ottimizzazione di consolidateAfter in base ai requisiti del carico di lavoro.

Esempio NodePool con famiglia di istanze GPU e consolidamento 

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: gpu
spec:
  disruption:
    budgets:
    - nodes: 10%
    consolidateAfter: 1h
    consolidationPolicy: WhenEmpty
  template:
    metadata: {}
    spec:
      nodeClassRef:
        group: eks.amazonaws.com
        kind: NodeClass
        name: default
      requirements:
        - key: "karpenter.sh/capacity-type"
          operator: In
          values: ["on-demand"]
        - key: "kubernetes.io/arch"
          operator: In
          values: ["amd64"]
        - key: "eks.amazonaws.com/instance-family"
          operator: In
          values:
          - g6e
          - g6
      terminationGracePeriod: 24h0m0s

Invece di impostare il, eks.amazonaws.com/instance-gpu-name potresti utilizzare eks.amazonaws.com/instance-family per specificare la famiglia di istanze. Per altre etichette note che influenzano la revisione della pianificazione, consultare Etichette supportate dalla modalità automatica di EKS.

Se hai requisiti di archiviazione specifici, puoi ottimizzare lo storage iops temporaneo dei nodi size e throughput crearne uno personalizzato NodeClass a cui fare riferimento nel. NodePool Scopri di più sulle opzioni configurabili NodeClass .

Esempio di configurazione di archiviazione per NodeClass 

apiVersion: eks.amazonaws.com/v1
kind: NodeClass
metadata:
  name: gpu
spec:
  ephemeralStorage:
    iops: 3000
    size: 80Gi
    throughput: 125

Definire un AWS Trainium e AWS Inferentia NodePool

Quanto segue NodePool contiene un eks.amazonaws.com/instance-category set che dice, avvia solo le istanze della famiglia Inferentia e Trainium:

        - key: "eks.amazonaws.com/instance-category"
          operator: In
          values:
            - inf
            - trn