Disponibilizar modelos abertos do Gemma usando GPUs no GKE com vLLM


Neste tutorial, mostramos como implantar e disponibilizar um modelo de linguagem grande (LLM) Gemma 3 usando GPUs no Google Kubernetes Engine (GKE) com o framework de disponibilização vLLM. Isso fornece uma base para entender e explorar a implantação prática de LLM para inferência em um ambiente Kubernetes gerenciado. Você implanta um contêiner pré-criado que executa vLLM no GKE. Você também configura o GKE para carregar os pesos Gemma 1B, 4B, 12B e 27B do Hugging Face.

Este tutorial é destinado a engenheiros de machine learning (ML), administradores e operadores de plataformas e especialistas em dados e IA que tenham interesse em usar os recursos de orquestração de contêineres do Kubernetes para veicular cargas de trabalho de IA/ML em hardwares de GPU H200, H100, A100 e L4. Para saber mais sobre papéis comuns e exemplos de tarefas referenciados no conteúdo do Google Cloud , consulte Tarefas e funções de usuário comuns do GKE Enterprise.

Se você precisa de uma plataforma de IA gerenciada unificada projetada para criar e disponibilizar modelos de ML rapidamente e de maneira econômica, recomendamos testar nossa solução de implantação da Vertex AI.

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

Contexto

Esta seção descreve as principais tecnologias usadas neste guia.

Gemma

O Gemma é um conjunto de modelos multimodais de inteligência artificial (IA) generativa, leve e abertamente lançados sob licença aberta. Esses modelos de IA estão disponíveis para execução em aplicativos, hardware, dispositivos móveis ou serviços hospedados. O Gemma 3 apresenta a multimodalidade e oferece suporte a entradas de linguagem visual e saídas de texto. Ela lida com janelas de contexto de até 128.000 tokens e oferece suporte a mais de 140 idiomas. O Gemma 3 também oferece recursos aprimorados de matemática, raciocínio e chat, incluindo saídas estruturadas e chamadas de função.

É possível usar os modelos Gemma para geração de texto ou ajustá-los para tarefas especializadas.

Para mais informações, consulte a documentação do Gemma.

GPUs

As GPUs permitem acelerar cargas de trabalho específicas em execução nos nós, como machine learning e processamento de dados. O GKE oferece uma gama de opções de tipos de máquina para configuração de nós, incluindo tipos de máquina com GPUs NVIDIA H200, H100, L4 e A100.

vLLM

O vLLM é um framework de disponibilização de LLM de código aberto altamente otimizado que pode aumentar a capacidade de disponibilização em GPUs, com recursos como:

  • Otimização da implementação do transformador com PagedAttention
  • Lotes contínuos para melhorar a capacidade geral de exibição
  • Paralelismo de tensor e exibição distribuída em várias GPUs

Para mais informações, consulte a documentação do vLLM.

Objetivos

  1. Prepare seu ambiente com um cluster do GKE no modo Autopilot ou Standard.
  2. Implante um contêiner vLLM no seu cluster.
  3. Use o vLLM para mostrar o modelo Gemma 3 por meio de curl e de uma interface de chat na Web.

Antes de começar

  • Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

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

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

  • Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.
    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      Acessar o IAM
    2. Selecionar um projeto.
    3. Clique em CONCEDER ACESSO.
    4. No campo Novos principais, insira seu identificador de usuário. Normalmente, é o endereço de e-mail de uma Conta do Google.

    5. Na lista Selecionar um papel, escolha um.
    6. Para conceder outros papéis, clique em Adicionar outro papel e adicione cada papel adicional.
    7. Clique em Salvar.

Receber acesso ao modelo

Para acessar o modelo pelo "Rosto abraçado", você vai precisar de um token de rosto abraçado.

Siga as etapas abaixo para gerar um novo token, caso ainda não tenha um:

  1. Clique em Seu perfil > Configurações > Tokens de acesso.
  2. Selecione Novo token.
  3. Especifique um Nome de sua escolha e um Papel de pelo menos Read.
  4. Selecione Gerar um token.
  5. Copie o token gerado para a área de transferência.

Preparar o ambiente

Neste tutorial, você vai usar o Cloud Shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo kubectl e gcloud CLI.

Para configurar o ambiente com o Cloud Shell, siga estas etapas:

  1. No console Google Cloud , inicie uma sessão do Cloud Shell clicando em Ícone de ativação do Cloud Shell Ativar o Cloud Shell no consoleGoogle Cloud . Isso inicia uma sessão no painel inferior do console Google Cloud .

  2. Defina as variáveis de ambiente padrão:

    gcloud config set project PROJECT_ID
    gcloud config set billing/quota_project PROJECT_ID
    export PROJECT_ID=$(gcloud config get project)
    export REGION=REGION
    export CLUSTER_NAME=CLUSTER_NAME
    export HF_TOKEN=HF_TOKEN
    

    Substitua os seguintes valores:

    • PROJECT_ID: o Google Cloud ID do projeto.
    • REGION: uma região compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.
    • CLUSTER_NAME: o nome do cluster.
    • HF_TOKEN: o token do Hugging Face gerado anteriormente.

Criar e configurar recursos Google Cloud

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 ou Standard. Recomendamos que você use um cluster do Autopilot para ter uma experiência totalmente gerenciada do Kubernetes. Para escolher o modo de operação do GKE mais adequado para suas cargas de trabalho, consulte Escolher um modo de operação do GKE.

Piloto automático

No Cloud Shell, execute este comando:

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

Substitua os seguintes valores:

  • PROJECT_ID: o Google Cloud ID do projeto.
  • REGION: uma região compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.
  • CLUSTER_NAME: o nome do cluster.

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

Padrão

  1. No Cloud Shell, execute o seguinte comando para criar um cluster Standard:

    gcloud container clusters create CLUSTER_NAME \
        --project=PROJECT_ID \
        --region=REGION \
        --workload-pool=PROJECT_ID.svc.id.goog \
        --release-channel=rapid \
        --num-nodes=1
    

    Substitua os seguintes valores:

    • PROJECT_ID: o Google Cloud ID do projeto.
    • REGION: uma região compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.
    • CLUSTER_NAME: o nome do cluster.

    A criação do cluster pode levar vários minutos.

  2. Para criar um pool de nós para o cluster com o tamanho de disco adequado, execute o seguinte comando:

    Gemma 3 1B

    gcloud container node-pools create gpupool \
        --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
        --project=PROJECT_ID \
        --location=REGION \
        --node-locations=REGION-a \
        --cluster=CLUSTER_NAME \
        --machine-type=g2-standard-8 \
        --num-nodes=1
    

    O GKE cria um único pool de nós contendo uma GPU L4 para cada nó.

    Gemma 3 4B

    gcloud container node-pools create gpupool \
        --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
        --project=PROJECT_ID \
        --location=REGION \
        --node-locations=REGION-a \
        --cluster=CLUSTER_NAME \
        --machine-type=g2-standard-8 \
        --num-nodes=1
    

    O GKE cria um único pool de nós contendo uma GPU L4 para cada nó.

    Gemma 3 12B

    gcloud container node-pools create gpupool \
        --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \
        --project=PROJECT_ID \
        --location=REGION \
        --node-locations=REGION-a \
        --cluster=CLUSTER_NAME \
        --machine-type=g2-standard-48 \
        --num-nodes=1
    

    O GKE cria um único pool de nós contendo quatro GPUs L4 para cada nó.

    Gemma 3 27B

    gcloud container node-pools create gpupool \
        --accelerator type=nvidia-a100-80gb,count=1,gpu-driver-version=latest \
        --project=PROJECT_ID \
        --location=REGION \
        --node-locations=REGION-a \
        --cluster=CLUSTER_NAME \
        --machine-type=a2-ultragpu-1g \
        --disk-type=pd-ssd \
        --num-nodes=1 \
        --disk-size=256
    

    O GKE cria um único pool de nós contendo uma GPU A100 de 80 GB.

Criar um secret do Kubernetes para as credenciais do Hugging Face

No Cloud Shell, faça o seguinte:

  1. Configure kubectl para se comunicar com o cluster:

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

    Substitua os seguintes valores:

    • REGION: uma região compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.
    • CLUSTER_NAME: o nome do cluster.
  2. Crie um secret do Kubernetes que contenha o token do Hugging Face:

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

    Substitua HF_TOKEN pelo token do Hugging Face que você gerou anteriormente.

Implantar vLLM

Nesta seção, você implantará o contêiner vLLM para exibir o modelo Gemma que você quer usar. Para implantar o modelo, este tutorial usa implantações do Kubernetes. Uma implantação é um objeto da API do Kubernetes que permite executar várias réplicas de pods distribuídos entre os nós de um cluster.

Gemma 3 1B-it

Siga estas instruções para implantar o modelo ajustado por instruções do Gemma 3 1B (entrada somente de texto).

  1. Crie o seguinte manifesto vllm-3-1b-it.yaml:

    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-3-1b-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:20250312_0916_RC01
            resources:
              requests:
                cpu: "2"
                memory: "10Gi"
                ephemeral-storage: "10Gi"
                nvidia.com/gpu: "1"
              limits:
                cpu: "2"
                memory: "10Gi"
                ephemeral-storage: "10Gi"
                nvidia.com/gpu: "1"
            command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
            args:
            - --model=$(MODEL_ID)
            - --tensor-parallel-size=1
            - --host=0.0.0.0
            - --port=8000
            env:
            - name: MODEL_ID
              value: google/gemma-3-1b-it
            - name: HUGGING_FACE_HUB_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
                medium: Memory
          nodeSelector:
            cloud.google.com/gke-accelerator: nvidia-l4
            cloud.google.com/gke-gpu-driver-version: latest
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: llm-service
    spec:
      selector:
        app: gemma-server
      type: ClusterIP
      ports:
        - protocol: TCP
          port: 8000
          targetPort: 8000
  2. Aplique o manifesto:

    kubectl apply -f vllm-3-1b-it.yaml
    

Gemma 3 4B-it

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

  1. Crie o seguinte manifesto vllm-3-4b-it.yaml:

    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-3-4b-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:20250312_0916_RC01
            resources:
              requests:
                cpu: "2"
                memory: "20Gi"
                ephemeral-storage: "20Gi"
                nvidia.com/gpu: "1"
              limits:
                cpu: "2"
                memory: "20Gi"
                ephemeral-storage: "20Gi"
                nvidia.com/gpu: "1"
            command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
            args:
            - --model=$(MODEL_ID)
            - --tensor-parallel-size=1
            - --host=0.0.0.0
            - --port=8000
            - --max-model-len=32768
            - --max-num-seqs=4
            env:
            - name: MODEL_ID
              value: google/gemma-3-4b-it
            - name: HUGGING_FACE_HUB_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
                medium: Memory
          nodeSelector:
            cloud.google.com/gke-accelerator: nvidia-l4
            cloud.google.com/gke-gpu-driver-version: latest
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: llm-service
    spec:
      selector:
        app: gemma-server
      type: ClusterIP
      ports:
        - protocol: TCP
          port: 8000
          targetPort: 8000
  2. Aplique o manifesto:

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

    No nosso exemplo, limitamos a janela de contexto a 32 mil tokens usando a opção vLLM --max-model-len=32768. 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 3 12B-it

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

  1. Crie o seguinte manifesto vllm-3-12b-it.yaml:

    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-3-12b-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:20250312_0916_RC01
            resources:
              requests:
                cpu: "4"
                memory: "32Gi"
                ephemeral-storage: "32Gi"
                nvidia.com/gpu: "2"
              limits:
                cpu: "4"
                memory: "32Gi"
                ephemeral-storage: "32Gi"
                nvidia.com/gpu: "2"
            command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
            args:
            - --model=$(MODEL_ID)
            - --tensor-parallel-size=2
            - --host=0.0.0.0
            - --port=8000
            - --max-model-len=16384
            - --max-num-seqs=4
            env:
            - name: MODEL_ID
              value: google/gemma-3-12b-it
            - name: HUGGING_FACE_HUB_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
                medium: Memory
          nodeSelector:
            cloud.google.com/gke-accelerator: nvidia-l4
            cloud.google.com/gke-gpu-driver-version: latest
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: llm-service
    spec:
      selector:
        app: gemma-server
      type: ClusterIP
      ports:
        - protocol: TCP
          port: 8000
          targetPort: 8000
  2. Aplique o manifesto:

    kubectl apply -f vllm-3-12b-it.yaml
    

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

Gemma 3 27B-it

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

  1. Crie o seguinte manifesto vllm-3-27b-it.yaml:

    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-3-27b-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:20250312_0916_RC01
            resources:
              requests:
                cpu: "10"
                memory: "128Gi"
                ephemeral-storage: "120Gi"
                nvidia.com/gpu : "1"
              limits:
                cpu: "10"
                memory: "128Gi"
                ephemeral-storage: "120Gi"
                nvidia.com/gpu : "1"
            command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
            args:
            - --model=$(MODEL_ID)
            - --tensor-parallel-size=1
            - --host=0.0.0.0
            - --port=8000
            - --swap-space=16
            - --gpu-memory-utilization=0.95
            - --max-model-len=32768
            - --max-num-seqs=4
            env:
            - name: MODEL_ID
              value: google/gemma-3-27b-it
            - name: HUGGING_FACE_HUB_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
                medium: Memory
          nodeSelector:
            cloud.google.com/gke-accelerator: nvidia-a100-80gb
            cloud.google.com/gke-gpu-driver-version: latest
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: llm-service
    spec:
      selector:
        app: gemma-server
      type: ClusterIP
      ports:
        - protocol: TCP
          port: 8000
          targetPort: 8000
  2. Aplique o manifesto:

    kubectl apply -f vllm-3-27b-it.yaml
    

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

Um pod no cluster faz o download dos pesos do modelo do Hugging Face e inicia o mecanismo de exibição.

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

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

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. O processo pode levar alguns minutos. O resultado será assim:

INFO:     Automatically detected platform cuda.
...
INFO      [launcher.py:34] Route: /v1/chat/completions, Methods: POST
...
INFO:     Started server process [13]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
Default STARTUP TCP probe succeeded after 1 attempt for container "vllm--google--gemma-3-4b-it-1" on port 8080.

Verifique se o download do modelo foi concluído antes de prosseguir para a próxima seção.

Disponibilizar o modelo

Nesta seção, você vai interagir com o modelo.

Configurar o encaminhamento de portas

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

kubectl port-forward service/llm-service 8000:8000

O resultado será assim:

Forwarding from 127.0.0.1:8000 -> 8000

Interagir com o modelo usando curl

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

Este exemplo mostra como testar o modelo ajustado por instrução da Gemma 3 4B 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:8000/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
    "model": "google/gemma-3-4b-it",
    "messages": [
        {
          "role": "user",
          "content": "Why is the sky blue?"
        }
    ]
}'

A saída será assim:

{
    "id": "chatcmpl-e4a2e624bea849d9b09f838a571c4d9e",
    "object": "chat.completion",
    "created": 1741763029,
    "model": "google/gemma-3-4b-it",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "reasoning_content": null,
                "content": "Okay, let's break down why the sky appears blue! It's a fascinating phenomenon rooted in physics, specifically something called **Rayleigh scattering**. Here's the explanation: ...",
                "tool_calls": []
            },
            "logprobs": null,
            "finish_reason": "stop",
            "stop_reason": 106
        }
    ],
    "usage": {
        "prompt_tokens": 15,
        "total_tokens": 668,
        "completion_tokens": 653,
        "prompt_tokens_details": null
    },
    "prompt_logprobs": null
}

(Opcional) Interagir com o modelo usando uma interface de chat do GRadio

Nesta seção, você criará um aplicativo de chat na Web que permite interagir com seu modelo ajustado por instruções. Para simplificar, esta seção descreve apenas a abordagem de teste usando o modelo 4B-it.

O Gradio é uma biblioteca Python que tem um wrapper ChatInterface que cria interfaces de usuário para chatbots.

Implantar a interface de chat

  1. No Cloud Shell, salve o seguinte manifesto como gradio.yaml. Mude google/gemma-2-9b-it para google/gemma-3-4b-it ou para outro nome de modelo do Gemma 3 usado na implantação.

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: gradio
      labels:
        app: gradio
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: gradio
      template:
        metadata:
          labels:
            app: gradio
        spec:
          containers:
          - name: gradio
            image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.4
            resources:
              requests:
                cpu: "250m"
                memory: "512Mi"
              limits:
                cpu: "500m"
                memory: "512Mi"
            env:
            - name: CONTEXT_PATH
              value: "/v1/chat/completions"
            - name: HOST
              value: "http://llm-service:8000"
            - name: LLM_ENGINE
              value: "openai-chat"
            - name: MODEL_ID
              value: "google/gemma-2-9b-it"
            - name: DISABLE_SYSTEM_MESSAGE
              value: "true"
            ports:
            - containerPort: 7860
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: gradio
    spec:
      selector:
        app: gradio
      ports:
      - protocol: TCP
        port: 8080
        targetPort: 7860
      type: ClusterIP
    
  2. Aplique o manifesto:

    kubectl apply -f gradio.yaml
    
  3. Aguarde até que a implantação esteja disponível:

    kubectl wait --for=condition=Available --timeout=900s deployment/gradio
    

Usar a interface de chat

  1. No Cloud Shell, execute este comando:

    kubectl port-forward service/gradio 8080:8080
    

    Isso cria um encaminhamento de porta do Cloud Shell para o serviço GRadio.

  2. Clique no botão Ícone de visualização na Web Visualização da Web no canto superior direito da barra de tarefas do Cloud Shell. Clique em Visualizar na porta 8080. Uma nova guia será aberta no navegador.

  3. Interaja com Gemma usando a interface de chat do GRadio. Adicione uma solicitação e clique em Enviar.

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 observar o desempenho do modelo, use a integração do painel do vLLM no Cloud Monitoring. Com esse painel, você pode conferir métricas de desempenho críticas, como taxa de transferência de token, latência de solicitação e taxas de erro.

Para usar o painel do vLLM, é necessário ativar o Google Cloud Managed Service para Prometheus, que coleta as métricas do vLLM, no cluster do GKE. O vLLM expõe métricas no formato Prometheus por padrão. Não é necessário instalar um exportador adicional.

Depois, é possível conferir as métricas usando o painel de vLLM. Para saber como usar o Google Cloud Managed Service para Prometheus para 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 Google Cloud pelos recursos criados neste guia, execute o seguinte comando:

gcloud container clusters delete CLUSTER_NAME \
    --region=REGION

Substitua os seguintes valores:

  • REGION: uma região compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.
  • CLUSTER_NAME: o nome do cluster.

A seguir