Alocar dispositivos atuais para cargas de trabalho com DRA

É possível solicitar dispositivos de maneira flexível para cargas de trabalho do Google Kubernetes Engine (GKE) usando a alocação dinâmica de recursos (DRA, na sigla em inglês). Neste documento, mostramos como criar um ResourceClaimTemplate para solicitar dispositivos em pools de nós no cluster e, em seguida, criar uma carga de trabalho para observar como o Kubernetes aloca os dispositivos de maneira flexível para os pods.

Este documento é destinado a operadores de aplicativos e engenheiros de dados que executam cargas de trabalho como IA/ML ou computação de alto desempenho (HPC).

Sobre como solicitar dispositivos com DRA

Ao configurar a infraestrutura do GKE para DRA, os drivers de DRA nos nós criam objetos DeviceClass no cluster. Uma DeviceClass define uma categoria de dispositivos, como GPUs, que estão disponíveis para solicitação de cargas de trabalho. Um administrador da plataforma pode implantar DeviceClasses adicionais que limitam os dispositivos que podem ser solicitados em cargas de trabalho específicas.

Para solicitar dispositivos em uma DeviceClass, crie um dos seguintes objetos:

  • ResourceClaim: Um ResourceClaim permite que um pod ou um usuário solicite recursos de hardware filtrando determinados parâmetros em uma DeviceClass.
  • ResourceClaimTemplate: um ResourceClaimTemplate define um modelo que os pods podem usar para criar automaticamente novos ResourceClaims por pod.

Para mais informações sobre ResourceClaims e ResourceClaimTemplates, consulte Quando usar ResourceClaims e ResourceClaimTemplates.

Os exemplos neste documento usam um ResourceClaimTemplate básico para solicitar a configuração de dispositivo especificada. Para mais informações sobre todos os campos que podem ser especificados, consulte a referência da API ResourceClaimTemplate.

Limitações

Considere as seguintes limitações:

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

  • Ativar a API Google Kubernetes Engine.
    • Ativar a API Google Kubernetes Engine
  • Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da CLI gcloud não sejam compatíveis com a execução dos comandos neste documento.

Reivindicar dispositivos e implantar cargas de trabalho

Para solicitar a alocação de dispositivos por pod, crie um ResourceClaimTemplate que tenha a configuração de dispositivo solicitada, como GPUs de um tipo específico. Ao implantar uma carga de trabalho que referencia o ResourceClaimTemplate, o Kubernetes cria ResourceClaims para cada pod na carga de trabalho com base no ResourceClaimTemplate. O Kubernetes aloca os recursos solicitados e programa os pods nos nós correspondentes.

Para solicitar GPUs em uma carga de trabalho com DRA, siga estas etapas:

  1. Salve o seguinte manifesto como gpu-claim-template.yaml:

    apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: gpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: single-gpu
        exactly:
          deviceClassName: gpu.nvidia.com
          allocationMode: ExactCount
          count: 1

  2. Crie o ResourceClaimTemplate:

    kubectl create -f gpu-claim-template.yaml

  3. Para criar uma carga de trabalho que referencia o ResourceClaimTemplate, salve o seguinte manifesto como dra-gpu-example.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: dra-gpu-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dra-gpu-example
  template:
    metadata:
      labels:
        app: dra-gpu-example
    spec:
      containers:
      - name: ctr
        image: ubuntu:22.04
        command: ["bash", "-c"]
        args: ["echo $(nvidia-smi -L || echo Waiting...); sleep infinity"]
        resources:
          claims:
          - name: single-gpu
      resourceClaims:
      - name: single-gpu
        resourceClaimTemplateName: gpu-claim-template
      tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"

  4. Implantar a carga de trabalho:

    kubectl create -f dra-gpu-example.yaml

Verificar a alocação de hardware

É possível verificar se as cargas de trabalho receberam hardware alocado verificando o ResourceClaim ou consultando os registros do pod. Para verificar a alocação, siga estas etapas:

  1. Acesse o ResourceClaim associado à carga de trabalho implantada:

    kubectl get resourceclaims

    O resultado será assim:

    NAME                                               STATE                AGE
dra-gpu-example-64b75dc6b-x8bd6-single-gpu-jwwdh   allocated,reserved   9s

  2. Confira mais detalhes sobre o hardware atribuído ao pod:

    kubectl describe resourceclaims RESOURCECLAIM

    Substitua RESOURCECLAIM pelo nome completo do ResourceClaim que você recebeu na saída da etapa anterior.

    O resultado será assim:

    Name:         dra-gpu-example-68f595d7dc-prv27-single-gpu-qgjq5
Namespace:    default
Labels:       <none>
Annotations:  resource.kubernetes.io/pod-claim-name: single-gpu
API Version:  resource.k8s.io/v1
Kind:         ResourceClaim
Metadata:
# Multiple lines are omitted here.
Spec:
  Devices:
    Requests:
      Exactly:
        Allocation Mode:    ExactCount
        Count:              1
        Device Class Name:  gpu.nvidia.com
      Name:                 single-gpu
Status:
  Allocation:
    Devices:
      Results:
        Device:   gpu-0
        Driver:   gpu.nvidia.com
        Pool:     gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
        Request:  single-gpu
    Node Selector:
      Node Selector Terms:
        Match Fields:
          Key:       metadata.name
          Operator:  In
          Values:
            gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
  Reserved For:
    Name:      dra-gpu-example-68f595d7dc-prv27
    Resource:  pods
    UID:       e16c2813-08ef-411b-8d92-a72f27ebf5ef
Events:        <none>

  3. Acesse os registros da carga de trabalho implantada:

    kubectl logs deployment/dra-gpu-example --all-pods=true

    O resultado será assim:

    [pod/dra-gpu-example-64b75dc6b-x8bd6/ctr] GPU 0: Tesla T4 (UUID: GPU-2087ac7a-f781-8cd7-eb6b-b00943cc13ef)

    Essa saída indica que o GKE alocou uma GPU para o contêiner.

A seguir