Asigna dispositivos de forma dinámica a cargas de trabajo con DRA

Estándar

Puedes solicitar dispositivos de forma flexible para tus cargas de trabajo de Google Kubernetes Engine (GKE) con la asignación dinámica de recursos (DRA). En este documento, se muestra cómo crear un objeto ResourceClaimTemplate para solicitar dispositivos y, luego, crear una carga de trabajo para observar cómo Kubernetes asigna los dispositivos a tus Pods de manera flexible.

Este documento está dirigido a los operadores de aplicaciones y los ingenieros de datos que ejecutan cargas de trabajo como IA/AA o computación de alto rendimiento (HPC).

Acerca de la solicitud de dispositivos con DRA

Cuando configuras tu infraestructura de GKE para DRA, los controladores de DRA en tus nodos crean objetos DeviceClass en el clúster. Un DeviceClass define una categoría de dispositivos, como las GPUs, que están disponibles para solicitar cargas de trabajo. De manera opcional, un administrador de la plataforma puede implementar DeviceClasses adicionales que limiten los dispositivos que puedes solicitar en cargas de trabajo específicas.

Para solicitar dispositivos dentro de un DeviceClass, crea uno de los siguientes objetos:

ResourceClaim: Un ResourceClaim permite que un Pod o un usuario soliciten recursos de hardware filtrando ciertos parámetros dentro de un DeviceClass.
ResourceClaimTemplate: Un ResourceClaimTemplate define una plantilla que los Pods pueden usar para crear automáticamente nuevos ResourceClaims por Pod.

Para obtener más información sobre ResourceClaims y ResourceClaimTemplates, consulta Cuándo usar ResourceClaims y ResourceClaimTemplates.

En los ejemplos de esta página, se usa un ResourceClaimTemplate básico para solicitar la configuración del dispositivo especificada. Para obtener más información sobre todos los campos que puedes especificar, consulta la referencia de la API de ResourceClaimTemplate.

Limitaciones

No se admite el aprovisionamiento automático de nodos.
Los clústeres de Autopilot no admiten DRA.
No puedes usar las siguientes funciones de uso compartido de GPU:
- GPU de tiempo compartido
- GPU de varias instancias
- Servicio de varios procesos (MPS)

Requisitos

Para usar DRA, tu versión de GKE debe ser la 1.34 o una posterior.

También debes conocer los siguientes requisitos y limitaciones:

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la propiedad compute/region. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

Asegúrate de que tus clústeres de GKE estén configurados para cargas de trabajo de DRA.

Usa DRA para implementar cargas de trabajo

Para solicitar la asignación de dispositivos por Pod, crea un ResourceClaimTemplate que tenga la configuración del dispositivo que solicitaste, como GPUs de un tipo específico. Cuando implementas una carga de trabajo que hace referencia a ResourceClaimTemplate, Kubernetes crea ResourceClaims para cada Pod de la carga de trabajo según el ResourceClaimTemplate. Kubernetes asigna los recursos solicitados y programa los Pods en los nodos correspondientes.

Para solicitar dispositivos en una carga de trabajo con DRA, selecciona una de las siguientes opciones:

GPU

Guarda el siguiente manifiesto 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

Crea el ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Para crear una carga de trabajo que haga referencia a ResourceClaimTemplate, guarda el siguiente manifiesto 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"

Implementa la carga de trabajo:
```
kubectl create -f dra-gpu-example.yaml
```

TPU

Guarda el siguiente manifiesto 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 solicita todas las TPU, por lo que todas las TPU de un nodo se asignan a cada ResourceClaim resultante.

Crea el ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Para crear una carga de trabajo que haga referencia a ResourceClaimTemplate, guarda el siguiente manifiesto 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"

Implementa la carga de trabajo:
```
kubectl create -f dra-tpu-example.yaml
```

Verifica la asignación de hardware

Para verificar que se haya asignado hardware a tus cargas de trabajo, revisa el objeto ResourceClaim o los registros de tu Pod. Para verificar la asignación de GPUs o TPUs, selecciona una de las siguientes opciones: