Se usó la API de Cloud Translation para traducir esta página.

Cómo asignar dispositivos de forma dinámica a cargas de trabajo con DRA

Estándar

En esta página, se explica cómo implementar cargas de trabajo de asignación dinámica de recursos (DRA) en tus clústeres de Google Kubernetes Engine. En esta página, crearás un objeto ResourceClaimTemplate para solicitar hardware con DRA y, luego, implementarás una carga de trabajo básica para demostrar cómo Kubernetes asigna hardware de forma flexible en tus Pods.

Esta página está dirigida 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 asignación dinámica de recursos

La DRA es una función integrada de Kubernetes que te permite solicitar, asignar y compartir hardware de forma flexible en tu clúster entre Pods y contenedores. Para obtener más información, consulta Acerca de la asignación dinámica de recursos.

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 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 los objetos ResourceClaim y ResourceClaimTemplate, 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 información más detallada, consulta la documentación de Kubernetes.ResourceClaimTemplateSpec

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.32.1-gke.1489001 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 gcloud components update para obtener la versión más reciente.
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, primero debes crear un objeto ResourceClaimTemplate que genere un objeto ResourceClaim para describir tu solicitud de GPU o TPU, que Kubernetes usa como plantilla para crear nuevos objetos ResourceClaim para cada Pod en una carga de trabajo. Cuando especificas ResourceClaimTemplate en una carga de trabajo, Kubernetes asigna los recursos solicitados y programa los Pods en los nodos correspondientes.

GPU

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

Crea 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: ["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"

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

Este ResourceClaimTemplate solicita que GKE asigne un grupo de nodo TPU completo a cada ResourceClaim.

Crea 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, consulta ResourceClaim o revisa los registros de tu Pod.