Esta página foi traduzida pela API Cloud Translation.

Disponibilizar modelos Llama usando GPUs no GKE com vLLM

Autopilot Standard

Neste tutorial, mostramos como implantar e disponibilizar o modelo de linguagem grande (LLM) Llama 4 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 LLMs para inferência em um ambiente gerenciado do Kubernetes. Você implanta um contêiner pré-criado que executa vLLM no GKE. Você também configura o GKE para carregar o Llama do Hugging Face.

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.

Llama

O Llama é um modelo de linguagem grande da Meta projetado para uma variedade de tarefas de processamento de linguagem natural, incluindo geração de texto, tradução e resposta a perguntas. O GKE oferece a infraestrutura necessária para atender às necessidades de treinamento e disponibilização distribuídos de modelos dessa escala. Para mais informações, consulte a documentação do Llama.

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 exibição de LLM de código aberto altamente otimizado que pode aumentar a capacidade de exibiçã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

Prepare seu ambiente com um cluster do GKE no modo Autopilot ou Standard.
Implante um contêiner vLLM no seu cluster.
Use o vLLM para disponibilizar modelos do Llama 4 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.

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 (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 (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

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

Check for the roles

In the Google Cloud console, go to the IAM page.
Go to IAM
Select the project.
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.
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

In the Google Cloud console, go to the IAM page.
Acessar o IAM
Selecione o projeto.
Clique em Conceder acesso.
No campo Novos principais, digite seu identificador de usuário. Normalmente, é o endereço de e-mail de uma Conta do Google.
Na lista Selecionar papel, escolha um.
Para conceder outros papéis, adicione-os clicando em Adicionar outro papel.
Clique em Salvar.

Crie uma conta do Hugging Face caso ainda não tenha uma.
Verifique se o projeto tem cota suficiente para GPUs H100 e H200. Para saber mais, consulte Planejar a cota de GPU e Cota de GPU.

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:

Clique em Seu perfil > Configurações > Tokens de acesso.
Selecione Novo token.
Especifique um Nome de sua escolha e um Papel de pelo menos Read.
Selecione Gerar um token.
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:

No console do Google Cloud , inicie uma sessão do Cloud Shell clicando em Ativar o Cloud Shell no Google Cloud console. Isso inicia uma sessão no painel inferior do console Google Cloud .
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 modelos Llama 4 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 que ofereça suporte ao 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

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 que ofereça suporte ao tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU H100.
- CLUSTER_NAME: o nome do cluster.
A criação do cluster pode levar vários minutos.

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-h100-80gb,count=1,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=a3-highgpu-8g \
    --disk-type=pd-ssd \
    --num-nodes=1 \
    --disk-size=256

O GKE cria um único pool de nós com oito GPUs H100 de 80 GB.

Criar um secret do Kubernetes para as credenciais do Hugging Face

No Cloud Shell, faça o seguinte:

Configure kubectl para que ele possa 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.

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ê implanta o contêiner vLLM para veicular os modelos Llama 4 que quer usar:

Llama 4 Maverick 17B-128E
Llama 4 Scout 17B-16E

Para implantar o modelo, este tutorial usa implantações do Kubernetes. 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.

Llama 4 Maverick 17B-128e

Para implantar o modelo Llama 4 Maverick 17B-128E, siga estas instruções:

Crie o seguinte manifesto vllm-llama4-maverick-17b-128e.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Maverick-17B-128E
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=131072
        - --gpu-memory-utilization=0.95
        - --disable-log-stats
        - --dtype=auto
        - --kv-cache-dtype=auto
        - --max-num-seqs=64
        - --model=meta-llama/Llama-4-Maverick-17B-128E
        - --tensor-parallel-size=8
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Maverick-17B-128E'
        - 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-h200-141gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

Aplique o manifesto:
```
kubectl apply -f vllm-llama4-maverick-17b-128e.yaml
```
No nosso exemplo, limitamos a janela de contexto em 128 K usando a opção --max-model-len=131072 do vLLM.

Llama 4 Maverick 17B-128e-it

Para implantar o modelo ajustado por instruções Llama 4 Maverick 17B-128e, siga estas instruções:

Crie o seguinte manifesto vllm-llama4-maverick-17b-128e-instruct.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=131072
        - --gpu-memory-utilization=0.95
        - --disable-log-stats
        - --dtype=auto
        - --kv-cache-dtype=auto
        - --max-num-seqs=64
        - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct
        - --tensor-parallel-size=8
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct'
        - 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-h200-141gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

Aplique o manifesto:
```
kubectl apply -f vllm-llama4-maverick-17b-128e-instruct.yaml
```
No nosso exemplo, limitamos a janela de contexto em 128 K usando a opção --max-model-len=131072 do vLLM.

Llama 4 Maverick 17B-128e-it-fp8

Para implantar o modelo Llama 4 Maverick 17B-128e-Instruct-FP8, siga estas instruções:

Crie o seguinte manifesto vllm-llama4-maverick-17b-128e-instruct-fp8.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct-FP8
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=524288
        - --gpu-memory-utilization=0.90
        - --disable-log-stats
        - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8
        - --tensor-parallel-size=8
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8'
        - 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-h100-80gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

Aplique o manifesto:
```
kubectl apply -f vllm-llama4-maverick-17b-128e-instruct-fp8.yaml
```
No nosso exemplo, limitamos a janela de contexto em 512 K usando a opção --max-model-len=524288 vLLM.

Llama 4 Scout 17B-16e

Para implantar o modelo Llama 4 Scout 17B-16E, siga estas instruções:

Crie o seguinte manifesto vllm-llama4-scout-17b-16e.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Scout-17B-16E
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=262144
        - --limit_mm_per_prompt
        - '{"image": 5}'
        - --disable-log-stats
        - --model=meta-llama/Llama-4-Scout-17B-16E
        - --tensor-parallel-size=8
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64        
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Scout-17B-16E'
        - 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-h100-80gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

Aplique o manifesto:
```
kubectl apply -f vllm-llama4-scout-17b-16e.yaml
```
No nosso exemplo, limitamos a janela de contexto em 256 K usando a opção --max-model-len=262144 vLLM.

Llama 4 Scout 17B-16e-it

Para implantar o modelo ajustado por instruções Llama 4 Scout 17B-16e Instruct, siga estas instruções:

Crie o seguinte manifesto vllm-llama4-scout-17b-16e-instruct.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Scout-17B-16E-Instruct
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=1310720
        - --limit_mm_per_prompt
        - '{"image": 5}'
        - --disable-log-stats
        - --model=meta-llama/Llama-4-Scout-17B-16E-Instruct
        - --tensor-parallel-size=8
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Scout-17B-16E-Instruct'
        - 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-h100-80gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

Aplique o manifesto:
```
kubectl apply -f vllm-llama4-scout-17b-16e-instruct.yaml
```
No nosso exemplo, limitamos a janela de contexto em 1.280 K usando a opção --max-model-len=1310720 do vLLM.

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

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

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

kubectl logs -f -l app=llama-server

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

INFO:     Started server process [145]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
...
INFO 04-07 13:36:29 [async_llm.py:228] Added request chatcmpl-4149ea4cf35e48559f9f819dcdbbb23e.
INFO:     127.0.0.1:44018 - "POST /v1/chat/completions HTTP/1.1" 200 OK

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

Para configurar o encaminhamento de portas para o modelo, execute o seguinte comando:

kubectl port-forward service/llama-service 8080:8000

O resultado será assim:

Forwarding from 127.0.0.1:8080 -> 7080

Interagir com o modelo usando curl

Nesta seção, mostramos como realizar um teste preliminar básico para verificar o modelo Llama ajustado por instruções implantado. Para outros modelos, substitua meta-llama/Llama-4-Scout-17B-16E pelo nome do modelo respectivo.

Este exemplo mostra como testar o modelo Llama 4 Scout 17B-16E com entrada somente de texto.

Em uma nova sessão do terminal, use curl para conversar com seu modelo:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-4-Scout-17B-16E",
    "messages": [{"role": "user", "content": "San Francisco is a"}],
    "max_tokens": 7,
    "temperature": 0
  }'

O resultado será assim:

"message":{"role":"assistant","reasoning_content":null,"content":"San Francisco is a city","tool_calls":[]}

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 a mensagem Connection refused, verifique se o encaminhamento de portas está ativo.

Observar o desempenho do modelo

Para observar a performance do modelo, use a integração do painel do vLLM no Cloud Monitoring. Com esse painel, é possível conferir métricas de desempenho importantes, como taxa de transferência de tokens, latência de solicitação e taxas de erro.

Para usar o painel do vLLM, ative 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 do Prometheus por padrão. Não é necessário instalar um exportador adicional.

Em seguida, use o painel do vLLM para conferir as métricas. Para informações sobre como usar o Google Cloud Managed Service para Prometheus para coletar métricas do seu modelo, consulte as orientações de capacidade de observação 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

Saiba mais sobre GPUs no GKE.
Aprenda a usar o Llama com o vLLM em outros aceleradores, incluindo GPUs A100 e H100, visualizando o exemplo de código no GitHub.
Saiba mais como implantar cargas de trabalho de GPU no Autopilot.
Aprenda a implantar cargas de trabalho de GPU no Standard.
Conheça o repositório do GitHub e a documentação do vLLM.
Conhecer o Model Garden da Vertex AI.
Descubra como executar cargas de trabalho de IA/ML otimizadas com os recursos de orquestração da plataforma GKE.

Disponibilizar modelos Llama usando GPUs no GKE com vLLM Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Contexto

Llama

GPUs

vLLM

Objetivos

Antes de começar

Check for the roles

Grant the roles

Receber acesso ao modelo

Preparar o ambiente

Criar e configurar recursos Google Cloud

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

Piloto automático

Padrão

Criar um secret do Kubernetes para as credenciais do Hugging Face

Implantar vLLM

Llama 4 Maverick 17B-128e

Llama 4 Maverick 17B-128e-it

Llama 4 Maverick 17B-128e-it-fp8

Llama 4 Scout 17B-16e

Llama 4 Scout 17B-16e-it

Disponibilizar o modelo

Configurar o encaminhamento de portas

Interagir com o modelo usando curl

Resolver problemas

Observar o desempenho do modelo

Limpar

Excluir os recursos implantados

A seguir

Disponibilizar modelos Llama usando GPUs no GKE com vLLM