Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Usa vLLM en GKE para ejecutar la inferencia con gpt-oss-120b

GPU agrupadas

En este instructivo, se muestra cómo implementar y entregar un modelo de lenguaje gpt-oss-120b con el framework de vLLM. Implementas este modelo en un clúster de Autopilot de Google Kubernetes Engine (GKE) y consumes una sola máquina virtual A4 (VM) que tiene 8 GPU B200.

Este instructivo está dirigido a ingenieros de aprendizaje automático (AA), administradores y operadores de plataformas, y especialistas en datos y en IA que estén interesados en usar las funciones de organización de contenedores de Kubernetes para controlar las cargas de trabajo de inferencia.

Objetivos

Accede a gpt-oss-120b con Hugging Face.
Prepara tu entorno.
Crear un clúster de GKE en modo Autopilot
Crea un Secret de Kubernetes para las credenciales de Hugging Face.
Crear un bucket de Cloud Storage
Descarga el modelo en tu bucket de Cloud Storage.
Implementar un contenedor de vLLM en tu clúster de GKE.
Interactúa con el modelo de lenguaje gpt-oss con curl.
Realizar una limpieza

Costos

En este instructivo, se usan componentes facturables de Google Cloud, incluidos los siguientes:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Antes de comenzar

Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Instala Google Cloud CLI.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un proyecto de Google Cloud .

Roles necesarios para seleccionar o crear un proyecto

Seleccionar un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
Crea un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Crea un proyecto de Google Cloud :
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre de tu proyecto de Google Cloud .

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita la API requerida, si aún no está habilitada:

Roles necesarios para habilitar las APIs

Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

gcloud services enable container.googleapis.com

Instala Google Cloud CLI.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un proyecto de Google Cloud .

Roles necesarios para seleccionar o crear un proyecto

Seleccionar un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
Crea un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Crea un proyecto de Google Cloud :
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre de tu proyecto de Google Cloud .

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita la API requerida, si aún no está habilitada:

Roles necesarios para habilitar las APIs

gcloud services enable container.googleapis.com

Otorga roles a tu cuenta de usuario. Ejecuta el siguiente comando una vez para cada uno de los siguientes roles de IAM: roles/container.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Reemplaza lo siguiente:
- PROJECT_ID: ID del proyecto
- USER_IDENTIFIER: Es el identificador de tu cuenta de usuario de . Por ejemplo, myemail@example.com. cuenta de
- ROLE: Es el rol de IAM que otorgas a tu cuenta de usuario.
Accede a una cuenta de Hugging Face o crea una.

Accede a gpt-oss con Hugging Face

Para usar Hugging Face y acceder a gpt-oss, haz lo siguiente:

Accede a Hugging Face y explora el modelo gpt-oss.
Crea un token de acceso de Hugging Face read.
Copia y guarda el valor del token read access. Lo usarás más adelante en este instructivo.

Prepara el entorno

Para preparar tu entorno, configura las variables de entorno predeterminadas:

export PROJECT_ID="YOUR_PROJECT_ID"
export RESERVATION_URL="YOUR_RESERVATION_NAME"
export REGION="YOUR_REGION"
export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export GCS_BUCKET="YOUR_GCS_BUCKET"
export HUGGING_FACE_TOKEN="YOUR_HF_TOKEN"
export NETWORK="YOUR_NETWORK_NAME"
export SUBNETWORK="YOUR_SUBNETWORK_NAME"
export PROJECT_NUMBER=$(gcloud projects describe "${PROJECT_ID}" --format="value(projectNumber)")

gcloud config set project "${PROJECT_ID}"
gcloud config set billing/quota_project "${PROJECT_ID}"

Reemplaza lo siguiente:

YOUR_PROJECT_ID: Es el ID del proyecto de Google Cloud en el que deseas crear el clúster de GKE.
YOUR_RESERVATION_NAME: Es la URL de la reserva que deseas usar para crear tu clúster de GKE. Según el proyecto en el que existe la reserva, especifica uno de los siguientes valores:
- La reserva existe en tu proyecto: RESERVATION_NAME
- La reserva existe en un proyecto diferente, y tu proyecto puede usarla: projects/RESERVATION_PROJECT_ID/reservations/RESERVATION_NAME
YOUR_REGION: Es la región en la que deseas crear tu clúster de GKE. Solo puedes crear el clúster en la región en la que existe tu reserva.
YOUR_CLUSTER_NAME: Es el nombre del clúster de GKE que se creará.
YOUR_GCS_BUCKET: Es el nombre del bucket de Cloud Storage en el que descargas el modelo.
YOUR_HF_TOKEN: Es el token de acceso de Hugging Face que creaste en la sección anterior.
YOUR_NETWORK_NAME: Es la red que usa el clúster de GKE. Especifica uno de los siguientes valores:
- Si creaste una red personalizada, especifica el nombre de tu red.
- De lo contrario, especifica default.
YOUR_SUBNETWORK_NAME: Es la subred que usa el clúster de GKE. Especifica uno de los siguientes valores:
- Si creaste una subred personalizada, especifica el nombre de tu subred. Solo puedes especificar una subred que exista en la misma región que la reserva.
- De lo contrario, especifica default.

Crea un clúster de GKE en modo Autopilot

Para crear un clúster de GKE en el modo Autopilot, ejecuta el siguiente comando:

gcloud container clusters create-auto $CLUSTER_NAME \
    --project=$PROJECT_ID \
    --region=$REGION \
    --release-channel=rapid \
    --network=$NETWORK \
    --subnetwork=$SUBNETWORK

La creación del clúster de GKE puede tardar un tiempo en completarse. Para verificar que Google Cloud haya terminado de crear tu clúster, ve a Clústeres de Kubernetes en la consola de Google Cloud .

Crea un secreto de Kubernetes para las credenciales de Hugging Face

Para crear un Secret de Kubernetes para las credenciales de Hugging Face, haz lo siguiente:

Configura kubectl para que se comunique con tu clúster de GKE:

gcloud container clusters get-credentials $CLUSTER_NAME \
    --location=$REGION

Crea un Secret de Kubernetes para almacenar tu token de Hugging Face:

kubectl create secret generic hf-secret \
    --from-literal=hf_token=${HUGGING_FACE_TOKEN} \
    --dry-run=client -o yaml | kubectl apply -f -

Cree un bucket de Cloud Storage

Si usas un bucket de Cloud Storage existente, asegúrate de que se cumplan las siguientes condiciones:

Tu bucket de Cloud Storage está en la misma región que tu clúster de GKE.
Tu cuenta de servicio tiene los permisos write necesarios en el bucket.

Para almacenar tu modelo en un bucket de Cloud Storage nuevo, completa los siguientes pasos:

Ejecuta el siguiente comando para crear un bucket:

gcloud storage buckets create gs://$GCS_BUCKET --location=$REGION --uniform-bucket-level-access

Otorga permisos de write en el bucket de Cloud Storage a la cuenta de servicio predeterminada.

gcloud storage buckets add-iam-policy-binding gs://$GCS_BUCKET \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/default" \
    --role="roles/storage.objectAdmin"

Descarga el modelo en tu bucket de Cloud Storage

Para descargar el modelo en tu bucket de Cloud Storage, completa los siguientes pasos:

Crea un archivo gpt-download-job.yaml:

apiVersion: batch/v1
kind: Job
metadata:
  name: gpt-download-job
  namespace: default
spec:
  template:
    metadata:
      labels:
        app: gpt-oss-downloader
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      restartPolicy: OnFailure
      containers:
      - name: downloader
        image: python:3.11-slim
        resources:
          requests:
            cpu: "4"
            memory: "16Gi"
          limits:
            cpu: "4"
            memory: "16Gi"
        env:
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        - name: HF_HUB_ENABLE_HF_TRANSFER
          value: "0"
        - name: HF_HOME
          value: "/tmp/hf_cache"
        command: ["/bin/sh", "-c"]
        args:
        - |
          echo "Installing Hugging Face Hub library..."
          pip install -U "huggingface_hub"

          echo "Beginning model snapshot download to GCS Fuse..."
          hf download openai/gpt-oss-120b \
            --token "$HUGGING_FACE_HUB_TOKEN" \
            --local-dir /mnt/gcs/gpt-oss-120b \
            --max-workers 1

          DOWNLOAD_STATUS=$?

          if [ $DOWNLOAD_STATUS -eq 0 ]; then
            echo "Download Complete!"
          else 
            echo "ERROR: Model download failed with exit code $DOWNLOAD_STATUS"
            exit $DOWNLOAD_STATUS
          fi

        volumeMounts:
        - mountPath: /mnt/gcs
          name: gcs-bucket-volume
      volumes:
      - name: gcs-bucket-volume
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: $GCS_BUCKET
            mountOptions: "implicit-dirs"

Para inicializar el trabajo de descarga, aplica el manifiesto gpt-download-job.yaml.
```
envsubst '$GCS_BUCKET' < gpt-download-job.yaml | kubectl apply -f -
```
El recurso de trabajo descarga los pesos del modelo gpt-oss-120b de Hugging Face en tu bucket de Cloud Storage. La descarga tarda unos 30 minutos en completarse. Cuando finalice la descarga, continúa con la siguiente sección para iniciar la implementación del modelo.
Para ver el estado de finalización, ejecuta el siguiente comando:
```
kubectl wait \
    --for=condition=Complete \
    --timeout=7200s job/gpt-download-job
```
La marca --timeout especifica cuánto tiempo supervisa el comando el trabajo antes de que se agote el tiempo de espera.
Para borrar el trabajo, ejecuta el siguiente comando:
```
kubectl delete job gpt-download-job
```

Implementa un contenedor de vLLM en tu clúster de GKE

Después de descargar el modelo en tu bucket de Cloud Storage, implementa un contenedor de vLLM en tu clúster de GKE:

Crea un archivo vllm-gpt-oss-120b.yaml con la implementación de vLLM que elegiste:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gpt-oss-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gpt-oss
  template:
    metadata:
      labels:
        app: gpt-oss
        ai.gke.io/model: gpt-oss-120b
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      containers:
      - name: vllm-inference
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250822_0916_RC01
        resources:
          requests:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "240Gi"
            nvidia.com/gpu: "8"
          limits:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "240Gi"
            nvidia.com/gpu: "8"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/mnt/gcs/gpt-oss-120b
        - --tensor-parallel-size=8
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=8192
        - --max-num-seqs=4
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
        - mountPath: /mnt/gcs
          name: gcs-bucket-volume
          readOnly: true
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 900
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 900
          periodSeconds: 5
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      - name: gcs-bucket-volume
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: $GCS_BUCKET
            mountOptions: "implicit-dirs,file-cache:max-size-mb:-1,file-cache:enable-parallel-downloads:true,file-cache:max-parallel-downloads:32,file-cache:parallel-downloads-per-file:8,file-cache:download-chunk-size-mb:16"
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-b200
        cloud.google.com/reservation-name: $RESERVATION_URL
        cloud.google.com/reservation-affinity: "specific"
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: oss-service
spec:
  selector:
    app: gpt-oss
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000
---
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: vllm-gpt-oss-monitoring
spec:
  selector:
    matchLabels:
      app: gpt-oss
  endpoints:
  - port: 8000
    path: /metrics
    interval: 30s

Aplica el archivo vllm-gpt-oss-120b.yaml a tu clúster de GKE:

envsubst < vllm-gpt-oss-120b.yaml | kubectl apply -f -

Para ver el estado de finalización, ejecuta el siguiente comando:
```
kubectl wait \
    --for=condition=Available \
    --timeout=7200s deployment/vllm-gpt-oss-deployment
```
La marca --timeout permite que el comando supervise la implementación durante el período especificado.

Interactúa con el modelo `gpt-oss` con curl

Para verificar el modelo de gpt-oss que implementaste, haz lo siguiente:

Configura la redirección de puertos al modelo gpt-oss:
```
kubectl port-forward service/oss-service 8000:8000
```

Abre una nueva ventana de terminal. Luego, puedes chatear con tu modelo usando curl:

curl http://127.0.0.1:8000/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Describe a sailboat in one short sentence?"
    }
  ]
}' | jq .

El resultado que ves es similar al siguiente:

{
  "id": "chatcmpl-2235c39759c040daae23ce2addc40c0a",
  "object": "chat.completion",
  "created": 1756831629,
  "model": "openai/gpt-oss-120b",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "A sleek vessel gliding on water, its cloth sails billowing like captured wind.",
        "refusal": null,
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": [],
        "reasoning_content": "User asks: \"Describe a sailboat in one short sentence?\" We need to produce a short sentence description. Should comply with policy. It's fine. Provide a short sentence."
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 80,
    "total_tokens": 142,
    "completion_tokens": 62,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null,
  "kv_transfer_params": null
}

Observa el rendimiento del modelo

Para observar el rendimiento de tu modelo, puedes usar la integración del panel de vLLM en Cloud Monitoring. Este panel te ayuda a ver métricas de rendimiento fundamentales para tu modelo, como la capacidad de procesamiento de tokens, la latencia de red y las tasas de error. Para obtener información, consulta vLLM en la documentación de Monitoring.

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra recursos

Cuando termines el instructivo, borra los recursos que ya no necesites.

Para borrar el Deployment y el Service definidos en el archivo vllm-gpt-oss-120b.yaml y el Secret de Kubernetes del clúster de GKE, ejecuta el siguiente comando:
```
envsubst < vllm-gpt-oss-120b.yaml | kubectl delete -f -
kubectl delete secret hf-secret
```
Para borrar tu bucket de Cloud Storage, ejecuta el siguiente comando:
```
gcloud storage rm --recursive gs://$GCS_BUCKET
```

Para borrar tu clúster de GKE, haz lo siguiente:

gcloud container clusters delete $CLUSTER_NAME \
    --region=$REGION \
    --quiet

Borra tu proyecto

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo su contenido. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

Borra un proyecto de Google Cloud :

gcloud projects delete PROJECT_ID