TensorFlow-Inferenzarbeitslasten mit TensorRT5 und NVIDIA T4-GPU ausführen

In dieser Anleitung wird beschrieben, wie Sie mit NVIDIA TensorRT5-GPUs in Google Compute Engine Deep-Learning-Inferenzen für umfangreiche Arbeitslasten ausführen.

Einige Grundlagen vorab:

  • Die Deep-Learning-Inferenz ist die Phase im maschinellen Lernprozess, in der ein trainiertes Modell zur Erkennung, Verarbeitung und Klassifizierung von Ergebnissen verwendet wird.
  • NVIDIA TensorRT ist eine für die Ausführung von Deep-Learning-Arbeitslasten optimierte Plattform.
  • GPUs dienen zum Beschleunigen datenintensiver Arbeitslasten wie maschinelles Lernen und Datenverarbeitung. In Compute Engine sind verschiedene NVIDIA-GPUs verfügbar. In dieser Anleitung werden T4-GPUs verwendet, da diese speziell für Arbeitslasten mit Deep-Learning-Inferenzen konzipiert wurden.

Zielsetzungen

In dieser Anleitung werden die folgenden Verfahren behandelt:

  • Vorbereiten eines Modells mit einer vorab trainierten Grafik
  • Testen der Inferenzgeschwindigkeit für ein Modell mit unterschiedlichen Optimierungsmodi
  • Konvertieren eines benutzerdefinierten Modells nach TensorRT
  • Einrichten eines Clusters mit mehreren Zonen. Dieser Mehrzonencluster ist so konfiguriert:
    • Grundlage sind Google Deep Learning-VM-Images. Auf diesen Images sind TensorFlow, TensorFlow Serving und TensorRT5 vorinstalliert.
    • Autoscaling ist aktiviert. Das Autoscaling in dieser Anleitung basiert auf der GPU-Nutzung.
    • Load-Balancing ist aktiviert.
    • Firewall ist aktiviert.
  • Ausführen einer Inferenzarbeitslast im Mehrzonencluster

Überblick über die Architektur für die Anleitung

Kosten

Die Kosten für die Ausführung dieser Anleitung variieren je nach Abschnitt.

Der geschätzte Preis für das Vorbereiten des Modells und das Testen der Inferenzgeschwindigkeiten bei verschiedenen Optimierungsgeschwindigkeiten liegt bei etwa 22,34 $ pro Tag. Diese Kostenschätzung basiert auf den folgenden Spezifikationen:

  • 1 VM-Instanz: n1-standard-8 (8 vCPUs, 30 GB RAM)
  • 1 NVIDIA Tesla T4-GPU

Der geschätzte Preis für die Einrichtung des Mehrzonenclusters liegt bei ungefähr 154,38 $ pro Tag. Diese Kostenschätzung basiert auf den folgenden Spezifikationen:

  • 2 VM-Instanzen: n1-standard-16 (16 vCPUs, 60 GB RAM)
  • 4 NVIDIA Tesla T4-GPUs für jede VM-Instanz
  • 100 GB SSD für jede VM-Instanz
  • 1 Weiterleitungsregel

Diese Kosten wurden mithilfe des Preisrechners geschätzt.

Vorbereitung

Projekt einrichten

  1. Melden Sie sich in Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, registrieren Sie sich hier für ein neues Konto.

  2. Wählen Sie ein Google Cloud Platform-Projekt aus oder erstellen Sie eines.

    Zur Seite "Ressourcen verwalten"

  3. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Platform-Projekt aktiviert ist.

    Informationen zum Aktivieren der Abrechnung

  4. Aktivieren Sie die Compute Engine und Cloud Machine Learning erforderlichen APIs.

    Aktivieren Sie die APIs.

Tools einrichten

Sie verwenden die gcloud-Befehlszeile in dieser Anleitung:

  1. Installieren Sie das gcloud-Befehlszeilentool oder aktualisieren Sie es auf die neueste Version.
  2. (Optional) Legen Sie eine Standardregion und -zone fest.

Modell vorbereiten

In diesem Abschnitt wird das Erstellen einer VM-Instanz beschrieben, die zum Ausführen des Modells verwendet wird. In diesem Abschnitt wird auch beschrieben, wie Sie ein Modell aus dem offiziellen Tensorflow-Modellkatalog herunterladen.

  1. Erstellen Sie die VM-Instanz:

    export IMAGE_FAMILY="tf-1-12-cu100"
    export ZONE="us-central1-b"
    export INSTANCE_NAME="model-prep"
    gcloud compute instances create $INSTANCE_NAME \
        --zone=$ZONE \
        --image-family=$IMAGE_FAMILY \
        --machine-type=n1-standard-8 \
        --image-project=deeplearning-platform-release \
        --maintenance-policy=TERMINATE \
        --accelerator="type=nvidia-tesla-t4,count=1" \
        --metadata="install-nvidia-driver=True"
    
  2. Wählen Sie ein Modell aus. In dieser Anleitung kommt das ResNet-Modell zum Einsatz. Dieses ResNet-Modell wurde mit dem ImageNet-Dataset in TensorFlow trainiert.

    Führen Sie den folgenden Befehl aus, um das ResNet-Modell in die VM-Instanz herunterzuladen:

    wget -q http://download.tensorflow.org/models/official/resnetv2_imagenet_frozen_graph.pb
    

    Halten Sie den Speicherort des ResNet-Modells in der Variablen $WORKDIR fest.

    export WORKDIR=[MODEL_LOCATION]
    

Inferenzgeschwindigkeitstest ausführen

Dieser Abschnitt behandelt die folgenden Verfahren:

  • Einrichten des ResNet-Modells
  • Ausführen von Inferenztests mit verschiedenen Optimierungsmodi
  • Überprüfen der Ergebnisse der Inferenztests

Der Testvorgang im Überblick

TensorRT kann zwar die Geschwindigkeit von Inferenzarbeitslasten erhöhen, die bedeutendste Verbesserung folgt jedoch aus dem Quantisierungsprozess.

Die Modellquantisierung ist der Prozess, durch den Sie die Genauigkeit der Gewichtung für ein Modell reduzieren. Wenn zum Beispiel die Anfangsgewichtung eines Modells FP32 ist, können Sie die Genauigkeit auf FP16, INT8 oder sogar INT4 reduzieren. Es ist wichtig, den richtigen Kompromiss zwischen Geschwindigkeit (Genauigkeit der Gewichtungen) und Genauigkeit eines Modells zu finden. Zum Glück bietet TensorFlow eine Funktion, die genau dies tut. Sie misst die Genauigkeit und stellt sie der Geschwindigkeit oder anderen Messwerten wie Durchsatz, Latenz, Knotenkonvertierungsrate und Gesamttrainingszeit gegenüber.

Vorgehensweise

  1. Richten Sie das ResNet-Modell ein. Führen Sie die folgenden Befehle aus, um das Modell einzurichten:

    git clone https://github.com/tensorflow/models.git
    cd models
    git checkout f0e10716160cd048618ccdd4b6e18336223a172f
    touch research/__init__.py
    touch research/tensorrt/__init__.py
    cp research/tensorrt/labellist.json .
    cp research/tensorrt/image.jpg ..
    
  2. Führen Sie den Test aus. Die Ausführung dieses Befehls dauert einige Zeit.

    python -m research.tensorrt.tensorrt \
        --frozen_graph=$WORKDIR/resnetv2_imagenet_frozen_graph.pb \
        --image_file=$WORKDIR/image.jpg \
        --native --fp32 --fp16 --int8 \
        --output_dir=$WORKDIR
    

    Dabei gilt:

    • $WORKDIR ist das Verzeichnis, in das Sie das ResNet-Modell heruntergeladen haben.
    • Die --native-Argumente sind die verschiedenen zu testenden Quantisierungsmodi.
  3. Überprüfen Sie die Ergebnisse. Nach Abschluss des Tests können Sie die Inferenzergebnisse für jeden Optimierungsmodus vergleichen.

    Predictions:
    Precision:  native [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty',     u'lakeside, lakeshore', u'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus']
    Precision:  FP32 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'lakeside,   lakeshore', u'sandbar, sand bar']
    Precision:  FP16 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'lakeside,   lakeshore', u'sandbar, sand bar']
    Precision:  INT8 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'grey         whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus', u'lakeside, lakeshore']
    

    Führen Sie den folgenden Befehl aus, um die vollständigen Ergebnisse zu sehen:

    cat $WORKDIR/log.txt
    

    Screenshot der Leistungsergebnisse

    Wie Sie sehen, sind die Ergebnisse für FP32 und FP16 identisch. Wenn Sie also mit TensorRT arbeiten möchten, können Sie auf jeden Fall sofort mit FP16 beginnen. INT8 liefert etwas schlechtere Ergebnisse.

    Außerdem sehen Sie, dass die Ausführung des Modells mit TensorRT5 die folgenden Ergebnisse liefert:

    • Durch die FP32-Optimierung wird der Durchsatz von 314 fps um 40 % auf 440 fps verbessert. Gleichzeitig nimmt die Latenz um etwa 30 % ab und beträgt 0,28 ms statt 0,40 ms.
    • Durch die FP16-Optimierung anstelle der nativen TensorFlow-Grafik wird die Geschwindigkeit von 314 fps um 214 % auf 988 fps erhöht. Gleichzeitig nimmt die Latenz um 0,12 ms ab und beträgt im Vergleich ca. nur ein Drittel.
    • Mit INT8 können Sie eine Beschleunigung von 385 % von 314 fps auf 1.524 fps beobachten, wobei die Latenz auf 0,08 ms sinkt.

Benutzerdefiniertes Modell nach TensorRT konvertieren

Für diese Konvertierung können Sie ein INT8-Modell verwenden.

  1. Laden Sie das Modell herunter. Zum Konvertieren eines benutzerdefinierten Modells in eine TensorRT-Grafik benötigen Sie ein gespeichertes Modell. Führen Sie den folgenden Befehl aus, um ein gespeichertes INT8-ResNet-Modell abzurufen:

    wget http://download.tensorflow.org/models/official/20181001_resnet/savedmodels/resnet_v2_fp32_savedmodel_NCHW.tar.gz
    tar -xzvf resnet_v2_fp32_savedmodel_NCHW.tar.gz
    
  2. Konvertieren Sie das Modell mithilfe von TFTools in die TensorRT-Grafik. Führen Sie den folgenden Befehl aus, um das Modell mithilfe von TFTools zu konvertieren:

    git clone https://github.com/GoogleCloudPlatform/ml-on-gcp.git
    cd ml-on-gcp/dlvm/tools
    python ./convert_to_rt.py \
        --input_model_dir=$WORKDIR/resnet_v2_fp32_savedmodel_NCHW/1538687196 \
        --output_model_dir=$WORKDIR/resnet_v2_int8_NCHW/00001 \
        --batch_size=128 \
        --precision_mode="INT8"
    

    Sie haben jetzt ein INT8-Modell im Verzeichnis $WORKDIR/resnet_v2_int8_NCHW/00001.

    Versuchen Sie, einen Inferenztest auszuführen, um zu bestätigen, dass alles ordnungsgemäß eingerichtet ist.

    tensorflow_model_server --model_base_path=$WORKDIR/resnet_v2_int8_NCHW/ --rest_api_port=8888
    
  3. Laden Sie das Modell in Google Cloud Storage hoch. Dieser Schritt ist erforderlich, damit das Modell von dem Mehrzonencluster verwendet werden kann, der im nächsten Abschnitt eingerichtet wird. Führen Sie die folgenden Schritte aus, um das Modell hochzuladen:

    1. Archivieren Sie das Modell.

      tar -zcvf model.tar.gz ./resnet_v2_int8_NCHW/
      
    2. Laden Sie das Archiv hoch.

      export GCS_PATH=<gcs_path>
      gsutil cp model.tar.gz $GCS_PATH
      

      Bei Bedarf erhalten Sie über folgende URL eine eingefrorene INT8-Grafik aus Google Cloud Storage:

      gs://cloud-samples-data/dlvm/t4/model.tar.gz
      

Mehrzonencluster einrichten

Cluster erstellen

Da Sie nun ein Modell auf der Google Cloud Storage-Plattform gespeichert haben, können Sie einen Cluster erstellen.

  1. Erstellen Sie eine Instanzvorlage. Eine Instanzvorlage ist eine nützliche Ressource zum Erstellen neuer Instanzen. Siehe Instanzvorlagen.

    export INSTANCE_TEMPLATE_NAME="tf-inference-template"
    export IMAGE_FAMILY="tf-1-12-cu100"
    export PROJECT_NAME="your_project_name"
    
    gcloud beta compute --project=$PROJECT_NAME instance-templates create $INSTANCE_TEMPLATE_NAME \
         --machine-type=n1-standard-16 \
         --maintenance-policy=TERMINATE \
         --accelerator=type=nvidia-tesla-t4,count=4 \
         --min-cpu-platform=Intel\ Skylake \
         --tags=http-server,https-server \
         --image-family=$IMAGE_FAMILY \
         --image-project=deeplearning-platform-release \
         --boot-disk-size=100GB \
         --boot-disk-type=pd-ssd \
         --boot-disk-device-name=$INSTANCE_TEMPLATE_NAME \
         --metadata startup-script-url=gs://cloud-samples-data/dlvm/t4/start_agent_and_inf_server_4.sh
    
    • Diese Instanzvorlage enthält ein Startskript, das durch den Metadatenparameter angegeben wird.
      • Dieses Startskript wird während der Instanzerstellung in jeder Instanz ausgeführt, die diese Vorlage verwendet.
      • Dieses Startskript führt die folgenden Schritte aus:
        • Monitoring-Agent herunterladen, der die GPU-Auslastung in der Instanz überwacht
        • Modell herunterladen
        • Inferenzdienst starten
      • Im Startskript enthält tf_serve.py die Inferenzlogik. Für dieses Beispiel haben wir eine sehr kleine Python-Datei auf Basis des TFServe-Pakets erstellt.
      • Sie können sich das Startskript unter startup_inf_script.sh ansehen.
  2. Erstellen Sie eine verwaltete Instanzgruppe. Diese verwaltete Instanzgruppe wird benötigt, um mehrere ausgeführte Instanzen in bestimmten Zonen einzurichten. Die Instanzen werden auf der Grundlage der im vorherigen Schritt erstellten Instanzvorlage erstellt.

    export INSTANCE_GROUP_NAME="deeplearning-instance-group"
    export INSTANCE_TEMPLATE_NAME="tf-inference-template"
    gcloud compute instance-groups managed create $INSTANCE_GROUP_NAME \
        --template $INSTANCE_TEMPLATE_NAME \
        --base-instance-name deeplearning-instances \
        --size 2 \
        --zones us-central1-a,us-central1-b
    
    • Sie können diese Instanz in jeder verfügbaren Zone erstellen, die T4-GPUs unterstützt. Sie müssen nur über GPU-Kontingente in der Zone verfügen.
    • Das Erstellen der Instanz dauert einige Zeit. Führen Sie den folgenden Befehl aus, um den Fortschritt zu beobachten:

      export INSTANCE_GROUP_NAME="deeplearning-instance-group"
      
      gcloud compute instance-groups managed list-instances $INSTANCE_GROUP_NAME --region us-central1
      

      Screenshot der Instanzerstellung

    • Nachdem die verwaltete Instanzgruppe erstellt worden ist, sollten Sie eine Ausgabe wie diese sehen:

      Screenshot der ausgeführten Instanz

  3. Prüfen Sie, ob die Messwerte auf der Google Cloud Platform auf der Seite "Stackdriver" verfügbar sind.

    1. Rufen Sie die Seite "Stackdriver" auf.
    2. Suchen Sie gpu_utilization.

      Screenshot der Initiierung von Stackdriver

    3. Wenn Daten eingehen, sollten Sie etwa Folgendes sehen:

      Screenshot von laufendem Stackdriver

Autoscaling aktivieren

  1. Aktivieren Sie das Autoscaling für die verwaltete Instanzgruppe.

    export INSTANCE_GROUP_NAME="deeplearning-instance-group"
    
    gcloud compute instance-groups managed set-autoscaling $INSTANCE_GROUP_NAME \
        --custom-metric-utilization metric=custom.googleapis.com/gpu_utilization,utilization-target-type=GAUGE,utilization-target=85 \
        --max-num-replicas 4 \
        --cool-down-period 360 \
        --region us-central1
    

    custom.googleapis.com/gpu_utilization ist der vollständige Pfad zu unserem Messwert. Im Beispiel ist eine Auslastung von 85 angegeben. Das bedeutet, dass die Plattform immer dann eine neue Instanz in der Gruppe erzeugt, wenn die GPU-Auslastung 85 % erreicht.

  2. Testen Sie das Autoscaling. Führen Sie die folgenden Schritte aus, um das Autoscaling zu testen:

    1. Stellen Sie eine SSH-Verbindung zur Instanz her. Siehe Verbindung mit einer Instanz herstellen.
    2. Erzeugen Sie mit dem gpu-burn-Tool 600 Sekunden lang eine GPU-Auslastung von 100 %:

      git clone https://github.com/GoogleCloudPlatform/ml-on-gcp.git
      cd ml-on-gcp/third_party/gpu-burn
      git checkout c0b072aa09c360c17a065368294159a6cef59ddf
      make
      ./gpu_burn 600 > /dev/null &
      
    3. Rufen Sie die Seite "Stackdriver" auf. Beobachten Sie das Autoscaling. Der Cluster wird durch Hinzufügen einer weiteren Instanz vergrößert.

      Screenshot des Autoscalings

    4. Gehen Sie in der GCP Console zur Seite "Instanzgruppen".

      Zur Seite "Instanzgruppen"

    5. Klicken Sie auf die verwaltete Instanzgruppe deeplearning-instance-group.

    6. Klicken Sie auf den Tab "Monitoring".

      Screenshot des Tabs "Monitoring"

      Jetzt sollte Ihre Autoscaling-Logik erfolglos versuchen, so viele Instanzen wie möglich einzurichten, um die Last zu reduzieren.

      Und genau das passiert:

      Screenshot mit zusätzlichen Instanzen

      Nun können Sie das Einrichten von Instanzen anhalten und beobachten, wie das System verkleinert wird.

Load-Balancer einrichten

Sehen wir uns nun an, was bereits vorhanden ist:

  • Ein trainiertes, mit TensorRT5 (INT8) optimiertes Modell
  • Eine verwaltete Instanzgruppe. Für diese Instanzen ist das Autoscaling basierend auf der GPU-Auslastung aktiviert

Jetzt können Sie vor den Instanzen einen Load-Balancer erstellen.

  1. Erstellen Sie Systemdiagnosen. Anhand der Systemdiagnosen lässt sich feststellen, ob ein bestimmter Host im Back-End den Traffic bereitstellen kann.

    export HEALTH_CHECK_NAME="http-basic-check"
    
    gcloud compute health-checks create http $HEALTH_CHECK_NAME \
        --request-path /v1/models/default \
        --port 8888
    
  2. Erstellen Sie einen Back-End-Dienst, der eine Instanzgruppe und eine Systemdiagnose enthält.

    1. Erstellen Sie die Systemdiagnose.

      export HEALTH_CHECK_NAME="http-basic-check"
      export WEB_BACKED_SERVICE_NAME="tensorflow-backend"
      
      gcloud compute backend-services create $WEB_BACKED_SERVICE_NAME \
          --protocol HTTP \
          --health-checks $HEALTH_CHECK_NAME \
          --global
      
    2. Erweitern Sie den neuen Back-End-Dienst um die Instanzgruppe.

      export INSTANCE_GROUP_NAME="deeplearning-instance-group"
      export WEB_BACKED_SERVICE_NAME="tensorflow-backend"
      
      gcloud compute backend-services add-backend $WEB_BACKED_SERVICE_NAME \
          --balancing-mode UTILIZATION \
          --max-utilization 0.8 \
          --capacity-scaler 1 \
          --instance-group $INSTANCE_GROUP_NAME \
          --instance-group-region us-central1 \
          --global
      
  3. Richten Sie die Weiterleitungs-URL ein. Der Load-Balancer muss wissen, welche URL an die Back-End-Dienste weitergeleitet werden kann.

    export WEB_BACKED_SERVICE_NAME="tensorflow-backend"
    export WEB_MAP_NAME="map-all"
    
    gcloud compute url-maps create $WEB_MAP_NAME \
        --default-service $WEB_BACKED_SERVICE_NAME
    
  4. Erstellen Sie den Load-Balancer.

    export WEB_MAP_NAME="map-all"
    export LB_NAME="tf-lb"
    
    gcloud compute target-http-proxies create $LB_NAME \
        --url-map $WEB_MAP_NAME
    
  5. Weisen Sie dem Load-Balancer eine externe IP-Adresse zu.

    export IP4_NAME="lb-ip4"
    
    gcloud compute addresses create $IP4_NAME \
        --ip-version=IPV4 \
        --global
    
  6. Suchen Sie die zugewiesene IP-Adresse.

    gcloud compute addresses list
    
  7. Richten Sie die Weiterleitungsregel ein, die GCP anweist, alle Anfragen von der öffentlichen IP-Adresse an den Load-Balancer weiterzuleiten.

    export IP=$(gcloud compute addresses list | grep ${IP4_NAME} | awk '{print $2}')
    export LB_NAME="tf-lb"
    export FORWARDING_RULE="lb-fwd-rule"
    
    gcloud compute forwarding-rules create $FORWARDING_RULE \
        --address $IP \
        --global \
        --target-http-proxy $LB_NAME \
        --ports 80
    

    Nachdem die globalen Weiterleitungsregeln erstellt wurden, kann es mehrere Minuten dauern, bis die Konfiguration aktiv ist.

Firewall aktivieren

  1. Überprüfen Sie, ob Firewallregeln vorhanden sind, die Verbindungen von externen Quellen zu Ihren VM-Instanzen zulassen.

    gcloud compute firewall-rules list
    
  2. Wenn Sie keine Firewallregeln haben, die diese Verbindungen zulassen, müssen Sie diese erstellen. Führen Sie die folgenden Befehle aus, um Firewallregeln zu erstellen:

    gcloud compute firewall-rules create www-firewall-80 \
        --target-tags http-server --allow tcp:80
    
    gcloud compute firewall-rules create www-firewall-8888 \
        --target-tags http-server --allow tcp:8888
    

Inferenz ausführen

  1. Mit dem folgenden Python-Skript können Sie Bilder in ein Format konvertieren, das auf den Server hochgeladen werden kann.

    from PIL import Image
    import numpy as np
    import json
    import codecs
    <br>
    img = Image.open("image.jpg").resize((240, 240))
    img_array=np.array(img)
    result = {
           "instances":[img_array.tolist()]
            }
    file_path="/tmp/out.json"
    print(json.dump(result, codecs.open(file_path, 'w', encoding='utf-8'), separators=(',', ':'), sort_keys=True, indent=4))
    
  2. Führen Sie die Inferenz aus.

    curl -X POST $IP/v1/models/default:predict -d @/tmp/out.json
    

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud Platform-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

  1. Löschen Sie die Weiterleitungsregeln.

    gcloud compute forwarding-rules delete $FORWARDING_RULE --global
    
  2. Löschen Sie die IPV4-Adresse.

    gcloud compute addresses delete $IP4_NAME --global
    
  3. Löschen Sie den Load-Balancer.

    gcloud compute target-http-proxies delete $LB_NAME
    
  4. Löschen Sie die Weiterleitungs-URL.

    gcloud compute url-maps delete $WEB_MAP_NAME
    
  5. Löschen Sie den Back-End-Dienst.

    gcloud compute backend-services delete $WEB_BACKED_SERVICE_NAME --global
    
  6. Löschen Sie die Systemdiagnosen.

    gcloud compute health-checks delete $HEALTH_CHECK_NAME
    
  7. Löschen Sie die verwaltete Instanzgruppe.

    gcloud compute instance-groups managed delete $INSTANCE_GROUP_NAME --region us-central1
    
  8. Löschen Sie die Instanzvorlage.

    gcloud beta compute --project=$PROJECT_NAME instance-templates delete $INSTANCE_TEMPLATE_NAME
    
  9. Löschen Sie die Firewallregeln.

    gcloud compute firewall-rules delete www-firewall-80
    gcloud compute firewall-rules delete www-firewall-8888
    
Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...

Compute Engine-Dokumentation