Esta página foi traduzida pela API Cloud Translation.

Alocar dispositivos dinamicamente para cargas de trabalho com DRA

Standard

Nesta página, explicamos como implantar cargas de trabalho de alocação dinâmica de recursos (DRA, na sigla em inglês) nos clusters do Google Kubernetes Engine. Nesta página, você vai criar um ResourceClaimTemplate para solicitar hardware com DRA e implantar uma carga de trabalho básica para demonstrar como o Kubernetes aloca hardware de maneira flexível nos seus pods.

Esta página é destinada a operadores de aplicativos e engenheiros de dados que executam cargas de trabalho como IA/ML ou computação de alto desempenho (HPC).

Sobre a alocação dinâmica de recursos

O DRA é um recurso integrado do Kubernetes que permite solicitar, alocar e compartilhar hardware de maneira flexível no cluster entre pods e contêineres. Para mais informações, consulte Sobre a alocação dinâmica de recursos.

Sobre como solicitar dispositivos com a 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 de plataforma pode implantar DeviceClasses adicionais que limitam os dispositivos que você pode solicitar em cargas de trabalho específicas.

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

ResourceClaim: uma 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 objetos ResourceClaim e ResourceClaimTemplate, consulte Quando usar ResourceClaims e ResourceClaimTemplates.

Os exemplos nesta página usam um ResourceClaimTemplate básico para solicitar a configuração de dispositivo especificada. Para mais informações, consulte a documentação do Kubernetes ResourceClaimTemplateSpec.

Limitações

O provisionamento automático de nós não é compatível.
Os clusters do Autopilot não são compatíveis com DRA.
Não é possível usar os seguintes recursos de compartilhamento de GPU:
- GPUs de compartilhamento de tempo
- GPUs com várias instâncias
- Serviço multiprocesso (MPS)

Requisitos

Para usar o DRA, a versão do GKE precisa ser 1.32.1-gke.1489001 ou mais recente.

Você também precisa conhecer os seguintes requisitos e limitações:

Antes de começar

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

Ativar a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.
Observação:para instalações atuais da CLI gcloud, defina a propriedade compute/region. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, você evita erros na CLI gcloud como este: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

Verifique se os clusters do GKE estão configurados para cargas de trabalho de DRA.

Usar o DRA para implantar cargas de trabalho

Para solicitar a alocação de dispositivos por pod, primeiro crie um ResourceClaimTemplate que produza um ResourceClaim para descrever sua solicitação de GPUs ou TPUs, que o Kubernetes usa como um modelo para criar novos objetos ResourceClaim para cada pod em uma carga de trabalho. Quando você especifica o ResourceClaimTemplate em uma carga de trabalho, o Kubernetes aloca os recursos solicitados e programa os pods nos nós correspondentes.

GPU

Salve o seguinte manifesto como claim-template.yaml:

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

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

Para criar uma carga de trabalho que faça referência ao ResourceClaimTemplate, salve o manifesto a seguir 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: ["while [ 1 ]; do date; echo $(nvidia-smi -L || echo Waiting...); sleep 60; done"]
        resources:
          claims:
          - name: single-gpu
      resourceClaims:
      - name: single-gpu
        resourceClaimTemplateName: gpu-claim-template
      tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"

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

TPU

Salve o seguinte manifesto como claim-template.yaml:

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

Esse ResourceClaimTemplate solicita que o GKE aloque um pool de nós de TPU inteiro para cada ResourceClaim.

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

Para criar uma carga de trabalho que faça referência ao ResourceClaimTemplate, salve o manifesto a seguir 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"

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

Verificar a alocação de hardware

Para verificar se as cargas de trabalho receberam hardware, confira o ResourceClaim ou os registros do seu pod.