In diesem Dokument wird beschrieben, wie Sie die unter Skalierbares TensorFlow-Inferenzsystem beschriebene Referenzarchitektur bereitstellen.
Diese Reihe richtet sich an Entwickler, die mit Google Kubernetes Engine und ML-Frameworks (ML) vertraut sind, einschließlich TensorFlow und NVIDIA TensorRT.
Nachdem Sie diese Bereitstellung abgeschlossen haben, finden Sie weitere Informationen unter Leistung eines TensorFlow-Inferenzsystems messen und optimieren.
Architektur
Das folgende Diagramm zeigt die Architektur des Inferenzsystems.
Cloud Load Balancing sendet den Anfragetraffic an den nächstgelegenen GKE-Cluster. Der Cluster enthält für jeden Knoten einen Pod. In jedem Pod bietet ein Triton Inference Server einen Inferenzdienst für die Bereitstellung von ResNet-50-Modellen und eine NVIDIA T4-GPU verbessert die Leistung. Monitoring-Server im Cluster erfassen Messwertdaten zur GPU-Auslastung und Arbeitsspeichernutzung.
Weitere Informationen finden Sie unter Skalierbares TensorFlow-Inferenzsystem.
Lernziele
- Vortrainiertes ResNet-50-Modell herunterladen und TensorFlow-Integration mit TensorRT (TF-TRT) verwenden, um Optimierungen anzuwenden
- ResNet-50-Modell von einem NVIDIA Triton-Inferenzserver bereitstellen
- Mit Prometheus und Grafana ein Monitoringsystem für Triton erstellen
- Mit Locust ein Belastungstest-Tool erstellen
Kosten
Neben der NVIDIA T4-GPU verwenden Sie in dieser Bereitstellung die folgenden kostenpflichtigen Komponenten von Google Cloud:
Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.
Löschen Sie nach Abschluss dieser Bereitstellung die von Ihnen erstellten Ressourcen nicht. Sie benötigen diese Ressourcen, wenn Sie die Bereitstellung messen und optimieren.
Hinweise
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
-
Enable the GKE API.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
-
Enable the GKE API.
Optimierte Modelle mit TF-TRT erstellen
In diesem Abschnitt erstellen Sie eine Arbeitsumgebung und optimieren das vortrainierte Modell.
Das vortrainierte Modell verwendet das fiktive Dataset unter gs://cloud-tpu-test-datasets/fake_imagenet/
.
Es gibt auch eine Kopie des vortrainierten Modells am Cloud Storage-Speicherort unter gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/
.
Arbeitsumgebung erstellen
Für Ihre Arbeitsumgebung erstellen Sie eine Compute Engine-Instanz mit Deep Learning-VM-Images. Sie optimieren und quantifizieren das ResNet-50-Modell mit TensorRT auf dieser Instanz.
In the Google Cloud console, activate Cloud Shell.
Stellen Sie eine Instanz mit dem Namen
working-vm
bereit:gcloud config set project PROJECT_ID gcloud config set compute/zone us-west1-b gcloud compute instances create working-vm \ --scopes cloud-platform \ --image-family common-cu113 \ --image-project deeplearning-platform-release \ --machine-type n1-standard-8 \ --min-cpu-platform="Intel Skylake" \ --accelerator=type=nvidia-tesla-t4,count=1 \ --boot-disk-size=200GB \ --maintenance-policy=TERMINATE \ --metadata="install-nvidia-driver=True"
Ersetzen Sie
PROJECT_ID
durch die ID des Google Cloud-Projekts, das Sie zuvor erstellt haben.Dieser Befehl startet eine Compute Engine-Instanz mit NVIDIA T4. Beim ersten Start wird der NVIDIA GPU-Treiber, der mit TensorRT 5.1.5 kompatibel ist, automatisch installiert.
Modelldateien mit unterschiedlichen Optimierungen erstellen
In diesem Abschnitt wenden Sie die folgenden Optimierungen mithilfe von TF-TRT auf das ursprüngliche ResNet-50-Modell an:
- Grafikoptimierung
- Konvertieren in FP16 mit der Grafikoptimierung
- Quantisieren mit INT8 mit der Grafikoptimierung
Weitere Informationen zu diesen Optimierungen finden Sie unter Leistungsoptimierung.
Gehen Sie in der Google Cloud Console zu Compute Engine > VM-Instanzen.
Sie sehen die Instanz
working-vm
, die Sie zuvor erstellt haben.Klicken Sie zum Öffnen der Terminalkonsole der Instanz auf SSH.
Mit diesem Terminal führen Sie die übrigen Befehle in diesem Dokument aus.
Klonen Sie im Terminal das erforderliche Repository und ändern Sie das aktuelle Verzeichnis:
cd $HOME git clone https://github.com/GoogleCloudPlatform/gke-tensorflow-inference-system-tutorial cd gke-tensorflow-inference-system-tutorial/server
Laden Sie das vortrainierte ResNet-50-Modell in ein lokales Verzeichnis herunter:
mkdir -p models/resnet/original/00001 gsutil cp -R gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/* models/resnet/original/00001
Erstellen Sie ein Container-Image, das Optimierungstools für TF-TRT enthält:
docker build ./ -t trt-optimizer docker image list
Der letzte Befehl zeigt eine Tabelle mit Repositories.
Kopieren Sie in der Tabelle in der Zeile für das Repository
tft-optimizer
die Image-ID.Wenden Sie die Optimierungen (Grafikoptimierung, Konvertierung in FP16 und Quantisierung mit INT8) auf das ursprüngliche Modell an:
export IMAGE_ID=IMAGE_ID nvidia-docker run --rm \ -v `pwd`/models/:/workspace/models ${IMAGE_ID} \ --input-model-dir='models/resnet/original/00001' \ --output-dir='models/resnet' \ --precision-mode='FP32' \ --batch-size=64 nvidia-docker run --rm \ -v `pwd`/models/:/workspace/models ${IMAGE_ID} \ --input-model-dir='models/resnet/original/00001' \ --output-dir='models/resnet' \ --precision-mode='FP16' \ --batch-size=64 nvidia-docker run --rm \ -v `pwd`/models/:/workspace/models ${IMAGE_ID} \ --input-model-dir='models/resnet/original/00001' \ --output-dir='models/resnet' \ --precision-mode='INT8' \ --batch-size=64 \ --calib-image-dir='gs://cloud-tpu-test-datasets/fake_imagenet/' \ --calibration-epochs=10
Ersetzen Sie
IMAGE_ID
durch die Image-ID fürtft-optimizer
, die Sie im vorherigen Schritt kopiert haben.Die Option
--calib-image-dir
gibt den Speicherort der Trainingsdaten an, die für das vortrainierte Modell verwendet werden. Dieselben Trainingsdaten werden für eine Kalibrierung für die INT8-Quantisierung verwendet. Der Kalibrierungsprozess kann etwa 5 Minuten dauern.Wenn die Befehle ausgeführt wurden, sieht die letzte Ausgabezeile in etwa so aus, wobei die optimierten Modelle unter
./models/resnet
gespeichert werden:INFO:tensorflow:SavedModel written to: models/resnet/INT8/00001/saved_model.pb
Die Verzeichnisstruktur sieht in etwa so aus:
models └── resnet ├── FP16 │ └── 00001 │ ├── saved_model.pb │ └── variables ├── FP32 │ └── 00001 │ ├── saved_model.pb │ └── variables ├── INT8 │ └── 00001 │ ├── saved_model.pb │ └── variables └── original └── 00001 ├── saved_model.pb └── variables ├── variables.data-00000-of-00001 └── variables.index
In der folgenden Tabelle wird die Beziehung zwischen Verzeichnissen und Optimierungen zusammengefasst.
Verzeichnis | Optimierung |
---|---|
FP16 |
Konvertierung in FP16 zusätzlich zur Grafikoptimierung |
FP32 |
Grafikoptimierung |
INT8 |
Quantisieren mit INT8 zusätzlich zur Grafikoptimierung |
original |
Ursprüngliches Modell (keine Optimierung mit TF-TRT) |
Inferenzserver bereitstellen
In diesem Abschnitt stellen Sie Triton-Server mit fünf Modellen bereit. Zuerst laden Sie die im vorherigen Abschnitt erstellte Modell-Binärdatei in Cloud Storage hoch. Dann erstellen Sie einen GKE-Cluster und stellen Triton-Server im Cluster bereit.
Modellbinärdatei hochladen
Laden Sie im SSH-Terminal die Binärdateien des Modells und die
config.pbtxt
-Konfigurationsdateien in einen Storage-Bucket hoch:export PROJECT_ID=PROJECT_ID export BUCKET_NAME=${PROJECT_ID}-models mkdir -p original/1/model/ cp -r models/resnet/original/00001/* original/1/model/ cp original/config.pbtxt original/1/model/ cp original/imagenet1k_labels.txt original/1/model/ mkdir -p tftrt_fp32/1/model/ cp -r models/resnet/FP32/00001/* tftrt_fp32/1/model/ cp tftrt_fp32/config.pbtxt tftrt_fp32/1/model/ cp tftrt_fp32/imagenet1k_labels.txt tftrt_fp32/1/model/ mkdir -p tftrt_fp16/1/model/ cp -r models/resnet/FP16/00001/* tftrt_fp16/1/model/ cp tftrt_fp16/config.pbtxt tftrt_fp16/1/model/ cp tftrt_fp16/imagenet1k_labels.txt tftrt_fp16/1/model/ mkdir -p tftrt_int8/1/model/ cp -r models/resnet/INT8/00001/* tftrt_int8/1/model/ cp tftrt_int8/config.pbtxt tftrt_int8/1/model/ cp tftrt_int8/imagenet1k_labels.txt tftrt_int8/1/model/ mkdir -p tftrt_int8_bs16_count4/1/model/ cp -r models/resnet/INT8/00001/* tftrt_int8_bs16_count4/1/model/ cp tftrt_int8_bs16_count4/config.pbtxt tftrt_int8_bs16_count4/1/model/ cp tftrt_int8_bs16_count4/imagenet1k_labels.txt tftrt_int8_bs16_count4/1/model/ gsutil mb gs://${BUCKET_NAME} gsutil -m cp -R original tftrt_fp32 tftrt_fp16 tftrt_int8 tftrt_int8_bs16_count4 \ gs://${BUCKET_NAME}/resnet/
Ersetzen Sie
PROJECT_ID
durch die ID des Google Cloud-Projekts, das Sie zuvor erstellt haben.Die folgenden Abstimmungsparameter werden in den
config.pbtxt
-Dateien angegeben:- Modellname
- Name des Tensors und des Ausgabetensors
- GPU-Zuweisung für jedes Modell
- Batchgröße und Anzahl von Instanzgruppen
Die Datei
original/1/model/config.pbtxt
enthält beispielsweise den folgenden Inhalt:name: "original" platform: "tensorflow_savedmodel" max_batch_size: 64 input { name: "input" data_type: TYPE_FP32 format: FORMAT_NHWC dims: [ 224, 224, 3 ] } output { name: "probabilities" data_type: TYPE_FP32 dims: 1000 label_filename: "imagenet1k_labels.txt" } default_model_filename: "model" instance_group [ { count: 1 kind: KIND_GPU } ] dynamic_batching { preferred_batch_size: [ 64 ] max_queue_delay_microseconds: 20000 }
Weitere Informationen zur Batchgröße und zur Anzahl der Instanzgruppen finden Sie unter Leistungsoptimierung.
In der folgenden Tabelle sind die fünf Modelle aufgeführt, die Sie in diesem Abschnitt bereitgestellt haben.
Modellname | Optimierung |
---|---|
original |
Ursprüngliches Modell (keine Optimierung mit TF-TRT) |
tftrt_fp32 |
Grafikoptimierung (Batch-Größe=64, Instanzgruppen=1) |
tftrt_fp16 |
Konvertierung in FP16 zusätzlich zur Grafikoptimierung (Batch-Größe=64, Instanzgruppen=1) |
tftrt_int8 |
Quantisieren mit INT8 zusätzlich zur Grafikoptimierung (Batch-Größe=64, Instanzgruppen=1) |
tftrt_int8_bs16_count4 |
Quantisieren mit INT8 zusätzlich zur Grafikoptimierung (Batch-Größenbereich, Instanzgruppen=4) |
Inferenzserver mithilfe von Triton bereitstellen
Installieren und konfigurieren Sie im SSH-Terminal das Authentifizierungspaket, um GKE-Cluster zu verwalten:
export USE_GKE_GCLOUD_AUTH_PLUGIN=True sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin
Erstellen Sie einen GKE-Cluster und einen GPU-Knotenpool mit Compute-Knoten, die eine NVIDIA T4-GPU verwenden:
gcloud auth login gcloud config set compute/zone us-west1-b gcloud container clusters create tensorrt-cluster \ --num-nodes=20 gcloud container node-pools create t4-gpu-pool \ --num-nodes=1 \ --machine-type=n1-standard-8 \ --cluster=tensorrt-cluster \ --accelerator type=nvidia-tesla-t4,count=1
Das Flag
--num-nodes
gibt 20 Instanzen für den GKE-Cluster und eine Instanz für den GPU-Knotenpoolt4-gpu-pool
an.Der GPU-Knotenpool besteht aus einer einzelnen
n1-standard-8
-Instanz mit einer NVIDIA T4-GPU. Die Anzahl der GPU-Instanzen sollte gleich oder größer sein als die Anzahl der Inferenz-Server-Pods, da die NVIDIA T4 GPU nicht von mehreren Pods in derselben Instanz gemeinsam genutzt werden kann.Rufen Sie die Clusterinformationen auf:
gcloud container clusters list
Die Ausgabe sieht etwa so aus:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS tensorrt-cluster us-west1-b 1.14.10-gke.17 XX.XX.XX.XX n1-standard-1 1.14.10-gke.17 21 RUNNING
Zeigen Sie die Knotenpoolinformationen an:
gcloud container node-pools list --cluster tensorrt-cluster
Die Ausgabe sieht etwa so aus:
NAME MACHINE_TYPE DISK_SIZE_GB NODE_VERSION default-pool n1-standard-1 100 1.14.10-gke.17 t4-pool n1-standard-8 100 1.14.10-gke.17
Aktivieren Sie die Arbeitslast
daemonSet
:gcloud container clusters get-credentials tensorrt-cluster kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Mit diesem Befehl wird der NVIDIA GPU-Treiber auf den Knoten im GPU-Knotenpool geladen. Der Treiber wird auch automatisch geladen, wenn Sie dem GPU-Knotenpool einen neuen Knoten hinzufügen.
Inferenzserver im Cluster bereitstellen:
sed -i.bak "s/YOUR-BUCKET-NAME/${PROJECT_ID}-models/" trtis_deploy.yaml kubectl create -f trtis_service.yaml kubectl create -f trtis_deploy.yaml
Warten Sie einige Minuten, bis die Dienste verfügbar sind.
Rufen Sie die
clusterIP
-Adresse von Triton ab und speichern Sie sie in einer Umgebungsvariablen:export TRITON_IP=$(kubectl get svc inference-server \ -o "jsonpath={.spec['clusterIP']}") echo ${TRITON_IP}
An diesem Punkt liefert der Inferenzserver vier ResNet-50-Modelle, die Sie im Abschnitt Modelldateien mit unterschiedlichen Optimierungen erstellen erstellt haben. Clients können das Modell angeben, das beim Senden von Inferenzanfragen verwendet werden soll.
Monitoring-Server mit Prometheus und Grafana bereitstellen
Stellen Sie im SSH-Terminal Prometheus-Server auf dem Cluster bereit:
sed -i.bak "s/CLUSTER-IP/${TRITON_IP}/" prometheus-configmap.yml kubectl create namespace monitoring kubectl apply -f prometheus-service.yml -n monitoring kubectl create -f clusterRole.yml kubectl create -f prometheus-configmap.yml -n monitoring kubectl create -f prometheus-deployment.yml -n monitoring
Rufen Sie die Endpunkt-URL des Prometheus-Dienstes ab.
ip_port=$(kubectl get svc prometheus-service \ -o "jsonpath={.spec['clusterIP']}:{.spec['ports'][0]['port']}" -n monitoring) echo "http://${ip_port}"
Notieren Sie sich die Prometheus-Endpunkt-URL, da Sie sie später zum Konfigurieren von Grafana verwenden.
Stellen Sie Grafana-Server im Cluster bereit:
kubectl create -f grafana-service.yml -n monitoring kubectl create -f grafana-deployment.yml -n monitoring
Warten Sie einige Minuten, bis alle Dienste verfügbar sind.
Rufen Sie die Endpunkt-URL des Grafana-Dienstes ab.
ip_port=$(kubectl get svc grafana-service \ -o "jsonpath={.status['loadBalancer']['ingress'][0]['ip']}:{.spec['ports'][0]['port']}" -n monitoring) echo "http://${ip_port}"
Notieren Sie sich die Grafana-Endpunkt-URL, die im nächsten Schritt verwendet werden soll.
Rufen Sie in einem Webbrowser die Grafana-URL auf, die Sie im vorherigen Schritt notiert haben.
Melden Sie sich mit der Standard-Nutzer-ID und dem Standard-Passwort (
admin
undadmin
) an. Ändern Sie bei entsprechender Aufforderung das Standardpasswort.Klicken Sie auf Erste Datenquelle hinzufügen und wählen Sie in der Liste Zeitachsendatenbanken die Option Prometheus aus.
Geben Sie auf dem Tab Einstellungen im Feld URL die Prometheus-Endpunkt-URL ein, die Sie zuvor notiert haben.
Klicken Sie auf Speichern und Testen und kehren Sie dann zum Startbildschirm zurück.
Fügen Sie einen Monitoring-Messwert für
nv_gpu_utilization
hinzu:- Klicken Sie auf Erstes Dashboard erstellen und dann auf Visualisierung hinzufügen.
- Wählen Sie in der Liste Datenquelle die Option Prometheus aus.
Geben Sie im Tab Abfrage im Feld Messwert den Wert
nv_gpu_utilization
ein.Geben Sie im Abschnitt Feldoptionen im Feld Titel
GPU Utilization
ein und klicken Sie dann auf Übernehmen.Auf der Seite wird ein Feld für die GPU-Nutzung angezeigt.
Fügen Sie einen Monitoring-Messwert für
nv_gpu_memory_used_bytes
hinzu:- Klicken Sie auf Hinzufügen und wählen Sie Visualisierung aus.
Geben Sie im Tab Abfrage im Feld Messwert den Wert
nv_gpu_memory_used_bytes
ein.Geben Sie im Abschnitt Feldoptionen im Feld Titel
GPU Memory Used
ein und klicken Sie dann auf Speichern.
Klicken Sie zum Hinzufügen des Dashboards im Bereich Dashboard speichern auf Speichern.
Sie sehen die Grafiken für die GPU-Nutzung und den verwendeten GPU-Arbeitsspeicher.
Belastungstest-Tool bereitstellen
In diesem Abschnitt stellen Sie das Locust-Belastungstest-Tool in GKE bereit und generieren Arbeitslasten, um die Leistung der Inferenzserver zu messen.
Erstellen Sie im SSH-Terminal ein Docker-Image, das die Triton-Clientbibliotheken enthält, und laden Sie es in Container Registry hoch:
cd ../client git clone https://github.com/triton-inference-server/server cd server git checkout r19.05 sed -i.bak "s/bootstrap.pypa.io\/get-pip.py/bootstrap.pypa.io\/pip\/2.7\/get-pip.py/" Dockerfile.client docker build -t tritonserver_client -f Dockerfile.client . gcloud auth configure-docker docker tag tritonserver_client \ gcr.io/${PROJECT_ID}/tritonserver_client docker push gcr.io/${PROJECT_ID}/tritonserver_client
Der Build-Prozess kann etwa 5 Minuten dauern. Wenn der Vorgang abgeschlossen ist, wird im SSH-Terminal eine Eingabeaufforderung angezeigt.
Erstellen Sie nach Abschluss des Build-Prozesses ein Docker-Image, um Testarbeitslasten zu generieren, und laden Sie es in Container Registry hoch:
cd .. sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" Dockerfile docker build -t locust_tester -f Dockerfile . docker tag locust_tester gcr.io/${PROJECT_ID}/locust_tester docker push gcr.io/${PROJECT_ID}/locust_tester
Ändern oder ersetzen Sie
YOUR-PROJECT-ID
in den Befehlen nicht.Dieses Image wird aus dem Image erstellt, das Sie im vorherigen Schritt erstellt haben.
Stellen Sie die Locust-Dateien
service_master.yaml
unddeployment_master.yaml
bereit:sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_master.yaml sed -i.bak "s/CLUSTER-IP-TRTIS/${TRITON_IP}/" deployment_master.yaml kubectl create namespace locust kubectl create configmap locust-config --from-literal model=original --from-literal saddr=${TRITON_IP} --from-literal rps=10 -n locust kubectl apply -f service_master.yaml -n locust kubectl apply -f deployment_master.yaml -n locust
Die Ressource
configmap
wird verwendet, um das ML-Modell anzugeben, an das Clients Anfragen zur Inferenz senden.Warten Sie einige Minuten, bis die Dienste verfügbar sind.
Rufen Sie die
clusterIP
-Adresse deslocust-master
-Clients ab und speichern Sie diese Adresse in einer Umgebungsvariablen:export LOCUST_MASTER_IP=$(kubectl get svc locust-master -n locust \ -o "jsonpath={.spec['clusterIP']}") echo ${LOCUST_MASTER_IP}
Stellen Sie den Locust-Client bereit:
sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_slave.yaml sed -i.bak "s/CLUSTER-IP-LOCUST-MASTER/${LOCUST_MASTER_IP}/" deployment_slave.yaml kubectl apply -f deployment_slave.yaml -n locust
Mit diesen Befehlen werden zehn Locust-Client-Pods bereitgestellt, mit denen Sie Testarbeitslasten generieren können. Wenn Sie mit der aktuellen Anzahl von Clients nicht genügend Anfragen generieren können, können Sie die Anzahl der Pods mit dem folgenden Befehl ändern:
kubectl scale deployment/locust-slave --replicas=20 -n locust
Wenn in einem Standardcluster nicht genügend Kapazität vorhanden ist, um die Anzahl der Replikate zu erhöhen, empfehlen wir, die Anzahl der Knoten im GKE-Cluster zu erhöhen.
Kopieren Sie die URL der Locust-Konsole und öffnen Sie diese URL in einem Webbrowser:
export LOCUST_IP=$(kubectl get svc locust-master -n locust \ -o "jsonpath={.status.loadBalancer.ingress[0].ip}") echo "http://${LOCUST_IP}:8089"
Die Locust-Konsole wird geöffnet und Sie können Testarbeitslasten daraus erstellen.
Ausgeführte Pods prüfen
Um sicherzustellen, dass die Komponenten erfolgreich bereitgestellt werden, prüfen Sie, ob die Pods ausgeführt werden.
Prüfen Sie im SSH-Terminal den Inferenzserver-Pod:
kubectl get pods
Die Ausgabe sieht in etwa so aus:
NAME READY STATUS RESTARTS AGE inference-server-67786cddb4-qrw6r 1/1 Running 0 83m
Wenn Sie nicht die erwartete Ausgabe erhalten, prüfen Sie, ob Sie die Schritte unter Inferenzserver mithilfe von Triton bereitstellen ausgeführt haben.
Prüfen Sie die Locust-Pods:
kubectl get pods -n locust
Die Ausgabe sieht in etwa so aus:
NAME READY STATUS RESTARTS AGE locust-master-75f6f6d4bc-ttllr 1/1 Running 0 10m locust-slave-76ddb664d9-8275p 1/1 Running 0 2m36s locust-slave-76ddb664d9-f45ww 1/1 Running 0 2m36s locust-slave-76ddb664d9-q95z9 1/1 Running 0 2m36s
Wenn Sie nicht die erwartete Ausgabe erhalten, prüfen Sie, ob Sie die Schritte unter Belastungstest-Tool bereitstellen ausgeführt haben.
Prüfen Sie die Monitoring-Pods:
kubectl get pods -n monitoring
Die Ausgabe sieht in etwa so aus:
NAME READY STATUS RESTARTS AGE grafana-deployment-644bbcb84-k6t7v 1/1 Running 0 79m prometheus-deployment-544b9b9f98-hl7q8 1/1 Running 0 81m
Wenn Sie nicht die erwartete Ausgabe erhalten, prüfen Sie, ob Sie die Schritte unter Monitoring-Server mit Prometheus und Grafana bereitstellen ausgeführt haben.
Im nächsten Teil dieser Reihe nutzen Sie dieses Inferenzserversystem, um zu lernen, wie verschiedene Optimierungen die Leistung verbessern und diese Optimierungen zu interpretieren sind. Weitere Informationen finden Sie unter Leistung eines TensorFlow-Inferenzsystems messen und optimieren.
Nächste Schritte
- Mehr über Google Kubernetes Engine (GKE) erfahren.
- Mehr über Cloud Load Balancing erfahren.
- Weitere Referenzarchitekturen, Diagramme und Best Practices finden Sie im Cloud-Architekturcenter.