En este documento, se explica cómo aprovisionar grupos de nodo TPU y programar porciones dinámicas en Google Kubernetes Engine (GKE) con Kueue y la programación basada en la topología (TAS).
También puedes usar la segmentación dinámica interactuando directamente con los recursos personalizados de Slice. Para obtener más información, consulta Usa la segmentación dinámica con un programador personalizado.
Antes de seguir estas instrucciones, asegúrate de comprender los conceptos de la segmentación dinámica.
Requisitos
Para usar la segmentación dinámica en GKE, debes cumplir con los siguientes requisitos:
- Usa un clúster de Standard en el canal rápido en una de las siguientes
versiones:
- Para la configuración de super-slicing dinámico (topologías iguales o superiores
a
4x4x4), usa la versión 1.35.2-gke.1842000 o una posterior. - Para la configuración de subsegmentación dinámica (topologías más pequeñas
que
4x4x4), usa la versión 1.36.0-gke.3712000 o una posterior.
- Para la configuración de super-slicing dinámico (topologías iguales o superiores
a
- Usa la versión Ironwood (TPU7x).
- Usa la imagen de Container-Optimized OS para tus nodos.
- Para usar el aprovisionamiento incremental, usa las reservas del modo All Capacity. El modo All Capacity es una función habilitada por Cluster Director de TPU.
- Para la división dinámica en porciones secundarias, asegúrate de que tus nodos tengan eventos de mantenimiento pendientes. Supervisa tus instancias para detectar eventos de mantenimiento pendientes. Si alguno de tus nodos tiene un evento de mantenimiento pendiente con una hora de finalización entre el 18 de septiembre de 2026 y el 30 de septiembre de 2026, debes activar de forma manual el evento de mantenimiento del host en esos nodos antes de poder usar la división secundaria.
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
- Para usar Google Cloud CLI en esta tarea,
instala y, luego,
inicializa la
gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando
gcloud components updatepara 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.
- Asegúrate de tener un clúster estándar existente en la versión 1.35.2-gke.1842000 o posterior, en el canal rápido. Para crear un clúster nuevo, consulta Crea un clúster regional.
- Asegúrate de tener suficiente cuota para Ironwood (TPU7x) en tu región.
- Si planeas ejecutar cargas de trabajo de Multislice, instala JobSet v0.10.1 o una versión posterior.
- Si planeas ejecutar cargas de trabajo de Ray, habilita el complemento Ray Operator en la versión 1.37 o posterior de GKE. Como alternativa, si administras tu propia instalación de KubeRay de código abierto en lugar de usar el complemento, instala KubeRay v1.6.2 o una versión posterior y el webhook de Ray TPU v1.4.2 o una versión posterior.
- Solicita capacidad de TPU en el modo All Capacity.
Usa la segmentación dinámica en GKE con Kueue
En esta sección, se describe el flujo de trabajo para usar la segmentación dinámica en GKE.
- Visualiza la topología y el estado de las reservas en el modo All Capacity.
- Habilita el controlador de porciones en tu clúster.
- Instala Kueue, JobSet, LWS y KubeRay.
- Crea nodo TPU TPU.
- Configura Kueue para crear un recurso personalizado Slice.
- Ejecuta cargas de trabajo en la segmentación dinámica con Kueue.
- Realiza una limpieza.
Habilita el controlador de porciones
Para usar la segmentación dinámica, habilita el controlador de porciones en tu clúster.
Actualiza tu clúster:
gcloud container clusters update CLUSTER_NAME \ --location=LOCATION \ --enable-slice-controllerReemplaza lo siguiente:
CLUSTER_NAME: El nombre de tu clúster.LOCATION: Es la región con tu capacidad de TPU disponible.
Obtén credenciales para poder comunicarte con tu clúster con los comandos de
kubectl:gcloud config set container/cluster CLUSTER_NAME gcloud container clusters get-credentials CLUSTER_NAME \ --location=LOCATIONEn el resultado del siguiente comando, verifica que el valor
slices.accelerator.gke.ioesté presente:kubectl get crd slices.accelerator.gke.ioEl resultado es similar a lo siguiente:
slices.accelerator.gke.io 2026-01-09T23:58:02Z
Instala Kueue, JobSet, LWS y KubeRay
Si ya instalaste Kueue, JobSet, LWS o KubeRay, puedes omitir esta sección.
Instala Kueue
Sigue las instrucciones de la documentación de Kueue o ejecuta el siguiente comando:
kubectl apply --server-side -f https://github.com/kubernetes-sigs/kueue/releases/download/KUEUE_VERSION/manifests.yaml
Reemplaza KUEUE_VERSION por la versión de Kueue requerida
según los requisitos de carga de trabajo y topología. Para la división dinámica en porciones, usa
Kueue v0.18.2 o una versión posterior. Para la división dinámica en porciones, usa Kueue v0.16.6 o una versión posterior.
Si planeas ejecutar cargas de trabajo de Ray, usa Kueue v0.20.1 o una versión posterior, o v0.19.8 o
una versión posterior en la serie de versiones v0.19.
Instala JobSet
Sigue las instrucciones de la documentación de JobSet o ejecuta el siguiente comando:
kubectl apply --server-side -f https://github.com/kubernetes-sigs/jobset/releases/download/JOBSET_VERSION/manifests.yaml
Reemplaza JOBSET_VERSION por la versión de JobSet requerida
según tus requisitos de topología. Para la división dinámica en porciones secundarias, usa JobSet
v0.12.0 o una versión posterior. Para el super-slicing dinámico, usa JobSet v0.11.1 o una versión posterior.
Instala LWS
LeaderWorkerSet (LWS) solo es necesario para la división dinámica en subporciones.
Sigue las instrucciones de la documentación de LWS o ejecuta el siguiente comando:
kubectl apply --server-side -f https://github.com/kubernetes-sigs/lws/releases/download/LWS_VERSION/manifests.yaml
Reemplaza LWS_VERSION por la versión de LWS requerida. Usa
LWS v0.8.0 o una versión posterior.
Instala KubeRay
Si planeas ejecutar cargas de trabajo de Ray, habilita el operador de Ray en tu clúster. El operador de Ray requiere la versión 1.37 o posterior de GKE:
gcloud container clusters update CLUSTER_NAME \
--location=LOCATION \
--update-addons=RayOperator=ENABLED
Reemplaza lo siguiente:
CLUSTER_NAME: El nombre de tu clúster.LOCATION: la región o zona de Compute Engine del clúster.
El complemento Ray Operator incluye automáticamente el webhook de Ray TPU. Si administras tu propia instalación de KubeRay de código abierto en lugar de usar el complemento, instala KubeRay v1.6.2 o una versión posterior siguiendo la documentación de KubeRay. Luego, configura las variables de entorno y la admisión de trabajador TPU instalando el webhook de Ray TPU v1.4.2 o posterior.
Crea grupos de nodos con aprovisionamiento incremental
En esta sección, se describe cómo crear los grupos de nodo TPU con aprovisionamiento incremental. GKE convierte toda tu capacidad de TPU en grupos de nodos que comprenden grupos de 16 nodos de VMs de Ironwood (TPU7x) o subbloques. GKE aprovisiona estos grupos de nodos incluso cuando no puede encontrar todas las VMs en buen estado. Para ello, coloca nodos en partes en buen estado de la máquina anfitrión y aprovisiona de forma incremental las máquinas en mal estado mientras se reparan.
Puedes orientar tu grupo de nodos para que pertenezca a cualquiera de las siguientes opciones:
- Es un bloque específico de TPU, que se expone en las reservas del modo All Capacity. La segmentación por bloques permite que GKE cree el grupo de nodos en cualquier subbloque disponible dentro del bloque especificado.
- Un subbloque específico o un grupo específico de 16 nodos de VMs de Ironwood (TPU7x) de TPU para un control más detallado.
Crear una política de cargas de trabajo
Para crear un grupo de nodos de porción de TPU con Ironwood (TPU7x), primero debes crear una
política de carga de trabajo con el campo accelerator-topology-mode establecido en provision_only. Este parámetro de configuración
activa el proceso de aprovisionamiento incremental.
Crea una política de cargas de trabajo:
gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
--project=PROJECT_ID \
--region=REGION \
--type=HIGH_THROUGHPUT \
--accelerator-topology=4x4x4 \
--accelerator-topology-mode=provision_only
Reemplaza lo siguiente:
WORKLOAD_POLICY_NAME: Es un nombre para tu política de carga de trabajo.PROJECT_ID: Es el ID del proyecto de Google Cloud .REGION: Es la región de la política de carga de trabajo.
En este comando, haz lo siguiente:
- Siempre establece el campo
accelerator-topologyen4x4x4para que coincida con la cantidad total de chips dentro de un solo subbloque. - Siempre establece el campo
accelerator-topology-modeenprovision_onlypara asegurarte de que se active el proceso de aprovisionamiento incremental. Cuando se establece el campoprovision_only, el grupo de nodos aprovisiona nodos TPU sin formar vínculos ICI ni OCS.
Orienta tu grupo de nodos para que pertenezca a un bloque o un subbloque
Puedes segmentar subbloques o bloques específicos dentro de tu reserva en el modo All Capacity.
- Orientar a un bloque: Cada grupo de nodos usa la capacidad de un bloque especificado. GKE coloca el grupo de nodos dentro de un subbloque disponible en ese bloque. Debes crear tantos grupos de nodos como subbloques haya en el bloque que deseas usar.
Orientación a un subbloque: Cada grupo de nodos se asigna a un subbloque específico y disponible. Cuando se usa la segmentación por subbloque, GKE crea el grupo de nodos si al menos una VM está en buen estado. El aprovisionamiento incremental ayuda a garantizar que todos los nodos se ubiquen dentro del subbloque especificado.
Bloquear
Para recuperar el nombre del bloque en una reserva y el recuento de subbloques disponibles en el bloque, completa los siguientes pasos en el documento Visualiza la topología y el estado de las reservas en el modo All Capacity:
Identifica el nombre del bloque enumerando todos los bloques de reserva y copiando el valor en el campo
name:. Este valor es el nombre del bloque oBLOCK_NAMEen este documento.Determina cuántos grupos de nodos crear describiendo un bloque de reserva e identificando el valor en el campo
reservationSubBlockCount. Este valor es la cantidad de subbloques disponibles. Por ejemplo, el valorreservationSubBlockCount: 4indica que el bloque tiene cuatro subbloques disponibles y que debes crear cuatro grupos de nodos independientes.
Establece la ruta de acceso de la reserva:
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME"Reemplaza lo siguiente:
RESERVATION_NAME: Es el nombre de tu reserva de TPU.BLOCK_NAME: el nombre del bloque.
Crea un grupo de nodos para cada subbloque identificado en el paso anterior. Por ejemplo, si el recuento es
4, ejecuta este comando cuatro veces. Usa un nombre único para cada grupo de nodos.gcloud container node-pools create NODE_POOL_NAME \ --cluster=CLUSTER_NAME \ --node-locations=ZONE \ --machine-type=tpu7x-standard-4t \ --num-nodes=16 \ --placement-policy=WORKLOAD_POLICY_NAME \ --reservation-affinity=specific \ --reservation=${RESERVATION_PATH}Reemplaza lo siguiente:
NODE_POOL_NAME: es el nombre de tu grupo de nodos nuevo.CLUSTER_NAME: Es el nombre del clúster de GKE.WORKLOAD_POLICY_NAME: Es el nombre de la política de carga de trabajo que creaste.ZONE: Es la zona del grupo de nodos, por ejemplo,us-central1-a.
En subbloque
Para recuperar el nombre del bloque y los IDs de los subbloques disponibles, completa los siguientes pasos en el documento Visualiza la topología y el estado de las reservas en el modo All Capacity:
Para identificar el nombre del bloque, enumera todos los bloques de reserva y copia el valor en el campo
name:. Este valor es el nombre del bloque oBLOCK_NAMEen este documento.Para identificar el nombre de los subbloques, enumera todos los subbloques de un bloque y copia el valor en el campo
name:para cada entrada enreservationSubBlocks. Este valor es el nombre del subbloque oSUBBLOCK_NAMEen este documento.
Establece la ruta de acceso de la reserva:
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUBBLOCK_NAME"Reemplaza lo siguiente:
RESERVATION_NAME: Es el nombre de tu reserva de TPU.BLOCK_NAME: el nombre del bloque.SUBBLOCK_NAME: el nombre del subbloque.
Crea el grupo de nodos:
gcloud container node-pools create NODE_POOL_NAME \ --project=PROJECT_ID \ --cluster=CLUSTER_NAME \ --node-locations=ZONE \ --machine-type=tpu7x-standard-4t \ --num-nodes=16 \ --placement-policy=WORKLOAD_POLICY_NAME \ --reservation-affinity=specific \ --reservation=${RESERVATION_PATH}Reemplaza lo siguiente:
NODE_POOL_NAME: Es un nombre único para el grupo de nodos nuevo, por ejemplo,sub-block-pool-1.PROJECT_ID: Es el ID del proyecto de Google Cloud .CLUSTER_NAME: el nombre del clúster de GKE.ZONE: la zona del grupo de nodos, por ejemplo,us-central2-b.WORKLOAD_POLICY_NAME: Es el nombre de la política de carga de trabajo que creaste.
En esta etapa, se crean los nodos, pero sus vínculos de interconexión entre chips (ICI) aún no están activos. Por lo tanto, no puedes ejecutar cargas de trabajo en estos grupos de nodos directamente.
Para habilitar todos los vínculos de ICI necesarios para formar el segmento y permitir que se programen las cargas de trabajo, crea un segmento dinámico con uno de los siguientes métodos:
- Crea un recurso personalizado Slice. En lugar de Pods, usas un recurso personalizado Slice para definir la topología especificada, que activa el controlador de porciones.
- Programa cargas de trabajo de GKE con Kueue y TAS. Kueue controla automáticamente la creación y eliminación de recursos personalizados de Slice. Evita modificar manualmente los recursos personalizados de Slice creados por Kueue.
Crea una porción dinámica con Kueue y TAS
En esta sección, programarás cargas de trabajo de GKE con Kueue y TAS.
Instala el controlador de porciones de Kueue
Para instalar el controlador de porciones de Kueue, guarda el siguiente manifiesto como
slice-controller.yaml:Aplica el manifiesto
slice-controller.yaml:kubectl apply -f slice-controller.yamlPara configurar Kueue para la segmentación dinámica, guarda el siguiente manifiesto como
dynamic-slice-topology.yaml:Aplica el manifiesto
dynamic-slice-topology.yaml:kubectl apply -f dynamic-slice-topology.yamlEn este manifiesto, configuras Kueue para la segmentación dinámica definiendo los siguientes recursos:
- Topología de porción dinámica de Ironwood (TPU7x) (
superslice-topology): La topología define los niveles que Kueue considera cuando programa cargas de trabajo de segmentación dinámica. Estos niveles son los siguientes:- Etiqueta
cloud.google.com/gce-topology-block: Este nivel es obligatorio para comprender qué subbloques pertenecen a qué bloques, ya que solo los subbloques del mismo bloque pueden formar un segmento. - Etiqueta
cloud.google.com/gke-tpu-partition-4x4x4-id: Este nivel representa subbloques individuales de Ironwood (TPU7x) (topología4x4x4). - Etiquetas
cloud.google.com/gke-tpu-partition-2x4x4-id,cloud.google.com/gke-tpu-partition-2x2x4-id,cloud.google.com/gke-tpu-partition-2x2x2-idycloud.google.com/gke-tpu-partition-2x2x1-id: estos niveles representan particiones dinámicas de porciones secundarias dentro de un subbloque y requieren la versión 1.36.0-gke.3712000 o posterior de GKE. - Etiqueta
kubernetes.io/hostname: Este nivel es obligatorio para asignar Pods a VMs específicas y observar sus etiquetas y taints.
- Etiqueta
- ResourceFlavor de SuperSlice de Ironwood (TPU7x) (
superslice-rf) y ResourceFlavor predeterminado (default-flavor): El tipo de recursosuperslice-rfincluye la etiquetacloud.google.com/gke-tpu-accelerator: tpu7xpara que coincida con los nodos con máquinas de Ironwood (TPU7x). El tipo de recursodefault-flavorvacío coincide con los Pods que solo tienen CPU, como un Pod principal de Ray. - SuperSlice AdmissionCheck (
superslice-ac): Esta verificación de admisión le indica a Kueue que no programe una carga de trabajo hasta que el controlador de porciones de GKE confirme que la porción se activó. Primero, se define la verificación de admisión y, luego, se agrega alClusterQueueque controla las cargas de trabajo de segmentación dinámica. - ClusterQueue (
cq) y LocalQueue (lq): Estos campos administran los recursosgoogle.com/tpu,cpuymemory. La ClusterQueuecqincluye la verificación de admisiónsuperslice-acen la secciónadmissionChecksStrategy. El camponominalQuotase puede configurar de dos maneras:- Cuota específica: Establece el campo
nominalQuotapara que coincida con la capacidad existente para el uso compartido justo y la administración de cuotas. - Cuota ilimitada: Establece el campo
nominalQuotaen un valor muy alto, como"999999", para modelar una cuota ilimitada. Para enfocarse en TAS y la segmentación dinámica, esta configuración omite la funcionalidad de administración de cuotas de Kueue.
- Cuota específica: Establece el campo
- Topología de porción dinámica de Ironwood (TPU7x) (
Define la selección del estado de la partición
Más allá del estado y la preparación estándar de los nodos, GKE expone el estado específico de
cada forma de partición con la etiqueta cloud.google.com/gke-tpu-partition-[shape]-state
(en la que [shape] coincide con la forma del ID de partición, como 2x2x1, 2x2x2, 2x2x4, 2x4x4
o 4x4x4). Esta etiqueta permite que GKE tenga en cuenta los factores que influyen en la formación de porciones,
como el estado de los vínculos de TPU. La configuración de subsegmentación dinámica (topologías más pequeñas
que 4x4x4) requiere la versión 1.36.0-gke.3712000 o posterior de GKE.
Puedes definir el valor de la etiqueta de estado de la partición de la siguiente manera:
HEALTHY: La partición está en buen estado y es completamente funcional.DEGRADED: La infraestructura de la partición se encuentra en un estado degradado, por ejemplo, debido a la degradación del vínculo de OCS. La partición aún puede formar un segmento, pero el rendimiento general puede ser menor en comparación con las particiones en buen estado. Este estado solo se aplica a la topología4x4x4de nivel superior. Las topologías más pequeñas no tienen un estado degradado.UNHEALTHY: La partición no está en buen estado y no puede formar una porción.UNSET: El estado no está definido debido a que la inicialización del controlador de porciones de GKE no se realizó correctamente.INCOMPLETE: No se aprovisionan todos los nodos dentro de la partición.
El webhook del controlador de porciones de Kueue valida si una carga de trabajo incluye un requisito de estado de partición específico. Si no se indica ninguna preferencia, el webhook inserta una afinidad de nodo predeterminada.
El comportamiento es el siguiente:
- Si hay un
nodeSelectoronodeAffinityque se orienta a la etiquetacloud.google.com/gke-tpu-partition-[shape]-state, no se modifica. Si no existe tal configuración de etiqueta, el webhook inserta la siguiente afinidad de nodo predeterminada para garantizar que solo se usen las particiones disponibles:
nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: cloud.google.com/gke-tpu-partition-4x4x4-state operator: In values: - "HEALTHY" - "DEGRADED"
En la siguiente sección, se incluyen ejemplos en los que se configura la etiqueta cloud.google.com/gke-tpu-partition-4x4x4-state para especificar los diferentes parámetros de configuración de estado de los subbloques.
Ejecuta cargas de trabajo de prueba en la segmentación dinámica con Kueue
En esta sección, se describe cómo implementar cargas de trabajo en la segmentación dinámica con Kueue y TAS. Incluye ejemplos que muestran cómo crear una carga de trabajo de porción dinámica y una carga de trabajo que consta de varias porciones. Las cargas de trabajo se envían como recursos de JobSet o Ray.
Ejemplo 1: Una sola carga de trabajo usa un solo segmento dinámico
En el siguiente ejemplo, se describe cómo crear una carga de trabajo con una porción que tenga una
topología 4x12x16, que se compone de 12 subbloques. La cantidad de Pods se
calculó de la siguiente manera: (4 * 12 * 16) / 4 chips por nodo = 192 Pods.
Guarda el siguiente manifiesto como
big-super-slice.yaml:En este manifiesto, las siguientes anotaciones le indican a Kueue las características y la topología de la porción para configurar lo siguiente:
cloud.google.com/gke-tpu-slice-topology: Especifica"4x12x16"como la topología de porción dinámica. Los requisitos para la topología del aceleradortpu7xincluyen las siguientes reglas:- Para la división dinámica en porciones secundarias, puedes especificar topologías más pequeñas que
4x4x4, como2x2x1,2x2x2,2x2x4o2x4x4. Estas topologías más pequeñas requieren la versión 1.36.0-gke.3712000 o posterior de GKE. - Para la división dinámica en superporciones: Puedes especificar topologías que sean
iguales o superiores a
4x4x4. Para la configuración dinámica de super-slicing, cada dimensión de la topología solicitada debe ser un múltiplo de cuatro, por ejemplo,4A x 4B x 4C. - La topología debe ser una cadena tridimensional en el formato
AxBxC, por ejemplo,4x8x8. - Las dimensiones deben ordenarse de forma no decreciente: A <= B <= C. Por
ejemplo,
4x8x4no es válido; debería ser4x4x8. - El producto de las dimensiones (ABC) no debe superar 9,216.
- Las topologías de porciones más grandes admitidas pueden incluir hasta 32 subbloques. Por
ejemplo,
8x16x16con 32 subbloques,8x12x20con 30 subbloques o12x12x12con 27 subbloques están dentro de los límites aceptados.
- Para la división dinámica en porciones secundarias, puedes especificar topologías más pequeñas que
cloud.google.com/gke-tpu-accelerator: tpu7x: Programa Pods en VMs que ejecutan Ironwood (TPU7x).kueue.x-k8s.io/queue-name: asigna el JobSet a una LocalQueue de Kueue.- El webhook inserta la afinidad de nodos predeterminada para garantizar que se usen los nodos
HEALTHYyDEGRADED.
Aplica el manifiesto
big-super-slice.yaml:kubectl apply -f big-super-slice.yamlDespués de aplicar el manifiesto, Kueue crea un
JobSetllamadobig-super-slice. Luego, Kueue intenta formar una sola porción dinámica con una topología4x12x16. Una vez que el segmento está activo, Kueue admite la carga de trabajo y los 192 Pods se programan en los nodos para formar el segmento dinámico que ejecuta tus cargas de trabajo.
Ejemplo 2: Carga de trabajo con más de una réplica
En el siguiente ejemplo, se muestra cómo crear una carga de trabajo que use dos
segmentaciones dinámicas, cada una compuesta por cuatro subbloques que se orienten solo a nodos HEALTHY.
Guarda el siguiente manifiesto como
two-super-slices.yaml:Aplica el manifiesto
two-super-slices.yaml:kubectl apply -f two-super-slices.yaml
En este manifiesto, estableces el campo replicas en 2 en la sección replicatedJobs.
Después de aplicar el manifiesto, Kueue
intenta formar dos porciones independientes con una topología 4x8x8. Kueue crea una
segmentación dinámica para cada réplica definida en jobset.spec.replicatedJobs[].replicas.
Si se especifican n réplicas, Kueue crea n porciones dinámicas para la carga de trabajo
y espera a que todas las porciones se activen antes de admitir la carga de trabajo.
Ejemplo 3: Ejecuta una carga de trabajo de Ray en una porción dinámica
En el siguiente ejemplo, se muestra cómo ejecutar una carga de trabajo de Ray distribuida en una segmentación dinámica con KubeRay y TAS de Kueue. Antes de implementar la carga de trabajo, asegúrate de haber instalado KubeRay.
En este ejemplo, se implementa un recurso personalizado de RayJob que solicita una porción secundaria dinámica de 2x2x2 en dos hosts de trabajadores de tpu7x-standard-4t (ocho chips, 16 dispositivos lógicos de JAX). El recurso RayJob ejecuta una secuencia de comandos de Python que inicializa Ray y
verifica la asignación de dispositivos TPU de JAX en ambos hosts de trabajador.
Guarda el siguiente manifiesto como
rayjob-dynamic-slice.yaml:En este manifiesto, se aplica lo siguiente:
cloud.google.com/gke-tpu-slice-topology: "2x2x2": solicita una porción secundaria dinámica de2x2x2. El webhook del controlador de porciones de Kueue inserta automáticamente las anotaciones de TAS de Kueue necesarias para la partición2x2x2.kueue.x-k8s.io/queue-name: lq: Se orienta a la LocalQueue de Kueue.shutdownAfterJobFinishes: true: Apaga automáticamente el clúster de Ray cuando finaliza el trabajo por lotes. Kueue lo requiere.tolerations: Tolera de forma explícita el reprochegoogle.com/tpu=present:NoSchedulepara que TAS de Kueue valide la plantilla de PodSet antes de la admisión.
Crea el RayJob a partir del manifiesto
rayjob-dynamic-slice.yaml:kubectl create -f rayjob-dynamic-slice.yamlVerifica que Kueue haya admitido la carga de trabajo y que el segmento dinámico esté activo:
kubectl get slices.accelerator.gke.ioEl resultado confirma que el estado de la porción es
ACTIVE:NAME TYPE TOPOLOGY STATE AGE rayjob-tpu7x-dynamic-slice-tpu-workers-0-046a2cbc tpu7x 2x2x2 ACTIVE 20sVerifica el descubrimiento de TPU en los trabajadores inspeccionando los registros del remitente del trabajo:
kubectl logs -l ray.io/originated-from-crd=RayJob -c ray-job-submitter --tail=-1En el resultado, confirma los siguientes detalles:
- La sección
Cluster resourcesincluye el par clave-valor'TPU': 8.0. - En la sección
=== Worker TPU Devices ===, se muestra el bloquebackend: 'tpu', con los pares clave-valordevice_count: 16ylocal_device_count: 8para ambos trabajadores. - El resultado termina con el mensaje
Job 'rayjob-tpu7x-dynamic-slice-...' succeeded.
- La sección
Después de crear el RayJob, Kueue pone en cola la carga de trabajo hasta que el segmento dinámico esté activo, admite la carga de trabajo y, luego, inicia el clúster de Ray para ejecutar la secuencia de comandos de punto de entrada.
Para los clústeres de Ray interactivos o de larga duración, puedes implementar un recurso personalizado de RayCluster
con la muestra
raycluster-dynamic-slice.yaml. Establece el par clave-valor spec.suspend: true para que Kueue aprovisione el
segmento dinámico antes de que KubeRay cree Pods de trabajador.
Optimiza la programación de cargas de trabajo con la reutilización de porciones
De forma predeterminada, Kueue le indica al controlador de porciones que aprovisione una nueva porción de TPU para cada ejecución de carga de trabajo y que la borre cuando se complete la carga de trabajo. Este comportamiento puede generar deserción y sobrecarga en la infraestructura subyacente.
Con la reutilización de porciones, las cargas de trabajo nuevas pueden reutilizar porciones de TPU inactivas existentes que tengan límites de hardware y topología idénticos. Cuando habilitas la reutilización de porciones, Kueue marca la porción como inactiva al final de un trabajo en lugar de borrarla. Un trabajo nuevo que solicita la misma partición reclama y reutiliza la porción de forma instantánea, lo que evita el retraso en el aprovisionamiento del hardware.
Habilita la reutilización de porciones
Para optimizar por completo la reutilización de porciones, debes configurar el controlador de Slice y Kueue para que funcionen juntos.
Configura el controlador de porciones: Actualiza los argumentos de implementación del controlador de porciones de Kueue para incluir la marca
--reuse-slices=true. Para garantizar que las cargas de trabajo se programen de forma óptima en los segmentos existentes, agrega también la marca--add-preferred-node-affinity=true.Configura Kueue (recomendado): Para permitir que Kueue use las sugerencias de afinidad de nodos preferidas del controlador, debes habilitar el interruptor de función
TASRespectNodeAffinityPreferreden tu configuración de Kueue.Por ejemplo, edita el ConfigMap
kueue-manager-configpara agregar el interruptor de función:apiVersion: v1 kind: ConfigMap metadata: name: kueue-manager-config namespace: kueue-system data: controller_manager_config.yaml: | apiVersion: config.kueue.x-k8s.io/v1beta1 kind: Configuration featureGates: TASRespectNodeAffinityPreferred: true # ...Después de cambiar el ConfigMap, reinicia la implementación de
kueue-controller-managerpara aplicar el cambio:kubectl rollout restart deploy kueue-controller-manager -n kueue-system
Aplicar la eliminación de porciones por carga de trabajo
Para que una carga de trabajo específica limpie sus porciones y evite que se reutilicen, completa los siguientes pasos:
Aplica la siguiente etiqueta a tu definición de Job o JobSet:
kueue.gke.io/tpu-enforce-slice-deletion: "true"Después de aplicar esta etiqueta, la carga de trabajo aún se puede programar en una porción inactiva existente. Sin embargo, después de que se complete la carga de trabajo, la porción se borrará de forma permanente en lugar de devolverse al grupo reutilizable.
Configura Kueue para que pase esta etiqueta del objeto Job del framework al objeto Workload de Kueue. Para ello, agrega la etiqueta a la lista
labelKeysToCopyen tu configuración de Kueue:labelKeysToCopy: - "kueue.gke.io/tpu-enforce-slice-deletion"
Supervisa el segmento
Puedes ver el estado de la porción y supervisar sus métricas con las métricas del sistema de GKE.
Supervisa el estado de la porción
Cuando una carga de trabajo crea o usa de forma activa una porción, el controlador de porciones adjunta etiquetas para identificar la carga de trabajo que la usa. Debido a que los nombres de Slice se generan de forma dinámica (y se desvinculan del nombre de la carga de trabajo cuando se habilita la reutilización), debes usar estas etiquetas para encontrar el Slice asignado a tu carga de trabajo.
Para encontrar los segmentos asignados a una carga de trabajo, ejecuta el siguiente comando:
kubectl get slice -l kueue.gke.io/tpu-slice-used-by-namespace=NAMESPACE,kueue.gke.io/tpu-slice-used-by-workload=WORKLOAD_NAMEReemplaza lo siguiente:
NAMESPACE: el espacio de nombres de tu carga de trabajo.WORKLOAD_NAME: Es el nombre de la carga de trabajo de Kueue, que suele ser el mismo que el del objeto Job o JobSet.
Copia el nombre de la porción del resultado del comando anterior.
Usa el nombre de la porción para verificar el estado detallado de tu porción dinámica:
kubectl describe slice SLICE_NAMEReemplaza
SLICE_NAMEpor el nombre de tu porción.
El resultado es similar a lo siguiente:
Name: s-4x4x4-74d3fb0b
Namespace:
Labels: <none>
Annotations: <none>
API Version: accelerator.gke.io/v1beta1
Kind: Slice
Metadata:
Creation Timestamp: 2026-02-12T23:44:28Z
Finalizers:
accelerator.gke.io/slice-finalizer
Generation: 1
Resource Version: 1770939905695871008
UID: 6dbbfe14-4486-4462-864d-e078d0ca8b5b
Spec:
Partition Ids:
5eae6a4f59d59cf30a9bf49de618eb2b
Topology: 4x4x4
Type: tpu7x
Status:
Conditions:
Last Transition Time: 2026-02-12T23:45:05Z
Message:
Reason: ACTIVE
Status: True
Type: Ready
Last Transition Time: 2026-02-12T23:45:05Z
Message: NodeLabelingCompleted
Reason: NodeLabelIsAdded
Status: True
Type: NodeLabeled
Events: <none>
Supervisa las métricas de la porción
Puedes supervisar las siguientes métricas del sistema de GKE que exponen la condición de una porción:
kubernetes.io/accelerator/slice/statekubernetes.io/accelerator/partition/statekubernetes.io/accelerator/slice/deformation_durationskubernetes.io/accelerator/slice/formation_durations
Para obtener más información sobre las métricas, consulta Métricas del sistema de GKE.
Métricas del controlador de Kueue Slice
También puedes supervisar las siguientes métricas de Prometheus que expone el controlador de porciones de Kueue para observar el ciclo de vida, la reutilización y las verificaciones de admisión de las porciones:
Métricas del ciclo de vida de Slice
Las métricas del ciclo de vida de Slice hacen un seguimiento de la creación y eliminación de segmentos:
tpu_ac_slice_create_time: Es un histograma que mide cuánto tiempo tardó en crearse la porción.tpu_ac_slices_created: Contador que hace un seguimiento de los segmentos creados (incluye una etiquetais_reusable).tpu_ac_slices_status: Es un indicador que hace un seguimiento de la cantidad actual de porciones por estado, incluidas las etiquetasis_reusableyin_use.tpu_ac_slice_delete_time: Es un histograma que mide cuánto tiempo tardó en borrarse la porción.tpu_ac_slices_deleted: Contador que hace un seguimiento de las porciones borradas.tpu_ac_slices_gc: El contador de seguimiento eliminó automáticamente las porciones.
Métricas de reutilización de porciones
Las métricas de reutilización de Slice hacen un seguimiento de la reutilización exitosa y los conflictos de las porciones de TPU:
tpu_ac_slices_reused: Es el contador que hace un seguimiento de las porciones reutilizadas correctamente.tpu_ac_slices_conflict: Indica las porciones de seguimiento de contadores que se borraron debido a discrepancias de topología o forma.
Métricas de carga de trabajo y admisión
Las métricas de carga de trabajo y admisión realizan un seguimiento de la duración y los resultados de las verificaciones de admisión:
tpu_ac_admission_time: Es un histograma que mide la duración del proceso de verificación de admisión. Nota: Esto mide la duración de la verificación de admisión del controlador de porciones y no incluye el tiempo general de admisión de la carga de trabajo de Kueue.tpu_ac_workload_processed: Es el contador de decisiones de verificación de admisión, que contiene una etiquetatarget_state.
Métricas generales
Las métricas generales hacen un seguimiento de los problemas y errores operativos:
tpu_ac_problem: Es un contador que hace un seguimiento de los problemas o errores operativos. Esta métrica incluye una etiquetaproblemque indica el tipo de error específico.
Realiza una limpieza
Para evitar cargos inesperados, borra tus porciones antes de borrar los grupos de nodos.
Borra tus cargas de trabajo. Esta acción activa Kueue para borrar los recursos personalizados de Slice asociados:
Para JobSets:
kubectl delete jobset JOBSET_NAMEReemplaza
JOBSET_NAMEpor el nombre de tu JobSet, por ejemplo,big-super-slice.Para RayJobs:
kubectl delete rayjob -l kueue.x-k8s.io/queue-name=lqPara RayClusters:
kubectl delete raycluster RAY_CLUSTER_NAMEReemplaza
RAY_CLUSTER_NAMEpor el nombre de tu RayCluster.
Borra el grupo de nodo TPU:
gcloud container node-pools delete NODE_POOL_NAME \ --cluster=CLUSTER_NAME \ --location=LOCATION
Usa la segmentación dinámica con tu propio programador (opcional)
Este documento se enfoca en el uso de Kueue y TAS. Sin embargo, también puedes administrar la segmentación dinámica con tu propio programador personalizado. Si eliges usar un programador diferente, sigue la información de referencia del recurso personalizado Slice.
¿Qué sigue?
- Obtén más información sobre el Cluster Director de TPU.
- Obtén información para administrar eventos de mantenimiento con TPU en el modo All Capacity.
- Aprende a implementar cargas de trabajo de Cloud TPU con segmentación dinámica en Cluster Toolkit.