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

  1. 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.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  4. Enable the GKE API.

    Enable the API

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

    Go to project selector

  6. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

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

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

  2. 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.

  1. 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.

  2. Klicken Sie zum Öffnen der Terminalkonsole der Instanz auf SSH.

    Mit diesem Terminal führen Sie die übrigen Befehle in diesem Dokument aus.

  3. 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
    
  4. 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
    
  5. 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.

  6. Kopieren Sie in der Tabelle in der Zeile für das Repository tft-optimizer die Image-ID.

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

  1. 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
    
  2. 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.

  3. 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
    
  4. 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
    
  5. 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.

  6. 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
    
  7. Warten Sie einige Minuten, bis die Dienste verfügbar sind.

  8. 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

  1. 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
    
  2. 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.

  3. Stellen Sie Grafana-Server im Cluster bereit:

    kubectl create -f grafana-service.yml -n monitoring
    kubectl create -f grafana-deployment.yml -n monitoring
    
  4. Warten Sie einige Minuten, bis alle Dienste verfügbar sind.

  5. 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.

  6. Rufen Sie in einem Webbrowser die Grafana-URL auf, die Sie im vorherigen Schritt notiert haben.

  7. Melden Sie sich mit der Standard-Nutzer-ID und dem Standard-Passwort (admin und admin) an. Ändern Sie bei entsprechender Aufforderung das Standardpasswort.

  8. Klicken Sie auf Erste Datenquelle hinzufügen und wählen Sie in der Liste Zeitachsendatenbanken die Option Prometheus aus.

  9. Geben Sie auf dem Tab Einstellungen im Feld URL die Prometheus-Endpunkt-URL ein, die Sie zuvor notiert haben.

  10. Klicken Sie auf Speichern und Testen und kehren Sie dann zum Startbildschirm zurück.

  11. 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.

  12. 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.

  13. 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.

  1. 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.

  2. 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.

  3. 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.

  4. Warten Sie einige Minuten, bis die Dienste verfügbar sind.

  5. 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}
    
  6. 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.

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

  1. 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.

  2. 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.

  3. 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