Esta página se ha traducido con Cloud Translation API.

Asignar dispositivos dinámicamente a cargas de trabajo con DRA

Estándar

En esta página se explica cómo desplegar 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 ResourceClaimTemplate para solicitar hardware con DRA y, a continuación, desplegarás una carga de trabajo básica para mostrar cómo Kubernetes asigna hardware de forma flexible a tus pods.

Esta página está dirigida a operadores de aplicaciones y ingenieros de datos que ejecutan cargas de trabajo como IA/ML o computación de alto rendimiento (HPC).

Acerca de la asignación dinámica de recursos

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 el artículo 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 de tus nodos crean objetos DeviceClass en el clúster. Una DeviceClass define una categoría de dispositivos, como GPUs, que se pueden solicitar para 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 en un DeviceClass, crea uno de los siguientes objetos:

ResourceClaim: ResourceClaim permite que un pod o un usuario soliciten recursos de hardware filtrando determinados parámetros en un DeviceClass.
ResourceClaimTemplate: 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 ResourceClaimTemplateSpecdocumentación de Kubernetes.

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:
- Compartir GPUs por tiempo
- GPUs con varias instancias
- Servicio multiproceso (MPS)

Requisitos

Para usar DRA, tu versión de GKE debe ser la 1.32.1-gke.1489001 o una posterior.

También debe conocer los siguientes requisitos y limitaciones:

Antes de empezar

Antes de empezar, asegúrate de haber 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 gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.
Nota: Si ya tienes instalada la CLI de gcloud, 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, primero debes crear un ResourceClaimTemplate que genere un ResourceClaim para describir tu solicitud de GPUs o TPUs. Kubernetes usa este ResourceClaim como plantilla para crear nuevos objetos ResourceClaim para cada pod de 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 archivo de 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 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: ["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"

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/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 nodos de TPU completo a cada ResourceClaim.

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 ResourceClaim o los registros de tu pod.