TensorFlow Serving

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

Neste documento, descrevemos como configurar a implantação do Google Kubernetes Engine para usar o Google Cloud Managed Service para Prometheus a fim de coletar métricas do Serviço do TensorFlow. Esta página mostra como fazer o seguinte:

• Configure o TF Serving para gerar relatórios de métricas.
• Configurar um recurso PodMonitoring para o serviço gerenciado para Prometheus a fim de coletar as métricas exportadas.
• Instalar um painel no Cloud Monitoring para ver as métricas.

Estas instruções se aplicam somente ao usar a coleção gerenciada com o serviço gerenciado para Prometheus. Se você estiver usando a coleção autoimplantada, consulte a documentação do TF Serving para ver informações da instalação.

Estas instruções são um exemplo e devem funcionar na maioria dos ambientes do Kubernetes. Se você estiver com problemas para instalar um aplicativo ou exportador devido a políticas restritivas de segurança ou da organização, recomendamos consultar a documentação de código aberto para receber suporte.

Para informações sobre o TensorFlow Serving, consulte Serviços do TF. Para informações sobre como configurar o TF Serving no Google Kubernetes Engine, consulte o guia do GKE para o TF Serving.

Pré-requisitos

Para coletar métricas do TF Serving usando o Managed Service para Prometheus e a coleta gerenciada, sua implantação precisa atender aos seguintes requisitos:

• Seu cluster precisa executar a versão 1.21.4-gke.300 ou posterior do Google Kubernetes Engine.
• É necessário executar o Managed Service para Prometheus com a coleta gerenciada ativada. Para mais informações, consulte Começar a usar a coleta gerenciada.

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

Confira a seguir um exemplo de buffer de protocolo do MonitoringConfig:

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

Se você estiver seguindo o guia de configuração do Google Kubernetes Engine, Exiba um modelo com uma única GPU no GKE. O buffer do protocolo MonitoringConfig é definido como parte da configuração padrão.

Se você estiver configurando o TF Serving, faça o seguinte para especificar o buffer do protocolo MonitoringConfig:

1. Crie um arquivo chamado monitoring_config.txt contendo o buffer de protocolo MonitoringConfig no diretório do modelo antes de fazer o upload do diretório para o bucket do Cloud Storage.

2. Faça upload do diretório do modelo para o bucket do Cloud Storage:

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

3. Defina a variável de ambiente PATH_TO_MONITORING_CONFIG como o caminho do arquivo monitoring_config.txt enviado, por exemplo:

   export PATH_TO_MONITORING_CONFIG=/data/tfserve-model-repository/monitoring_config.txt
   

4. Adicione a flag e o valor a seguir ao comando do contêiner no arquivo YAML de implantação do contêiner:

   "--monitoring_config=$PATH_TO_MONITORING_CONFIG"
   

   Por exemplo, o comando pode ser parecido com este:

   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" ]
   

Modificar a configuração de exibição do TF

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

# 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

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

Para aplicar as alterações de configuração de um arquivo local, execute o seguinte comando:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Também é possível usar o Terraform para gerenciar as configurações.

1. Configure o encaminhamento de portas usando o seguinte comando:

     kubectl -n NAMESPACE_NAME port-forward POD_NAME 8000
   

2. Acesse o endpoint localhost:8000/monitoring/prometheus/metrics usando o navegador ou o utilitário curl em outra sessão de terminal.

Definir um recurso do PodMonitoring

Para descobrir o destino, o operador do Managed Service para Prometheus requer um recurso PodMonitoring que corresponde ao TF Serving no mesmo namespace.

É possível usar a seguinte configuração do 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 as alterações de configuração de um arquivo local, execute o seguinte comando:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Também é possível usar o Terraform para gerenciar as configurações.

Verificar a configuração

Use o Metrics Explorer para verificar se você configurou corretamente o serviço do TF. Pode levar um ou dois minutos para que o Cloud Monitoring ingira as métricas.

Para verificar se as métricas foram transferidas, faça o seguinte:

1. No Console do Google Cloud, acesse a página do leaderboard Metrics Explorer:

   Acesse o Metrics explorer

   Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.

2. Na barra de ferramentas do painel do criador de consultas, selecione o botão code MQL ou code PromQL.
3. Verifique se PromQL está selecionado na opção de ativar/desativar Idioma. A alternância de idiomas está na mesma barra de ferramentas que permite formatar sua consulta.
4. Digite e execute a seguinte consulta:
   

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

Ver painéis

A integração do Cloud Monitoring inclui o painel Visão geral do Prometheus do TensorFlow Serving. Os painéis são instalados automaticamente ao configurar a integração. Também é possível visualizar visualizações estáticas de painéis sem instalar a integração.

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

1. No console do Google Cloud, acesse a página  Painéis:

   Ir para Painéis

   Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.

2. Selecione a guia Lista de painéis.
3. Escolha a categoria Integrações.
4. Clique no nome do painel, por exemplo, Visão geral do TensorFlow Serving Prometheus.

Para acessar uma visualização estática do painel, faça o seguinte:

1. No console do Google Cloud, acesse a página  Integrações:

   Acessar Integrações

   Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.

2. Clique no filtro de plataforma de implantação do Kubernetes Engine.
3. Localize a integração do TensorFlow Serving e clique em Visualizar detalhes.
4. Selecione a guia Painéis.

Solução de problemas

Para resolver problemas de transferências de métricas, consulte Problemas com a coleta de exportadores em Resolver problemas no processamento.