Atribua dinamicamente dispositivos a cargas de trabalho com a DRA

Padrão

Pode pedir dispositivos de forma flexível para as suas cargas de trabalho do Google Kubernetes Engine (GKE) usando a atribuição dinâmica de recursos (DRA). Este documento mostra como criar um ResourceClaimTemplate para pedir dispositivos e, em seguida, criar uma carga de trabalho para observar como o Kubernetes atribui os dispositivos de forma flexível aos seus pods.

Este documento destina-se a operadores de aplicações e engenheiros de dados que executam cargas de trabalho como IA/AA ou computação de elevado desempenho (HPC).

Acerca do pedido de dispositivos com DRA

Quando configura a sua infraestrutura do GKE para a DRA, os controladores da DRA nos seus nós criam objetos DeviceClass no cluster. Uma DeviceClass define uma categoria de dispositivos, como GPUs, que estão disponíveis para pedido para cargas de trabalho. O administrador da plataforma pode implementar opcionalmente DeviceClasses adicionais que limitam os dispositivos que pode pedir em cargas de trabalho específicas.

Para pedir dispositivos numa DeviceClass, crie um dos seguintes objetos:

ResourceClaim: um ResourceClaim permite que um Pod ou um utilizador peça recursos de hardware filtrando determinados parâmetros numa 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 nesta página usam um ResourceClaimTemplate básico para pedir a configuração do dispositivo especificada. Para mais informações sobre todos os campos que pode especificar, consulte a referência da API ResourceClaimTemplate.

Limitações

A administração de contas automática de nós não é suportada.
Os clusters do Autopilot não suportam o DRA.
Não pode usar as seguintes funcionalidades de partilha de GPU:
- GPUs de partilha de tempo
- GPUs de várias instâncias
- Serviço multiprocessos (MPS)

Requisitos

Para usar o DRA, a versão do GKE tem de ser a 1.34 ou posterior.

Também deve conhecer os seguintes requisitos e limitações:

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

Ative a API Google Kubernetes Engine.

Ative a API Google Kubernetes Engine

Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize a CLI gcloud. Se instalou anteriormente a CLI gcloud, execute o comando gcloud components update para obter a versão mais recente. As versões anteriores da CLI gcloud podem não suportar a execução dos comandos neste documento.
Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

Certifique-se de que os clusters do GKE estão configurados para cargas de trabalho da DRA.

Use o DRA para implementar cargas de trabalho

Para pedir a atribuição de dispositivos por Pod, crie um ResourceClaimTemplate com a configuração do dispositivo pedida, como GPUs de um tipo específico. Quando implementa uma carga de trabalho que faz referência ao ResourceClaimTemplate, o Kubernetes cria ResourceClaims para cada Pod na carga de trabalho com base no ResourceClaimTemplate. O Kubernetes atribui os recursos pedidos e agenda os pods nos nós correspondentes.

Para pedir dispositivos numa carga de trabalho com DRA, selecione uma das seguintes opções:

GPU

Guarde o seguinte manifesto como 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

Crie o ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Para criar uma carga de trabalho que referencie o ResourceClaimTemplate, guarde 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...)"]
        resources:
          claims:
          - name: single-gpu
      resourceClaims:
      - name: single-gpu
        resourceClaimTemplateName: gpu-claim-template
      tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"

Implemente a carga de trabalho:
```
kubectl create -f dra-gpu-example.yaml
```

TPU

Guarde o seguinte manifesto como claim-template.yaml:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: tpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: all-tpus
        exactly:
          deviceClassName: tpu.google.com
          allocationMode: All

Este ResourceClaimTemplate pede que o GKE atribua um conjunto de nós de TPU inteiro a cada ResourceClaim.

Crie o ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Para criar uma carga de trabalho que referencie o ResourceClaimTemplate, guarde o seguinte manifesto como dra-tpu-example.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dra-tpu-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dra-tpu-example
  template:
    metadata:
      labels:
        app: dra-tpu-example
    spec:
      containers:
      - name: ctr
        image: ubuntu:22.04
        command:
          - /bin/sh
          - -c
          - |
            echo "Environment Variables:"
            env
            echo "Sleeping indefinitely..."
            sleep infinity
        resources:
          claims:
          - name: all-tpus
      resourceClaims:
      - name: all-tpus
        resourceClaimTemplateName: tpu-claim-template
      tolerations:
      - key: "google.com/tpu"
        operator: "Exists"
        effect: "NoSchedule"

Implemente a carga de trabalho:
```
kubectl create -f dra-tpu-example.yaml
```

Valide a atribuição de hardware

Pode verificar se o hardware foi atribuído às suas cargas de trabalho consultando o ResourceClaim ou os registos do seu pod. Para validar a atribuição de GPUs ou TPUs, selecione uma das seguintes opções: