Neste documento, descrevemos como implantar o GKE Inference Gateway.
Este documento é destinado a especialistas em rede responsáveis por gerenciar a infraestrutura do GKE e administradores de plataforma que gerenciam cargas de trabalho de IA.
Antes de ler esta página, você precisa conhecer:
- Sobre o GKE Inference Gateway.
- Orquestração de IA/ML no GKE.
- Glossário de IA generativa.
- Balanceamento de carga no Google Cloud, especialmente como os balanceadores de carga interagem com o GKE.
- Extensões de serviço do GKE. Para mais informações, consulte a documentação do controlador de gateway do GKE.
- Personalizar o tráfego do gateway do GKE usando as extensões de serviço.
O GKE Inference Gateway aprimora o gateway do Google Kubernetes Engine (GKE) para otimizar a disponibilização de aplicativos e cargas de trabalho de IA generativa no GKE. Ele oferece gerenciamento e escalonamento eficientes de cargas de trabalho de IA, permite objetivos de performance específicos da carga de trabalho, como latência, e melhora a utilização de recursos, a observabilidade e a segurança da IA.
Antes de começar
Antes de começar, verifique se você realizou as tarefas a seguir:
- Ative a API Google Kubernetes Engine. Ativar a API Google Kubernetes Engine
- Para usar a Google Cloud CLI nesta tarefa,
instale e
inicialize a
CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando o comando
gcloud components update. Talvez as versões anteriores da CLI gcloud não sejam compatíveis com a execução dos comandos neste documento.
Ative a API Compute Engine, a API Kubernetes Engine, a API Network Services e a API Model Armor, se necessário.
Acesse Ativar o acesso a APIs e siga as instruções.
Verifique se você tem os seguintes papéis no projeto:
roles/container.admin,roles/iam.serviceAccountAdmin.Verifique se o projeto tem cota suficiente para GPUs H100. Para saber mais, consulte Planejar a cota de GPU e Cotas de alocação.
Crie uma conta do Hugging Face caso ainda não tenha uma. Você vai precisar disso para acessar os recursos do modelo neste tutorial.
Solicite acesso ao modelo Llama 3.1 e gere um token de acesso. O acesso a esse modelo requer um pedido de aprovação no Hugging Face, e a implantação vai falhar se o acesso não tiver sido concedido.
- Assinar o contrato de consentimento de licença: é necessário assinar o contrato de consentimento para usar o modelo Llama 3.1. Acesse a página do modelo no Hugging Face, verifique sua conta e aceite os termos.
- Gerar um token de acesso: para acessar o modelo, você precisa de um token do Hugging Face. Na sua conta do Hugging Face, acesse Seu perfil > Configurações > Tokens de acesso, crie um novo token com pelo menos permissões de leitura e copie-o para a área de transferência.
Configure uma sub-rede somente proxy para sua rede VPC. O controlador de gateway requer uma sub-rede somente proxy ativa na região para provisionar o balanceador de carga de aplicativo.
Requisitos do GKE Gateway Controller
- GKE versão 1.32.3 ou posterior.
- Google Cloud CLI versão 407.0.0 ou mais recente.
- A API Gateway é compatível apenas com clusters nativos de VPC.
- O cluster precisa ter o complemento
HttpLoadBalancingativado. - Se você estiver usando o Istio, será necessário fazer upgrade do Istio para uma das seguintes versões:
- 1.15.2 ou mais recente
- 1.14.5 ou mais recente
- 1.13.9 ou mais recente
- Se você estiver usando a VPC compartilhada, será necessário atribuir o papel
Compute Network Userà conta de serviço do GKE referente ao projeto de serviço no projeto host.
Restrições e limitações
As seguintes restrições e limitações se aplicam:
- O GKE Inference Gateway só é compatível com os recursos GatewayClass
gke-l7-regional-external-managedegke-l7-rilb. - Não há suporte para balanceadores de carga de aplicativo internos entre regiões.
- Um InferencePool pode ter no máximo oito
targetPorts.
Configurar o GKE Inference Gateway
Para configurar o GKE Inference Gateway, considere este exemplo. Uma
equipe executa os modelos vLLM e
Llama3 e faz experimentos ativos com dois
adaptadores distintos ajustados com LoRA: "food-review" e "cad-fabricator".
O fluxo de trabalho de alto nível para configurar o GKE Inference Gateway é o seguinte:
- Preparar o ambiente: configure a infraestrutura e os componentes necessários.
- Criar um pool de inferência: defina um pool de servidores de modelos usando o recurso personalizado InferencePool.
- Especificar objetivos de inferência: especifique
objetivos de inferência usando o recurso personalizado
InferenceObjective. - Criar o gateway: exponha o serviço de inferência usando a API Gateway.
- Crie o
HTTPRoute: defina como o tráfego HTTP é roteado para o serviço de inferência. - Enviar solicitações de inferência: faça solicitações ao modelo implantado.
Criar o gateway
O recurso Gateway é o ponto de entrada para o tráfego externo no cluster do Kubernetes. Ele define os listeners que aceitam conexões de entrada.
O GKE Inference Gateway funciona com as seguintes classes de gateway:
gke-l7-rilb: para balanceadores de carga de aplicativo internos regionais.gke-l7-regional-external-managed: para balanceadores de carga de aplicativo externos regionais.
Para mais informações, consulte a documentação sobre classes de gateway.
Para criar um gateway, siga estas etapas:
Salve o seguinte manifesto de amostra como
gateway.yaml:apiVersion: gateway.networking.k8s.io/v1 kind: Gateway metadata: name: GATEWAY_NAME spec: gatewayClassName: GATEWAY_CLASS listeners: - protocol: HTTP port: 80 name: httpSubstitua:
GATEWAY_NAME: um nome exclusivo para o recurso de gateway. Por exemplo,inference-gateway.GATEWAY_CLASS: a classe de gateway que você quer usar. Por exemplo,gke-l7-regional-external-managed.
Aplique o manifesto ao cluster:
kubectl apply -f gateway.yaml
Observação: para mais informações sobre como configurar o TLS para proteger o gateway com HTTPS, consulte a documentação do GKE sobre configuração do TLS.
Preparar o ambiente
Instale o Helm.
Crie um cluster do GKE:
- Crie um cluster do GKE Autopilot ou Standard com a versão 1.32.3 ou mais recente. Para uma configuração de referência de implantação com um clique, consulte o exemplo do
cluster-toolkit gke-a3-highgpu. - Configure os nós com a família de computação e o acelerador de sua preferência.
- Use o Guia de início rápido de inferência do GKE para manifestos de implantação pré-configurados e testados, com base no acelerador, no modelo e nas necessidades de desempenho selecionados.
- Crie um cluster do GKE Autopilot ou Standard com a versão 1.32.3 ou mais recente. Para uma configuração de referência de implantação com um clique, consulte o exemplo do
Instale as definições de recursos personalizados (CRDs) necessárias no cluster do GKE:
Para as versões
1.34.0-gke.1626000ou mais recentes do GKE, a CRDInferencePoolé incluída por padrão. Portanto, instale apenas o CRDInferenceObjectiveAlfa:kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/raw/v1.5.0/config/crd/bases/inference.networking.x-k8s.io_inferenceobjectives.yamlPara versões do GKE anteriores à
1.34.0-gke.1626000, instale os CRDs InferencePool v1 eInferenceObjectiveAlfa:kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.5.0/manifests.yamlPara mais informações, consulte a matriz de compatibilidade.
Se você estiver usando uma versão do GKE anterior à
v1.32.2-gke.1182001e quiser usar o Model Armor com o GKE Inference Gateway, instale os CRDs de extensão de tráfego e roteamento:kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcptrafficextensions.yaml kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcproutingextensions.yamlConfigure as variáveis de ambiente a seguir:
export GAIE_VERSION=v1.5.0 export GUIDE_NAME="optimized-baseline" export NAMESPACE=llm-d-optimized-baseline export INFRA_PROVIDER=gke # gke | baseInstale as definições de recursos personalizados (CRDs) da extensão de inferência da API Gateway exigidas pelo seletor de endpoints (EPP) do llm-d:
kubectl apply -k \ "https://github.com/kubernetes-sigs/gateway-api-inference-extension/config/crd?ref=${GAIE_VERSION}"Crie o namespace de destino:
kubectl create namespace ${NAMESPACE}
Criar um servidor de modelos e uma implantação de modelo
Nesta seção, mostramos como implantar um servidor de modelos e um modelo. O exemplo usa um
servidor de modelos vLLM com um modelo Llama3. A implantação é rotulada como
app:vllm-llama3-8b-instruct. Essa implantação também usa dois adaptadores LoRA
chamados food-review e cad-fabricator do Hugging Face.
É possível adaptar esse exemplo com seu próprio contêiner do servidor de modelos e modelo, porta de disponibilização do modelo e nome de implantação. Também é possível configurar adaptadores LoRA na implantação ou implantar o modelo de base. As etapas a seguir descrevem como criar os recursos necessários do Kubernetes.
Crie um Secret do Kubernetes para armazenar o token do Hugging Face. Esse token é usado para acessar o modelo de base e os adaptadores LoRA:
kubectl create secret generic hf-token --from-literal=token=HF_TOKENSubstitua
HF_TOKENpelo seu token do Hugging Face.Implante o servidor de modelos vLLM usando a sobreposição do Kustomize específica do GKE do guia de referência otimizada do llm-d. A configuração de
INFRA_PROVIDER=gkeaplica configurações específicas do GKE, incluindo a integração do Cloud Monitoring:kubectl apply -n ${NAMESPACE} \ -k guides/${GUIDE_NAME}/modelserver/gpu/vllm/${INFRA_PROVIDER}/
Observação: o GKE oferece monitoramento automático de aplicativos por padrão. A pilha de monitoramento llm-d não é necessária para o GKE, mas está disponível se você preferir usá-la.
Se o servidor de modelos exigir várias portas, verifique se a especificação do contêiner expõe cada uma delas. O exemplo a seguir define uma implantação em que o contêiner expõe três portas:
Exemplo de implantação de várias portas
apiVersion: apps/v1
kind: Deployment
metadata:
name: multiport-model-server
spec:
replicas: 3
selector:
matchLabels:
app: multiport-model-server
template:
metadata:
labels:
app: multiport-model-server
spec:
containers:
- name: model-server
image: your-model-server-image
ports:
- containerPort: 8080
- containerPort: 8081
- containerPort: 9000
Criar um pool de inferência
O recurso personalizado InferencePool do Kubernetes define um grupo de pods com um
modelo de linguagem grande (LLM) de base comum e uma configuração de computação. O campo selector
especifica quais pods pertencem a esse pool. Os rótulos nesse seletor precisam
corresponder exatamente aos rótulos aplicados aos pods do servidor de modelos. O campo targetPorts
define as portas que o servidor de modelos usa nos pods. É possível
especificar até oito portas. O campo extensionRef faz referência a um serviço de extensão que fornece mais recursos para o pool de inferência. O
InferencePool permite que o GKE Inference Gateway encaminhe o tráfego para os pods do servidor
de modelos.
O manifesto InferencePool a seguir especifica várias targetPorts que correspondem às portas expostas pela implantação do servidor de modelos:
Exemplo de InferencePool de várias portas
apiVersion: inference.networking.k8s.io/v1
kind: InferencePool
metadata:
name: my-multiport-pool
namespace: default
spec:
selector:
matchLabels:
app: multiport-model-server
targetPorts:
- number: 8080
- number: 8081
- number: 9000
Antes de criar o InferencePool, verifique se os pods do servidor de modelos que o InferencePool seleciona já estão em execução.
Clone as receitas e recomendações para o InferencePool do repositório do GitHub llm-d. Esta etapa é obrigatória:
git clone https://github.com/llm-d/llm-d -b v0.7.0 && cd llm-d
Para criar um InferencePool e um seletor de endpoints usando o Helm, siga estas etapas:
helm install ${GUIDE_NAME} \
-f guides/recipes/scheduler/base.values.yaml \
-f guides/${GUIDE_NAME}/scheduler/${GUIDE_NAME}.values.yaml \
--set provider.name=gke \
--set inferenceExtension.monitoring.gke.enabled=true \
-n ${NAMESPACE} \
--version ${GAIE_VERSION} \
oci://LLM_D_REGISTRY_PATH
Substitua:
GAIE_VERSION: a versão do gráfico Helm. Por exemplo,v1.5.0.LLM_D_REGISTRY_PATH: o caminho do registro OCI para o gráfico Helm. Por exemplo,registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.
No arquivo guides/recipes/scheduler/base.values.yaml, mude o campo a seguir para corresponder ao rótulo do pod de implantação do modelo:
inferencePool.modelServers.matchLabels: a chave e o valor do rótulo usado para selecionar os pods do servidor de modelos.Observação: a chave e o valor estão alinhados com o exemplo do guia
optimized-baseline, então vamos substituí-los para corresponder aos rótulos do pod de implantação.
Para monitoramento, a extração de métricas do Google Cloud Managed Service para Prometheus é ativada por padrão.
- Para desativar esse recurso, adicione a flag
--set inferenceExtension.monitoring.prometheus.enabled=falseao comando. - Se você usar o monitoramento padrão em um cluster do Autopilot do GKE, também será necessário adicionar a flag
--set provider.gke.autopilot=true.
A instalação do Helm instala automaticamente a política de tempo limite necessária, o seletor de endpoints e os pods necessários para observabilidade.
Isso cria um objeto InferencePool: vllm-llama3-8b-instruct que faz referência
aos serviços de endpoint do modelo nos pods. Ele também cria uma implantação do
seletor de endpoints chamada app:vllm-llama3-8b-instruct-epp para esse
InferencePool criado.
Implantar o seletor de endpoints com alta disponibilidade
A implantação do seletor de endpoints (EPP, na sigla em inglês) com back-ends preferenciais permite uma topologia de roteamento ativo-passivo com o Cloud Load Balancing.
Usar o seletor de endpoints com back-ends preferenciais ajuda você a:
- Consistência de estado: o Cloud Load Balancing direciona 100% do tráfego de estado estável
ext_procpara a réplica principal do seletor de endpoints (epp-0), preservando o estado do cache de chave-valor (KV) e o contexto de programação de solicitações. - Failover sem inatividade: se o pod principal do seletor de endpoints falhar ou
passar por manutenção, o Cloud Load Balancing vai detectar a falha usando
verificações de integridade ativas do gRPC e vai rotear imediatamente o tráfego para a réplica
em espera (
epp-1). - Resiliência de fail-open: quando pareadas com
failureMode: FailOpen, as falhas de roteamento temporárias ignoram o seletor de endpoints e permitem que as solicitações sejam encaminhadas diretamente aos servidores de modelos sem descartar as solicitações do usuário.
Quando você ativa os back-ends preferenciais, o GKE modifica a arquitetura e o roteamento das seguintes maneiras:
- Arquitetura StatefulSet do seletor de endpoints: o seletor de endpoints é implantado
como um StatefulSet em vez de uma implantação. Os ordinais de pod designam os papéis
da réplica: o ordinal
epp-0serve como a réplica principal fixada ao nível de back-endPREFERRED, e o ordinalepp-1serve como a réplica em espera fixada ao nívelDEFAULT. - O estado de roteamento permanece centralizado: o tráfego de estado estável de
ext_procé roteado exclusivamente para a réplica principal do seletor de endpoints (epp-0) para manter o rastreamento do cache de chave-valor (KV) e o estado de programação de solicitações centralizados. Seepp-0ficar não íntegro, o Cloud Load Balancing vai transferir o tráfego para a réplica em espera (epp-1). - Arquitetura de serviço duplo: o gráfico Helm cria um serviço principal (
Service/${GUIDE_NAME}-epp) e um serviço de backup em espera (Service/${GUIDE_NAME}-epp-backup). O recursoInferencePooltem como destino declarativo o serviço de backup em espera. Ancorar a propriedade declarativa do Gateway ao serviço em espera garante que os loops de reconciliação do controlador do Gateway do GKE não desvinculem os grupos de endpoints de rede (NEGs) principais que você anexar ao serviço de back-end.
Para criar um InferencePool e um seletor de endpoints com alta disponibilidade usando o Helm, siga estas etapas:
Implante o InferencePool e o seletor de endpoints com back-ends preferidos usando o Helm:
helm install ${GUIDE_NAME} \ -f guides/recipes/scheduler/base.values.yaml \ -f guides/${GUIDE_NAME}/scheduler/${GUIDE_NAME}.values.yaml \ --set provider.name=gke \ --set inferenceExtension.monitoring.gke.enabled=true \ --set provider.gke.preferredBackends.enabled=true \ --set provider.gke.preferredBackends.preferredReplicas=1 \ --set provider.gke.preferredBackends.defaultReplicas=1 \ -n ${NAMESPACE} \ --version ${GAIE_VERSION} \ oci://LLM_D_REGISTRY_PATHSubstitua:
GAIE_VERSION: a versão da extensão de inferência da API Gateway (GAIE) do gráfico Helm. Por exemplo,v1.5.0. Os back-ends preferenciais exigem o gráfico Helm versãov1.5.0ou posterior.LLM_D_REGISTRY_PATH: o caminho do registro OCI para o gráfico Helm. Por exemplo,registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.
Para uma lista completa de parâmetros, consulte
values.yaml.Anexe o NEG principal ao
BackendService:export PROJECT_ID=PROJECT_ID export REGION=REGION export BACKEND_SERVICE=$(gcloud compute backend-services list --project=${PROJECT_ID} --format="value(name)" | grep "${GUIDE_NAME}-epp") export PRIMARY_NEG=$(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.network_endpoint_groups["9002"]') for ZONE in $(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.zones[]'); do gcloud compute backend-services add-backend ${BACKEND_SERVICE} \ --network-endpoint-group=${PRIMARY_NEG} \ --network-endpoint-group-zone=${ZONE} \ --region=${REGION} \ --project=${PROJECT_ID} \ --balancing-mode=RATE \ --max-rate-per-endpoint=100 \ --preference=PREFERRED sleep 15 doneSubstitua:
PROJECT_ID: o ID do projeto Google Cloud .REGION: a região do Google Cloud do cluster e do serviço de back-end.
Depois que os NEGs zonais forem anexados ao Google Cloud BackendService, o escalonamento
das contagens de réplicas (preferredReplicas ou defaultReplicas) ou a reinicialização de pods
não exigirá a execução de comandos gcloud novamente. O controlador de NEG do GKE sincroniza automaticamente os endereços IP de pods individuais nos NEGs zonais registrados.
Se você excluir e recriar o recurso pai Gateway ou InferencePool,
o controlador de gateway do GKE vai recriar o BackendService
Google Cloudcom um novo identificador de nuvem. Nesse caso, execute o
fluxo de trabalho de anexação anterior para anexar NEGs zonais principais ao BackendService
recém-criado.
Criar o HTTPRoute
O recurso HTTPRoute define como o gateway do GKE encaminha
as solicitações HTTP recebidas para serviços de back-end, como o InferencePool. O recurso HTTPRoute especifica regras de correspondência (por exemplo, cabeçalhos ou caminhos) e o back-end para onde o tráfego precisa ser encaminhado.
Para criar um
HTTPRoute, salve o seguinte manifesto de amostra comohttproute.yaml:apiVersion: gateway.networking.k8s.io/v1 kind: HTTPRoute metadata: name: HTTPROUTE_NAME spec: parentRefs: - name: GATEWAY_NAME rules: - matches: - path: type: PathPrefix value: PATH_PREFIX backendRefs: - name: INFERENCE_POOL_NAME group: "inference.networking.k8s.io" kind: InferencePoolSubstitua:
HTTPROUTE_NAME: um nome exclusivo para o recursoHTTPRoute. Por exemplo,my-route.GATEWAY_NAME: o nome do recursoGatewayque você criou. Por exemplo,inference-gateway.PATH_PREFIX: o prefixo de caminho usado para corresponder às solicitações recebidas. Por exemplo,/para corresponder a todos.INFERENCE_POOL_NAME: o nome do recurso InferencePool para o qual você quer rotear o tráfego. Por exemplo,vllm-llama3-8b-instruct.
Aplique o manifesto ao cluster:
kubectl apply -f httproute.yaml
Especificar objetivos de inferência
O recurso personalizado InferenceObjective permite especificar a prioridade das solicitações.
O campo metadata.name do recurso InferenceObjective especifica o
nome do objetivo de inferência, o campo Priority especifica a importância
da exibição e o campo poolRef especifica o InferencePool em que o
modelo é exibido.
apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceObjective
metadata:
name: NAME
spec:
priority: VALUE
poolRef:
name: INFERENCE_POOL_NAME
group: "inference.networking.k8s.io"
Substitua:
NAME: o nome do objetivo de inferência. Por exemplo,food-review.VALUE: a prioridade do objetivo de inferência. Esse é um número inteiro em que um valor mais alto indica uma solicitação mais crítica. Por exemplo, 10.INFERENCE_POOL_NAME: o nome do InferencePool que você criou na etapa anterior. Por exemplo,vllm-llama3-8b-instruct.
Para criar um InferenceObjective, siga estas etapas:
Salve o seguinte manifesto
inference-objectives.yamlcomo : Esse manifesto cria dois recursosInferenceObjective. A primeira configura o objetivo de inferênciafood-reviewno InferencePoolvllm-llama3-8b-instructcom prioridade 10. A segunda configura o objetivo de inferênciallama3-base-modelpara ser veiculado com uma prioridade maior, de 20.apiVersion: inference.networking.x-k8s.io/v1alpha2 kind: InferenceObjective metadata: name: food-review spec: priority: 10 poolRef: name: vllm-llama3-8b-instruct group: "inference.networking.k8s.io" --- apiVersion: inference.networking.x-k8s.io/v1alpha2 kind: InferenceObjective metadata: name: llama3-base-model spec: priority: 20 # Higher priority poolRef: name: vllm-llama3-8b-instructAplique o manifesto de amostra ao cluster:
kubectl apply -f inference-objectives.yaml
Verificar a implantação
Para verificar se todos os componentes estão em execução, execute os seguintes comandos:
kubectl get inferencepool
kubectl get inferenceobjective
kubectl get pods -l app=vllm-llama3-8b-instruct-epp
Enviar solicitação de inferência
Depois de configurar o GKE Inference Gateway, envie solicitações de inferência para o modelo implantado. Isso permite gerar texto com base no comando de entrada e nos parâmetros especificados.
Para enviar solicitações de inferência, siga estas etapas:
Configure as variáveis de ambiente a seguir:
export GATEWAY_NAME=GATEWAY_NAME export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTPSubstitua:
GATEWAY_NAME: o nome do recurso de gateway.PORT_NUMBER: o número da porta que você configurou no gateway.
Para acessar o endpoint do gateway, execute o seguinte comando:
echo "Waiting for the Gateway IP address..." IP="" while [ -z "$IP" ]; do IP=$(kubectl get gateway/${GATEWAY_NAME} -o jsonpath='{.status.addresses[0].value}' 2>/dev/null) if [ -z "$IP" ]; then echo "Gateway IP not found, waiting 5 seconds..." sleep 5 fi done echo "Gateway IP address is: $IP" PORT=${PORT_NUMBER}Para enviar uma solicitação ao endpoint
/v1/completionsusandocurl, execute o seguinte comando:curl -i -X POST ${IP}:${PORT}/v1/completions \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' \ -d '{ "model": "MODEL_NAME", "prompt": "PROMPT_TEXT", "max_tokens": MAX_TOKENS, "temperature": "TEMPERATURE" }'Substitua:
MODEL_NAME: o nome do modelo ou adaptador LoRA a ser usado.PROMPT_TEXT: o comando de entrada para o modelo.MAX_TOKENS: o número máximo de tokens a serem gerados na resposta.TEMPERATURE: controla a aleatoriedade da saída. Use o valor0para uma saída determinista ou um número maior para uma saída mais criativa.
O exemplo a seguir mostra como enviar uma solicitação de amostra para o GKE Inference Gateway:
curl -i -X POST ${IP}:${PORT}/v1/completions -H 'Content-Type: application/json' -H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' -d '{
"model": "food-review-1",
"prompt": "What is the best pizza in the world?",
"max_tokens": 2048,
"temperature": 0
}'
Esteja ciente dos seguintes comportamentos:
- Corpo da solicitação: o corpo da solicitação pode incluir outros parâmetros, como
stopetop_p. Consulte a especificação da API OpenAI para ver uma lista completa de opções. - Tratamento de erros: implemente o tratamento de erros adequado no código do cliente para
lidar com possíveis erros na resposta. Por exemplo, verifique o código de status HTTP na resposta
curl. Um código de status diferente de200geralmente indica um erro. - Autenticação e autorização: para implantações de produção, proteja o endpoint de API com mecanismos de autenticação e autorização. Inclua os
cabeçalhos apropriados (por exemplo,
Authorization) nas solicitações.
Matriz de compatibilidade
A tabela descreve a matriz de compatibilidade e suporte para as definições de recursos personalizados (CRDs) da extensão de inferência da API Gateway. Ele detalha quais versões do CustomResourceDefinition são compatíveis com o GKE em comparação com o projeto de código aberto (OSS) da extensão de inferência da API Gateway, incluindo requisitos de versão específicos e notas de instalação.
| Nome da CustomResourceDefinition | Versão da API CustomResourceDefinition | Suporte gerenciado do GKE | Suporte a OSS (extensão de inferência da API Gateway) |
|---|---|---|---|
| InferencePool V1 | inference.networking.k8s.io/v1 | Compatível com o GKE 1.32.3 ou mais recente e CustomResourceDefinition instalado por padrão no GKE 1.34.0-gke.1626000 ou mais recente | Compatível a partir da extensão de inferência da API Gateway v1.0.0 |
| InferencePool Alfa (recomendamos que os usuários comecem com o InferencePool v1, já que a versão Alfa foi descontinuada) | inference.networking.x-k8s.io/v1alpha2 | Compatível com o GKE 1.32.3 ou mais recente. No entanto, o CustomResourceDefinition não é instalado por padrão no GKE. Os usuários precisam instalar manualmente o CustomResourceDefinition da extensão de inferência da API Gateway. | Compatível a partir da extensão de inferência da API Gateway v0.2.0 |
| InferenceObjective Alfa | inference.networking.x-k8s.io/v1alpha2 | O GKE não gerencia o InferenceObjective | Compatível a partir da extensão de inferência da API Gateway v1.0.0 |
| InferenceModel Alfa (recomendamos que os usuários comecem com InferenceObjective, já que o InferenceModel foi descontinuado) | inference.networking.x-k8s.io/v1alpha2 | O GKE não gerencia o InferenceModel | Compatível a partir da extensão de inferência da API Gateway v0.2.0. |
Proteger o back-end de inferência com TLS de back-end
O TLS de back-end permite que o balanceador de carga do gateway do GKE verifique a identidade dos back-ends de inferência aos quais ele se conecta. O TLS de back-end adiciona uma etapa de verificação explícita durante o handshake de TLS entre o gateway e o pod de back-end. Essa verificação ajuda a garantir que o gateway se comunique apenas com servidores de modelos confiáveis e extensões do Endpoint Picker.
Para configurar o TLS de back-end para suas cargas de trabalho de inferência, anexe uma
BackendTLSPolicy a um recurso InferencePool ou GCPInferencePoolImport. Para
configurar o gateway para que ele possa verificar o certificado do seletor de endpoints, anexe
uma BackendTLSPolicy ao serviço do seletor de endpoints referenciado pelo
campo spec.endpointPickerRef do InferencePool.
Para mais informações, consulte Configurar TLS de back-end.
A seguir
- Personalizar a configuração do GKE Inference Gateway
- Configurar o roteamento baseado no corpo
- Disponibilizar um LLM com o GKE Inference Gateway
- Usar o roteamento baseado em latência prevista com o GKE Inference Gateway