Skalierbares TensorFlow-Inferenzsystem bereitstellen

Last reviewed 2023-11-02 UTC

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.

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.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the GKE API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the GKE API.

Enable the 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.

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.

Zu Seite „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ür tft-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-Knotenpool t4-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 und admin) 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:
1. Klicken Sie auf Erstes Dashboard erstellen und dann auf Visualisierung hinzufügen.
2. Wählen Sie in der Liste Datenquelle die Option Prometheus aus.
3. Geben Sie im Tab Abfrage im Feld Messwert den Wert nv_gpu_utilization ein.
4. 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:
1. Klicken Sie auf Hinzufügen und wählen Sie Visualisierung aus.
2. Geben Sie im Tab Abfrage im Feld Messwert den Wert nv_gpu_memory_used_bytes ein.
3. 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 und deployment_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 des locust-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.