En este documento, se describe cómo implementar GKE Inference Gateway.
Este documento está dirigido a los especialistas en redes responsables de administrar la infraestructura de GKE y a los administradores de plataformas que administran las cargas de trabajo de IA.
Antes de leer esta página, asegúrate de estar familiarizado con los siguientes temas:
- Acerca de GKE Inference Gateway.
- Organización de IA y AA en GKE.
- Glosario de IA generativa.
- Balanceo de cargas en Google Cloud, en especial, cómo interactúan los balanceadores de cargas con GKE.
- Extensiones de servicio de GKE. Para obtener más información, consulta la documentación del controlador de Gateway de GKE.
- Personaliza el tráfico de GKE Gateway con extensiones de servicio.
GKE Inference Gateway mejora la puerta de enlace de Google Kubernetes Engine (GKE) para optimizar la entrega de aplicaciones y cargas de trabajo de IA generativa en GKE. Proporciona una administración y un escalamiento eficientes de las cargas de trabajo de IA, permite objetivos de rendimiento específicos de la carga de trabajo, como la latencia, y mejora el uso de recursos, la observabilidad y la seguridad de la IA.
Antes de comenzar
Antes de comenzar, asegúrate de haber realizado las siguientes tareas:
- Habilita la API de Google Kubernetes Engine. Habilitar la API de Google Kubernetes Engine
- Para usar Google Cloud CLI en esta tarea,
instala y, luego,
inicializa la
gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando
gcloud components updatepara obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos de este documento.
Habilita la API de Compute Engine, la API de Kubernetes Engine, la API de Network Services y la API de Model Armor si es necesario.
Ve a Habilita el acceso a las APIs y sigue las instrucciones.
Asegúrate de tener los siguientes roles en el proyecto:
roles/container.admin,roles/iam.serviceAccountAdmin.Asegúrate de que tu proyecto tenga la cuota suficiente para las GPU H100. Para obtener más información, consulta Planifica la cuota de GPU y Cuotas de asignación.
Crea una cuenta de Hugging Face, si todavía no la tienes. Necesitarás esto para acceder a los recursos del modelo de este instructivo.
Solicitar acceso al modelo de Llama 3.1 y generar un token de acceso El acceso a este modelo requiere una solicitud aprobada en Hugging Face, y la implementación fallará si no se otorgó el acceso.
- Firma el acuerdo de consentimiento de licencia: Debes firmar el acuerdo de consentimiento para usar el modelo de Llama 3.1. Ve a la página del modelo en Hugging Face, verifica tu cuenta y acepta las condiciones.
- Genera un token de acceso: Para acceder al modelo, necesitas un token de Hugging Face. En tu cuenta de Hugging Face, ve a Tu perfil > Configuración > Tokens de acceso, crea un token nuevo con, al menos, permisos de lectura y cópialo en el portapapeles.
Configura una subred de solo proxy para tu red de VPC. El controlador de Gateway requiere una subred de solo proxy activa en la región para aprovisionar el balanceador de cargas de aplicaciones.
Requisitos del controlador de la puerta de enlace de GKE
- GKE versión 1.32.3 o posterior.
- Versión 407.0.0 o posterior de Google Cloud CLI.
- La API de Gateway solo es compatible con clústeres nativos de la VPC.
- El clúster debe tener el complemento
HttpLoadBalancinghabilitado. - Si usas Istio, debes actualizarlo a una de las siguientes versiones:
- 1.15.2 o una versión posterior
- 1.14.5 o una versión posterior
- 1.13.9 o una versión posterior
- Si usas una VPC compartida, en el proyecto host, debes
asignar el rol
Compute Network Usera la cuenta de servicio de GKE para el proyecto de servicio.
Restricciones y limitaciones
Se aplican las siguientes restricciones y limitaciones:
- GKE Inference Gateway solo es compatible con los recursos de GatewayClass
gke-l7-regional-external-managedygke-l7-rilb. - No se admiten los balanceadores de cargas de aplicaciones internos entre regiones.
- Un InferencePool puede tener un máximo de ocho
targetPorts.
Configura GKE Inference Gateway
Para configurar GKE Inference Gateway, considera este ejemplo. Un
equipo ejecuta modelos vLLM y
Llama3, y experimenta de forma activa con dos
adaptadores ajustados de LoRA distintos: "food-review" y "cad-fabricator".
El flujo de trabajo de alto nivel para configurar GKE Inference Gateway es el siguiente:
- Prepara el entorno: configura la infraestructura y los componentes necesarios.
- Crea un grupo de inferencia: Define un grupo de servidores de modelos con el recurso personalizado InferencePool.
- Especifica objetivos de inferencia: Especifica
objetivos de inferencia con el recurso personalizado
InferenceObjective - Crea la puerta de enlace: Expón el servicio de inferencia con la API de Gateway.
- Crea el
HTTPRoute: Define cómo se enruta el tráfico HTTP al servicio de inferencia. - Envía solicitudes de inferencia: Realiza solicitudes al modelo implementado.
Crea la Gateway
El recurso Gateway es el punto de entrada para el tráfico externo en tu clúster de Kubernetes. Define los objetos de escucha que aceptan las conexiones entrantes.
GKE Inference Gateway funciona con las siguientes clases de Gateway:
gke-l7-rilb: para balanceadores de cargas de aplicaciones internos regionales.gke-l7-regional-external-managed: para balanceadores de cargas de aplicaciones externos regionales.
Para obtener más información, consulta la documentación de GatewayClasses.
Para crear una puerta de enlace, sigue estos pasos:
Guarda el siguiente manifiesto de muestra 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: httpReemplaza lo siguiente:
GATEWAY_NAME: Es un nombre único para tu recurso de puerta de enlace. Por ejemplo,inference-gatewayGATEWAY_CLASS: Es la clase de puerta de enlace que deseas usar. Por ejemplo,gke-l7-regional-external-managed
Aplica el manifiesto al clúster:
kubectl apply -f gateway.yaml
Nota: Para obtener más información sobre cómo configurar TLS para proteger tu puerta de enlace con HTTPS, consulta la documentación de GKE sobre la configuración de TLS.
Prepara el entorno
Instala Helm.
Crea un clúster de GKE:
- Crea un clúster de GKE Autopilot o Standard
con la versión 1.32.3 o posterior. Para ver una configuración de referencia
de implementación con un clic, consulta el ejemplo de
cluster-toolkit gke-a3-highgpu. - Configura los nodos con la familia de procesamiento y el acelerador que prefieras.
- Usa la guía de inicio rápido de inferencia de GKE para obtener manifiestos de implementación preconfigurados y probados, según el acelerador, el modelo y las necesidades de rendimiento que selecciones.
- Crea un clúster de GKE Autopilot o Standard
con la versión 1.32.3 o posterior. Para ver una configuración de referencia
de implementación con un clic, consulta el ejemplo de
Instala las definiciones de recursos personalizados (CRD) necesarias en tu clúster de GKE:
Para las versiones
1.34.0-gke.1626000o posteriores de GKE, la CRDInferencePoolse incluye de forma predeterminada. Por lo tanto, instala solo la 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.yamlEn las versiones de GKE anteriores a la
1.34.0-gke.1626000, instala las CRD de InferencePool v1 yInferenceObjectivealfa:kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.5.0/manifests.yamlPara obtener más información, consulta la matriz de compatibilidad.
Si usas una versión de GKE anterior a la
v1.32.2-gke.1182001y quieres usar Model Armor con GKE Inference Gateway, debes instalar las CRD de extensión de tráfico y enrutamiento: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.yamlConfigura las siguientes variables de entorno:
export GAIE_VERSION=v1.5.0 export GUIDE_NAME="optimized-baseline" export NAMESPACE=llm-d-optimized-baseline export INFRA_PROVIDER=gke # gke | baseInstala las definiciones de recursos personalizados (CRD) de la extensión de inferencia de la API de Gateway que requiere el selector de extremos (EPP) de llm-d:
kubectl apply -k \ "https://github.com/kubernetes-sigs/gateway-api-inference-extension/config/crd?ref=${GAIE_VERSION}"Crea el espacio de nombres de destino:
kubectl create namespace ${NAMESPACE}
Crea un servidor de modelos y una implementación de modelos
En esta sección, se muestra cómo implementar un servidor de modelos y un modelo. En el ejemplo, se usa un
servidor de modelos de vLLM con un modelo de Llama3. La implementación se etiqueta como
app:vllm-llama3-8b-instruct. Esta implementación también usa dos adaptadores de LoRA
llamados food-review y cad-fabricator de Hugging Face.
Puedes adaptar este ejemplo con tu propio contenedor de servidor de modelos y modelo, puerto de entrega de modelos y nombre de implementación. También puedes configurar adaptadores de LoRA en la implementación o implementar el modelo base. En los siguientes pasos, se describe cómo crear los recursos de Kubernetes necesarios.
Crea un Secret de Kubernetes para almacenar tu token de Hugging Face. Este token se usa para acceder al modelo base y a los adaptadores de LoRA:
kubectl create secret generic hf-token --from-literal=token=HF_TOKENReemplaza
HF_TOKENpor tu token de Hugging Face.Implementa el servidor de modelos de vLLM con la superposición de Kustomize específica de GKE de la guía de referencia optimizada de llm-d. La configuración de
INFRA_PROVIDER=gkeaplica parámetros específicos de GKE, incluida la integración de Cloud Monitoring:kubectl apply -n ${NAMESPACE} \ -k guides/${GUIDE_NAME}/modelserver/gpu/vllm/${INFRA_PROVIDER}/
Nota: GKE proporciona supervisión automática de aplicaciones de forma predeterminada. La pila de supervisión de llm-d no es obligatoria para GKE, pero está disponible si prefieres usarla.
Si tu servidor de modelos requiere varios puertos, asegúrate de que la especificación del contenedor exponga cada puerto. En el siguiente ejemplo, se define un Deployment en el que el contenedor expone tres puertos:
Ejemplo de implementación de varios puertos
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
Crea un grupo de inferencia
El recurso personalizado de Kubernetes InferencePool define un grupo de Pods con un
modelo de lenguaje grande (LLM) base y una configuración de procesamiento comunes. El campo selector
especifica qué Pods pertenecen a este grupo. Las etiquetas de este selector deben
coincidir exactamente con las etiquetas aplicadas a los Pods del servidor de modelos. El campo targetPorts
define los puertos que usa el servidor de modelos dentro de los Pods. Puedes
especificar hasta ocho puertos. El campo extensionRef hace referencia a un servicio de extensión
que proporciona capacidad adicional para el grupo de inferencia. InferencePool
permite que GKE Inference Gateway enrute el tráfico a los Pods del servidor
de modelos.
En el siguiente manifiesto de InferencePool, se especifican varios targetPorts que corresponden a los puertos expuestos por el Deployment del servidor de modelos:
Ejemplo de InferencePool de varios puertos
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 crear el InferencePool, asegúrate de que los Pods del servidor de modelos que selecciona InferencePool ya se estén ejecutando.
Clona las recetas y recomendaciones para InferencePool desde el repositorio de GitHub de llm-d. Este paso es obligatorio:
git clone https://github.com/llm-d/llm-d -b v0.7.0 && cd llm-d
Para crear un InferencePool y un selector de extremos con Helm, sigue estos pasos:
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
Reemplaza lo siguiente:
GAIE_VERSION: Es la versión del gráfico de Helm. Por ejemplo,v1.5.0.LLM_D_REGISTRY_PATH: Es la ruta de acceso del registro de OCI para el gráfico de Helm. Por ejemplo,registry.k8s.io/gateway-api-inference-extension/charts/inferencepool
En el archivo guides/recipes/scheduler/base.values.yaml, cambia el siguiente campo para que coincida con la etiqueta del Pod de implementación de tu modelo:
inferencePool.modelServers.matchLabels: la clave y el valor de la etiqueta que se usa para seleccionar los Pods del servidor de modelos.Nota: La clave y el valor se alinean con el ejemplo de la guía de
optimized-baseline, por lo que los reemplazaremos para que coincidan con las etiquetas de tu Pod de Deployment.
Para la supervisión, la recopilación de métricas de Google Cloud Managed Service para Prometheus está habilitada de forma predeterminada.
- Para inhabilitar esta función, agrega la marca
--set inferenceExtension.monitoring.prometheus.enabled=falseal comando. - Si usas la supervisión predeterminada en un clúster de GKE Autopilot, también debes agregar la marca
--set provider.gke.autopilot=true.
La instalación de Helm instala automáticamente la política de tiempo de espera necesaria, el selector de extremos y los Pods necesarios para la observabilidad.
Esto crea un objeto InferencePool: vllm-llama3-8b-instruct que hace referencia
a los servicios de extremos del modelo dentro de los Pods. También crea una implementación del
selector de extremos llamado app:vllm-llama3-8b-instruct-epp para este InferencePool
creado.
Implementa el selector de extremos con alta disponibilidad
La implementación del selector de extremos (EPP) con backends preferidos habilita una topología de enrutamiento activa-pasiva respaldada por Cloud Load Balancing.
Usar el selector de extremos con backends preferidos te ayuda a lograr lo siguiente:
- Coherencia de estado: Cloud Load Balancing dirige el 100% del tráfico de estado estable
de
ext_proca la réplica principal del selector de extremos (epp-0), lo que conserva el estado de la caché de pares clave-valor (KV) y el contexto de programación de solicitudes. - Conmutación por error sin tiempo de inactividad: Si el Pod de Endpoint Picker principal falla o
se somete a mantenimiento, Cloud Load Balancing detecta la falla con
verificaciones de estado de gRPC activas y enruta el tráfico de inmediato a la réplica
en espera (
epp-1). - Resiliencia de continuidad ante errores: Cuando se vincula con
failureMode: FailOpen, las fallas de enrutamiento transitorias omiten el selector de extremos y permiten que las solicitudes se reenvíen directamente a los servidores de modelos sin descartar las solicitudes de los usuarios.
Cuando habilitas los backends preferidos, GKE modifica la arquitectura y el enrutamiento de las siguientes maneras:
- Arquitectura de StatefulSet del selector de extremos: El selector de extremos se implementa
como un StatefulSet en lugar de un Deployment. Los ordinales de Pod designan los roles de réplica: el ordinal
epp-0funciona como la réplica principal fijada al nivel de backendPREFERRED, y el ordinalepp-1funciona como la réplica en espera fijada al nivelDEFAULT. - El estado de enrutamiento permanece centralizado: El tráfico de estado estable de
ext_procse enruta exclusivamente a la réplica principal del selector de extremos (epp-0) para mantener centralizados el seguimiento de la caché de pares clave-valor (KV) y el estado de programación de solicitudes. Siepp-0se encuentra en mal estado, Cloud Load Balancing cambia el tráfico a la réplica en espera (epp-1). - Arquitectura de servicio doble: El gráfico de Helm crea un Service principal
(
Service/${GUIDE_NAME}-epp) y un Service de copia de seguridad en espera (Service/${GUIDE_NAME}-epp-backup). El recursoInferencePoolse orienta de forma declarativa al Service de copia de seguridad en espera. Anclar la propiedad declarativa de la puerta de enlace al Service en espera garantiza que los bucles de conciliación del controlador de la puerta de enlace de GKE no desconecten los grupos de extremos de red (NEG) principales que conectas al servicio de backend.
Para crear un InferencePool y un selector de extremos con alta disponibilidad con Helm, sigue estos pasos:
Implementa InferencePool y el selector de extremos con los backends preferidos con 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_PATHReemplaza lo siguiente:
GAIE_VERSION: Es la versión de la extensión de inferencia de la API de Gateway (GAIE) del gráfico de Helm. Por ejemplo,v1.5.0. Los backends preferidos requieren la versiónv1.5.0o una posterior del gráfico de Helm.LLM_D_REGISTRY_PATH: Es la ruta de acceso del registro de OCI para el gráfico de Helm. Por ejemplo,registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.
Para obtener una lista completa de los parámetros, consulta
values.yaml.Conecta el NEG principal al
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 doneReemplaza lo siguiente:
PROJECT_ID: Es el ID del proyecto de Google Cloud .REGION: la región de Google Cloud tu clúster y servicio de backend.
Después de que los NEG zonales se conectan al Google Cloud BackendService, no es necesario volver a ejecutar los comandos gcloud para escalar los recuentos de réplicas (preferredReplicas o defaultReplicas) ni reiniciar los Pods. El controlador de NEG de GKE
sincroniza automáticamente las direcciones IP de Pods individuales en los
NEG zonales registrados.
Si borras y vuelves a crear el recurso Gateway o InferencePool superior,
el controlador de GKE Gateway vuelve a crear el BackendService
Google Cloudsubyacente con un identificador de nube nuevo. En ese caso, ejecuta el
flujo de trabajo de conexión anterior para conectar los NEG zonales principales al BackendService
recién creado.
Crea el HTTPRoute
El recurso HTTPRoute define cómo la puerta de enlace de GKE enruta
las solicitudes HTTP entrantes a los servicios de backend, como tu InferencePool. El recurso HTTPRoute especifica las reglas de coincidencia (por ejemplo, encabezados o rutas de acceso) y el backend al que se debe reenviar el tráfico.
Para crear un
HTTPRoute, guarda el siguiente manifiesto de ejemplo 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: InferencePoolReemplaza lo siguiente:
HTTPROUTE_NAME: Es un nombre único para tu recursoHTTPRoute. Por ejemplo,my-route.GATEWAY_NAME: Es el nombre del recursoGatewayque creaste. Por ejemplo,inference-gateway.PATH_PREFIX: Es el prefijo de ruta de acceso que usas para que coincida con las solicitudes entrantes. Por ejemplo,/para que coincida con todo.INFERENCE_POOL_NAME: Es el nombre del recurso InferencePool al que deseas enrutar el tráfico. Por ejemplo,vllm-llama3-8b-instruct
Aplica el manifiesto al clúster:
kubectl apply -f httproute.yaml
Especifica los objetivos de inferencia
El recurso personalizado InferenceObjective te permite especificar la prioridad de las solicitudes.
El campo metadata.name del recurso InferenceObjective especifica el
nombre del objetivo de inferencia, el campo Priority especifica su importancia
de entrega y el campo poolRef especifica el InferencePool en el que se
entrega el modelo.
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"
Reemplaza lo siguiente:
NAME: Es el nombre de tu objetivo de inferencia. Por ejemplo,food-reviewVALUE: Es la prioridad del objetivo de inferencia. Este es un número entero en el que un valor más alto indica una solicitud más crítica. Por ejemplo, 10.INFERENCE_POOL_NAME: Es el nombre del InferencePool que creaste en el paso anterior. Por ejemplo,vllm-llama3-8b-instruct.
Para crear un InferenceObjective, sigue estos pasos:
Guarda el siguiente manifiesto como
inference-objectives.yaml. Este manifiesto crea dos recursosInferenceObjective. La primera configura el InferenceObjectivefood-reviewen el InferencePoolvllm-llama3-8b-instructcon una prioridad de 10. La segunda configura el objetivo de inferencia dellama3-base-modelpara que se publique con una prioridad más alta, 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-instructAplica el manifiesto de muestra a tu clúster:
kubectl apply -f inference-objectives.yaml
Verifica la implementación
Para verificar que todos los componentes estén en ejecución, ejecuta los siguientes comandos:
kubectl get inferencepool
kubectl get inferenceobjective
kubectl get pods -l app=vllm-llama3-8b-instruct-epp
Envía una solicitud de inferencia
Después de configurar GKE Inference Gateway, puedes enviar solicitudes de inferencia al modelo implementado. Esto te permite generar texto según tu instrucción de entrada y los parámetros especificados.
Para enviar solicitudes de inferencia, sigue estos pasos:
Configura las siguientes variables de entorno:
export GATEWAY_NAME=GATEWAY_NAME export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTPReemplaza lo siguiente:
GATEWAY_NAME: Es el nombre de tu recurso de puerta de enlace.PORT_NUMBER: Es el número de puerto que configuraste en la puerta de enlace.
Para obtener el extremo de la puerta de enlace, ejecuta el siguiente 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 una solicitud al extremo
/v1/completionsconcurl, ejecuta el siguiente 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" }'Reemplaza lo siguiente:
MODEL_NAME: Es el nombre del modelo o del adaptador de LoRA que se usará.PROMPT_TEXT: Es la instrucción de entrada para el modelo.MAX_TOKENS: Es la cantidad máxima de tokens que se generarán en la respuesta.TEMPERATURE: Controla la aleatoriedad del resultado. Usa el valor0para obtener un resultado determinístico o un número más alto para obtener un resultado más creativo.
En el siguiente ejemplo, se muestra cómo enviar una solicitud de muestra a 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
}'
Ten en cuenta los siguientes comportamientos:
- Cuerpo de la solicitud: El cuerpo de la solicitud puede incluir parámetros adicionales, como
stopytop_p. Consulta la especificación de la API de OpenAI para obtener una lista completa de las opciones. - Manejo de errores: Implementa un manejo de errores adecuado en el código del cliente para
abordar los posibles errores en la respuesta. Por ejemplo, verifica el código de estado HTTP
en la respuesta
curl. Un código de estado que no sea200suele indicar un error. - Autenticación y autorización: Para las implementaciones de producción, protege tu
extremo de API con mecanismos de autenticación y autorización. Incluye los
encabezados adecuados (por ejemplo,
Authorization) en tus solicitudes.
Matriz de compatibilidad
En la tabla, se describe la matriz de compatibilidad y asistencia para las definiciones de recursos personalizados (CRD) de la extensión de inferencia de la API de Gateway. En él, se detallan las versiones de CustomResourceDefinition que admite GKE en comparación con el proyecto de código abierto (OSS) de Gateway API Inference Extension, incluidos los requisitos de versiones específicos y las notas de instalación.
| Nombre de CustomResourceDefinition | Versión de la API de CustomResourceDefinition | Asistencia administrada de GKE | Compatibilidad con OSS (extensión de inferencia de la API de Gateway) |
|---|---|---|---|
| InferencePool de V1 | inference.networking.k8s.io/v1 | Se admite en GKE 1.32.3 o versiones posteriores, y CustomResourceDefinition se instala de forma predeterminada en GKE 1.34.0-gke.1626000 o versiones posteriores | Compatible a partir de la versión 1.0.0 de la extensión de inferencia de la API de Gateway |
| InferencePool alfa (se recomienda a los usuarios que comiencen con InferencePool v1, ya que la versión alfa de InferencePool dejó de estar disponible) | inference.networking.x-k8s.io/v1alpha2 | Compatible con GKE 1.32.3 o versiones posteriores. Sin embargo, CustomResourceDefinition no se instala de forma predeterminada en GKE. Los usuarios deben instalar manualmente la CustomResourceDefinition desde la extensión de inferencia de la API de Gateway. | Compatible a partir de la versión 0.2.0 de la extensión de inferencia de la API de Gateway |
| InferenceObjective alfa | inference.networking.x-k8s.io/v1alpha2 | GKE no administra InferenceObjective | Compatible a partir de la versión 1.0.0 de la extensión de inferencia de la API de Gateway |
| InferenceModel alfa (se recomienda a los usuarios que comiencen con InferenceObjective, ya que InferenceModel dejó de estar disponible) | inference.networking.x-k8s.io/v1alpha2 | GKE no administra InferenceModel | Se admite a partir de la versión 0.2.0 de la extensión de inferencia de la API de Gateway. |
Protege tu backend de inferencia con TLS de backend
La TLS de backend permite que el balanceador de cargas de GKE Gateway verifique la identidad de los backends de inferencia a los que se conecta. La TLS de backend agrega un paso de verificación explícito durante el protocolo de enlace TLS entre la puerta de enlace y el Pod de backend. Esta verificación ayuda a garantizar que la puerta de enlace se comunique solo con servidores de modelos y extensiones de Endpoint Picker de confianza.
Para configurar la TLS de backend para tus cargas de trabajo de inferencia, adjunta una
BackendTLSPolicy a un recurso InferencePool o GCPInferencePoolImport. Para
configurar la puerta de enlace de modo que pueda verificar el certificado del selector de extremos, adjunta
una BackendTLSPolicy al servicio del selector de extremos al que hace referencia el
campo spec.endpointPickerRef de InferencePool.
Para obtener más información, consulta Configura TLS de backend.
¿Qué sigue?
- Personaliza la configuración de GKE Inference Gateway
- Configura el enrutamiento basado en el cuerpo
- Entrega un LLM con GKE Inference Gateway
- Usa el enrutamiento basado en la latencia prevista con GKE Inference Gateway