Todos los productos
Search

Este producto

    Container Service for Kubernetes:Enable GPU scheduling features

    Centro de documentos

    Container Service for Kubernetes:Enable GPU scheduling features

    Última actualización: Sep 04, 2026

    Al desplegar cargas de trabajo de GPU en un clúster ACK administrado Pro, asigne etiquetas de programación de GPU (exclusiva, compartida, con detección de topología) y etiquetas de modelo de tarjeta GPU para optimizar la utilización y dirigir la programación. La programación compartida y con detección de topología requieren la versión Pro; la programación por modelo de tarjeta es compatible con todos los tipos de clúster.

    Descripción general de las etiquetas de programación

    Las etiquetas de programación de GPU identifican los modelos de GPU y las políticas de asignación para una gestión detallada de recursos.

    Modo de programación

    Valor de etiqueta

    Casos de uso

    Programación exclusiva (Predeterminado)

    ack.node.gpu.schedule: default

    Para tareas críticas de rendimiento que requieren acceso exclusivo a la GPU, como el entrenamiento de modelos y la computación de alto rendimiento (HPC).

    Programación compartida

    ack.node.gpu.schedule: cgpu

    ack.node.gpu.schedule: core_mem

    ack.node.gpu.schedule: share

    ack.node.gpu.schedule: mps

    Ideal para tareas ligeras concurrentes, como escenarios de multiinquilinato e inference.

    • cgpu: Potencia de cómputo compartida con memoria de GPU aislada, basado en cGPU de Alibaba Cloud.

    • core_mem: Potencia de cómputo y memoria de GPU aisladas.

    • share: Potencia de cómputo y memoria de GPU compartidas sin aislamiento.

    • mps: Potencia de cómputo compartida con memoria de GPU aislada, basado en NVIDIA Multi-Process Service (MPS) con cGPU de Alibaba Cloud.

    ack.node.gpu.placement: binpack

    ack.node.gpu.placement: spread

    Optimiza la asignación de recursos en nodos con múltiples GPU que tienen habilitada la programación compartida cgpu, core_mem, share o mps.

    • binpack: (Predeterminado) Llena una GPU con pods antes de asignar la siguiente, lo que reduce la fragmentación de recursos. Ideal para maximizar la utilización o ahorrar energía.

    • spread: Distribuye los pods entre las GPU para reducir el impacto de la falla de una sola tarjeta. Adecuado para cargas de trabajo de alta disponibilidad.

    Programación con detección de topología

    ack.node.gpu.schedule: topology

    Asigna la combinación óptima de GPU a un pod según la topología física de las GPU dentro de un nodo. Ideal para tareas sensibles a la latencia de comunicación entre GPU.

    Programación por modelo de tarjeta

    aliyun.accelerator/nvidia_name: <nombre de tarjeta GPU>

    Use estas etiquetas para establecer la memoria de GPU y la cantidad de tarjetas para los trabajos.
    aliyun.accelerator/nvidia_mem: <memoria de GPU por tarjeta>
    aliyun.accelerator/nvidia_count: <número total de tarjetas GPU>

    Programa trabajos en nodos con un modelo específico de GPU o evita nodos con un modelo específico.

    Habilitar funciones de programación

    Un nodo solo admite un modo de programación de GPU a la vez (exclusivo, compartido o con detección de topología). Al habilitar un modo, los recursos extendidos reportados por otros modos se establecen en 0.

    Programación exclusiva

    Si no hay etiquetas de programación de GPU, la programación exclusiva es el modo predeterminado. Una sola tarjeta GPU es la unidad mínima de asignación para los pods.

    Si habilitó otro modo de programación de GPU, eliminar únicamente la etiqueta no restaura la programación exclusiva. Establezca la etiqueta en ack.node.gpu.schedule: default mediante el node pool para restaurarla.

    Programación compartida

    La programación compartida solo está disponible para clúster ACK administrado Pro. Consulte Limitations.

    1. Instalar el componente ack-ai-installer****

      1. Inicie sesión en la consola de ACK. En el panel de navegación izquierdo, haga clic en Clusters.

      2. En la página Clusters, haga clic en el nombre de su clúster. En el panel de navegación izquierdo, haga clic en Applications > Cloud-native AI Suite.

      3. En la página Cloud-native AI Suite, haga clic en Deploy. En la página Cloud-native AI Suite, seleccione Scheduling Policy Extension (Batch Task Scheduling, GPU Sharing, Topology-aware GPU Scheduling).

        Para configurar la política de programación cGPU, consulte Install and use the cGPU component .

      4. En la página Cloud-native AI Suite, haga clic en Deploy Cloud-native AI Suite.

        En la lista de componentes de la página Cloud-native AI Suite, compruebe que el componente ack-ai-installer esté instalado.

    2. Habilitar la programación compartida

      1. En la página Clusters, haga clic en el nombre del clúster de destino. En el panel de navegación izquierdo, elija Nodes > Node Pools.

      2. En la página Node Pools, haga clic en Create Node Pool, configure las etiquetas de nodo y luego haga clic en Confirm.

        Mantenga los valores predeterminados para las demás configuraciones. Consulte Scheduling label overview para ver casos de uso de etiquetas.

        • Configure la programación compartida básica.

          Haga clic en el icono Agregar Node Labels para Node Labels, establezca la Key en ack.node.gpu.schedule y seleccione uno de los siguientes valores de etiqueta: cgpu, core_mem, share o mps (requiere installing the MPS Control Daemon component).

        • Configure la programación compartida de múltiples tarjetas.

          Para nodos con varias tarjetas GPU, configure la programación de múltiples tarjetas para optimizar la asignación de recursos.

          Haga clic en el icono Agregar Node Labels para Node Labels, establezca la Key en ack.node.gpu.placement y seleccione uno de los siguientes valores de etiqueta: binpack o spread.

    3. Verificar la programación compartida

      cgpu/share/mps

      Compruebe que la programación compartida cgpu, share o mps esté habilitada. Reemplace <NODE_NAME> con el nombre de su nodo.

      kubectl get nodes <NODE_NAME> -o yaml | grep -q "aliyun.com/gpu-mem"

      Salida esperada:

      aliyun.com/gpu-mem: "60"

      Un valor distinto de cero confirma que la programación compartida cgpu, share o mps está habilitada.

      core_mem

      Compruebe que la programación compartida core_mem esté habilitada. Reemplace <NODE_NAME> con el nombre de su nodo.

      kubectl get nodes <NODE_NAME> -o yaml | grep -E 'aliyun\.com/gpu-core\.percentage|aliyun\.com/gpu-mem'

      Salida esperada:

      aliyun.com/gpu-core.percentage:"80"
aliyun.com/gpu-mem:"6"

      Los valores distintos de cero para aliyun.com/gpu-core.percentage y aliyun.com/gpu-mem confirman que la programación compartida core_mem está habilitada.

      binpack

      Use GPU resource query tool para comprobar la asignación de recursos de GPU en el nodo:

      kubectl inspect cgpu

      Salida esperada:

      NAME                   IPADDRESS      GPU0(Allocated/Total)  GPU1(Allocated/Total)  GPU2(Allocated/Total)  GPU3(Allocated/Total)  GPU Memory(GiB)
cn-shanghai.192.0.2.109  192.0.2.109  15/15                   9/15                   0/15                   0/15                   24/60
--------------------------------------------------------------------------------------
Allocated/Total GPU Memory In Cluster:
24/60 (40%)

      La GPU0 está totalmente asignada (15/15) antes que la GPU1 (9/15), lo que confirma que la estrategia binpack está activa.

      spread

      Use GPU resource query tool para comprobar la asignación de recursos de GPU en el nodo:

      kubectl inspect cgpu

      Salida esperada:

      NAME                   IPADDRESS      GPU0(Allocated/Total)  GPU1(Allocated/Total)  GPU2(Allocated/Total)  GPU3(Allocated/Total)  GPU Memory(GiB)
cn-shanghai.192.0.2.109  192.0.2.109  4/15                   4/15                   0/15                   4/15                   12/60
--------------------------------------------------------------------------------------
Allocated/Total GPU Memory In Cluster:
12/60 (20%)

      Los recursos se distribuyen uniformemente (4/15) entre GPU0, GPU1 y GPU3, lo que confirma que la política spread está activa.

    Programación con detección de topología

    La programación con detección de topología solo está disponible para clúster ACK administrado Pro. Consulte System component version requirements.

    1. Install the ack-ai-installer component.

    2. Habilitar la programación con detección de topología

      Agregue una etiqueta de programación con detección de topología mediante el node pool: En las etiquetas de nodo del node pool de destino, establezca la Key en ack.node.gpu.schedule con el valor topology.

      Al habilitar la programación de GPU con detección de topología en un nodo, se deshabilitan las cargas de trabajo de GPU sin detección de topología. Para restaurar la programación exclusiva, cambie el valor de la etiqueta a default mediante el node pool.

    3. Verificar la programación con detección de topología

      Compruebe que la programación con detección de topology esté habilitada. Reemplace <NODE_NAME> con el nombre de su nodo.

      kubectl get nodes <NODE_NAME> -o yaml | grep aliyun.com/gpu

      Salida esperada:

      aliyun.com/gpu: "2"

      Un valor distinto de cero para aliyun.com/gpu confirma que la programación con detección de topology está habilitada.

    Programación por modelo de tarjeta

    Programe trabajos en nodos con un modelo de GPU especificado o evite modelos específicos.

    1. Consultar el modelo de tarjeta GPU

      Consulte el modelo de tarjeta GPU de los nodos del clúster.

      El campo NVIDIA_NAME muestra el modelo de tarjeta GPU.
      kubectl get nodes -L aliyun.accelerator/nvidia_name

      Salida esperada:

      NAME                        STATUS   ROLES    AGE   VERSION            NVIDIA_NAME
cn-shanghai.192.XX.XX.176   Ready    <none>   17d   v1.26.3-aliyun.1   Tesla-V100-SXM2-32GB
cn-shanghai.192.XX.XX.177   Ready    <none>   17d   v1.26.3-aliyun.1   Tesla-V100-SXM2-32GB

      Métodos alternativos de comprobación

      En la página Clusters, haga clic en el nombre del clúster de destino. En el panel de navegación izquierdo, elija Workloads > Pods. Para un pod en ejecución (por ejemplo, tensorflow-mnist-multigpu-***), haga clic en Terminal en la columna Actions. Seleccione el contenedor de destino en la lista desplegable y ejecute los siguientes comandos.

      • Consulte el modelo de tarjeta: nvidia-smi --query-gpu=gpu_name --format=csv,noheader --id=0 | sed -e 's/ /-/g'

      • Consulte la memoria de GPU de cada tarjeta: nvidia-smi --id=0 --query-gpu=memory.total --format=csv,noheader | sed -e 's/ //g'

      • Consulte el número total de tarjetas GPU en el nodo: nvidia-smi -L | wc -l

    2. Habilitar la programación por modelo de tarjeta

      1. En la página Clusters, haga clic en el nombre de su clúster. En el panel de navegación izquierdo, haga clic en Workloads > Jobs.

      2. En la página Jobs, haga clic en Create from YAML. Use los siguientes ejemplos para crear una aplicación y habilitar la programación por modelo de tarjeta.

        Especificar modelo de tarjeta

        Asegúrese de que su aplicación se ejecute en nodos con un modelo específico de tarjeta GPU.

        En aliyun.accelerator/nvidia_name: "Tesla-V100-SXM2-32GB", reemplace Tesla-V100-SXM2-32GB con el modelo real de tarjeta de su nodo.

        Detalles de YAML

        apiVersion: batch/v1
kind: Job
metadata:
  name: tensorflow-mnist
spec:
  parallelism: 1
  template:
    metadata:
      labels:
        app: tensorflow-mnist
    spec:
      nodeSelector:
        aliyun.accelerator/nvidia_name: "Tesla-V100-SXM2-32GB" # Runs the application on a Tesla V100-SXM2-32GB GPU.
      containers:
      - name: tensorflow-mnist
        image: registry.cn-beijing.aliyuncs.com/acs/tensorflow-mnist-sample:v1.5
        command:
        - python
        - tensorflow-sample-code/tfjob/docker/mnist/main.py
        - --max_steps=1000
        - --data_dir=tensorflow-sample-code/data
        resources:
          limits:
            nvidia.com/gpu: 1
        workingDir: /root
      restartPolicy: Never

        Una vez creado el trabajo, elija Workloads > Pods . La lista de pods confirma que el pod está programado en un nodo con el modelo de tarjeta GPU coincidente.

        Excluir modelo de tarjeta

        Use etiquetas de modelo de tarjeta GPU con afinidad de nodo para evitar la programación en ciertos modelos de tarjeta.

        En values: - "Tesla-V100-SXM2-32GB", reemplace Tesla-V100-SXM2-32GB con el modelo real de tarjeta de su nodo.

        Detalles de YAML

        apiVersion: batch/v1
kind: Job
metadata:
  name: tensorflow-mnist
spec:
  parallelism: 1
  template:
    metadata:
      labels:
        app: tensorflow-mnist
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: aliyun.accelerator/nvidia_name  # Card model scheduling label
                operator: NotIn
                values:
                - "Tesla-V100-SXM2-32GB"            # Prevents the pod from being scheduled to a node with a Tesla-V100-SXM2-32GB card.
      containers:
      - name: tensorflow-mnist
        image: registry.cn-beijing.aliyuncs.com/acs/tensorflow-mnist-sample:v1.5
        command:
        - python
        - tensorflow-sample-code/tfjob/docker/mnist/main.py
        - --max_steps=1000
        - --data_dir=tensorflow-sample-code/data
        resources:
          limits:
            nvidia.com/gpu: 1
        workingDir: /root
      restartPolicy: Never

        Una vez creado el trabajo, la aplicación no se programa en nodos donde aliyun.accelerator/nvidia_name es Tesla-V100-SXM2-32GB, pero puede ejecutarse en nodos GPU con otros modelos de tarjeta.

    Mejor práctica: Usar node pools separados para cada modo de programación

    Cree un node pool separado para cada modo de programación de GPU y gestione los atributos de programación mediante etiquetas de node pool. Evite mezclar varios modos de programación dentro del mismo node pool. Configuración recomendada:

    • Node pool de programación exclusiva: No se requieren etiquetas de programación de GPU; los nodos usan la programación exclusiva de forma predeterminada. Adecuado para tareas que requieren acceso exclusivo a la GPU, como el entrenamiento de modelos y HPC.

    • Node pool de programación compartida: Establezca ack.node.gpu.schedule: cgpu (u otro valor de etiqueta compartida). Adecuado para escenarios que requieren mayor utilización de GPU, como servicios de inference y multiinquilinato.

    • Node pool de programación con detección de topología: Establezca ack.node.gpu.schedule: topology. Adecuado para tareas sensibles a la latencia de comunicación entre GPU, como el entrenamiento distribuido.

    Las etiquetas de programación por modelo de tarjeta (aliyun.accelerator/nvidia_name) pueden combinarse con cualquiera de los modos de programación anteriores para restringir aún más la programación de pods a nodos con modelos específicos de GPU.

    Cambiar modos de programación

    • Para cambiar el modo de programación de un nodo específico, elimine el nodo de su node pool actual y agréguelo al node pool con el modo de programación de destino.

    • Para cambiar el modo de programación de todo un node pool, modifique las etiquetas mediante operaciones de node pool. De forma predeterminada, los cambios de etiquetas en un node pool solo se aplican a los nuevos nodos. Para sincronizar los cambios con los nodos existentes, seleccione Update Labels and Taints of Existing Nodes al editar el node pool.

      Importante

      No se recomienda usar kubectl label para modificar directamente las etiquetas de programación de nodos, ya que esto puede causar problemas.

      Ejecutar kubectl label node <NODE_NAME> ack.node.gpu.schedule=<value> --overwrite para cambiar de modo de programación puede provocar errores de asignación de recursos en pods de GPU en ejecución, e incluso desencadenar la expulsión de pods o errores de programación irrecuperables. Use las etiquetas de node pool para gestionar los modos de programación y garantizar la coherencia en todos los nodos del pool.