Esta página foi traduzida pela API Cloud Translation.

Personalizar a configuração do GKE Inference Gateway

Autopilot Standard

Nesta página, descrevemos como personalizar a implantação do GKE Inference Gateway.

Esta página é destinada a especialistas Rede responsáveis por gerenciar a infraestrutura do GKE e administradores de plataforma que gerenciam cargas de trabalho de IA.

Para gerenciar e otimizar cargas de trabalho de inferência, configure recursos avançados do gateway de inferência do GKE.

Entenda e configure os seguintes recursos avançados:

Para usar a integração do Model Armor, configure as verificações de segurança e proteção de IA.
Para conferir as métricas e os painéis do GKE Inference Gateway e do servidor de modelos e ativar o registro de acesso HTTP para informações detalhadas de solicitação e resposta, configure a observabilidade.
Para escalonar automaticamente as implantações do GKE Inference Gateway, configure o escalonamento automático.

Configurar verificações de segurança e proteção de IA

O gateway de inferência do GKE se integra ao Model Armor para realizar verificações de segurança em comandos e respostas para aplicativos que usam modelos de linguagem grandes (LLMs). Essa integração oferece uma camada extra de aplicação de segurança no nível da infraestrutura que complementa as medidas de segurança no nível do aplicativo. Isso permite a aplicação centralizada de políticas em todo o tráfego de LLM.

O diagrama a seguir ilustra a integração do Model Armor com o gateway de inferência do GKE em um cluster do GKE:

Integração do Google Cloud Model Armor em um cluster do GKE — **Figura:** integração do Model Armor em um cluster do GKE

Para configurar as verificações de segurança de IA, siga estas etapas:

Verifique se os pré-requisitos a seguir foram atendidos:
1. Ative o serviço Model Armor no seu projeto do Google Cloud .
2. Crie os modelos do Model Armor usando o console do Model Armor, a Google Cloud CLI ou a API.
Verifique se você já criou um modelo de proteção de modelo chamado my-model-armor-template-name-id.
Para configurar o GCPTrafficExtension, siga estas etapas:
1. Salve o seguinte manifesto de amostra 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'
```
  Substitua:
  - GATEWAY_NAME: o nome do gateway.
  - MODEL_ARMOR_TEMPLATE_NAME: o nome do seu modelo do Model Armor.
  O arquivo gcp-traffic-extension.yaml inclui as seguintes configurações:
  - targetRefs: especifica o gateway a que essa extensão se aplica.
  - extensionChains: define uma cadeia de extensões a serem aplicadas ao tráfego.
  - matchCondition: define as condições em que as extensões são aplicadas.
  - extensions: define as extensões a serem aplicadas.
  - supportedEvents: especifica os eventos durante os quais a extensão é invocada.
  - timeout: especifica o tempo limite da extensão.
  - googleAPIServiceName: especifica o nome do serviço para a extensão.
  - metadata: especifica os metadados da extensão, incluindo o extensionPolicy e as configurações de limpeza de comandos ou respostas.
2. Aplique o manifesto de amostra ao cluster:
```
kubectl apply -f `gcp-traffic-extension.yaml`
```

Depois de configurar as verificações de segurança de IA e integrá-las ao seu gateway, o Model Armor filtra automaticamente comandos e respostas com base nas regras definidas.

Configurar observabilidade

O gateway de inferência do GKE fornece insights sobre a integridade, o desempenho e o comportamento das suas cargas de trabalho de inferência. Isso ajuda você a identificar e resolver problemas, otimizar a utilização de recursos e garantir a confiabilidade dos seus aplicativos.

Google Cloud fornece os seguintes painéis do Cloud Monitoring que oferecem observabilidade de inferência para o gateway de inferência do GKE:

Painel do GKE Inference Gateway: fornece métricas de ouro para veiculação de LLMs, como capacidade de processamento de solicitações e tokens, latência, erros e utilização do cache para o InferencePool. Para conferir a lista completa de métricas disponíveis do GKE Inference Gateway, consulte Métricas expostas.
Painel do servidor de modelo: fornece um painel para os sinais dourados do servidor de modelo. Isso permite monitorar a carga e o desempenho dos servidores de modelos, como KVCache Utilization e Queue length. Isso permite monitorar a carga e a performance dos servidores de modelo.
Painel do balanceador de carga: informa métricas do balanceador de carga, como solicitações por segundo, latência de atendimento de solicitações de ponta a ponta e códigos de status de solicitação-resposta. Essas métricas ajudam você a entender o desempenho do serviço de solicitações de ponta a ponta e identificar erros.
Métricas do Data Center GPU Manager (DCGM): fornecem métricas de GPUs NVIDIA, como o desempenho e a utilização delas. É possível configurar métricas do NVIDIA Data Center GPU Manager (DCGM) no Cloud Monitoring. Para mais informações, consulte Coletar e conferir métricas do DCGM.

Acessar o painel do GKE Inference Gateway

Para acessar o painel do GKE Inference Gateway, siga estas etapas:

No console Google Cloud , acesse a página Recomendações.

Acessar Monitoring
No painel de navegação, selecione Painéis.
Na seção Integrações, selecione GMP.
Na página Modelos de painel do Cloud Monitoring, pesquise "Gateway".
Acesse o painel do GKE Inference Gateway.

Como alternativa, siga as instruções em Painel do Monitoring.

Configurar o painel de observabilidade do servidor de modelo

Para coletar indicadores de ouro de cada servidor de modelo e entender o que contribui para o desempenho do GKE Inference Gateway, configure o monitoramento automático para seus servidores de modelo. Isso inclui servidores de modelo como os seguintes:

Para acessar os painéis de controle de integração, siga estas etapas:

Colete as métricas do servidor de modelos.
No console Google Cloud , acesse a página Recomendações.

Acessar Monitoring
No painel de navegação, selecione Painéis.
Em Integrações, selecione GMP. Os painéis de integração correspondentes são exibidos.

Figura: painéis de integração

Para mais informações, consulte Personalizar o monitoramento de aplicativos.

Configurar os alertas do Cloud Monitoring

Para configurar alertas do Cloud Monitoring para o GKE Inference Gateway, siga estas etapas:

Modifique o limite nos alertas. Salve o seguinte manifesto de amostra 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 criar políticas de alertas, execute o seguinte comando:
```
gcloud alpha monitoring policies migrate --policies-from-prometheus-alert-rules-yaml=alerts.yaml
```
As novas políticas de alertas aparecem na página "Alertas".

Modificar alertas

A lista completa das métricas mais recentes está disponível no repositório do GitHub kubernetes-sigs/gateway-api-inference-extension, e é possível adicionar novos alertas ao manifesto usando outras métricas.

Para fazer mudanças nos alertas de amostra, use o seguinte exemplo:

  - 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'

O alerta será acionado se o 99º percentil da duração da solicitação em 5 minutos for superior a 10 segundos. É possível modificar a seção expr do alerta para ajustar o limite com base nos seus requisitos.

Configurar a geração de registros para o GKE Inference Gateway

A configuração do registro em log para o GKE Inference Gateway fornece informações detalhadas sobre solicitações e respostas, o que é útil para solução de problemas, auditoria e análise de desempenho. Os registros de acesso HTTP registram todas as solicitações e respostas, incluindo cabeçalhos, códigos de status e carimbos de data/hora. Esse nível de detalhes pode ajudar você a identificar problemas, encontrar erros e entender o comportamento das cargas de trabalho de inferência.

Para configurar o registro em registros do GKE Inference Gateway, ative o registro de acesso HTTP para cada um dos seus objetos InferencePool.

Salve o seguinte manifesto de amostra 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

Substitua:

NAMESPACE_NAME: o nome do namespace em que seu InferencePool está implantado.
INFERENCE_POOL_NAME: o nome do InferencePool.

Aplique o manifesto de amostra ao cluster:

kubectl apply -f logging-backend-policy.yaml

Depois de aplicar esse manifesto, o GKE Inference Gateway vai ativar os registros de acesso HTTP para o InferencePool especificado. É possível ver esses registros no Cloud Logging. Os registros incluem informações detalhadas sobre cada solicitação e resposta, como o URL da solicitação, cabeçalhos, código de status da resposta e latência.

Configure o escalonamento automático

O escalonamento automático ajusta a alocação de recursos em resposta às variações de carga, mantendo a performance e a eficiência de recursos ao adicionar ou remover pods dinamicamente com base na demanda. Para o GKE Inference Gateway, isso envolve o escalonamento automático horizontal de pods em cada InferencePool. O escalonador automático horizontal de pods (HPA) do GKE escalona automaticamente os pods com base em métricas do servidor de modelos, como KVCache Utilization. Isso garante que o serviço de inferência processe diferentes cargas de trabalho e volumes de consultas, gerenciando o uso de recursos de maneira eficiente.

Para configurar instâncias InferencePool para que elas façam o escalonamento automático com base nas métricas produzidas pelo GKE Inference Gateway, siga estas etapas:

Implante um objeto PodMonitoring no cluster para coletar métricas produzidas pelo gateway de inferência do GKE. Para mais informações, consulte Configurar a capacidade de observação.

Implante o adaptador de métricas personalizadas do Stackdriver para dar ao HPA acesso às métricas:

Salve o seguinte manifesto de amostra 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