En este instructivo, se muestra cómo implementar y entregar
Qwen3-30B-A3B (Qwen/Qwen3-30B-A3B-FP8),
un modelo de mezcla de expertos, en Google Kubernetes Engine (GKE). La implementación usa
aceleradores de TPU v6e (Trillium) de varios hosts y el
framework de entrega de vLLM TPU
con TorchTPU (torchtpu) y desagregación de decodificación de precompletado (PD).
En la configuración de implementación que se describe en este instructivo, aprovisionas
dos grupos de nodos ct6e-standard-4t de varios hosts, cada uno organizado en una topología
2x4 (ocho chips TPU v6e en dos nodos por grupo de nodos, para un total de 16
chips TPU v6e). Usa la API de JobSet de Kubernetes y Ray para hacer lo siguiente:
- Ejecuta servidores de decodificación y precompletado de varios hosts desagregados en porciones de TPU v6e independientes con el paralelismo de datos y el paralelismo de expertos habilitados.
- Enruta las solicitudes a través de un proxy de desagregación.
Para ejecutar un flujo de trabajo de entrega de TorchTPU de vLLM de varios hosts similar en aceleradores TPU7x (Ironwood) con el modelo Qwen3.5-397B más grande, consulta Entrega Qwen3.5-397B en GKE con TorchTPU de vLLM de varios hosts en aceleradores TPU7x.
Objetivos
- Configura tu clúster de GKE y los grupos de nodos de TPU v6e de varios hosts.
- Almacena en etapa intermedia las ponderaciones del modelo en un bucket de Cloud Storage.
- Implementa los servidores proxy, decodificación y precompletado de TorchTPU de vLLM de varios hosts con JobSet.
- Ejecutar una carga de trabajo de comparativas de entrega y analizar los resultados
- Realizar una limpieza
Costos
En este documento, usarás los siguientes componentes facturables de Google Cloud:
Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.
Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.
Antes de comenzar
Configura tu entorno para el instructivo:
Habilita la API de Kubernetes Engine en tu proyecto de Google Cloud :
Instala y, luego, inicializa Google Cloud CLI. Si usas Cloud Shell, omite este paso.
Instala
kubectly elgke-gcloud-auth-plugin. Si usas Cloud Shell, estas herramientas están preinstaladas.Si ejecutas este instructivo desde una estación de trabajo de Linux o macOS en lugar de Cloud Shell, instala la utilidad
envsubst(incluida en el paquetegettextogettext-base).Asegúrate de que tu proyecto tenga suficiente cuota de SSD y de direcciones IP externas en la región en la que se encuentra tu capacidad de TPU:
En la consola de Google Cloud , ve a la página Cuotas y límites del sistema.
Filtra por SSD de disco persistente (GB) y verifica que tengas suficiente cuota de SSD disponible en tu región de destino.
Filtra por Direcciones IPv4 externas regionales en uso y verifica que tengas suficiente cuota de direcciones IP en tu región de destino.
Obtén un token de acceso de Hugging Face
Necesitas un token de acceso de Hugging Face para usar este instructivo. Puedes registrarte para obtener una cuenta gratuita en Hugging Face. Después de tener una cuenta, genera un token de acceso:
- En la página Welcome to Hugging Face, haz clic en el avatar de tu cuenta y selecciona Tokens de acceso.
- En la página Tokens de acceso, haz clic en Crear token nuevo.
- Selecciona el tipo de token Lectura y, luego, ingresa un nombre para el token.
- Se mostrará tu token de acceso. Guarda el token en un lugar seguro.
Roles obligatorios
Si quieres obtener los permisos que necesitas para completar este instructivo, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:
- Administrador de Kubernetes Engine (
roles/container.admin) - Administrador de Compute (
roles/compute.admin) - Administrador de almacenamiento (
roles/storage.admin) - Usuario de la cuenta de servicio (
roles/iam.serviceAccountUser) - Consumidor de Service Usage (
roles/serviceusage.serviceUsageConsumer)
Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.
También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.
Configura tus variables de entorno
Para configurar tus variables de entorno, completa los siguientes pasos:
Configura la autenticación:
Exporta las variables de entorno que usarás en este instructivo:
Reemplaza lo siguiente:
YOUR_PROJECT_ID: Es el ID de tu proyecto de Google Cloud .YOUR_REGION: Es la región en la que deseas implementar el clúster, comous-central1.YOUR_ZONE: Es la zona en la que deseas implementar tus grupos de nodos de TPU v6e, comous-central1-c.YOUR_CLUSTER_NAME: el nombre del clúster de GKE. El nombre debe comenzar con una letra minúscula, contener solo letras minúsculas, números y guiones (-), no terminar con un guion y tener 40 caracteres o menos.YOUR_RESERVATION_NAME: Si usas una reserva, es el nombre de tu reserva de TPU v6e.YOUR_GCS_BUCKET: Es un nombre único a nivel global para el bucket de Cloud Storage que usas para almacenar en etapa intermedia los pesos del modelo. Para obtener más información, consulta Requisitos para nombrar los buckets.YOUR_HF_TOKEN: Es tu token de acceso de Hugging Face.
Si usas una imagen de contenedor de vLLM TorchTPU personalizada, reemplaza el URI de imagen
vllm/vllm-torchtpupredeterminado en la variableVLLM_IMAGEpor el URI de tu imagen. Para ver las imágenes públicas, consulta el repositorio de vLLM TorchTPU.
Crea el clúster de GKE
Para crear un clúster de GKE en modo estándar y conectar dos grupos de nodos TPU v6e de varios hosts para la desagregación de precompletado y decodificación, completa los siguientes pasos:
Crea un clúster de GKE regional con la federación de Workload Identity para GKE habilitada:
El resultado es similar a lo siguiente:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS STACK_TYPE asq-v6e us-central1 1.35.7-gke.1027000 35.226.172.84 e2-standard-4 1.35.7-gke.1027000 3 RUNNING IPV4Crea dos grupos de nodos de TPU v6e de varios hosts, cada uno con dos nodos
ct6e-standard-4t(ocho chips TPU v6e en una topología2x4por grupo de nodos, para un total de 16 chips TPU v6e). Selecciona tu opción de consumo de capacidad:VMs Spot
Aprovisiona los grupos de nodos con la capacidad de Spot (
--spot):Las instancias que usan la capacidad de Spot pueden tardar en crearse después de que se crea el grupo de nodos, y se pueden interrumpir durante las ejecuciones de las cargas de trabajo.
Reserva específica
Aprovisiona los grupos de nodos con una reserva específica:
Para obtener más información sobre las reservas de TPU, consulta Acerca de las reservas de Cloud TPU.
VMs de inicio flexible
Aprovisiona los grupos de nodos con la opción de consumo inicio flexible:
Para obtener más información, consulta Ejecuta una carga de trabajo por lotes pequeña con TPU y VMs de inicio flexible.
El resultado de cada grupo de nodos es similar al siguiente:
NAME MACHINE_TYPE DISK_SIZE_GB NODE_VERSION np-0 ct6e-standard-4t 100 1.35.7-gke.1027000Configura las credenciales de
kubectlpara comunicarte con tu clúster:
Almacena las ponderaciones del modelo en Cloud Storage
Almacena en etapa de pruebas las ponderaciones del modelo en un bucket de Cloud Storage para las ejecuciones de tu carga de trabajo:
Crea un bucket de Cloud Storage con acceso uniforme a nivel de bucket:
Otorga permisos de Identity and Access Management (IAM) en el bucket a tu cuenta de servicio predeterminada de Compute Engine y a la cuenta de servicio predeterminada de Kubernetes:
Crea un Secret de Kubernetes llamado
hf-secretpara almacenar tu token de acceso de Hugging Face:Recupera el manifiesto
download_qwen3_30b.yaml:Como alternativa, crea un archivo llamado
download_qwen3_30b.yamlcon el siguiente contenido:Descarga las ponderaciones del modelo
Qwen/Qwen3-30B-A3B-FP8en el volumen de etapa de pruebas y transfiérelas a tu bucket de Cloud Storage:Este paso tarda entre 5 y 10 minutos en completarse.
Espera a que se inicie el Pod y supervisa los registros del trabajo de descarga:
Una vez que finalice el trabajo, verifica que los siete fragmentos de
.safetensorsestén en tu bucket de Cloud Storage:Borra el trabajo de etapa de pruebas completado:
Implementa el servidor de TorchTPU de vLLM de varios hosts
El manifiesto de la carga de trabajo (v6e_qwen3_server_multihost_slice.yaml) define un
recurso JobSet de Kubernetes (vllm-qwen3-30b-pd-disagg-v6e) con tres
trabajos replicados que coordinan la entrega de precompletado y decodificación desagregados en
los dos grupos de nodos de TPU v6e de 2x4:
Servidor de precompletado (
prefill): Ejecuta dos réplicas en un grupo de nodos TPU v6e2x4(dos nodosct6e-standard-4tcon cuatro chips por host, para un total de ocho núcleos de TPU). Los Pods forman un clúster de Ray de dos nodos y, luego, inician vLLM TorchTPU en el puerto8000paraQwen/Qwen3-30B-A3B-FP8. El servidor usaTPURaidenConnectorconfigurado comokv_producercon las siguientes marcas:--data-parallel-size=8--tensor-parallel-size=1--enable-expert-parallel--load-format=runai_streamer
Servidor de decodificación (
decode): Ejecuta dos réplicas en el segundo grupo de nodos de TPU v6e2x4(ocho núcleos de TPU en total). El JobSet usa reglas de afinidad y antiafinidad de Pods en la etiquetacloud.google.com/gke-nodepoolpara aislar el precompletado y la decodificación en grupos de nodos independientes. Los Pods forman un clúster de Ray de dos nodos y, luego, inician vLLM TorchTPU en el puerto7200conTPURaidenConnectorconfigurado comokv_consumer.Proxy de desagregación (
proxy): Ejecuta la secuencia de comandostoy_proxy_server.pyen el puerto10000para coordinar el enrutamiento de solicitudes y la transferencia de caché de KV entre el servidor de precompletado (puerto8000) y el servidor de decodificación (puerto7200).
Para implementar y supervisar los servidores de vLLM desagregados, completa los siguientes pasos:
Instala el controlador y la CustomResourceDefinition de JobSet de Kubernetes en tu clúster:
Recupera el manifiesto del servidor:
Como alternativa, crea un archivo llamado
v6e_qwen3_server_multihost_slice.yamlcon el siguiente contenido:Sustituye el nombre del bucket de Cloud Storage y la imagen de contenedor en el archivo
v6e_qwen3_server_multihost_slice.yamly aplica el manifiesto:replicascloud.google.com/gke-tpu-topology- el recuento de TPU
ray status --data-parallel-size
Espera a que los Pods estén listos y, luego, supervisa los registros de los Pods de precompletado y decodificación hasta que se complete el inicio de la aplicación:
Espera a que los Pods de precompletado, decodificación y proxy alcancen el estado
Ready:Transmite los registros del servidor de pre-rellenado:
Transmite los registros del servidor de decodificación:
Para detener la transmisión de registros en cualquier momento, presiona Control + C. La carga y la compilación iniciales del modelo tardan entre 15 y 25 minutos aproximadamente en la primera ejecución.
Si usas capacidad interrumpible, como la capacidad de Spot o las VMs de inicio flexible, es posible que los nodos de porción de TPU tarden más en crearse después de la creación del grupo de nodos y que se interrumpan durante las ejecuciones de las cargas de trabajo. Para obtener más detalles, consulta Instancias de VMs interrumpibles. Para verificar si se crearon los nodos de porción de TPU, consulta Verifica el estado y las condiciones del nodo.
Espera hasta que los registros del servidor de precompletado y decodificación informen
Application startup completeantes de ejecutar la carga de trabajo de comparativas:(APIServer pid=1) INFO: Started server process [1] (APIServer pid=1) INFO: Waiting for application startup. (APIServer pid=1) INFO: Application startup complete.
Ejecuta una carga de trabajo de comparativas
Para comparar el modelo Qwen3-30B-A3B implementado con una carga de trabajo de entrada de 8,192 tokens y
salida de 1,024 tokens (8k/1k) con el proxy de desagregación, completa
los siguientes pasos:
Recupera el manifiesto de la comparativa:
Como alternativa, crea un archivo llamado
v6e_qwen3_benchmark_multihost_slice.yamlcon el siguiente contenido:Aplica el manifiesto del objeto Job de comparativas:
Espera a que el Pod de comparativas esté listo y supervisa los registros del trabajo de comparativas:
La carga de trabajo de comparativas tarda aproximadamente 10 minutos en completarse. Los registros del Pod de comparativas se detienen hasta que se completan.
Una vez que se complete la comparativa, busca un resultado que contenga métricas como las siguientes:
Output token throughputTotal token throughputTTFTTPOT
Realiza una limpieza
Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este instructivo, borra las cargas de trabajo de Kubernetes, el clúster de GKE y el bucket de Cloud Storage:
Borra el trabajo de comparativas, el JobSet del servidor de vLLM y el Secret de Hugging Face:
Borra el clúster de GKE, que borra automáticamente todos los grupos de nodos del clúster:
Como alternativa, si quieres conservar tu clúster de GKE, borra los grupos de nodos de TPU v6e (
np-0ynp-1):Borra el bucket de Cloud Storage que almacena los pesos del modelo en etapa de pruebas. Si quieres conservar los pesos del modelo, omite este paso o cópialos en la ubicación que prefieras:
¿Qué sigue?
- Obtén más información sobre vLLM en Cloud TPU.
- Obtén más información sobre la TPU v6e (Trillium).
- Más información sobre Cloud TPU.