Nesta página, descrevemos como usar o início rápido da inferência do GKE para simplificar a implantação de cargas de trabalho de inferência de IA/ML no Google Kubernetes Engine (GKE). O guia de início rápido de inferência é um utilitário que permite especificar seus requisitos comerciais de inferência e receber configurações otimizadas do Kubernetes com base nas práticas recomendadas e nos comparativos de mercado do Google para modelos, servidores de modelos, aceleradores (GPUs, TPUs) e escalonamento. Isso ajuda a evitar o processo demorado de ajustar e testar configurações manualmente.
Esta página é destinada a engenheiros de machine learning (ML), administradores e operadores de plataforma e especialistas em dados e IA que querem entender como gerenciar e otimizar o GKE de maneira eficiente para inferência de IA/ML. Para saber mais sobre papéis comuns e tarefas de exemplo que mencionamos no conteúdo do Google Cloud , consulte Tarefas e funções de usuário comuns do GKE Enterprise.
Para saber mais sobre conceitos e terminologia de disponibilização de modelos e como os recursos de IA generativa do GKE podem melhorar e apoiar a performance da disponibilização de modelos, consulte Sobre a inferência de modelos no GKE.
Antes de ler esta página, confira os conceitos de Kubernetes, GKE e veiculação de modelos.
Como usar o guia de início rápido de inferência
As etapas gerais para usar o guia de início rápido de inferência são as seguintes: Clique nos links para instruções detalhadas.
- Conferir práticas recomendadas personalizadas: na página de IA/ML do GKE
no console Google Cloud ou na Google Cloud CLI no terminal,
comece fornecendo entradas como seu modelo aberto
preferido (por exemplo, Llama, Gemma ou Mistral).
- É possível especificar a meta de latência do aplicativo, indicando se ela é sensível à latência (como um chatbot) ou à capacidade de processamento (como análises em lote).
- Com base nos seus requisitos, o início rápido da inferência oferece opções de aceleradores, métricas de performance e manifestos do Kubernetes, que dão controle total para implantação ou outras modificações. Os manifestos gerados referenciam imagens públicas do servidor de modelo, então você não precisa criar essas imagens.
- Implante manifestos: usando o console Google Cloud ou o comando
kubectl apply
, implante os manifestos recomendados. Antes de fazer a implantação, verifique se você tem cota de acelerador suficiente para as GPUs ou TPUs selecionadas no seu projeto Google Cloud . - Monitorar a performance: use o Cloud Monitoring para monitorar as métricas de performance da carga de trabalho fornecidas pelo GKE. É possível conferir os painéis do servidor de modelo e ajustar a implantação conforme necessário.
Vantagens
O guia de início rápido da inferência ajuda você a economizar tempo e recursos fornecendo configurações otimizadas. Essas otimizações melhoram o desempenho e reduzem os custos de infraestrutura das seguintes maneiras:
- Você recebe práticas recomendadas detalhadas e personalizadas para definir o acelerador (GPU e TPU), o servidor de modelo e as configurações de escalonamento. O GKE atualiza rotineiramente a ferramenta com as correções, imagens e comparativos de desempenho mais recentes.
- É possível especificar os requisitos de latência e capacidade da sua carga de trabalho usando a UIGoogle Cloud ou uma interface de linha de comando e receber práticas recomendadas detalhadas e personalizadas como manifestos de implantação do Kubernetes.
Casos de uso
O guia de início rápido de inferência é adequado para cenários como estes:
- Descubra as arquiteturas de inferência ideais do GKE: se você estiver fazendo a transição de outro ambiente, como local ou um provedor de nuvem diferente, e quiser as arquiteturas de inferência recomendadas mais atualizadas no GKE para suas necessidades específicas de desempenho.
- Acelere as implantações de inferência de IA/ML: se você é um usuário experiente do Kubernetes e quer começar a implantar cargas de trabalho de inferência de IA rapidamente, o início rápido de inferência ajuda a descobrir e implementar implantações de práticas recomendadas no GKE, com configurações detalhadas de YAML baseadas em práticas recomendadas.
- Conheça as TPUs para melhorar o desempenho: se você já usa o Kubernetes no GKE com GPUs, use o início rápido de inferência para conhecer os benefícios das TPUs e alcançar um desempenho melhor.
Como funciona
O guia de início rápido de inferência oferece práticas recomendadas personalizadas com base em benchmarks internos exaustivos do Google de desempenho de réplica única para combinações de modelo, servidor de modelo e topologia de acelerador. Esses comparativos representam a latência versus a capacidade de transmissão, incluindo o tamanho da fila e as métricas de cache KV, que mapeiam as curvas de performance para cada combinação.
Como as práticas recomendadas personalizadas são geradas
Medimos a latência em tempo normalizado por token de saída (NTPOT) em milissegundos e a taxa de transferência em tokens de saída por segundo, saturando os aceleradores. Para saber mais sobre essas métricas de desempenho, consulte Sobre a inferência de modelos no GKE.
O perfil de latência de exemplo a seguir ilustra o ponto de inflexão em que a taxa de transferência atinge um platô (verde), o ponto pós-inflexão em que a latência piora (vermelho) e a zona ideal (azul) para uma taxa de transferência ideal na meta de latência. O início rápido da inferência fornece dados de desempenho e configurações para essa zona ideal.
Com base nos requisitos de latência de um aplicativo de inferência, o início rápido da inferência identifica combinações adequadas e determina o ponto de operação ideal na curva de latência-capacidade de processamento. Esse ponto define o limite do escalonador automático horizontal de pods (HPA) com um buffer para considerar a latência de escalonamento vertical. O limite geral também informa o número inicial de réplicas necessárias, embora o HPA ajuste esse número dinamicamente com base na carga de trabalho.
Comparativo de mercado
As configurações e os dados de performance fornecidos são baseados em comparativos de mercado que usam o conjunto de dados ShareGPT para enviar tráfego com a seguinte distribuição de entrada e saída.
Tokens de entrada | Tokens de saída | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Mín. | Mediana | Média | P90 | P99 | Máx. | Mín. | Mediana | Média | P90 | P99 | Máx. |
4 | 108 | 226 | 635 | 887 | 1024 | 1 | 132 | 195 | 488 | 778 | 1024 |
Antes de começar
Antes de começar, veja se você realizou as seguintes tarefas:
- Ative a API Google Kubernetes Engine. Ativar a API Google Kubernetes Engine
- Se você quiser usar a CLI do Google Cloud para essa tarefa,
instale e, em seguida,
inicialize a
CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão
mais recente executando
gcloud components update
.
No console Google Cloud , na página do seletor de projetos, selecione ou crie um projeto Google Cloud .
Verifique se o faturamento foi ativado para o projeto Google Cloud .
Verifique se você tem capacidade de acelerador suficiente para seu projeto:
- Se você usa GPUs: verifique a página "Cotas".
- Se você usa TPUs, consulte Garantir cota para TPUs e outros recursos do GKE.
Gere um token de acesso do Hugging Face e um Secret do Kubernetes correspondente, caso ainda não tenha um. Para criar um secret do Kubernetes que contenha o token do Hugging Face, execute o seguinte comando:
kubectl create secret generic hf-secret \ --from-literal=hf_api_token=HUGGING_FACE_TOKEN \ --namespace=NAMESPACE
Substitua os seguintes valores:
- HUGGING_FACE_TOKEN: o token do Hugging Face que você criou anteriormente.
- NAMESPACE: o namespace do Kubernetes em que você quer implantar o servidor de modelo.
Alguns modelos também podem exigir que você aceite e assine o contrato de licença de consentimento.
Preparar-se para usar a interface do usuário de IA/ML do GKE
Se você usar o console do Google Cloud , também precisará criar um cluster do Autopilot, caso ainda não tenha um no projeto. Siga as instruções em Criar um cluster do Autopilot.
Preparar para usar a interface de linha de comando
Se você usar a CLI gcloud para executar o guia de início rápido da inferência, também precisará executar estes comandos adicionais:
Ative a
gkerecommender.googleapis.com
API:gcloud services enable gkerecommender.googleapis.com
Defina o projeto de cota de faturamento que você usa para chamadas de API:
gcloud config set billing/quota_project PROJECT_ID
Verifique se a versão da CLI gcloud é pelo menos 526.0.0. Caso contrário, execute o seguinte:
gcloud components update
Limitações
Conheça as seguintes limitações antes de começar a usar o tutorial de início rápido da inferência:
- A implantação de modelos do consoleGoogle Cloud é compatível apenas com clusters do Autopilot.
- O guia de início rápido de inferência não fornece perfis para todos os modelos compatíveis com um determinado servidor de modelos.
Ver configurações otimizadas para inferência de modelo
Esta seção descreve como gerar e visualizar recomendações de configuração usando o console Google Cloud ou a linha de comando.
Console
- Clique em Implantar modelos.
Selecione o modelo que você quer ver. Os modelos compatíveis com o início rápido de inferência são mostrados com a tag Otimizado.
- Se você selecionou um modelo de fundação, uma página do modelo será aberta. Clique em Implantar. Você ainda pode modificar a configuração antes da implantação real.
- Você vai receber uma solicitação para criar um cluster do Autopilot se não houver um no seu projeto. Siga as instruções em Criar um cluster do Autopilot. Depois de criar o cluster, volte para a página de IA/ML do GKE no console do Google Cloud para selecionar um modelo.
A página de implantação do modelo é preenchida automaticamente com o modelo selecionado, o servidor de modelo e o acelerador recomendados. Também é possível configurar definições como latência máxima.
Para conferir o manifesto com a configuração recomendada, clique em Ver YAML.
gcloud
Use o comando gcloud alpha container ai profiles
para explorar e
ver combinações otimizadas de modelo, servidor de modelo, versão do servidor de modelo e
aceleradores:
Modelos
Para explorar e selecionar um modelo, use a opção models
.
gcloud alpha container ai profiles models list
Servidores de modelo
Para conferir os servidores de modelo recomendados para o modelo de seu interesse, use a opção model-servers
. Exemplo:
gcloud alpha container ai profiles model-servers list \
--model=meta-llama/Meta-Llama-3-8B
A saída será assim:
Supported model servers:
- vllm
Versões do servidor
Opcionalmente, para conferir as versões compatíveis do servidor de modelo que interessa a você, use a opção model-server-versions
. Se você pular esta etapa, o guia de início rápido de inferência vai usar a versão mais recente por padrão.
Exemplo:
gcloud alpha container ai profiles model-server-versions list \
--model=meta-llama/Meta-Llama-3-8B \
--model-server=vllm
A saída será assim:
Supported model server versions:
- e92694b6fe264a85371317295bca6643508034ef
- v0.7.2
Aceleradores
Para conferir os aceleradores recomendados para a combinação de modelo e servidor de modelo que você quer, use a opção accelerators
.
Exemplo:
gcloud alpha container ai profiles accelerators list \
--model=deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
--model-server-version=v0.7.2
A saída será assim:
Supported accelerators:
accelerator | model | model server | model server version | accelerator count | output tokens per second | ntpot ms
---------------------|-----------------------------------------|--------------|------------------------------------------|-------------------|--------------------------|---------
nvidia-tesla-a100 | deepseek-ai/DeepSeek-R1-Distill-Qwen-7B | vllm | v0.7.2 | 1 | 3357 | 72
nvidia-h100-80gb | deepseek-ai/DeepSeek-R1-Distill-Qwen-7B | vllm | v0.7.2 | 1 | 6934 | 30
For more details on each accelerator, use --format=yaml
A saída retorna uma lista de tipos de aceleradores e estas métricas:
- Capacidade de processamento, em tokens de saída por segundo
- Tempo normalizado por token de saída (NTPOT), em milissegundos
Os valores representam a performance observada no ponto em que a taxa de transferência para de aumentar e a latência começa a aumentar drasticamente (ou seja, o ponto de inflexão ou saturação) para um determinado perfil com esse tipo de acelerador. Para saber mais sobre essas métricas de desempenho, consulte Sobre a inferência de modelo no GKE.
Para mais opções, consulte a documentação da Google Cloud CLI.
Depois de escolher um modelo, um servidor de modelo, uma versão do servidor de modelo e um acelerador, você pode criar um manifesto de implantação.
Implantar configurações recomendadas
Esta seção descreve como gerar e implantar recomendações de configuração usando o console do Google Cloud ou a linha de comando.
Console
- Clique em Implantar modelos.
Selecione um modelo que você quer implantar. Os modelos compatíveis com o início rápido de inferência são mostrados com a tag Otimizado.
- Se você selecionou um modelo de fundação, uma página do modelo será aberta. Clique em Implantar. Você ainda pode modificar a configuração antes da implantação real.
- Você vai receber uma solicitação para criar um cluster do Autopilot se não houver um no seu projeto. Siga as instruções em Criar um cluster do Autopilot. Depois de criar o cluster, volte para a página de IA/ML do GKE no console do Google Cloud para selecionar um modelo.
A página de implantação do modelo é preenchida automaticamente com o modelo selecionado, o servidor de modelo e o acelerador recomendados. Também é possível configurar definições como latência máxima.
(Opcional) Para ver o manifesto com a configuração recomendada, clique em Ver YAML.
Para implantar o manifesto com a configuração recomendada, clique em Implantar. A operação de implantação pode levar vários minutos para ser concluída.
Para conferir sua implantação, acesse a página Kubernetes Engine > Cargas de trabalho.
gcloud
Gerar manifestos: no terminal, use a opção
manifests
para gerar manifestos de implantação, serviço e PodMonitoring:gcloud alpha container ai profiles manifests create
Use os parâmetros obrigatórios
--model
,--model-server
e--accelerator-type
para personalizar o manifesto.Também é possível definir estes parâmetros:
--target-ntpot-milliseconds
: defina esse parâmetro para especificar seu limite de HPA. Com esse parâmetro, é possível definir um limite de escalonamento para manter a latência P50 do tempo normalizado por token de saída (NTPOT, na sigla em inglês), que é medida no 50º quartil, abaixo do valor especificado. Escolha um valor acima da latência mínima do seu acelerador. O HPA é configurado para capacidade de processamento máxima se você especificar um valor NTPOT acima da latência máxima do acelerador. Exemplo:gcloud alpha container ai profiles manifests create \ --model=google/gemma-2-27b-it \ --model-server=vllm \ --model-server-version=v0.7.2 \ --accelerator-type=nvidia-l4 \ --target-ntpot-milliseconds=200
--model-server-version
: a versão do servidor de modelo. Se não for especificado, o padrão será a versão mais recente.--namespace
: o namespace em que os manifestos serão implantados. O namespace padrão é "default".--output
: os valores válidos incluemmanifest
,comments
eall
. Por padrão, esse parâmetro é definido comoall
. Você pode gerar apenas o manifesto para implantar cargas de trabalho ou apenas os comentários se quiser ver instruções para ativar recursos.--output-path
: se especificado, a saída será salva no caminho fornecido, em vez de ser impressa no terminal. Assim, você pode editar a saída antes de implantá-la. Por exemplo, é possível usar essa opção com--output=manifest
se você quiser salvar o manifesto em um arquivo YAML. Exemplo:gcloud alpha container ai profiles manifests create \ --model deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \ --model-server vllm \ --accelerator-type=nvidia-tesla-a100 \ --output=manifest \ --output-path /tmp/manifests.yaml
Para mais opções, consulte a documentação da Google Cloud CLI.
Provisione sua infraestrutura: siga estas etapas de provisionamento para garantir que ela esteja configurada corretamente para implantação, monitoramento e escalonamento de modelos.
Implante os manifestos: execute o comando
kubectl apply
e transmita o arquivo YAML dos manifestos. Exemplo:kubectl apply -f ./manifests.yaml
Provisione sua infraestrutura
Siga estas etapas para garantir que sua infraestrutura esteja configurada corretamente para implantação, monitoramento e escalonamento de modelos:
Criar um cluster: é possível disponibilizar seu modelo em clusters 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.
Se você não tiver um cluster, siga estas etapas:
Piloto automático
Siga estas instruções para criar um cluster do Autopilot. O GKE processa o provisionamento dos nós com capacidade de GPU ou TPU com base nos manifestos de implantação, se você tiver a cota necessária no seu projeto.
Padrão
- Crie um cluster zonal ou regional.
Crie um pool de nós com os aceleradores adequados. Siga estas etapas com base no tipo de acelerador escolhido:
- GPUs: primeiro, verifique a página "Cotas" no console do Google Cloud para garantir que você tenha capacidade de GPU suficiente. Em seguida, siga as instruções em Criar um pool de nós de GPU.
- TPUs: primeiro, verifique se você tem TPUs suficientes seguindo as instruções em Garantir cota para TPUs e outros recursos do GKE. Em seguida, crie um pool de nós de TPU.
(Opcional, mas recomendado) Ative os recursos de capacidade de observação: na seção de comentários do manifesto gerado, outros comandos são fornecidos para ativar os recursos de capacidade de observação sugeridos. Ao ativar esses recursos, você recebe mais insights para monitorar a performance e o status das cargas de trabalho e da infraestrutura subjacente.
Confira um exemplo de comando para ativar recursos de observabilidade:
gcloud beta container clusters update $CLUSTER_NAME \ --project=$PROJECT_ID \ --location=$LOCATION \ --enable-managed-prometheus \ --logging=SYSTEM,WORKLOAD \ --monitoring=SYSTEM,DEPLOYMENT,HPA,POD,DCGM \ --auto-monitoring-scope=ALL
Para mais informações, consulte Monitorar suas cargas de trabalho de inferência.
(Somente HPA) Implante um adaptador de métricas: um adaptador de métricas, como o adaptador de métricas personalizadas do Stackdriver, é necessário se os recursos do HPA foram gerados nos manifestos de implantação. O adaptador de métricas permite que o HPA acesse métricas do servidor de modelo que usam a API de métricas externas do kube. Para implantar o adaptador, consulte a documentação dele no GitHub.
Testar os endpoints de implantação
Se você implantou o manifesto usando a linha de comando, o serviço implantado será exposto no seguinte endpoint:
http://model-model_server-service:port/
Teste o serviço. Em um terminal separado, configure o encaminhamento de portas executando o seguinte comando:
kubectl port-forward service/model-model_server-service 8000:8000
Para exemplos de como criar e enviar uma solicitação ao seu endpoint, consulte a documentação do vLLM.
Monitore suas cargas de trabalho de inferência
Para monitorar as cargas de trabalho de inferência implantadas, acesse o Metrics Explorer no Google Cloud console.
Ativar o monitoramento automático
O GKE inclui um recurso de monitoramento automático que faz parte dos recursos de observabilidade mais amplos. Esse recurso verifica o cluster em busca de cargas de trabalho executadas em servidores de modelos compatíveis e implanta os recursos PodMonitoring que permitem que essas métricas de carga de trabalho fiquem visíveis no Cloud Monitoring. Para mais informações sobre como ativar e configurar o monitoramento automático, consulte Configurar o monitoramento automático de aplicativos para cargas de trabalho.
Depois de ativar o recurso, o GKE instala painéis pré-criados para monitorar aplicativos em cargas de trabalho compatíveis.
Se você fizer a implantação na página de IA/ML do GKE no console Google Cloud ,
os recursos PodMonitoring e HPA serão criados automaticamente para você usando a
configuração targetNtpot
.
Solução de problemas
- Se você definir uma latência muito baixa, o guia de início rápido da inferência talvez não gere uma recomendação. Para corrigir esse problema, selecione uma meta de latência entre os valores mínimo e máximo observados para os aceleradores selecionados.
- O guia de início rápido de inferência existe independentemente dos componentes do GKE. Portanto, a versão do cluster não é diretamente relevante para usar o serviço. No entanto, recomendamos usar um cluster novo ou atualizado para evitar discrepâncias no desempenho.
- Se você receber um erro
PERMISSION_DENIED
para comandosgkerecommender.googleapis.com
informando que um projeto de cota está faltando, defina-o manualmente. Executegcloud config set billing/quota_project PROJECT_ID
para corrigir isso.
A seguir
- Acesse o portal de orquestração de IA/ML no GKE para conferir nossos guias, tutoriais e casos de uso oficiais para executar cargas de trabalho de IA/ML no GKE.
- Para mais informações sobre a otimização da veiculação de modelos, consulte Práticas recomendadas para otimizar a inferência de modelos de linguagem grandes com GPUs. Ele aborda práticas recomendadas para veiculação de LLMs com GPUs no GKE, como quantização, paralelismo de tensor e gerenciamento de memória.
- Para mais informações sobre práticas recomendadas de escalonamento automático, consulte estes guias:
- Confira exemplos experimentais para aproveitar o GKE e acelerar suas iniciativas de IA/ML no GKE AI Labs.