Diese Seite wurde von der Cloud Translation API übersetzt.

TensorFlow bereitstellen
Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

In diesem Dokument wird beschrieben, wie Sie Ihre Google Kubernetes Engine-Bereitstellung so konfigurieren, dass Sie Google Cloud Managed Service for Prometheus verwenden können, um Messwerte von TensorFlow Serving zu erfassen. Dieses Dokument enthält Anleitungen für folgende Aufgaben:

TF Serving einrichten, um Messwerte zu erfassen
Eine PodMonitoring-Ressource für Managed Service for Prometheus konfigurieren, um die exportierten Messwerte zu erfassen.
Auf ein Dashboard in Cloud Monitoring zugreifen, um die Messwerte zu prüfen.

Diese Anleitung gilt nur, wenn Sie die verwaltete Sammlung mit Managed Service for Prometheus verwenden. Wenn Sie eine selbst bereitgestellte Sammlung verwenden, finden Sie Informationen zur Installation in der TF Serving-Dokumentation.

Diese Anleitung dient als Beispiel und sollte in den meisten Kubernetes-Umgebungen funktionieren. Wenn Sie aufgrund von restriktiven Sicherheits- oder Organisationsrichtlinien Probleme beim Installieren einer Anwendung oder eines Exporters haben, empfehlen wir Ihnen, die Open Source-Dokumentation für Support zu nutzen.

Weitere Informationen zu TensorFlow Serving finden Sie unter TF Serving. Informationen zum Einrichten von TF Serving in der Google Kubernetes Engine finden Sie im GKE-Leitfaden für TF Serving.

Vorbereitung

Zum Erfassen von Messwerten aus TF Serving mithilfe von Managed Service for Prometheus und einer verwalteten Erfassung muss Ihr Deployment die folgenden Anforderungen erfüllen:

Ihr Cluster muss Google Kubernetes Engine Version 1.21.4-gke.300 oder höher ausführen.
Sie müssen Managed Service for Prometheus mit aktivierter verwalteter Sammlung ausführen. Weitere Informationen finden Sie unter Erste Schritte mit verwalteter Sammlung.

TF Serving stellt Messwerte im Prometheus-Format bereit, wenn mit dem Flag --monitoring_config_file eine Datei mit einem MonitoringConfig-Protokollpuffer angegeben wird.

Im Folgenden finden Sie ein Beispiel für einen MonitoringConfig-Protokollbuffer:

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

Wenn Sie dem Einrichtungsleitfaden für die Google Kubernetes Engine Ein Modell mit einer einzelnen GPU in GKE bereitstellen folgen, wird der MonitoringConfig-Protokollbuffer als Teil der Standardeinrichtung definiert.

Wenn Sie TF Serving selbst einrichten, gehen Sie so vor, um den Protokollpuffer „MonitoringConfig“ anzugeben:

Erstellen Sie im Modellverzeichnis eine Datei namens monitoring_config.txt mit dem MonitoringConfig-Protokollbuffer, bevor Sie das Verzeichnis in den Cloud Storage-Bucket hochladen.

Laden Sie das Modellverzeichnis in den Cloud Storage-Bucket hoch:

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

Legen Sie die Umgebungsvariable PATH_TO_MONITORING_CONFIG auf den Pfad der hochgeladenen monitoring_config.txt-Datei fest, z. B.:
```
export PATH_TO_MONITORING_CONFIG=/data/tfserve-model-repository/monitoring_config.txt
```

Fügen Sie dem Befehl des Containers in der Bereitstellungs-YAML-Datei des Containers das folgende Flag und den folgenden Wert hinzu:

"--monitoring_config=$PATH_TO_MONITORING_CONFIG"

Der Befehl könnte beispielsweise so aussehen:

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

TF-Bereitstellungskonfiguration ändern

Ändern Sie die TF Serving-Konfiguration wie im folgenden Beispiel:

# 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

Sie müssen Ihrer Konfiguration alle Zeilen hinzufügen, denen das Symbol + vorangestellt ist.

Führen Sie den folgenden Befehl aus, um Konfigurationsänderungen aus einer lokalen Datei anzuwenden:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Sie können Ihre Konfigurationen auch mit Terraform verwalten.

So prüfen Sie, ob TF Serving Messwerte an den erwarteten Endpunkten ausgibt:

Richten Sie mit dem folgenden Befehl die Portweiterleitung ein:
```
  kubectl -n NAMESPACE_NAME port-forward POD_NAME 8000
```
Greifen Sie über den Browser oder das Dienstprogramm curl in einer anderen Terminalsitzung auf den Endpunkt localhost:8000/monitoring/prometheus/metrics zu.

PodMonitoring-Ressource definieren

Für die Zielerkennung benötigt der Managed Service for Prometheus-Operator eine PodMonitoring-Ressource, die TF Serving im selben Namespace entspricht.

Sie können die folgende PodMonitoring-Konfiguration verwenden:

# 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

Führen Sie den folgenden Befehl aus, um Konfigurationsänderungen aus einer lokalen Datei anzuwenden:

kubectl apply -n NAMESPACE_NAME -f FILE_NAME

Sie können Ihre Konfigurationen auch mit Terraform verwalten.

Konfiguration prüfen

Mit dem Metrics Explorer können Sie prüfen, ob TF Serving richtig konfiguriert ist. Es kann ein oder zwei Minuten dauern, bis Cloud Monitoring Ihre Messwerte aufgenommen hat.

So prüfen Sie, ob die Messwerte aufgenommen wurden:

Rufen Sie in der Google Cloud Console die Seite Metrics Explorer auf.
Zum Metrics Explorer

Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.
Klicken Sie in der Symbolleiste des Bereichs "Query Builder" auf die Schaltfläche MQL oder PromQL.
Prüfen Sie, ob PromQL in der Ein-/Aus-Schaltfläche PromQL ausgewählt ist. Die Sprachschaltfläche befindet sich in derselben Symbolleiste, mit der Sie Ihre Abfrage formatieren können.

Geben Sie die folgende Abfrage ein und führen Sie sie aus:

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

Dashboards ansehen

Die Cloud Monitoring-Integration beinhaltet das Dashboard TensorFlow Serving Prometheus – Übersicht. Dashboards werden automatisch mitkonfiguriert, wenn Sie die Integration konfigurieren. Sie können auch eine statische Vorschau von Dashboards aufrufen, ohne die Integration zu installieren.

So rufen Sie ein installiertes Dashboard auf:

Rufen Sie in der Google Cloud Console die Seite Dashboards auf.
Dashboards aufrufen

Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.
Wählen Sie den Tab Dashboard-Liste aus.
Wählen Sie die Kategorie Integrationen aus.
Klicken Sie auf den Namen des Dashboards, z. B. TensorFlow Serving Prometheus – Übersicht.

So rufen Sie eine statische Vorschau des Dashboards auf:

Öffnen Sie in der Google Cloud Console die Seite Einbindungen:
Zu „Integrationen“

Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.
Klicken Sie auf den Filter für die Deployment-Plattform Kubernetes Engine.
Suchen Sie nach der TensorFlow Serving-Integration und klicken Sie auf Details ansehen.
Wählen Sie den Tab Dashboards aus.

Fehlerbehebung

Informationen zur Fehlerbehebung bei Problemen mit der Messwertaufnahme finden Sie unter Probleme mit der Erfassung über Exporter unter Fehlerbehebung bei Problemen mit der Aufnahme.

TensorFlow bereitstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.