Implementar uma workload acelerada - Amazon EKS
Pré-requisitosEtapa 1: implantar uma workload de GPUEtapa 2: validarEtapa 3: limparExemplo de referência de NodePools

Ajudar a melhorar esta página

Para contribuir com este guia de usuário, escolha o link Editar esta página no GitHub, disponível no painel direito de cada página.

Implementar uma workload acelerada

Este tutorial demonstra como o Modo Automático do Amazon EKS simplifica a execução de workloads aceleradas. O Modo Automático do Amazon EKS simplifica as operações além do próprio cluster, automatizando os principais componentes da infraestrutura e fornecendo recursos de computação, rede, balanceamento de carga, armazenamento e do Identity and Access Management prontos para uso.

O Modo Automático do Amazon EKS inclui os drivers e plug-ins de dispositivos necessários para determinados tipos de instância, como drivers NVIDIA e AWS Neuron. Você não precisa instalar ou atualizar esses componentes.

O Modo Automático do EKS gerencia automaticamente os drivers destes aceleradores:

nota

O Modo Automático do EKS inclui o plug-in de dispositivo NVIDIA para o Kubernetes. Esse plug-in é executado automaticamente e não fica visível como um conjunto de daemons no cluster.

Suporte adicional de rede:

O Modo Automático do Amazon EKS elimina o trabalho de gerenciamento de drivers de aceleradores e plug-ins de dispositivos.

Você também pode aproveitar uma redução de custos escalando o cluster para zero. Você pode configurar o Modo Automático do EKS para encerrar instâncias quando nenhuma workload estiver em execução. Essa configuração é útil para workloads de inferência baseadas em lotes.

Veja a seguir um exemplo de como executar workloads aceleradas com o Modo Automático do Amazon EKS.

Pré-requisitos

  • Um cluster do Kubernetes com o Modo Automático do Amazon EKS configurado.

  • Uma classe de nó default do EKS conforme criada quando os grupos de nós gerenciados general-purpose ou system estão habilitados.

Etapa 1: implantar uma workload de GPU

Neste exemplo, você criará um NodePool para workloads baseadas em NVIDIA que requer 45 GB de memória de GPU. Com o Modo Automático do EKS, você usa as restrições de agendamento do Kubernetes para definir os requisitos de sua instância.

Para implantar o NodePool do Modo Automático do Amazon EKS e o exemplo de workload, consulte a seguinte definição de NodePool e pod e salve como nodepool-gpu.yaml e 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/instance-gpu-name: l40s
    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

Observe que o seletor eks.amazonaws.com/compute-type: auto requer que a workload seja implantada em um nó do Modo Automático do Amazon EKS. O NodePool também define uma taint que só permite que pods com tolerâncias para GPUs Nvidia sejam programados.

Aplique o NodePool e a workload ao cluster.

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

A seguinte saída deverá ser mostrada:

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

Aguarde alguns segundos e verifique os nós no cluster. Agora você deve ver um novo nó provisionado no cluster do Modo Automático do 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

Etapa 2: validar

Você pode ver que o Modo Automático do Amazon EKS executou g6e.2xlarge em vez de g6.2xlarge, pois a workload exigia uma instância com GPU l40s, de acordo com as seguintes restrições de programação do 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

Agora, veja os logs dos contêineres executando o seguinte comando:

kubectl logs nvidia-smi

Exemplo de resultado:

+---------------------------------------------------------------------------------------+
| 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                                                           |
+---------------------------------------------------------------------------------------+

Você pode ver que o contêiner detectou que está sendo executado em uma instância com uma GPU NVIDIA e que você não precisou instalar nenhum driver de dispositivo, pois é gerenciado pelo Modo Automático do Amazon EKS.

Etapa 3: limpar

Para remover todos os objetos criados, use o kubectl para excluir a implantação da amostra e o NodePool para que o nó seja encerrado:

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

Exemplo de referência de NodePools

Criar um NodePool NVIDIA

O seguinte NodePool define:

  • Executa somente instâncias da família g6e e g6

  • Consolida os nós quando estiverem vazios por uma hora

    • O valor de 1 hora para consolodateAfter é compatível com workloads elevadas e reduz a rotatividade de nós. Você pode ajustar consolidateAfter com base em seus requisitos de workload.

Exemplo de NodePool com consolidação e família de instâncias de GPU 

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

Em vez de definir eks.amazonaws.com/instance-gpu-name, você pode usar eks.amazonaws.com/instance-family para especificar a família de instâncias. Para outros rótulos conhecidos que influenciam a revisão da programação, consulte Rótulos compatíveis com o Modo Automático do EKS.

Se você tiver requisitos específicos de armazenamento, poderá ajustar iops, size e throughput do armazenamento temporário de nós criando o próprio NodeClass para referência no NodePool. Saiba mais sobre as opções configuráveis do NodeClass.

Exemplo de configuração de armazenamento para NodeClass 

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

Definir um AWS Trainium e AWS Inferentia NodePool

O NodePool abaixo tem uma configuração de eks.amazonaws.com/instance-category que instrui a executar apenas instâncias da família Inferentia e Trainium:

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