Disponibilizar modelos abertos do Gemma usando GPUs no GKE com vLLM

Para disponibilizar modelos de linguagem grandes (LLMs) Gemma 4 no Google Kubernetes Engine (GKE) com o framework vLLM usando GPUs, é necessário provisionar um cluster do GKE com aceleradores compatíveis, como GPUs NVIDIA H100.

Para disponibilizar modelos Gemma 4, o contêiner vLLM pré-criado é configurado para carregar pesos de modelo. Os pesos serão carregados dos buckets do Cloud Storage (especificados pelo argumento --model).

Depois que os pesos são carregados, o contêiner vLLM expõe um endpoint de API compatível com o OpenAI para inferência de alta capacidade de processamento.

Este tutorial é destinado a engenheiros de machine learning (ML), administradores e operadores de plataforma e especialistas em dados e IA interessados em usar os recursos de orquestração de contêineres do Kubernetes para veicular cargas de trabalho de IA/ML em hardware de GPU H100.

Antes de ler esta página, confira se você conhece os seguintes conceitos:

Objetivos

Este tutorial oferece uma base para entender e explorar a implantação prática de LLMs para inferência em um ambiente gerenciado do Kubernetes.

  1. Prepare seu ambiente com um cluster do GKE no modo Autopilot.
  2. Implante um contêiner vLLM no seu cluster.
  3. Use o vLLM para disponibilizar o modelo Gemma 4 pela interface curl.

Antes de começar

  • 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

  • Verifique se você tem os seguintes papéis no projeto: roles/container.admin, roles/iam.serviceAccountAdmin

    Verificar os papéis

    1. No console do Cloud de Confiance , acesse a página IAM.

      Acessar IAM
    2. Selecione o projeto.

    3. Na coluna Principal, encontre todas as linhas que identificam você ou um grupo no qual você está incluído. Para saber em quais grupos você está incluído, entre em contato com o administrador.

    4. Em todas as linhas que especificam ou incluem você, verifique a coluna Papel para ver se a lista de papéis inclui os papéis necessários.

    Conceder os papéis

    1. No console do Cloud de Confiance , acesse a página IAM.

      Acessar IAM
    2. Selecione o projeto.
    3. Clique em Conceder acesso.

    4. No campo Novos principais, digite seu identificador de usuário. Normalmente, é o identificador de um usuário em um pool de identidades de força de trabalho. Saiba mais em Representar usuários do pool de força de trabalho nas políticas do IAM ou entre em contato com seu administrador.

    5. Clique em Selecionar um papel e pesquise o papel.
    6. Para conceder outros papéis, adicione-os clicando em Adicionar outro papel.
    7. Clique em Salvar.

Preparar o ambiente

Neste tutorial, você vai usar o kubectl e a CLI gcloud para gerenciar recursos hospedados no Cloud de Confiance by S3NS. É possível autorizar com a CLI gcloud para acessar Cloud de Confiance by S3NS.

Para configurar o ambiente com a CLI gcloud, siga estas etapas:

  1. Defina as variáveis de ambiente padrão na CLI gcloud:

    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

    Substitua os seguintes valores:

    • PROJECT_ID: o Cloud de Confiance ID do projeto.
    • REGION: região u-france-east1 compatível com GPU H100. Você pode conferir quais regiões têm quais GPUs disponíveis.
    • CLUSTER_NAME: o nome do cluster.
    • GSA_NAME: o nome da conta de serviço do Google, por exemplo, gemma-gsa.
    • KSA_NAME: o nome da ServiceAccount do Kubernetes. Por exemplo, gemma-ksa.
    • NAMESPACE: o namespace do Kubernetes. Por exemplo, default.
    • MODEL_BUCKET_NAME: o nome do bucket do Cloud Storage em que os pesos do modelo serão armazenados. Ele pode ter o mesmo nome do modelo selecionado, como gemma-4-26b-it.

Criar e configurar recursos Cloud de Confiance

Siga estas instruções para criar os recursos necessários.

Criar um cluster do GKE e um pool de nós

É possível disponibilizar o Gemma em GPUs em um cluster do GKE Autopilot. O cluster do Autopilot oferece uma experiência totalmente gerenciada do Kubernetes.

Piloto automático

Na CLI gcloud, execute o seguinte comando:

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

Substitua os seguintes valores:

  • PROJECT_ID: o Cloud de Confiance ID do projeto.
  • CLUSTER_NAME: o nome do cluster.
  • REGION: a região em que o cluster está localizado.

O GKE cria um cluster do Autopilot com nós de CPU e GPU conforme solicitado pelas cargas de trabalho implantadas.

Criar um bucket do Cloud Storage

  1. Na CLI gcloud, execute o seguinte comando:

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

    Isso cria um bucket do Cloud Storage para armazenar os arquivos de modelo transferidos por download do Hugging Face.

  2. Fazer download e upload de pesos de modelos:

    Você precisa obter os pesos do modelo Gemma para as versões que pretende disponibilizar (por exemplo, do Hugging Face ou de outras fontes oficiais). Organize os arquivos baixados localmente em diretórios. Exemplo:

    • ./gemma-4-26b-it-local/ (contém todos os arquivos do modelo de TI de 26 bilhões de parâmetros)
    • ./gemma-4-31b-it-local/ (contendo todos os arquivos do modelo de TI de 31 bilhões)

    Faça upload desses diretórios para o bucket do Cloud Storage com os prefixos específicos esperados pelos manifestos de implantação:

    # 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}

    Essa estrutura de comando garante que os arquivos de modelo estejam localizados em caminhos como gs://${MODEL_BUCKET_NAME}/config.json etc.

Configurar a Identidade da carga de trabalho para acesso ao Cloud Storage

Para permitir que os pods do Kubernetes acessem com segurança o bucket do Cloud Storage que contém as ponderações do modelo, configure a Identidade da carga de trabalho do GKE.

  1. Crie a conta de serviço do Google (GSA):

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

  2. Determinar e exportar o e-mail da GSA:

    O formato do e-mail depende de o ${PROJECT_ID} ter escopo de domínio (conter dois pontos).

    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. Crie a conta de serviço do Kubernetes (KSA):

    Essa KSA é usada no manifesto de implantação.

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

    Verificar a criação

    kubectl get serviceaccounts --namespace ${NAMESPACE}

  4. Anote a KSA para vinculá-la à GSA:

    Essa anotação informa ao GKE qual GSA a KSA pode representar.

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

  5. Conceda à KSA permissão para representar a GSA:

    Essa vinculação do IAM na GSA permite que a KSA atue como a 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. Conceda à GSA permissão para ler do bucket:

    Conceda ao GSA o papel storage.objectViewer no bucket.

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

Implantar modelos do Gemma 4 no vLLM

Para implantar modelos do Gemma 4, crie buckets do Cloud Storage para cada modelo para armazenar os pesos do modelo e aplique um manifesto de implantação do Kubernetes para o tamanho de modelo selecionado. Uma implantação é um objeto da API Kubernetes que permite executar várias réplicas de pods distribuídos entre os nós de um cluster.

Procedimento

A aplicação desse manifesto extrai a imagem do contêiner vLLM, solicita uma GPU NVIDIA e se conecta automaticamente aos pesos do modelo dos buckets do Cloud Storage para iniciar o mecanismo de inferência vLLM.

Gemma 4 26B-A4B-it

Siga estas instruções para implantar o modelo ajustado por instruções do Gemma 4 26B-A4B.

  1. Crie o seguinte manifesto 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. Aplique o manifesto:

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

    Se quiser, limite o tamanho da janela de contexto em 16 K usando a opção --max-model-len=16384 do vLLM. Se você quiser um tamanho maior de janela de contexto (até 128 K), ajuste o manifesto e a configuração do pool de nós com mais capacidade de GPU.

Gemma 4 31B-it

Siga estas instruções para implantar o modelo ajustado por instruções do Gemma 4 31B.

  1. Crie o seguinte manifesto 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. Aplique o manifesto:

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

    No nosso exemplo, limitamos o tamanho da janela de contexto em 16 K usando a opção --max-model-len=16384 do vLLM. Se você quiser um tamanho maior de janela de contexto (até 128 mil), ajuste o manifesto e a configuração do pool de nós com mais capacidade de GPU.

Verificação

  1. Aguarde até que a implantação esteja disponível:

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

  2. Confira os registros da implantação em execução:

    kubectl logs -f -l app=gemma-server

    O recurso de implantação faz o download dos dados do modelo Gemma. O processo pode levar alguns minutos. O resultado será o seguinte:

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

Depois que a implantação estiver disponível, configure o encaminhamento de portas para interagir com o modelo.

Disponibilizar o modelo

Nesta seção, você vai interagir com o modelo. Verifique se o download do modelo foi concluído antes de prosseguir.

Configurar o encaminhamento de portas

Execute o seguinte comando para configurar o encaminhamento de portas para o modelo:

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

O resultado será assim:

Forwarding from 127.0.0.1:8080 -> 8080

Interagir com o modelo usando curl

Nesta seção, mostramos como realizar um teste preliminar básico para verificar os modelos ajustados por instruções do Gemma 4 implantados. Para outros modelos, substitua gemma-4-26B-A4B-it pelo nome do modelo respectivo.

Este exemplo mostra como testar o modelo ajustado por instrução da Gemma 4 26B com entrada somente de texto.

Em uma nova sessão do terminal, use curl para conversar com seu 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
}'

A saída será assim:

{
  "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
}

Resolver problemas

  • Se você receber a mensagem Empty reply from server, é possível que o contêiner não tenha concluído o download dos dados do modelo. Verifique os registros do pod novamente para ver a mensagem Connected, que indica que o modelo está pronto para ser disponibilizado.
  • Se você vir Connection refused, verifique se o encaminhamento de portas está ativo.

Observar o desempenho do modelo

Para conferir os painéis das métricas de observabilidade de um modelo, siga estas etapas:

  1. No console do Cloud de Confiance , acesse a página Modelos implantados.

    Acessar "Modelos implantados"

  2. Para ver detalhes sobre a implantação específica, incluindo métricas, registros e painéis, clique no nome do modelo na lista.

  3. Na página de detalhes do modelo, clique na guia Observabilidade para conferir os seguintes painéis. Se solicitado, clique em Ativar para ativar a coleta de métricas do cluster.

    • O painel Uso da infraestrutura mostra métricas de utilização.
    • O painel DCGM mostra as métricas do DCGM.
    • Se você estiver usando o vLLM, o painel Performance do modelo vai estar disponível e mostrará métricas de desempenho do modelo vLLM.

Também é possível conferir as métricas na integração do painel do vLLM no Cloud Monitoring. Essas métricas são agregadas para todas as implantações de vLLM sem filtros predefinidos.

O vLLM expõe métricas no formato do Prometheus por padrão. Não é necessário instalar um exportador adicional. Para informações sobre como usar o Google Cloud Managed Service para Prometheus e coletar métricas do seu modelo, consulte as orientações de observabilidade do vLLM na documentação do Cloud Monitoring.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir os recursos implantados

Para evitar cobranças na sua conta do Cloud de Confiance pelos recursos criados neste guia, execute o seguinte comando:

gcloud container clusters delete CLUSTER_NAME \
    --location=REGION

Substitua os seguintes valores:

  • REGION: a região do cluster.
  • CLUSTER_NAME: o nome do cluster.

A seguir