Prepara la infraestructura de GKE para las cargas de trabajo de DRA

En esta página, se explica cómo configurar tu infraestructura de Google Kubernetes Engine (GKE) para admitir la asignación dinámica de recursos (DRA). En esta página, crearás clústeres que pueden implementar cargas de trabajo de GPU o TPU, y, luego, instalarás de forma manual los controladores que necesitas para habilitar DRA.

Esta página está destinada a los administradores de plataformas que desean reducir la complejidad y la sobrecarga de la configuración de la infraestructura con dispositivos de hardware especializados.

Acerca del DRA

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.

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, según el tipo de hardware que quieras usar:

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.

  • Si no usas Cloud Shell, instala la CLI de Helm:

    curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

Crea un clúster de GKE Standard

Crea un clúster en modo estándar que habilite las APIs beta de Kubernetes para DRA:

gcloud container clusters create CLUSTER_NAME \
    --quiet \
    --enable-kubernetes-unstable-apis="resource.k8s.io/v1beta1/deviceclasses,resource.k8s.io/v1beta1/resourceclaims,resource.k8s.io/v1beta1/resourceclaimtemplates,resource.k8s.io/v1beta1/resourceslices" \
    --release-channel=rapid \
    --enable-autoupgrade \
    --location CONTROL_PLANE_LOCATION \
    --num-nodes "1" \
    --cluster-version GKE_VERSION \
    --workload-pool="PROJECT_ID.svc.id.goog"

Reemplaza lo siguiente:

  • CLUSTER_NAME: Es un nombre para tu clúster.
  • CONTROL_PLANE_LOCATION: Es la ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales.
  • GKE_VERSION: Es la versión de GKE que se usará para el clúster y los nodos. Debe ser 1.32.1-gke.1489001 o una versión posterior.
  • PROJECT_ID: el ID de tu proyecto

Prepara tu entorno de GKE para admitir la DRA

En GKE, puedes usar DRA con GPU y TPU. Cuando crees tus grupos de nodos, debes usar la siguiente configuración que funciona con DRA durante la versión preliminar:

  • En el caso de las GPUs, inhabilita la instalación automática de controladores de GPU.
  • Agrega los alcances de acceso requeridos para los nodos.
  • Agrega etiquetas de nodo para ejecutar solo cargas de trabajo de DRA en los nodos.
  • Habilita el ajuste de escala automático del clúster.

Todos los demás parámetros de configuración del grupo de nodos, como el tipo de máquina, el tipo y la cantidad de aceleradores, el sistema operativo del nodo y las ubicaciones de los nodos, dependen de tus requisitos.

Prepara tu entorno para las GPUs

  1. Crea un grupo de nodos con el hardware requerido:

    gcloud beta container node-pools create "gpu-pool" \
    --quiet \
    --project PROJECT_ID \
    --cluster CLUSTER_NAME \
    --location CONTROL_PLANE_LOCATION \
    --node-version KUBERNETES_VERSION \
    --machine-type "n1-standard-8" \
    --accelerator "type=nvidia-tesla-t4,count=2,gpu-driver-version=disabled" \
    --image-type "UBUNTU_CONTAINERD" \
    --disk-type "pd-standard" \
    --disk-size "100" \
    --scopes "https://www.googleapis.com/auth/devstorage.read_only","https://www.googleapis.com/auth/logging.write","https://www.googleapis.com/auth/monitoring","https://www.googleapis.com/auth/servicecontrol","https://www.googleapis.com/auth/service.management.readonly","https://www.googleapis.com/auth/trace.append" \
    --num-nodes "1" \
    --enable-autoscaling \
    --min-nodes "1" \
    --max-nodes "6" \
    --location-policy "ANY" \
    --max-surge-upgrade 1 \
    --max-unavailable-upgrade 0 \
    --node-locations ZONE \
    --node-labels=gke-no-default-nvidia-gpu-device-plugin=true,nvidia.com/gpu.present=true

    Reemplaza lo siguiente:

    • CLUSTER_NAME: El nombre de tu clúster.
    • CONTROL_PLANE_LOCATION: Es la ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales. Asegúrate de que la ubicación seleccionada pertenezca a la misma región en la que están disponibles las GPUs que especificas.
    • ZONE: Una zona en la que estén disponibles las GPUs que especifiques.

  2. Instala de forma manual los controladores en tus nodos de Container-Optimized OS o Ubuntu. Para obtener instrucciones detalladas, consulta Instala controladores de GPU de NVIDIA de forma manual.

    • Si usas COS, ejecuta los siguientes comandos para implementar el DaemonSet de instalación y, luego, instalar la versión predeterminada del controlador de GPU:

      kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

    • Si usas Ubuntu, el DaemonSet de instalación que implementes depende del tipo de GPU y de la versión del nodo de GKE, como se describe en la sección de Ubuntu de las instrucciones.

  3. Extrae y actualiza el gráfico de Helm que contiene el operador de GPU:

    helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
    && helm repo update

  4. Crea un espacio de nombres para el operador de GPU:

    kubectl create namespace gpu-operator

  5. Crea un objeto ResourceQuota en el espacio de nombres gpu-operator. El objeto ResourceQuota permite que el operador de GPU implemente Pods que tienen la misma prioridad que los Pods del sistema de Kubernetes.

    kubectl apply -n gpu-operator -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-operator-quota
spec:
  hard:
    pods: 100
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

  6. Instala el operador de GPU con la secuencia de comandos de Helm:

    helm install --wait --generate-name -n gpu-operator nvidia/gpu-operator \
    --set driver.enabled=false \
    --set operator.repository=ghcr.io/nvidia \
    --set operator.version=6171a52d \
    --set validator.repository=ghcr.io/nvidia/gpu-operator \
    --set validator.version=6171a52d \
    --set toolkit.repository=ghcr.io/nvidia \
    --set toolkit.version=5d9b27f1-ubuntu20.04 \
    --set gfd.repository=ghcr.io/nvidia \
    --set gfd.version=f171c926-ubi9 \
    --set cdi.enabled=true \
    --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
    --set toolkit.installDir=/home/kubernetes/bin/nvidia

Prepara tu entorno para las TPU

Crea un grupo de nodos que use TPUs. En el siguiente ejemplo, se crea un grupo de nodos de TPU Trillium:

gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME --num-nodes 1 \
    --location CONTROL_PLANE_LOCATION \
    --node-labels "gke-no-default-tpu-device-plugin=true,gke-no-default-tpu-dra-plugin=true" \
    --machine-type=ct6e-standard-8t \
    --enable-autoupgrade

Reemplaza lo siguiente: * NODEPOOL_NAME: El nombre de tu grupo de nodos. * CLUSTER_NAME: Es el nombre de tu clúster. * CONTROL_PLANE_LOCATION: La ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales.

Accede a los controladores de DRA y luego instálalos

En las siguientes secciones, se muestra cómo instalar los controladores de DRA para las GPUs y las TPUs. Los controladores de DRA permiten que Kubernetes asigne de forma dinámica los dispositivos conectados a las cargas de trabajo. Puedes instalar controladores de DRA para GPUs y TPUs con el gráfico de Helm proporcionado. Para acceder a los gráficos de Helm, completa los siguientes pasos:

  1. Clona el repositorio ai-on-gke para acceder a los gráficos de Helm que contienen los controladores de DRA para GPUs y TPUs:

    git clone https://github.com/GoogleCloudPlatform/ai-on-gke/common-infra.git

  2. Navega al directorio que contiene los gráficos:

    cd common-infra/common/charts

Instala controladores de DRA en GPUs

Después de que tengas acceso al gráfico de Helm que contiene los controladores de DRA, instala el controlador de DRA para GPUs completando el siguiente paso:

COS 

helm upgrade -i --create-namespace --namespace nvidia nvidia-dra-driver-gpu nvidia-dra-driver-gpu/ \
    --set image.repository=ghcr.io/nvidia/k8s-dra-driver-gpu \
    --set image.tag=d1fad7ed-ubi9 \
    --set image.pullPolicy=Always \
    --set controller.priorityClassName="" \
    --set kubeletPlugin.priorityClassName="" \
    --set nvidiaDriverRoot="/home/kubernetes/bin/nvidia/" \
    --set nvidiaCtkPath=/home/kubernetes/bin/nvidia/toolkit/nvidia-ctk \
    --set deviceClasses="{gpu}" \
    --set gpuResourcesEnabledOverride=true \
    --set resources.computeDomains.enabled=false \
    --set kubeletPlugin.tolerations[0].key=nvidia.com/gpu \
    --set kubeletPlugin.tolerations[0].operator=Exists \
    --set kubeletPlugin.tolerations[0].effect=NoSchedule \
    --set kubeletPlugin.tolerations[1].key=cloud.google.com/compute-class \
    --set kubeletPlugin.tolerations[1].operator=Exists \
    --set kubeletPlugin.tolerations[1].effect=NoSchedule

Ubuntu 

helm upgrade -i --create-namespace --namespace nvidia nvidia-dra-driver-gpu nvidia-dra-driver-gpu/ \
    --set image.repository=ghcr.io/nvidia/k8s-dra-driver-gpu \
    --set image.tag=d1fad7ed-ubi9 \
    --set image.pullPolicy=Always \
    --set controller.priorityClassName="" \
    --set kubeletPlugin.priorityClassName="" \
    --set nvidiaDriverRoot="/opt/nvidia" \
    --set nvidiaCtkPath=/home/kubernetes/bin/nvidia/toolkit/nvidia-ctk \
    --set deviceClasses="{gpu}" \
    --set gpuResourcesEnabledOverride=true \
    --set resources.computeDomains.enabled=false \
    --set kubeletPlugin.tolerations[0].key=nvidia.com/gpu \
    --set kubeletPlugin.tolerations[0].operator=Exists \
    --set kubeletPlugin.tolerations[0].effect=NoSchedule \
    --set kubeletPlugin.tolerations[1].key=cloud.google.com/compute-class \
    --set kubeletPlugin.tolerations[1].operator=Exists \
    --set kubeletPlugin.tolerations[1].effect=NoSchedule

Instala controladores de DRA en las TPU

Después de que tengas acceso al gráfico de Helm que contiene los controladores, instala el controlador de TPU completando el siguiente paso:

./tpu-dra-driver/install-tpu-dra-driver.sh

Verifica que tu infraestructura esté lista para la DRA

Confirma que ResourceSlice muestre los dispositivos de hardware que agregaste:

kubectl get resourceslices -o yaml

Si usaste el ejemplo de la sección anterior, el ResourceSlice se parecerá al siguiente, según el tipo de hardware que hayas usado:

GPU 

apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1beta1
  kind: ResourceSlice
  metadata:
    # lines omitted for clarity
  spec:
    devices:
    - basic:
        attributes:
          architecture:
            string: Turing
          brand:
            string: Nvidia
          cudaComputeCapability:
            version: 7.5.0
          cudaDriverVersion:
            version: 12.2.0
          driverVersion:
            version: 535.230.2
          index:
            int: 0
          minor:
            int: 0
          productName:
            string: Tesla T4
          type:
            string: gpu
          uuid:
            string: GPU-2087ac7a-f781-8cd7-eb6b-b00943cc13ef
        capacity:
          memory:
            value: 15Gi
      name: gpu-0

TPU 

apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1beta1
  kind: ResourceSlice
  metadata:
    # lines omitted for clarity
  spec:
    devices:
    - basic:
        attributes:
          index:
            int: 0
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "0"
    - basic:
        attributes:
          index:
            int: 1
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "1"
    - basic:
        attributes:
          index:
            int: 2
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "2"
    - basic:
        attributes:
          index:
            int: 3
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "3"
    driver: tpu.google.com
    nodeName: gke-tpu-b4d4b61b-fwbg
    pool:
      generation: 1
      name: gke-tpu-b4d4b61b-fwbg
      resourceSliceCount: 1
kind: List
metadata:
  resourceVersion: ""

¿Qué sigue?