Asignar dispositivos dinámicamente a cargas de trabajo con DRA

Estándar

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

Este documento está dirigido a operadores de aplicaciones y ingenieros de datos que ejecutan cargas de trabajo como IA/aprendizaje automático 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 de tus nodos crean objetos DeviceClass en el clúster. Un DeviceClass define una categoría de dispositivos, como las GPUs, que se pueden solicitar para las cargas de trabajo. Un administrador de la plataforma puede implementar de forma opcional DeviceClasses adicionales que limiten los dispositivos que puedes solicitar en cargas de trabajo específicas.

Para solicitar dispositivos de una clase de dispositivo, crea uno de los siguientes objetos:

ResourceClaim ResourceClaim permite que un pod o un usuario soliciten recursos de hardware filtrando determinados parámetros en una 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 de dispositivo especificada. Para obtener más información sobre todos los campos que puedes especificar, consulta la referencia de la API 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 para compartir la GPU:
- GPUs de tiempo compartido
- GPUs con varias instancias
- Servicio multiproceso (MPS)

Requisitos

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

También debe conocer los siguientes requisitos y limitaciones:

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la CLI de gcloud, obtén la versión más reciente ejecutando el comando gcloud components update. Es posible que las versiones anteriores de la interfaz de línea de comandos de gcloud no admitan la ejecución de los comandos de este documento.
Nota: En las instalaciones de gcloud CLI, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines 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 tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

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

Usar DRA para desplegar cargas de trabajo

Para solicitar la asignación de dispositivos por Pod, crea un ResourceClaimTemplate que tenga la configuración del dispositivo que has solicitado, como GPUs de un tipo específico. Cuando despliega una carga de trabajo que hace referencia a ResourceClaimTemplate, Kubernetes crea ResourceClaims para cada Pod de la carga de trabajo en función de 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 archivo de 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"

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

TPU

Guarda el siguiente archivo de 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 TPUs, por lo que todas las TPUs 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"

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

Verificar la asignación de hardware

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