Asigna dispositivos existentes a cargas de trabajo con DRA

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 existentes en grupos de nodos de tu clúster y, luego, crear una carga de trabajo para observar cómo Kubernetes asigna los dispositivos de forma flexible a tus Pods.

Este documento está destinado a operadores de aplicaciones y a 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 GPUs, que están disponibles para solicitar 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 dentro de un DeviceClass, crea uno de los siguientes objetos:

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

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

En los ejemplos de este documento, 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

Se aplica la siguiente limitación:

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 de este documento.

Reclama dispositivos e implementa cargas de trabajo

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

Para solicitar GPUs en una carga de trabajo con DRA, sigue estos pasos:

  1. Guarda el siguiente manifiesto como gpu-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

  2. Crea el ResourceClaimTemplate:

    kubectl create -f gpu-claim-template.yaml

  3. 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...); sleep infinity"]
        resources:
          claims:
          - name: single-gpu
      resourceClaims:
      - name: single-gpu
        resourceClaimTemplateName: gpu-claim-template
      tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"

  4. Implementa la carga de trabajo:

    kubectl create -f dra-gpu-example.yaml

Verifica la asignación de hardware

Para verificar que se haya asignado hardware a tus cargas de trabajo, consulta el ResourceClaim o los registros de tu Pod. Para verificar la asignación, sigue estos pasos:

  1. Obtén el ResourceClaim asociado con la carga de trabajo que implementaste:

    kubectl get resourceclaims

    El resultado es similar a este:

    NAME                                               STATE                AGE
dra-gpu-example-64b75dc6b-x8bd6-single-gpu-jwwdh   allocated,reserved   9s

  2. Obtén más detalles sobre el hardware asignado al Pod:

    kubectl describe resourceclaims RESOURCECLAIM

    Reemplaza RESOURCECLAIM por el nombre completo del ResourceClaim que obtuviste del resultado del paso anterior.

    El resultado es similar a este:

    Name:         dra-gpu-example-68f595d7dc-prv27-single-gpu-qgjq5
Namespace:    default
Labels:       <none>
Annotations:  resource.kubernetes.io/pod-claim-name: single-gpu
API Version:  resource.k8s.io/v1
Kind:         ResourceClaim
Metadata:
# Multiple lines are omitted here.
Spec:
  Devices:
    Requests:
      Exactly:
        Allocation Mode:    ExactCount
        Count:              1
        Device Class Name:  gpu.nvidia.com
      Name:                 single-gpu
Status:
  Allocation:
    Devices:
      Results:
        Device:   gpu-0
        Driver:   gpu.nvidia.com
        Pool:     gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
        Request:  single-gpu
    Node Selector:
      Node Selector Terms:
        Match Fields:
          Key:       metadata.name
          Operator:  In
          Values:
            gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
  Reserved For:
    Name:      dra-gpu-example-68f595d7dc-prv27
    Resource:  pods
    UID:       e16c2813-08ef-411b-8d92-a72f27ebf5ef
Events:        <none>

  3. Obtén registros de la carga de trabajo que implementaste:

    kubectl logs deployment/dra-gpu-example --all-pods=true

    El resultado es similar a este:

    [pod/dra-gpu-example-64b75dc6b-x8bd6/ctr] GPU 0: Tesla T4 (UUID: GPU-2087ac7a-f781-8cd7-eb6b-b00943cc13ef)

    Este resultado indica que GKE asignó una GPU al contenedor.

¿Qué sigue?