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 B200, H100, RTX Pro 6000 ou L4.

Para obter as ponderações do modelo Gemma 4, configure o contêiner vLLM pré-criado para fazer o download delas no repositório do Hugging Face. Como alternativa, o contêiner pode carregar pesos de modelo do armazenamento persistente, como o armazenamento em cache dos buckets de modelo do Cloud Storage em uma instância do Google Cloud Managed Lustre.

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 hardwares de GPU H200, H100, A100 e L4. Para saber mais sobre papéis comuns e tarefas de exemplo referenciados no conteúdo do Google Cloud , consulte Tarefas e funções de usuário comuns do GKE.

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 que você teste 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.

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áquinas 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 processamento 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

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 ou Standard.
  2. Implante um contêiner vLLM no seu cluster.
  3. Use o vLLM para disponibilizar o modelo Gemma 4 por meio de curl e de uma interface de chat na Web.

Antes de começar

  • Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloud, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud 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 Google Cloud 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

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud 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 Google Cloud 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 Google Cloud , 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 Google Cloud , 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 endereço de e-mail de uma Conta do Google.

    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 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 a CLI gcloud.

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

  1. No console do Google Cloud , inicie uma sessão do Cloud Shell clicando em Ícone de ativação do Cloud Shell Ativar o Cloud Shell no console doGoogle 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 ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME

    Substitua os seguintes valores:

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 \
    --location=CONTROL_PLANE_LOCATION \
    --release-channel=rapid

Substitua os seguintes valores:

  • PROJECT_ID: o Google Cloud ID do projeto.
  • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controle do cluster. Forneça 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 \
    --location=CONTROL_PLANE_LOCATION \
    --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.
    • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controle do cluster. Forneça 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:

      gcloud container node-pools create gpupool \
      --accelerator type=nvidia-rtx-pro-6000,count=1,gpu-driver-version=latest \
      --project=PROJECT_ID \
      --location=REGION \
      --node-locations=ZONE \
      --cluster=CLUSTER_NAME \
      --machine-type=g4-standard-48 \
      --num-nodes=1

    O GKE cria um único pool de nós contendo uma RTX PRO. 6.000 GPUs para cada nó.

Implantar modelos do Gemma 4 no vLLM usando pesos do Hugging Face

Para implantar modelos do Gemma 4 usando pesos do Hugging Face, aplique um manifesto de implantação do Kubernetes para o tamanho do 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 baixa automaticamente os pesos do Hugging Face para iniciar o mecanismo de inferência vLLM.

Gemma 4 E2B-it

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

  1. Crie o seguinte manifesto vllm-4-e2b-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-4-e2b-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: "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.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E2B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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-4-e2b-it.yaml

Gemma 4 E4B-it

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

  1. Crie o seguinte manifesto vllm-4-e4b-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-4-e4b-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: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E4b-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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-4-E4b-it.yaml

    No nosso exemplo, limitamos a janela de contexto em 32 K usando a opção --max-model-len=32768 do vLLM. 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 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: 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: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-26B-A4B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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-4-26b-a4b-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 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: 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: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-31B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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-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 do Hugging Face estiver disponível, configure o encaminhamento de portas para interagir com o modelo.

Implantar o Gemma ajustado do Managed Lustre

Para disponibilizar um modelo Gemma refinado (como o Gemma 3 27B) que já está armazenado em uma instância do Google Cloud Managed Lustre, é necessário montar o PersistentVolumeClaim (PVC) correspondente no contêiner vLLM.

Pré-requisitos

Verifique se você tem uma PVC no cluster do GKE que se conecta à instância do Lustre. Neste exemplo, o PVC é chamado de gemma-lustre-pvc.

Para saber como criar um PVC e um PersistentVolume (PV) para uma instância atual, consulte Acessar uma instância do Managed Lustre.

Procedimento

  1. Salve o seguinte manifesto YAML como vllm-lustre-gemma.yaml. Neste exemplo, o Deployment monta o PVC do Lustre em /data e instrui o vLLM a carregar os pesos do modelo desse caminho local.

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-lustre
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/data/gemma-3-27b
        - --tensor-parallel-size=1
        resources:
          limits:
            nvidia.com/gpu: "1"
        volumeMounts:
        - name: model-weights
          mountPath: /data
      volumes:
      - name: model-weights
        persistentVolumeClaim:
          claimName: gemma-lustre-pvc
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest

  2. Aplique o manifesto ao cluster do GKE:

    kubectl apply -f vllm-lustre-gemma.yaml

Verificação

Para confirmar se o modelo foi carregado do volume do Lustre, verifique os registros do pod na sequência de inicialização do vLLM:

kubectl logs -l app=gemma-server

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 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 ajustados por instruções do Gemma 4 implantados. Para outros modelos, substitua gemma-4-e4b-it pelo nome do modelo respectivo.

Este exemplo mostra como testar o modelo ajustado por instrução da Gemma 4 E4B 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-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
}

(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-4-E4B-it para o nome do modelo Gemma 4 usado na sua 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.7
        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-4-E4B-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

    4. 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 conferir os painéis das métricas de observabilidade de um modelo, siga estas etapas:

    1. No console do Google Cloud , 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.

    Para usar o painel no Cloud Monitoring, ative o Serviço Gerenciado do Google Cloud para Prometheus, que coleta as métricas do vLLM no cluster do GKE. 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 Google Cloud pelos recursos criados neste guia, execute o seguinte comando:

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

Substitua os seguintes valores:

  • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controle do cluster.
  • CLUSTER_NAME: o nome do cluster.

A seguir