Gerenciar dispositivos de GPU com alocação dinâmica de recursos

Nesta página, descrevemos como configurar suas cargas de trabalho de GPU para usar a alocação dinâmica de recursos nos clusters bare metal do Google Distributed Cloud. A alocação dinâmica de recursos é uma API do Kubernetes que permite solicitar e compartilhar recursos genéricos, como GPUs, entre pods e contêineres. Os drivers de terceiros gerenciam esses recursos.

Com a alocação dinâmica de recursos, o Kubernetes programa pods com base na configuração do dispositivo referenciado. Os operadores de apps não precisam selecionar nós específicos nas cargas de trabalho nem garantir que cada pod solicite exatamente o número de dispositivos conectados a esses nós. Esse processo é semelhante à alocação de volumes para armazenamento.

Esse recurso ajuda você a executar cargas de trabalho de IA alocando de forma dinâmica e precisa os recursos de GPU nos clusters bare metal, melhorando a utilização e o desempenho dos recursos para cargas de trabalho exigentes.

Esta página é destinada a administradores, arquitetos e operadores que gerenciam o ciclo de vida da infraestrutura de tecnologia subjacente. Para saber mais sobre papéis comuns e tarefas de exemplo referenciados no conteúdo do Google Cloud , consulte Funções e tarefas de usuário comuns do GKE Enterprise.

Antes de começar

Antes de configurar suas cargas de trabalho de GPU para usar a alocação dinâmica de recursos, verifique se os seguintes pré-requisitos foram atendidos:

Criar cargas de trabalho de GPU que usam alocação dinâmica de recursos

Para que suas cargas de trabalho de GPU aproveitem a alocação dinâmica de recursos para solicitar GPUs, elas precisam estar em um namespace compartilhado com um ResourceClaim que descreve a solicitação de alocação de dispositivos de GPU. Suas cargas de trabalho precisam fazer referência ao ResourceClaim para que o Kubernetes atribua recursos de GPU.

As etapas a seguir configuram um ambiente em que suas cargas de trabalho usam a alocação dinâmica de recursos para solicitar recursos de GPU:

  1. Para criar recursos relacionados à alocação dinâmica de recursos, crie um novo Namespace no cluster:

    cat <<EOF | kubectl apply --kubeconfig=CLUSTER_KUBECONFIG -f -
apiVersion: v1
kind: Namespace
metadata:
  name: NAMESPACE_NAME
EOF

    Substitua:

    • CLUSTER_KUBECONFIG: o caminho do arquivo kubeconfig do cluster de usuário.

    • NAMESPACE_NAME com o nome do namespace de alocação dinâmica de recursos.

  2. Crie um ResourceClaim para descrever a solicitação de acesso à GPU:

    cat <<EOF | kubectl apply --kubeconfig=CLUSTER_KUBECONFIG -f -
apiVersion: resource.k8s.io/v1beta1
kind: ResourceClaim
metadata:
  namespace: NAMESPACE_NAME
  name: RESOURCE_CLAIM_NAME
spec:
    devices:
      requests:
      - name: gpu
        deviceClassName: gpu.nvidia.com
EOF

    Substitua RESOURCE_CLAIM_NAME pelo nome da declaração de recurso para solicitações de GPU.

  3. Crie cargas de trabalho que referenciem o ResourceClaim criado na etapa anterior.

    Os exemplos de carga de trabalho a seguir mostram como referenciar um ResourceClaim chamado gpu-claim no namespace dra-test. Os contêineres no pod pod1 são exemplos de arquitetura de dispositivo de computação unificada (CUDA) da NVIDIA projetados para executar cargas de trabalho CUDA nas GPUs. Quando o pod pod1 é concluído com êxito, isso indica que a capacidade de alocação dinâmica de recursos está funcionando corretamente e que ela está pronta para gerenciar recursos de GPU no cluster.

    Ubuntu

    1. Use o comando a seguir para aplicar o manifesto ao cluster:

      cat <<EOF | kubectl apply --kubeconfig=CLUSTER_KUBECONFIG -f -
apiVersion: v1
kind: Pod
metadata:
  name: pod1
  namespace: dra-test
spec:
  restartPolicy: OnFailure
  resourceClaims:
    - name: gpu
      resourceClaimName: gpu-claim
  containers:
    - name: ctr0
      image: nvcr.io/nvidia/k8s/cuda-sample:vectoradd-cuda12.5.0
      resources:
        claims:
          - name: gpu
    - name: ctr1
      image: nvcr.io/nvidia/k8s/cuda-sample:devicequery
      resources:
        claims:
          - name: gpu
EOF

    RHEL

    1. Faça o download e instale o módulo de política do SELinux nvidia_container_t, que é necessário para acessar GPUs.

      Para mais informações, consulte o repositório dgx-selinux da NVIDIA.

    2. Use o comando a seguir para aplicar o manifesto ao cluster:

      cat <<EOF | kubectl apply --kubeconfig=CLUSTER_KUBECONFIG -f -
apiVersion: v1
kind: Pod
metadata:
  name: pod1
  namespace: dra-test
spec:
  restartPolicy: OnFailure
  securityContext:
    seLinuxOptions:
      type: nvidia_container_t
  resourceClaims:
    - name: gpu
      resourceClaimName: gpu-claim
  containers:
    - name: ctr0
      image: nvcr.io/nvidia/k8s/cuda-sample:vectoradd-cuda12.5.0
      resources:
        claims:
          - name: gpu
    - name: ctr1
      image: nvcr.io/nvidia/k8s/cuda-sample:devicequery
      resources:
        claims:
          - name: gpu
EOF

Limitações

Considere as seguintes limitações ao usar a alocação dinâmica de recursos:

  • Ao usar o SO RHEL, a política do SELinux pode interferir em contêineres que tentam acessar GPUs. Para mais informações, consulte Como usar GPUs em contêineres no RHEL 8 bare metal.

  • Esse recurso usa o grupo de APIs resource.k8s.io/v1beta1, que é diferente do grupo de APIs Kubernetes de código aberto para esse recurso, resource.k8s.io/v1. O grupo de APIs de código aberto v1 oferece mais recursos e melhor estabilidade do que o grupo de APIs v1beta1.

A seguir