Esta página foi traduzida pela API Cloud Translation.

TensorFlow Serving

Este documento descreve como configurar a implementação do Google Kubernetes Engine para que possa usar o Google Cloud Managed Service for Prometheus para recolher métricas do TensorFlow Serving. Este documento mostra como fazer o seguinte:

Configure o TF Serving para comunicar métricas.
Aceda a um painel de controlo predefinido no Cloud Monitoring para ver as métricas.

Estas instruções aplicam-se apenas se estiver a usar a recolha gerida com o serviço gerido para Prometheus. Se estiver a usar a recolha implementada automaticamente, consulte a documentação do TF Serving para obter informações de instalação.

Estas instruções são fornecidas como exemplo e espera-se que funcionem na maioria dos ambientes do Kubernetes. Se estiver com problemas na instalação de uma aplicação ou de um exportador devido a políticas organizacionais ou de segurança restritivas, recomendamos que consulte a documentação de código aberto para receber apoio técnico.

Para informações sobre o TensorFlow Serving, consulte o TF Serving. Para ver informações sobre a configuração do TF Serving no Google Kubernetes Engine, consulte o guia do GKE para o TF Serving.

Pré-requisitos

Para recolher métricas do TF Serving através do Managed Service for Prometheus e da recolha gerida, a sua implementação tem de cumprir os seguintes requisitos:

O cluster tem de estar a executar a versão 1.28.15-gke.2475000 ou posterior do Google Kubernetes Engine.
Tem de estar a executar o Managed Service for Prometheus com a recolha gerida ativada. Para mais informações, consulte o artigo Comece a usar a recolha gerida.

O TF Serving expõe métricas no formato Prometheus quando a flag --monitoring_config_file é usada para especificar um ficheiro que contém um buffer de protocolo MonitoringConfig.

Segue-se um exemplo de um buffer do protocolo MonitoringConfig:

prometheus_config {
  enable: true,
  path: "/monitoring/prometheus/metrics"
}

Se estiver a seguir o guia de configuração do Google Kubernetes Engine, Apresente um modelo com uma única GPU no GKE, o protocolo buffer MonitoringConfig é definido como parte da configuração predefinida.

Se estiver a configurar o TF Serving autonomamente, faça o seguinte para especificar o protocolo de buffer MonitoringConfig:

Crie um ficheiro com o nome monitoring_config.txt que contenha o buffer de protocolo MonitoringConfig no diretório do modelo antes de carregar o diretório para o contentor do Cloud Storage.

Carregue o diretório do modelo para o contentor do Cloud Storage:

gcloud storage cp MODEL_DIRECTORY gs://CLOUD_STORAGE_BUCKET_NAME --recursive

Defina a variável de ambiente PATH_TO_MONITORING_CONFIG para o caminho do ficheiro monitoring_config.txt carregado, por exemplo:
```
export PATH_TO_MONITORING_CONFIG=/data/tfserve-model-repository/monitoring_config.txt
```

Adicione a seguinte flag e valor ao comando do contentor no ficheiro YAML de implementação do contentor:

"--monitoring_config=$PATH_TO_MONITORING_CONFIG"

Por exemplo, o seu comando pode ter o seguinte aspeto:

command: [ "tensorflow_model_server", "--model_name=$MODEL_NAME", "--model_base_path=/data/tfserve-model-repository/$MODEL_NAME", "--rest_api_port=8000", "--monitoring_config_file=$PATH_TO_MONITORING_CONFIG" ]

Modifique a configuração do TF Serving

Modifique a configuração do TF Serving, conforme mostrado no seguinte exemplo:

# Copyright 2025 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tfserve-deployment
  labels:
    app: tfserve-server
spec:
  selector:
    matchLabels:
      app: tfserve
  replicas: 1
  template:
    metadata:
      labels:
        app: tfserve
      annotations:
        gke-gcsfuse/volumes: 'true'
    spec:
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      containers:
        - name: tfserve-server
          image: 'tensorflow/serving:2.13.1-gpu'
          command:
            - tensorflow_model_server
            - '--model_name=$MODEL_NAME'
            - '--model_base_path=/data/tfserve-model-repository/$MODEL_NAME'
            - '--rest_api_port=8000'
+           - '--monitoring_config_file=$PATH_TO_MONITORING_CONFIG'
          ports:
            - name: http
              containerPort: 8000
            - name: grpc
              containerPort: 8500
          resources:
            ...
          volumeMounts:
            - name: gcs-fuse-csi-vol
              mountPath: /data
              readOnly: false
      serviceAccountName: $K8S_SA_NAME
      volumes:
        - name: gcs-fuse-csi-vol
          csi:
            driver: gcsfuse.csi.storage.gke.io
            readOnly: false
            volumeAttributes:
              bucketName: $GSBUCKET
              mountOptions: implicit-dirs

Tem de adicionar todas as linhas precedidas pelo símbolo + à sua configuração.

Para aplicar alterações de configuração a partir de um ficheiro local, execute o seguinte comando:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Também pode usar o Terraform para gerir as suas configurações.

Para verificar se o TF Serving está a emitir métricas nos pontos finais esperados, faça o seguinte:

Configure o encaminhamento de portas com o seguinte comando:

  kubectl -n NAMESPACE_NAME port-forward POD_NAME 8000

Aceda ao ponto final localhost:8000/monitoring/prometheus/metrics através do navegador ou da utilidade curl noutra sessão de terminal.

Defina um recurso PodMonitoring

Para a deteção de destinos, o operador do Managed Service for Prometheus requer um recurso PodMonitoring que corresponda ao TF Serving no mesmo espaço de nomes.

Pode usar a seguinte configuração PodMonitoring:

# Copyright 2025 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: tfserve
  labels:
    app.kubernetes.io/name: tfserve
    app.kubernetes.io/part-of: google-cloud-managed-prometheus
spec:
  endpoints:
  - port: 8000
    scheme: http
    interval: 30s
    path: /monitoring/prometheus/metrics
  selector:
    matchLabels:
      app: tfserve

Para aplicar alterações de configuração a partir de um ficheiro local, execute o seguinte comando:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Também pode usar o Terraform para gerir as suas configurações.

Valide a configuração

Pode usar o Explorador de métricas para verificar se configurou corretamente o fornecimento do TF. O Cloud Monitoring pode demorar um ou dois minutos a carregar as suas métricas.

Para verificar se as métricas são carregadas, faça o seguinte:

Na Google Cloud consola, aceda à página Explorador de métricas:
Aceda ao Metrics Explorer

Se usar a barra de pesquisa para encontrar esta página, selecione o resultado cujo subtítulo é Monitorização.
Na barra de ferramentas do painel do criador de consultas, selecione o botão cujo nome é MQL ou PromQL.
Verifique se a opção PromQL está selecionada no botão Idioma. O botão para alternar o idioma encontra-se na mesma barra de ferramentas que lhe permite formatar a consulta.

Introduza e execute a seguinte consulta:

up{job="tfserve", cluster="CLUSTER_NAME", namespace="NAMESPACE_NAME"}

Veja painéis de controlo

A integração do Cloud Monitoring inclui o painel de controlo Vista geral do TensorFlow Serving Prometheus. Os painéis de controlo são instalados automaticamente quando configura a integração. Também pode ver pré-visualizações estáticas de painéis de controlo sem instalar a integração.

Para ver um painel de controlo instalado, faça o seguinte:

Na Google Cloud consola, aceda à página Painéis de controlo:
Aceda a Painéis de controlo

Se usar a barra de pesquisa para encontrar esta página, selecione o resultado cujo subtítulo é Monitorização.
Selecione o separador Lista de painéis de controlo.
Escolha a categoria Integrações.
Clique no nome do painel de controlo, por exemplo, Vista geral do Prometheus do TensorFlow Serving.

Para ver uma pré-visualização estática do painel de controlo, faça o seguinte:

Na Google Cloud consola, aceda à página Integrações:
Aceda a Integrações

Se usar a barra de pesquisa para encontrar esta página, selecione o resultado cujo subtítulo é Monitorização.
Clique no filtro de plataforma de implementação Kubernetes Engine.
Localize a integração do TensorFlow Serving e clique em Ver detalhes.
Selecione o separador Painéis de controlo.

Resolução de problemas

Para informações sobre a resolução de problemas de carregamento de métricas, consulte Problemas com a recolha de exportadores em Resolução de problemas do lado do carregamento.

TensorFlow Serving Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.