Esta página foi traduzida pela API Cloud Translation.

Atribua dinamicamente dispositivos a cargas de trabalho com a DRA

Padrão

Esta página explica como implementar cargas de trabalho de atribuição dinâmica de recursos (DRA) nos seus clusters do Google Kubernetes Engine. Nesta página, vai criar um ResourceClaimTemplate para pedir hardware com DRA e, em seguida, implementar uma carga de trabalho básica para demonstrar como o Kubernetes atribui hardware de forma flexível aos seus pods.

Esta página destina-se a operadores de aplicações e engenheiros de dados que executam cargas de trabalho como IA/ML ou computação de alto desempenho (HPC).

Acerca da atribuição dinâmica de recursos

A DRA é uma funcionalidade do Kubernetes incorporada que lhe permite pedir, atribuir e partilhar hardware de forma flexível no seu cluster entre pods e contentores. Para mais informações, consulte o artigo Acerca da atribuição dinâmica de recursos.

Acerca do pedido de dispositivos com DRA

Quando configura a sua infraestrutura do GKE para o DRA, os controladores do 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 num DeviceClass, crie um dos seguintes objetos:

ResourceClaim: Uma 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 os objetos ResourceClaim e ResourceClaimTemplate, 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 obter informações mais detalhadas, consulte a ResourceClaimTemplateSpec documentação do Kubernetes.

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.32.1-gke.1489001 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. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.
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, primeiro, cria um ResourceClaimTemplate que produz um ResourceClaim para descrever o seu pedido de GPUs ou TPUs, que o Kubernetes usa como um modelo para criar novos objetos ResourceClaim para cada pod numa carga de trabalho. Quando especifica o ResourceClaimTemplate numa carga de trabalho, o Kubernetes atribui os recursos pedidos e agenda os pods nos nós correspondentes.

GPU

Guarde 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 o ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Para criar uma carga de trabalho que faça referência ao 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: ["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"

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/v1beta1
kind: ResourceClaimTemplate
metadata:
  name: tpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: all-tpus
        deviceClassName: tpu.google.com
        allocationMode: All

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

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

Para criar uma carga de trabalho que faça referência ao 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 as suas cargas de trabalho receberam hardware consultando o ResourceClaim ou analisando os registos do seu pod.