Esta página foi traduzida pela API Cloud Translation.

Publique modelos Llama com GPUs no GKE com o vLLM

Autopilot Padrão

Este tutorial mostra como implementar e publicar o modelo de linguagem (conteúdo extenso) (MDI/CE) Llama 4 usando GPUs no Google Kubernetes Engine (GKE) com a framework de publicação vLLM. Isto fornece uma base para compreender e explorar a implementação prática de MDIs/CEs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado que executa o vLLM no GKE. Também configura o GKE para carregar o Llama do Hugging Face.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, e especialistas em dados e IA que tenham interesse em usar capacidades de orquestração de contentores do Kubernetes para publicar cargas de trabalho de IA/AA em hardware de GPU H200, H100, A100 e L4. Para saber mais acerca das funções comuns e das tarefas de exemplo que referimos no Google Cloud conteúdo, consulte Funções e tarefas comuns do utilizador do GKE.

Se precisar de uma plataforma de IA gerida unificada concebida para criar e apresentar rapidamente modelos de ML de forma económica, recomendamos que experimente a nossa solução de implementação do Vertex AI.

Antes de ler esta página, certifique-se de que conhece o seguinte:

Contexto

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

Llama

O Llama é um modelo de linguagem (conteúdo extenso) da Meta concebido 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 suportar as necessidades de preparação e publicação distribuídas de modelos desta escala. Para mais informações, consulte a documentação do Llama.

GPUs

As GPUs permitem-lhe acelerar cargas de trabalho específicas executadas nos seus nós, como a aprendizagem automática e o processamento de dados. O GKE oferece uma variedade de opções de tipos de máquinas para a configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H200, H100, L4 e A100.

vLLM

O vLLM é uma framework de publicação de LLMs de código aberto altamente otimizada que pode aumentar a taxa de transferência de publicação em GPUs, com funcionalidades como as seguintes:

Implementação do transformador otimizada com PagedAttention
Processamento em lote contínuo para melhorar o débito geral da publicação
Paralelismo de tensores e publicação distribuída em várias GPUs

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

Objetivos

Prepare o seu ambiente com um cluster do GKE no modo Autopilot ou Standard.
Implemente um contentor vLLM no seu cluster.
Use o vLLM para publicar modelos Llama 4 através do curl e de uma interface de chat 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.
Aceder ao IAM
Selecione o projeto.
Clique em Conceder acesso.
No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.
Na lista Selecionar uma função, selecione uma função.
Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
Clique em Guardar.

Crie uma conta Hugging Face, se ainda não tiver uma.
Certifique-se de que o seu projeto tem quota suficiente para GPUs H100 e H200. Para saber mais, consulte os artigos Planeie a quota de GPU e Quota de GPU.

Aceda ao modelo

Para aceder ao modelo através do Hugging Face, precisa de um token do Hugging Face.

Siga estes passos para gerar um novo token se ainda não tiver um:

Clique em O seu perfil > Definições > Tokens de acesso.
Selecione Novo token.
Especifique um nome à sua escolha e uma função de, pelo menos, Read.
Selecione Gerar um token.
Copie o token gerado para a área de transferência.

Prepare o seu ambiente

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

Para configurar o seu ambiente com o Cloud Shell, siga estes passos:

Na Google Cloud consola, inicie uma sessão do Cloud Shell clicando em Ativar Cloud Shell na Google Cloud consola. Esta ação inicia uma sessão no painel inferior da consola. Google Cloud
Defina as variáveis de ambiente predefinidas:
```
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 seu Google Cloud ID do projeto.
- REGION: uma região que suporta o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
- CLUSTER_NAME: o nome do cluster.
- HF_TOKEN: o token do Hugging Face que gerou anteriormente.

Crie e configure Google Cloud recursos

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

Crie um cluster e um node pool do GKE

Pode publicar modelos Llama 4 em GPUs num cluster padrão ou do GKE Autopilot. Recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.

Piloto automático

No Cloud Shell, execute o seguinte 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 seu Google Cloud ID do projeto.
CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Indique uma região que suporte o tipo de acelerador que quer usar, por exemplo, us-central1 para a 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 implementadas.

Standard

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 seu Google Cloud ID do projeto.
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Indique uma região que suporte o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU H100.
- CLUSTER_NAME: o nome do cluster.
A criação do cluster pode demorar vários minutos.

Para criar um conjunto de nós para o seu cluster com o tamanho do 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 node pool com oito GPUs H100 de 80 GB.

Crie um segredo do Kubernetes para as credenciais do Hugging Face

No Cloud Shell, faça o seguinte:

Configure o kubectl para que possa comunicar com o seu cluster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=REGION
```
Substitua os seguintes valores:
- REGION: uma região que suporta o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
- CLUSTER_NAME: o nome do cluster.

Crie um segredo 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 gerou anteriormente.

Implemente o vLLM

Nesta secção, implementa o contentor vLLM para publicar os modelos Llama 4 que quer usar:

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

Para implementar o modelo, este tutorial usa implementações do Kubernetes. Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídas entre os nós num cluster.

Llama 4 Maverick 17B-128e

Para implementar 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 capacidade de resposta a 128 mil tokens usando a opção --max-model-len=131072vLLM.

Llama 4 Maverick 17B-128e-it

Para implementar o modelo otimizado com 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 capacidade de resposta a 128 mil tokens usando a opção --max-model-len=131072vLLM.

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

Para implementar 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 capacidade de resposta em 512 K usando a opção --max-model-len=524288vLLM.

Llama 4 Scout 17B-16e

Para implementar 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 capacidade de resposta em 256 mil tokens usando a opção --max-model-len=262144vLLM.

Llama 4 Scout 17B-16e-it

Para implementar o modelo otimizado para 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 capacidade de resposta em 1280 K usando a opção --max-model-len=1310720vLLM.

Aguarde que a implementação esteja disponível:

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

Veja os registos da implementação em execução:

kubectl logs -f -l app=llama-server

O recurso de implementação transfere os dados do modelo. Este processo pode demorar alguns minutos. O resultado é semelhante ao seguinte:

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

Certifique-se de que o modelo é totalmente transferido antes de avançar para a secção seguinte.

Publique o modelo

Nesta secção, interage com o modelo.

Configure 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 é semelhante ao seguinte:

Forwarding from 127.0.0.1:8080 -> 7080

Interaja com o modelo através do curl

Esta secção mostra como pode realizar um teste rápido básico para validar o modelo Llama ajustado com instruções implementado. Para outros modelos, substitua meta-llama/Llama-4-Scout-17B-16E pelo nome do modelo respetivo.

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

Numa nova sessão de terminal, use curl para conversar com o 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 é semelhante ao seguinte:

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

Resolver problemas

Se receber a mensagem Empty reply from server, o contentor pode não ter terminado de transferir os dados do modelo. Verifique novamente os registos do Pod para ver a mensagem Connected, que indica que o modelo está pronto para publicação.
Se vir a mensagem Connection refused, verifique se o encaminhamento de portas está ativo.

Observe o desempenho do modelo

Para observar o desempenho do modelo, pode usar a integração do painel de controlo do vLLM no Cloud Monitoring. Com este painel de controlo, pode ver métricas de desempenho críticas, como o débito de tokens, a latência de pedidos e as taxas de erro.

Para usar o painel de controlo do vLLM, tem de ativar o Google Cloud Managed Service for Prometheus, que recolhe as métricas do vLLM, no seu cluster do GKE. O vLLM expõe métricas no formato Prometheus por predefinição; não precisa de instalar um exportador adicional.

Em seguida, pode ver as métricas através do painel de controlo do vLLM. Para obter informações sobre a utilização do serviço gerido do Google Cloud para Prometheus para recolher métricas do seu modelo, consulte as orientações de observabilidade da vLLM na documentação do Cloud Monitoring.

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

Elimine os recursos implementados

Para evitar incorrer em custos na sua Google Cloud conta pelos recursos que criou 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 controlo do seu cluster.
CLUSTER_NAME: o nome do cluster.

O que se segue?

Saiba mais acerca das GPUs no GKE.
Saiba como usar o Llama com o vLLM noutros aceleradores, incluindo GPUs A100 e H100, consultando o código de exemplo no GitHub.
Saiba como implementar cargas de trabalho de GPU no Autopilot.
Saiba como implementar cargas de trabalho de GPU no Standard.
Explore o repositório do GitHub do vLLM e a documentação.
Explore o Vertex AI Model Garden.
Descubra como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma do GKE.

Publique modelos Llama com GPUs no GKE com o 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

Aceda ao modelo

Prepare o seu ambiente

Crie e configure Google Cloud recursos

Crie um cluster e um node pool do GKE

Piloto automático

Standard

Crie um segredo do Kubernetes para as credenciais do Hugging Face

Implemente o 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

Publique o modelo

Configure o encaminhamento de portas

Interaja com o modelo através do curl

Resolver problemas

Observe o desempenho do modelo

Limpar

Elimine os recursos implementados

O que se segue?

Publique modelos Llama com GPUs no GKE com o vLLM