Entrega modelos abiertos de Gemma mediante GPU en GKE con vLLM

Para entregar Gemma 4 en Google Kubernetes Engine (GKE) con el framework de vLLM mediante GPUs, debes aprovisionar un clúster de GKE con aceleradores compatibles, como las GPUs NVIDIA H100.

Para entregar 4 modelos de Gemma, el contenedor de vLLM precompilado está configurado para cargar los pesos del modelo. Los pesos se cargarán desde buckets de Cloud Storage (especificados por el argumento --model).

Una vez que se cargan los pesos, el contenedor de vLLM expone un extremo de API compatible con OpenAI para la inferencia de alta capacidad de procesamiento.

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

Antes de leer esta página, asegúrate de estar familiarizado con lo siguiente:

Objetivos

En este instructivo, se proporciona una base para comprender y explorar la implementación práctica de LLM para la inferencia en un entorno de Kubernetes administrado.

  1. Prepara tu entorno con un clúster de GKE en modo Autopilot.
  2. Implementa un contenedor de vLLM en tu clúster.
  3. Usa vLLM para entregar el modelo de Gemma 4 a través de la interfaz de curl.

Antes de comenzar

  • In the Cloud de Confiance console, on the project selector page, select or create a Cloud de Confiance project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  • Verify that billing is enabled for your Cloud de Confiance project.

  • Enable the required API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  • Asegúrate de tener los siguientes roles en el proyecto: roles/container.admin, roles/iam.serviceAccountAdmin

    Verifica los roles

    1. En la Cloud de Confiance consola de, dirígete a la página IAM.

      Ir a IAM
    2. Selecciona el proyecto.

    3. En la columna Principal, busca todas las filas que te identifiquen a ti o a un grupo en el que estés incluido. Para saber en qué grupos estás incluido, comunícate con el administrador.

    4. Para todas las filas que te especifiquen o incluyan, consulta la columna Rol para ver si la lista de roles incluye los roles necesarios.

    Otorga los roles

    1. En la Cloud de Confiance consola de, dirígete a la página IAM.

      Ir a IAM
    2. Selecciona el proyecto.
    3. Haz clic en Grant access.

    4. En el campo Principales nuevas, ingresa tu identificador de usuario. Este suele ser el identificador de un usuario que pertenece a un grupo de identidades de personal. Para obtener más información, consulta Representa a los usuarios del grupo de personal en políticas de IAM o comunícate con el administrador.

    5. Haz clic en Selecciona un rol y, luego, busca el rol.
    6. Para otorgar roles adicionales, haz clic en Agregar otro rol y agrega cada rol adicional.
    7. Haz clic en Guardar.

Prepara el entorno

En este instructivo, usarás kubectl y la CLI de gcloud para administrar los recursos alojados en Cloud de Confiance by S3NS. Puedes autorizar con la CLI de gcloud para acceder a Cloud de Confiance by S3NS.

Para configurar tu entorno con gcloud CLI, sigue estos pasos:

  1. Establece las variables de entorno predeterminadas en gcloud CLI:

    gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=u-france-east1
export CLUSTER_NAME=CLUSTER_NAME
export GSA_NAME=GSA_NAME
export KSA_NAME=KSA_NAME
export NAMESPACE=NAMESPACE
export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
export MODEL_BUCKET_NAME=MODEL_BUCKET_NAME

    Reemplaza los siguientes valores:

    • PROJECT_ID: Es tu Cloud de Confiance ID del proyecto.
    • REGION: Es la región u-france-east1 que admite la GPU H100. Puedes encontrar qué región tiene qué GPUs disponibles.
    • CLUSTER_NAME: Es el nombre de tu clúster.
    • GSA_NAME: Es el nombre de la cuenta de servicio de Google, por ejemplo, gemma-gsa.
    • KSA_NAME: Es el nombre de la cuenta de servicio de Kubernetes, por ejemplo, gemma-ksa.
    • NAMESPACE: Es el espacio de nombres de Kubernetes, por ejemplo, default.
    • MODEL_BUCKET_NAME: Es el nombre del bucket de Cloud Storage en el que se almacenarán los pesos del modelo. Puede ser el mismo nombre que el modelo seleccionado, como gemma-4-26b-it.

Crea y configura Cloud de Confiance recursos

Sigue estas instrucciones para crear los recursos necesarios.

Crea un clúster de GKE y un grupo de nodos

Puedes entregar Gemma en GPUs en un clúster de GKE Autopilot. El clúster de Autopilot proporciona una experiencia de Kubernetes completamente administrada.

Autopilot

En gcloud CLI, ejecuta el siguiente comando:

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=REGION \
    --release-channel=rapid

Reemplaza los siguientes valores:

  • PROJECT_ID: Es tu Cloud de Confiance ID del proyecto.
  • CLUSTER_NAME: Es el nombre de tu clúster.
  • REGION: Es la región en la que se encuentra el clúster.

GKE crea un clúster de Autopilot con nodos de CPU y GPU según lo solicitan las cargas de trabajo implementadas.

Cree un bucket de Cloud Storage

  1. En gcloud CLI, ejecuta el siguiente comando:

    gcloud storage buckets create gs://${MODEL_BUCKET_NAME} \
  --project=${PROJECT_ID} \
  --location=${REGION} \
  --uniform-bucket-level-access

    Esto crea un bucket de Cloud Storage para almacenar los archivos del modelo que descargas de Hugging Face.

  2. Descarga y sube los pesos del modelo:

    Debes obtener los pesos del modelo de Gemma para las versiones que deseas entregar (p.ej., desde Hugging Face o cualquier otra fuente oficial). Organiza los archivos descargados de forma local en directorios. Por ejemplo:

    • ./gemma-4-26b-it-local/ (que contiene todos los archivos para el modelo 26B IT)
    • ./gemma-4-31b-it-local/ (que contiene todos los archivos para el modelo 31B IT)

    Sube estos directorios a tu bucket de Cloud Storage con los prefijos específicos que esperan los manifiestos de implementación:

    # Upload files for the 26B IT model
gcloud storage cp --recursive ./gemma-4-26b-it-local/* gs://${MODEL_BUCKET_NAME}

# Upload files for the 31B IT model
gcloud storage cp --recursive ./gemma-4-31b-it-local/* gs://${MODEL_BUCKET_NAME}

    Esta estructura de comandos garantiza que los archivos del modelo se encuentren en rutas de acceso como gs://${MODEL_BUCKET_NAME}/config.json, etcétera.

Configura Workload Identity para el acceso a Cloud Storage

Para permitir que tus pods de Kubernetes accedan de forma segura al bucket de Cloud Storage que contiene los pesos del modelo, configurarás Workload Identity de GKE.

  1. Crea la cuenta de servicio de Google (GSA):

    gcloud iam service-accounts create ${GSA_NAME} \
  --project=${PROJECT_ID}

  2. Determina y exporta el correo electrónico de la GSA:

    El formato del correo electrónico depende de si tu ${PROJECT_ID} tiene alcance de dominio (contiene dos puntos).

    if [[ $PROJECT_ID == *:* ]]; then
  DOMAIN=$(echo $PROJECT_ID | cut -d: -f1)
  PROJ_NAME=$(echo $PROJECT_ID | cut -d: -f2)
  export GSA_EMAIL="${GSA_NAME}@${PROJ_NAME}.${DOMAIN}.s3ns.iam.gserviceaccount.com"
else
  export GSA_EMAIL="${GSA_NAME}@${PROJECT_ID}.s3ns.iam.gserviceaccount.com"
fi
  echo "Using GSA Email: ${GSA_EMAIL}"

  3. Crea la cuenta de servicio de Kubernetes (KSA):

    Esta KSA se usa en tu manifiesto de implementación.

    kubectl create serviceaccount ${KSA_NAME} --namespace ${NAMESPACE}

    Verifica la creación

    kubectl get serviceaccounts --namespace ${NAMESPACE}

  4. Anota la KSA para vincularla a la GSA:

    Esta anotación le indica a GKE qué GSA puede suplantar la KSA.

    kubectl annotate serviceaccount ${KSA_NAME} \
  --namespace ${NAMESPACE} \
  iam.gke.io/gcp-service-account=${GSA_EMAIL}

  5. Otorga permiso a la KSA para suplantar a la GSA:

    Esta vinculación de IAM en la GSA permite que la KSA actúe como la GSA.

    if [[ $PROJECT_ID == *:* ]]; then
  DOMAIN=$(echo $PROJECT_ID | cut -d: -f1)
  PROJ_NAME=$(echo $PROJECT_ID | cut -d: -f2)
  export WI_MEMBER="serviceAccount:${PROJ_NAME}.${DOMAIN}.s3ns.svc.id.goog[${NAMESPACE}/${KSA_NAME}]"
else
  export WI_MEMBER="serviceAccount:${PROJECT_ID}.s3ns.svc.id.goog[${NAMESPACE}/${KSA_NAME}]"
fi

gcloud iam service-accounts add-iam-policy-binding ${GSA_EMAIL} \
  --role roles/iam.workloadIdentityUser \
  --member="${WI_MEMBER}" \
  --project=${PROJECT_ID}

  6. Otorga permiso a la GSA para leer desde el bucket:

    Otorga a la GSA el rol storage.objectViewer en el bucket.

    gcloud storage buckets add-iam-policy-binding gs://${MODEL_BUCKET_NAME} \
  --member="serviceAccount:${GSA_EMAIL}" \
  --role="roles/storage.objectViewer" \
  --project=${PROJECT_ID}

Implementa modelos de Gemma 4 en vLLM

Para implementar modelos de Gemma 4, crea buckets de Cloud Storage para cada modelo para almacenar los pesos del modelo y aplica un manifiesto de implementación de Kubernetes para el tamaño del modelo seleccionado. Una implementación es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de Pods que se distribuyen entre los nodos de un clúster.

Procedimiento

Aplicar este manifiesto extrae la imagen del contenedor de vLLM, solicita una GPU de NVIDIA y se conecta automáticamente a los pesos del modelo desde los buckets de Cloud Storage para iniciar el motor de inferencia de vLLM.

Gemma 4 26B-A4B-it

Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 4 26B-A4B.

  1. Crea el siguiente manifiesto vllm-4-26b-a4b-it.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: a3-edgegpu-8g-nolssd
spec:
  priorities:
  - machineType: a3-edgegpu-8g-nolssd
    gpu:
      count: 8
      type: nvidia-h100-80gb
  nodePoolAutoCreation:
    enabled: true
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-26b-a4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["./entrypoint.sh"] # Use the image's entrypoint
        args:
        - "python"
        - "-m"
        - "vllm.entrypoints.api_server"
        - "--host=0.0.0.0"
        - "--port=8080"
        - "--model=gs://gemma-4-26b-it" # YOUR Cloud Storage PATH
        - "--tensor-parallel-size=1"
        - "--max-num-seqs=128"
        - "--gpu-memory-utilization=0.9"
        - "--limit_mm_per_prompt.image=1"
        - "--enable-auto-tool-choice"
        - "--tool-call-parser=gemma4"
        - "--reasoning-parser=gemma4"
        ports:
        - containerPort: 8080
        env:
        - name: GOOGLE_CLOUD_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - name: CLOUDSDK_CORE_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - name: GCS_URI_ARG_KEY
          value: "model"
        - name: GCS_URI_ENV_KEY
          value: "AIP_STORAGE_URI"
        - name: LORA_ADAPTER_ARG_KEY
          value: "lora-modules"
        - name: HF_HUB_ENABLE_HF_TRANSFER
          value: "1"
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/compute-class: a3-edgegpu-8g-nolssd
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080

  2. Aplica el manifiesto

    kubectl apply -f vllm-4-26b-a4b-it.yaml

    Si lo deseas, puedes limitar el tamaño de la ventana de contexto en 16 K con la opción --max-model-len=16384 de vLLM. Si deseas un tamaño de ventana de contexto más grande (hasta 128 K), ajusta tu manifiesto y la configuración del grupo de nodos con más capacidad de GPU.

Gemma 4 31B-it

Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 4 31B.

  1. Crea el siguiente manifiesto vllm-4-31b-it.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: a3-edgegpu-8g-nolssd
spec:
  priorities:
  - machineType: a3-edgegpu-8g-nolssd
    gpu:
      count: 8
      type: nvidia-h100-80gb
  nodePoolAutoCreation:
    enabled: true
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-31b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["./entrypoint.sh"] # Use the image's entrypoint
        args:
        - "python"
        - "-m"
        - "vllm.entrypoints.api_server"
        - "--host=0.0.0.0"
        - "--port=8080"
        - "--model=gs://gemma-4-31b-it" # YOUR Cloud Storage PATH
        - "--tensor-parallel-size=1"
        - "--max-num-seqs=128"
        - "--gpu-memory-utilization=0.9"
        - "--limit_mm_per_prompt.image=1"
        - "--enable-auto-tool-choice"
        - "--tool-call-parser=gemma4"
        - "--reasoning-parser=gemma4"
        ports:
        - containerPort: 8080
        env:
        - name: GOOGLE_CLOUD_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - name: CLOUDSDK_CORE_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - name: GCS_URI_ARG_KEY
          value: "model"
        - name: GCS_URI_ENV_KEY
          value: "AIP_STORAGE_URI"
        - name: LORA_ADAPTER_ARG_KEY
          value: "lora-modules"
        - name: HF_HUB_ENABLE_HF_TRANSFER
          value: "1"
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/compute-class: a3-edgegpu-8g-nolssd
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080

  2. Aplica el manifiesto

    kubectl apply -f vllm-4-31b-it.yaml

    En nuestro ejemplo, limitamos el tamaño de la ventana de contexto en 16 K con la opción --max-model-len=16384 de vLLM. Si deseas un tamaño de ventana de contexto más grande (hasta 128 K), ajusta tu manifiesto y la configuración del grupo de nodos con más capacidad de GPU.

Verificación

  1. Espera a que la Deployment esté disponible:

    kubectl wait --for=condition=Available --timeout=1800s deployment/vllm-gemma-deployment

  2. Observa los registros de la Deployment en ejecución:

    kubectl logs -f -l app=gemma-server

    El recurso de implementación descarga los datos del modelo de Gemma. Este proceso puede demorar unos minutos. El resultado es similar a lo siguiente:

      ...
  ...
  (APIServer pid=1) INFO:     Started server process [1]
  (APIServer pid=1) INFO:     Waiting for application startup.
  (APIServer pid=1) INFO:     Application startup complete.

Una vez que la implementación esté disponible, configura la redirección de puertos para interactuar con el modelo.

Entrega el modelo

En esta sección, interactuarás con el modelo. Asegúrate de que el modelo se haya descargado por completo antes de continuar.

Configura la redirección de puertos

Ejecuta el siguiente comando para configurar la redirección de puertos al modelo:

kubectl port-forward svc/llm-service 8080:8080 --namespace default &

El resultado es similar al siguiente:

Forwarding from 127.0.0.1:8080 -> 8080

Interactúa con el modelo con curl

En esta sección, se muestra cómo puedes realizar una prueba de humo básica para verificar los modelos de Gemma 4 ajustados por instrucciones implementados. Para otros modelos, reemplaza gemma-4-26B-A4B-it por el nombre del modelo respectivo.

En este ejemplo, se muestra cómo probar el modelo ajustado por instrucciones de Gemma 4 26B con entrada solo de texto.

En una sesión de terminal nueva, usa curl para chatear con tu modelo:

curl http://127.0.0.1:8080/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
    "model": "google/gemma-4-26B-A4B-it",
    "messages": [
        {
          "role": "user",
          "content": "Why is the sky blue?"
        }
    ],
    "chat_template_kwargs": {
         "enable_thinking": true
    },
    "skip_special_tokens": false
}'

El resultado es similar al siguiente:

{
  "id": "chatcmpl-be75ccfcbdf753d1",
  "object": "chat.completion",
  "created": 1775006187,
  "model": "google/gemma-4-26B-A4B-it",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The short answer is a phenomenon called **Rayleigh scattering**.\n\nTo understand how it works, you have to look at three things: sunlight, the Earth's atmosphere, and how light travels.\n\n### 1. Sunlight is a Rainbow\nAlthough sunlight looks white to us, it is actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet). Light travels as **waves**, and each color has a different wavelength:\n*   **Red light** travels in long, lazy, wide waves.\n*   **Blue and violet light** travel in short, choppy, tight waves.\n\n### 2. The Atmosphere is an Obstacle Course\nEarth's atmosphere is filled with gases (mostly nitrogen and oxygen). As sunlight travels through the atmosphere, it strikes the molecules of these gases. \n\nBecause the gas molecules are very small, they affect the colors differently based on their wavelength:\n*   The **long waves** (reds and yellows) pass through the atmosphere mostly straight, without hitting much. They are like large ocean waves that roll right over small pebbles.\n*   The **short waves** (blues and violets) strike the gas molecules and get scattered in every direction. They are like small ripples that hit a pebble and splash everywhere.\n\nBecause this blue light is being scattered in every direction by the air, when you look up, your eyes are catching that scattered blue light coming from every part of the sky.\n\n### 3. Why isn't the sky violet?\nIf violet light has an even shorter wavelength than blue light, you might wonder why the sky doesn't look purple. There are two main reasons:\n1.  **The Sun's output:** The Sun emits much more blue light than violet light.\n2.  **Human Biology:** Human eyes are much more sensitive to blue than to violet. Our eyes interpret the scatter of mixed blue and violet light simply as pale blue.\n\n---\n\n### Bonus: Why are sunsets red?\nWhen the sun is setting, it is much lower on the horizon. This means the sunlight has to travel through a much **thicker** layer of the atmosphere to reach your eyes. \n\nBy the time the light gets to you, the blue light has been scattered away completely로. Only the long-wavelength colors—the reds, oranges, and pinks—are able to make it through that thick layer of air without being scattered away, creating the beautiful colors of a sunset.",
        "refusal": null,
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": [],
        "reasoning": "\"Why is the sky blue?\"\nScience/Physics (Atmospheric scattering).\nExplain the phenomenon clearly, accurately, and engagingly.\n\n    *   Sunlight (white light) is made of a spectrum of colors (ROYGBIV).\n    *   Earth's atmosphere is filled with gases (nitrogen, oxygen) and particles.\n    *   Rayleigh Scattering: Shorter wavelengths (blue/violet) scatter more easily than longer wavelengths (red/yellow) when hitting small gas molecules.\n    *   The human eye's sensitivity: Why isn't it violet?\n\n    A good scientific explanation should follow a logical flow:\n    *   *Direct Answer:* The core mechanism (Rayleigh Scattering).\n    *   *The Components:* Sunlight and the Atmosphere.\n    *   *The Mechanism:* How light interacts with gas molecules.\n    *   *The Wavelength Factor:* Comparing colors.\n    *   *The \"Wait, why not violet?\" question:* Addressing human perception.\n    *   *Bonus/Related concept:* Why sunsets are red.\n\n        *   Use the term **Rayleigh Scattering**.\n        *   Summarize: Its how sunlight interacts with the Earth's atmosphere.\n\n        *   Sunlight looks white, but it's actually a mix of all colors (the rainbow).\n        *   Each color travels as a different wavelength. Red = long/lazy waves; Blue/Violet = short/choppy waves.\n\n        *   The atmosphere is mostly Nitrogen and Oxygen.\n        *   When sunlight hits these tiny gas molecules, the light gets scattered in all directions.\n\n        *   Blue light travels in shorter, smaller waves.\n        *   Because these waves are small, they strike the gas molecules more frequently and get scattered more easily than the longer red/yellow waves.\n        *   Result: When you look up, your eyes are catching this \"scattered\" blue light coming from every direction.\n\n        *   *Technically*, violet light has an even shorter wavelength than blue, so it scatters *even more*. Why isn't the sky violet?\n        *   Two reasons: 1. The Sun emits more blue light than violet light. 2. Human eyes are much more sensitive to blue than violet.\n\n        *   Briefly mention sunsets to provide a complete picture.\n        *   At sunset, light travels through *more* atmosphere. The blue is scattered away completely, leaving only the long red/orange waves to reach your eyes.\n\n    *   *Tone Check:* Is it too academic? Use analogies (like waves in water or skipping stones) if needed, but keep it concise.\n    *   *Clarity:* Ensure the distinction between wavelength and scattering is clear."
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": 106,
      "token_ids": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 21,
    "total_tokens": 1122,
    "completion_tokens": 1101,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null,
  "prompt_token_ids": null,
  "kv_transfer_params": null
}

Soluciona problemas

  • Si recibes el mensaje Empty reply from server, es posible que el contenedor no haya terminado de descargar los datos del modelo. Vuelve a verificar los registros del Pod en busca del mensaje Connected, que indica que el modelo está listo para entregar.
  • Si ves Connection refused, verifica que tu redirección de puertos esté activa.

Observa el rendimiento del modelo

Para ver los paneles de las métricas de observabilidad de un modelo, sigue estos pasos:

  1. En la Cloud de Confiance consola, ve a la página Modelos implementados.

    Ir a Modelos implementados

  2. Para ver detalles sobre la implementación específica, incluidas sus métricas, registros y paneles, haz clic en el nombre del modelo en la lista.

  3. En la página de detalles del modelo, haz clic en la pestaña Observabilidad para ver los siguientes paneles. Si se te solicita, haz clic en Habilitar para habilitar la recopilación de métricas para el clúster.

    • En el panel Uso de infraestructura , se muestran las métricas de uso.
    • En el panel DCGM , se muestran las métricas de DCGM.
    • Si usas vLLM, el panel Rendimiento del modelo está disponible y muestra métricas para el rendimiento del modelo de vLLM.

También puedes ver las métricas en la integración del panel de vLLM en Cloud Monitoring. Estas métricas se agregan para todas las implementaciones de vLLM sin filtros preestablecidos.

vLLM expone las métricas en formato Prometheus de forma predeterminada. No es necesario que instales un exportador adicional. Para obtener información sobre el uso de Google Cloud Managed Service para Prometheus para recopilar métricas de tu modelo, consulta la vLLM de vLLM en la documentación de Cloud Monitoring.

Limpia

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 los recursos implementados

Para evitar que se generen cargos en tu Cloud de Confiance cuenta de por los recursos que creaste en esta guía, ejecuta el siguiente comando:

gcloud container clusters delete CLUSTER_NAME \
    --location=REGION

Reemplaza los siguientes valores:

  • REGION: Es la región del clúster.
  • CLUSTER_NAME: Es el nombre de tu clúster.

¿Qué sigue?