Se usó la API de Cloud Translation para traducir esta página.

Cómo personalizar la configuración de la puerta de enlace de inferencia de GKE

Autopilot Estándar

En esta página, se describe cómo personalizar la implementación de GKE Inference Gateway.

Esta página está dirigida a los especialistas en redes responsables de administrar la infraestructura de GKE y a los administradores de plataformas que administran cargas de trabajo de IA.

Para administrar y optimizar las cargas de trabajo de inferencia, debes configurar las funciones avanzadas de la puerta de enlace de inferencia de GKE.

Comprende y configura las siguientes funciones avanzadas:

Para usar la integración de Model Armor, configura las verificaciones de seguridad de la IA.
Para ver las métricas y los paneles del servidor de modelos y de GKE Inference Gateway, y para habilitar el registro de acceso HTTP para obtener información detallada sobre las solicitudes y respuestas, configura la observabilidad.
Para escalar automáticamente tus implementaciones de GKE Inference Gateway, configura el ajuste de escala automático.

Configura las verificaciones de seguridad y protección de la IA

GKE Inference Gateway se integra con Model Armor para realizar verificaciones de seguridad en las instrucciones y respuestas de las aplicaciones que usan modelos de lenguaje grandes (LLM). Esta integración proporciona una capa adicional de aplicación de la seguridad a nivel de la infraestructura que complementa las medidas de seguridad a nivel de la aplicación. Esto permite la aplicación centralizada de políticas en todo el tráfico de LLM.

En el siguiente diagrama, se ilustra la integración de Model Armor con GKE Inference Gateway en un clúster de GKE:

Integración de Google Cloud Model Armor en un clúster de GKE — **Figura:** Integración de Model Armor en un clúster de GKE

Para configurar las verificaciones de seguridad de la IA, sigue estos pasos:

Asegúrate de que se cumplan los siguientes requisitos:
1. Habilita el servicio Model Armor en tu proyecto Google Cloud .
2. Crea las plantillas de Model Armor con la consola de Model Armor, Google Cloud CLI o la API.
Asegúrate de haber creado una plantilla de Model Armor llamada my-model-armor-template-name-id.
Para configurar GCPTrafficExtension, sigue estos pasos:
1. Guarda el siguiente manifiesto de muestra como gcp-traffic-extension.yaml:
```
kind: GCPTrafficExtension
apiVersion: networking.gke.io/v1
metadata:
  name: my-model-armor-extension
spec:
  targetRefs:
  - group: "gateway.networking.k8s.io"
    kind: Gateway
    name: GATEWAY_NAME
  extensionChains:
  - name: my-model-armor-chain1
    matchCondition:
      celExpressions:
      - celMatcher: request.path.startsWith("/")
    extensions:
    - name: my-model-armor-service
      supportedEvents:
      - RequestHeaders
      timeout: 1s
      googleAPIServiceName: "modelarmor.us-central1.rep.googleapis.com"
      metadata:
        'extensionPolicy': MODEL_ARMOR_TEMPLATE_NAME
        'sanitizeUserPrompt': 'true'
        'sanitizeUserResponse': 'true'
```
  Reemplaza lo siguiente:
  - GATEWAY_NAME: Es el nombre de la puerta de enlace.
  - MODEL_ARMOR_TEMPLATE_NAME: El nombre de tu plantilla de Model Armor.
  El archivo gcp-traffic-extension.yaml incluye los siguientes parámetros de configuración:
  - targetRefs: Especifica la puerta de enlace a la que se aplica esta extensión.
  - extensionChains: Define una cadena de extensiones que se aplicará al tráfico.
  - matchCondition: Define las condiciones en las que se aplican las extensiones.
  - extensions: Define las extensiones que se aplicarán.
  - supportedEvents: Especifica los eventos durante los cuales se invoca la extensión.
  - timeout: Especifica el tiempo de espera de la extensión.
  - googleAPIServiceName: Especifica el nombre del servicio para la extensión.
  - metadata: Especifica los metadatos de la extensión, incluidos los parámetros de configuración de extensionPolicy y de limpieza de la respuesta o la instrucción.
2. Aplica el manifiesto de muestra a tu clúster:
```
kubectl apply -f `gcp-traffic-extension.yaml`
```

Después de configurar las verificaciones de seguridad de la IA y de integrarlas en tu puerta de enlace, Model Armor filtrará automáticamente las instrucciones y las respuestas según las reglas definidas.

Configura la observabilidad

La puerta de enlace de inferencia de GKE proporciona estadísticas sobre el estado, el rendimiento y el comportamiento de tus cargas de trabajo de inferencia. Esto te ayuda a identificar y resolver problemas, optimizar el uso de recursos y garantizar la confiabilidad de tus aplicaciones.

Google Cloud proporciona los siguientes paneles de Cloud Monitoring que ofrecen observabilidad de la inferencia para la puerta de enlace de inferencia de GKE:

Panel de Inference Gateway de GKE: Proporciona métricas clave para la entrega de LLM, como el rendimiento de solicitudes y tokens, la latencia, los errores y la utilización de la caché para InferencePool. Para ver la lista completa de las métricas disponibles de GKE Inference Gateway, consulta Métricas expuestas.
Panel del servidor de modelos: Proporciona un panel para los indicadores dorados del servidor de modelos. Esto te permite supervisar la carga y el rendimiento de los servidores de modelos, como KVCache Utilization y Queue length. Esto te permite supervisar la carga y el rendimiento de los servidores de modelos.
Panel del balanceador de cargas: Informa métricas del balanceador de cargas, como las solicitudes por segundo, la latencia de entrega de solicitudes de extremo a extremo y los códigos de estado de solicitud y respuesta. Estas métricas te ayudan a comprender el rendimiento de la publicación de solicitudes de extremo a extremo y a identificar errores.
Métricas de Data Center GPU Manager (DCGM): Proporciona métricas de las GPUs de NVIDIA, como el rendimiento y el uso de las GPUs de NVIDIA. Puedes configurar las métricas del administrador de GPU del centro de datos de NVIDIA (DCGM) en Cloud Monitoring. Para obtener más información, consulta Recopila y visualiza métricas de DCGM.

Visualiza el panel de la puerta de enlace de inferencia de GKE

Para ver el panel de la puerta de enlace de inferencia de GKE, sigue estos pasos:

En la consola de Google Cloud , ve a la página Monitoring.

Ir a Monitoring
En el panel de navegación, selecciona Paneles.
En la sección Integraciones, selecciona GMP.
En la página Plantillas de paneles de Cloud Monitoring, busca "Puerta de enlace".
Visualiza el panel de GKE Inference Gateway.

Como alternativa, puedes seguir las instrucciones que se indican en Panel de supervisión.

Configura el panel de observabilidad del servidor de modelos

Para recopilar indicadores clave de rendimiento de cada servidor de modelos y comprender qué contribuye al rendimiento de GKE Inference Gateway, puedes configurar la supervisión automática de tus servidores de modelos. Esto incluye servidores de modelos como los siguientes:

Para ver los paneles de integración, sigue estos pasos:

Recopila las métricas de tu servidor de modelos.
En la consola de Google Cloud , ve a la página Monitoring.

Ir a Monitoring
En el panel de navegación, selecciona Paneles.
En Integraciones, selecciona GMP. Se muestran los paneles de integración correspondientes.

Figura: Paneles de integración

Para obtener más información, consulta Personaliza la supervisión de aplicaciones.

Configura las alertas de Cloud Monitoring

Para configurar alertas de Cloud Monitoring para GKE Inference Gateway, sigue estos pasos:

Modificar el umbral en las alertas Guarda el siguiente manifiesto de muestra como alerts.yaml:

groups:
- name: gateway-api-inference-extension
  rules:
  - alert: HighInferenceRequestLatencyP99
    annotations:
      title: 'High latency (P99) for model {{ $labels.model_name }}'
      description: 'The 99th percentile request duration for model {{ $labels.model_name }} and target model {{ $labels.target_model_name }} has been consistently above 10.0 seconds for 5 minutes.'
    expr: histogram_quantile(0.99, rate(inference_model_request_duration_seconds_bucket[5m])) > 10.0
    for: 5m
    labels:
      severity: 'warning'
  - alert: HighInferenceErrorRate
    annotations:
      title: 'High error rate for model {{ $labels.model_name }}'
      description: 'The error rate for model {{ $labels.model_name }} and target model {{ $labels.target_model_name }} has been consistently above 5% for 5 minutes.'
    expr: sum by (model_name) (rate(inference_model_request_error_total[5m])) / sum by (model_name) (rate(inference_model_request_total[5m])) > 0.05
    for: 5m
    labels:
      severity: 'critical'
      impact: 'availability'
  - alert: HighInferencePoolAvgQueueSize
    annotations:
      title: 'High average queue size for inference pool {{ $labels.name }}'
      description: 'The average number of requests pending in the queue for inference pool {{ $labels.name }} has been consistently above 50 for 5 minutes.'
    expr: inference_pool_average_queue_size > 50
    for: 5m
    labels:
      severity: 'critical'
      impact: 'performance'
  - alert: HighInferencePoolAvgKVCacheUtilization
    annotations:
      title: 'High KV cache utilization for inference pool {{ $labels.name }}'
      description: 'The average KV cache utilization for inference pool {{ $labels.name }} has been consistently above 90% for 5 minutes, indicating potential resource exhaustion.'
    expr: inference_pool_average_kv_cache_utilization > 0.9
    for: 5m
    labels:
      severity: 'critical'
      impact: 'resource_exhaustion'

Para crear políticas de alertas, ejecuta el siguiente comando:
```
gcloud alpha monitoring policies migrate --policies-from-prometheus-alert-rules-yaml=alerts.yaml
```
Verás las nuevas políticas de alertas en la página Alertas.

Cómo modificar alertas

Puedes encontrar la lista completa de las métricas más recientes disponibles en el repositorio de GitHub de kubernetes-sigs/gateway-api-inference-extension, y puedes agregar alertas nuevas al manifiesto con otras métricas.

Para cambiar las alertas de muestra, toma como ejemplo la siguiente alerta:

  - alert: HighInferenceRequestLatencyP99
    annotations:
      title: 'High latency (P99) for model {{ $labels.model_name }}'
      description: 'The 99th percentile request duration for model {{ $labels.model_name }} and target model {{ $labels.target_model_name }} has been consistently above 10.0 seconds for 5 minutes.'
    expr: histogram_quantile(0.99, rate(inference_model_request_duration_seconds_bucket[5m])) > 10.0
    for: 5m
    labels:
      severity: 'warning'

La alerta se activará si el percentil 99 de la duración de la solicitud en 5 minutos supera los 10 segundos. Puedes modificar la sección expr de la alerta para ajustar el umbral según tus requisitos.

Configura el registro para la puerta de enlace de inferencia de GKE

Configurar el registro para la puerta de enlace de inferencia de GKE proporciona información detallada sobre las solicitudes y las respuestas, lo que resulta útil para solucionar problemas, realizar auditorías y analizar el rendimiento. Los registros de acceso HTTP registran cada solicitud y respuesta, incluidos los encabezados, los códigos de estado y las marcas de tiempo. Este nivel de detalle puede ayudarte a identificar problemas, encontrar errores y comprender el comportamiento de tus cargas de trabajo de inferencia.

Para configurar el registro de Inference Gateway de GKE, habilita el registro de acceso HTTP para cada uno de tus objetos InferencePool.

Guarda el siguiente manifiesto de muestra como logging-backend-policy.yaml:

apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
  name: logging-backend-policy
  namespace: NAMESPACE_NAME
spec:
  default:
    logging:
      enabled: true
      sampleRate: 500000
  targetRef:
    group: inference.networking.x-k8s.io
    kind: InferencePool
    name: INFERENCE_POOL_NAME

Reemplaza lo siguiente:

NAMESPACE_NAME: Es el nombre del espacio de nombres en el que se implementa tu InferencePool.
INFERENCE_POOL_NAME: el nombre de InferencePool.

Aplica el manifiesto de muestra a tu clúster:

kubectl apply -f logging-backend-policy.yaml

Después de aplicar este manifiesto, GKE Inference Gateway habilita los registros de acceso HTTP para el InferencePool especificado. Puedes ver estos registros en Cloud Logging. Los registros incluyen información detallada sobre cada solicitud y respuesta, como la URL de la solicitud, los encabezados, el código de estado de la respuesta y la latencia.

Configurar ajuste de escala automático

El ajuste de escala automático ajusta la asignación de recursos en respuesta a las variaciones de carga, lo que mantiene el rendimiento y la eficiencia de los recursos agregando o quitando Pods de forma dinámica según la demanda. En el caso de la puerta de enlace de inferencia de GKE, esto implica el ajuste de escala automático horizontal de los Pods en cada InferencePool. El Horizontal Pod Autoscaler (HPA) de GKE ajusta automáticamente la escala de los Pods en función de las métricas del servidor de modelos, como KVCache Utilization. Esto garantiza que el servicio de inferencia controle diferentes cargas de trabajo y volúmenes de consultas, a la vez que administra de manera eficiente el uso de recursos.

Para configurar instancias InferencePool de modo que se ajusten automáticamente según las métricas que produce GKE Inference Gateway, sigue estos pasos:

Implementa un objeto PodMonitoring en el clúster para recopilar las métricas que produce GKE Inference Gateway. Para obtener más información, consulta Configura la observabilidad.

Implementa el adaptador de métricas personalizadas de Stackdriver para otorgar acceso de HPA a las métricas:

Guarda el siguiente manifiesto de muestra como adapter_new_resource_model.yaml:

apiVersion: v1
kind: Namespace
metadata:
  name: custom-metrics
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: custom-metrics-stackdriver-adapter
  namespace: custom-metrics
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: custom-metrics:system:auth-delegator
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:auth-delegator
subjects:
- kind: ServiceAccount
  name: custom-metrics-stackdriver-adapter
  namespace: custom-metrics
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: custom-metrics-auth-reader
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: extension-apiserver-authentication-reader
subjects:
- kind: ServiceAccount
  name: custom-metrics-stackdriver-adapter
  namespace: custom-metrics
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: custom-metrics-resource-reader
  namespace: custom-metrics
rules:
- apiGroups:
  - ""
  resources:
  - pods
  - nodes
  - nodes/stats
  verbs:
  - get
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: custom-metrics-resource-reader
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: custom-metrics-resource-reader
subjects:
- kind: ServiceAccount
  name: custom-metrics-stackdriver-adapter
  namespace: custom-metrics
---
apiVersion: apps/v1
kind: Deployment
metadata:
  run: custom-metrics-stackdriver-adapter
  k8s-app: custom-metrics-stackdriver-adapter
spec:
  replicas: 1
  selector:
    matchLabels:
      run: custom-metrics-stackdriver-adapter
      k8s-app: custom-metrics-stackdriver-adapter
  template:
    metadata:
      labels:
        run: custom-metrics-stackdriver-adapter
        k8s-app: custom-metrics-stackdriver-adapter
        kubernetes.io/cluster-service: "true"
    spec:
      serviceAccountName: custom-metrics-stackdriver-adapter
      containers:
      - image: gcr.io/gke-release/custom-metrics-stackdriver-adapter:v0.15.2-gke.1
        imagePullPolicy: Always
        name: pod-custom-metrics-stackdriver-adapter
        command:
        - /adapter
        - --use-new-resource-model=true
        - --fallback-for-container-metrics=true
        resources:
          limits:
            cpu: 250m
            memory: 200Mi
          requests:
            cpu: 250m
            memory: 200Mi
---
apiVersion: v1
kind: Service
metadata:
  labels:
    run: custom-metrics-stackdriver-adapter
    k8s-app: custom-metrics-stackdriver-adapter
    kubernetes.io/cluster-service: 'true'
    kubernetes.io/name: Adapter
  name: custom-metrics-stackdriver-adapter
  namespace: custom-metrics
spec:
  ports:
  - port: 443
    protocol: TCP
    targetPort: 443
  selector:
    run: custom-metrics-stackdriver-adapter
    k8s-app: custom-metrics-stackdriver-adapter
  type: ClusterIP
---
apiVersion: apiregistration.k8s.io/v1
kind: APIService
metadata:
  name: v1beta1.custom.metrics.k8s.io
spec:
  insecureSkipTLSVerify: true
  group: custom.metrics.k8s.io
  groupPriorityMinimum: 100
  versionPriority: 100
  service:
    name: custom-metrics-stackdriver-adapter
    namespace: custom-metrics
  version: v1beta1
---
apiVersion: apiregistration.k8s.io/v1
kind: APIService
metadata:
  name: v1beta2.custom.metrics.k8s.io
spec:
  insecureSkipTLSVerify: true
  group: custom.metrics.k8s.io
  groupPriorityMinimum: 100
  versionPriority: 200
  service:
    name: custom-metrics-stackdriver-adapter
    namespace: custom-metrics
  version: v1beta2
---
apiVersion: apiregistration.k8s.io/v1
kind: APIService
metadata:
  name: v1beta1.external.metrics.k8s.io
spec:
  insecureSkipTLSVerify: true
  group: external.metrics.k8s.io
  groupPriorityMinimum: 100
  versionPriority: 100
  service:
    name: custom-metrics-stackdriver-adapter
    namespace: custom-metrics
  version: v1beta1
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: external-metrics-reader
rules:
- apiGroups:
  - "external.metrics.k8s.io"
  resources:
  - "*"
  verbs:
  - list
  - get
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: external-metrics-reader
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: external-metrics-reader
subjects:
- kind: ServiceAccount
  name: horizontal-pod-autoscaler
  namespace: kube-system