Skalierbare LLMs in GKE mit TorchServe bereitstellen

Umgebung vorbereiten

Klonen Sie das Beispiel-Repository und öffnen Sie das Anleitungsverzeichnis:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving

Cluster erstellen

Führen Sie dazu diesen Befehl aus:

gcloud container clusters create-auto ml-cluster \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=CLUSTER_VERSION \
    --location=us-central1

Ersetzen Sie Folgendes:

• RELEASE_CHANNEL: die Release-Version für Ihren Cluster. Muss rapid, regular oder stable sein. Wählen Sie einen Kanal mit der GKE-Version 1.28.3-gke.1203000 oder höher aus, um L4-GPUs zu verwenden. Informationen zu den in einem bestimmten Kanal verfügbaren Versionen finden Sie unter Standard- und verfügbare Versionen für Release-Versionen ansehen.
• CLUSTER_VERSION ist die zu verwendende GKE-Version. Es muss 1.28.3-gke.1203000 oder höher sein.

Dieser Vorgang kann mehrere Minuten dauern.

Artifact Registry-Repository erstellen

1. Erstellen Sie ein neues Artifact Registry-Standard-Repository im Docker-Format in derselben Region wie Ihr Cluster:

   gcloud artifacts repositories create models \
       --repository-format=docker \
       --location=us-central1 \
       --description="Repo for T5 serving image"
   

2. Prüfen Sie den Repository-Namen:

   gcloud artifacts repositories describe models \
       --location=us-central1
   

   Die Ausgabe sieht in etwa so aus:

   Encryption: Google-managed key
   Repository Size: 0.000MB
   createTime: '2023-06-14T15:48:35.267196Z'
   description: Repo for T5 serving image
   format: DOCKER
   mode: STANDARD_REPOSITORY
   name: projects/PROJECT_ID/locations/us-central1/repositories/models
   updateTime: '2023-06-14T15:48:35.267196Z'
   

Modell verpacken

In diesem Abschnitt verpacken Sie das Modell und das Bereitstellungs-Framework mithilfe von Cloud Build in einem einzigen Container-Image und übertragen das resultierende Image per Push in das Artifact Registry-Repository.

1. Prüfen Sie das Dockerfile für das Container-Image:

   # Copyright 2023 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.
   
   ARG BASE_IMAGE=pytorch/torchserve:0.7.1-cpu
   
   FROM alpine/git
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_REPO=https://huggingface.co/${MODEL_NAME}
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   RUN git clone "${MODEL_REPO}" /model
   
   FROM ${BASE_IMAGE}
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_VERSION=1.0
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   COPY --from=0 /model/. /home/model-server/
   COPY handler.py \
        model.py \
        requirements.txt \
        setup_config.json /home/model-server/
   
   RUN  torch-model-archiver \
        --model-name="${MODEL_NAME}" \
        --version="${MODEL_VERSION}" \
        --model-file="model.py" \
        --serialized-file="pytorch_model.bin" \
        --handler="handler.py" \
        --extra-files="config.json,spiece.model,tokenizer.json,setup_config.json" \
        --runtime="python" \
        --export-path="model-store" \
        --requirements-file="requirements.txt"
   
   FROM ${BASE_IMAGE}
   
   ENV PATH /home/model-server/.local/bin:$PATH
   ENV TS_CONFIG_FILE /home/model-server/config.properties
   # CPU inference will throw a warning cuda warning (not error)
   # Could not load dynamic library 'libnvinfer_plugin.so.7'
   # This is expected behaviour. see: https://stackoverflow.com/a/61137388
   ENV TF_CPP_MIN_LOG_LEVEL 2
   
   COPY --from=1 /home/model-server/model-store/ /home/model-server/model-store
   COPY config.properties /home/model-server/
   

   Dieses Dockerfile definiert den folgenden mehrstufigen Build-Prozess:

   1. Laden Sie die Modellartefakte aus dem Hugging Face-Repository herunter.
   2. Verpacken Sie das Modell mit dem Tool PyTorch Serving Archive. Dadurch wird eine Modellarchivdatei (.mar) erstellt, die der Inferenzserver zum Laden des Modells verwendet.
   3. Erstellen Sie das endgültige Image mit PyTorch Serve.

2. Erstellen Sie das Image und übertragen Sie es mit Cloud Build:

   gcloud builds submit model/ \
       --region=us-central1 \
       --config=model/cloudbuild.yaml \
       --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0
   

   Der Build-Prozess dauert einige Minuten. Wenn Sie ein größeres Modell als t5-small verwenden, kann der Build-Prozess deutlich länger dauern.

3. Prüfen Sie, ob sich das Image im Repository befindet:

   gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models
   

   Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.

   Die Ausgabe sieht in etwa so aus:

   IMAGE                                                     DIGEST         CREATE_TIME          UPDATE_TIME
   us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small     sha256:0cd...  2023-06-14T12:06:38  2023-06-14T12:06:38
   

Gepacktes Modell in GKE bereitstellen

Ändern Sie zum Bereitstellen des Images das Kubernetes-Manifest im Beispiel-Repository an Ihre Umgebung.

1. Prüfen Sie das Manifest für die Inferenzarbeitslast:

   # Copyright 2023 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: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     replicas: 1
     selector:
       matchLabels:
         model: t5
         version: v1.0
         machine: gpu
     template:
       metadata:
         labels:
           model: t5
           version: v1.0
           machine: gpu
       spec:
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
         securityContext:
           fsGroup: 1000
           runAsUser: 1000
           runAsGroup: 1000
         containers:
           - name: inference
             image: us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small:1.0-gpu
             imagePullPolicy: IfNotPresent
             args: ["torchserve", "--start", "--foreground"]
             resources:
               limits:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
               requests:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
             ports:
               - containerPort: 8080
                 name: http
               - containerPort: 8081
                 name: management
               - containerPort: 8082
                 name: metrics
             readinessProbe:
               httpGet:
                 path: /ping
                 port: http
               initialDelaySeconds: 120
               failureThreshold: 10
             livenessProbe:
               httpGet:
                 path: /models/t5-small
                 port: management
               initialDelaySeconds: 150
               periodSeconds: 5
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     type: ClusterIP
     selector:
       model: t5
       version: v1.0
       machine: gpu
     ports:
       - port: 8080
         name: http
         targetPort: http
       - port: 8081
         name: management
         targetPort: management
       - port: 8082
         name: metrics
         targetPort: metrics
   

2. Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-Projekt-ID.

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"
   

   Dadurch wird sichergestellt, dass der Container-Image-Pfad in der Deployment-Spezifikation mit dem Pfad zu Ihrem T5-Modell-Image in Artifact Registry übereinstimmt.

3. Erstellen Sie die Kubernetes-Ressourcen:

   kubectl create -f kubernetes/serving-gpu.yaml
   

So prüfen Sie, ob das Modell erfolgreich bereitgestellt wurde:

1. Rufen Sie den Status der Bereitstellung und des Dienstes ab:

   kubectl get -f kubernetes/serving-gpu.yaml
   

   Warten Sie ähnlich dem folgenden Beispiel, bis in der Ausgabe einsatzbereite Pods angezeigt werden. Je nach Größe des Images kann der erste Abruf des Images einige Minuten dauern.

   NAME                            READY   UP-TO-DATE    AVAILABLE   AGE
   deployment.apps/t5-inference    1/1     1             0           66s
   
   NAME                    TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)                       AGE
   service/t5-inference    ClusterIP   10.48.131.86    <none>        8080/TCP,8081/TCP,8082/TCP    66s
   

2. Öffnen Sie einen lokalen Port für den t5-inference-Dienst:

   kubectl port-forward svc/t5-inference 8080
   

3. Öffnen Sie ein neues Terminalfenster und senden Sie eine Testanfrage an den Dienst:

   curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"
   

   Wenn die Testanfrage fehlschlägt und die Pod-Verbindung geschlossen wird, prüfen Sie die Logs:

   kubectl logs deployments/t5-inference
   

   Wenn die Ausgabe in etwa so aussieht, konnte TorchServe einige Modellabhängigkeiten nicht installieren:

   org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small
   

   Starten Sie das Deployment neu, um dieses Problem zu beheben:

   kubectl rollout restart deployment t5-inference
   

   Der Deployment-Controller erstellt einen neuen Pod. Wiederholen Sie die vorherigen Schritte, um einen Port auf dem neuen Pod zu öffnen.

Mit der Webanwendung auf das bereitgestellte Modell zugreifen

1. Erstellen Sie die Fast Dash-Webanwendung als Container-Image und übertragen Sie sie per Push in Artifact Registry:

   gcloud builds submit client-app/ \
       --region=us-central1 \
       --config=client-app/cloudbuild.yaml
   

2. Öffnen Sie kubernetes/application.yaml in einem Texteditor und ersetzen Sie PROJECT_ID im Feld image: durch Ihre Projekt-ID. Alternativ können Sie den folgenden Befehl ausführen:

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"
   

3. Erstellen Sie die Kubernetes-Ressourcen:

   kubectl create -f kubernetes/application.yaml
   

   Es kann einige Zeit dauern, bis das Deployment und der Dienst vollständig bereitgestellt wurden.

4. Führen Sie zum Prüfen des Status den folgenden Befehl aus:

   kubectl get -f kubernetes/application.yaml
   

   Warten Sie, bis in der Ausgabe einsatzbereite Pods angezeigt werden, ähnlich dem Folgenden:

   NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/fastdash   1/1     1            0           1m
   
   NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   service/fastdash   NodePort   203.0.113.12    <none>        8050/TCP         1m
   

5. Die Webanwendung wird jetzt ausgeführt, obwohl sie nicht über eine externe IP-Adresse verfügbar gemacht wird. Öffnen Sie einen lokalen Port, um auf die Webanwendung zuzugreifen:

   kubectl port-forward service/fastdash 8050
   

6. Öffnen Sie in einem Browser die Weboberfläche:

   • Wenn Sie eine lokale Shell verwenden, öffnen Sie einen Browser und rufen Sie http://127.0.0.1:8050 auf.
   • Wenn Sie Cloud Shell verwenden, klicken Sie auf Webvorschau und dann auf Port ändern. Gib Port 8050 an.

7. Um eine Anfrage an das T5-Modell zu senden, geben Sie in der Weboberfläche Werte in den Feldern TEXT, TEXT und TEXT an. und klicken Sie auf TEXT. Eine Liste der verfügbaren Sprachen finden Sie in der T5-Dokumentation.

Autoscaling für das Modell aktivieren

In diesem Abschnitt erfahren Sie, wie Sie das Autoscaling für das Modell anhand von Messwerten aus Google Cloud Managed Service for Prometheus aktivieren. Gehen Sie dazu so vor:

1. Stackdriver-Adapter für benutzerdefinierte Messwerte installieren
2. PodMonitoring- und HorizontalPodAutoscaling-Konfigurationen anwenden.

Google Cloud Managed Service for Prometheus ist in Autopilot-Clustern mit Version 1.25 und höher standardmäßig aktiviert.

Stackdriver-Adapter für benutzerdefinierte Messwerte installieren

Mit diesem Adapter kann Ihr Cluster Messwerte von Prometheus verwenden, um Autoscaling-Entscheidungen in Kubernetes zu treffen.

1. Stellen Sie den Adapter bereit:

   kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
   

2. Erstellen Sie ein IAM-Dienstkonto für den Adapter:

   gcloud iam service-accounts create monitoring-viewer
   

3. Weisen Sie dem IAM-Dienstkonto die Rolle monitoring.viewer für das Projekt und die Rolle iam.workloadIdentityUser zu:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
       --role roles/monitoring.viewer
   gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
   

   Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.

4. Annotieren Sie das Kubernetes-Dienstkonto des Adapters, damit es die Identität des IAM-Dienstkontos übernehmen kann:

   kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
       --namespace custom-metrics \
       iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com
   

5. Starten Sie den Adapter neu, um die Änderungen zu übernehmen:

   kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
       --namespace=custom-metrics
   

PodMonitoring- und HorizontalPodAutoscaling-Konfigurationen anwenden.

PodMonitoring ist eine benutzerdefinierte Google Cloud Managed Service for Prometheus-Ressource, die die Aufnahme von Messwerten und das Ziel-Scraping in einem bestimmten Namespace ermöglicht.

1. Stellen Sie die PodMonitoring-Ressource im selben Namespace wie das TorchServe-Deployment bereit:

   kubectl apply -f kubernetes/pod-monitoring.yaml
   

2. Prüfen Sie das HorizontalPodAutoscaler-Manifest:

   # Copyright 2023 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: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: t5-inference
   spec:
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: t5-inference
     minReplicas: 1
     maxReplicas: 5
     metrics:
     - type: Pods
       pods:
         metric:
           name: prometheus.googleapis.com|ts_queue_latency_microseconds|counter
         target:
           type: AverageValue
           averageValue: "30000"
   

   Der HorizontalPodAutoscaler skaliert die T5-Modell-Pod-Menge anhand der kumulativen Dauer der Anfragewarteschlange. Die automatische Skalierung basiert auf dem Messwert ts_queue_latency_microseconds, der die kumulative Warteschlangendauer in Mikrosekunden anzeigt.

3. Erstellen Sie den HorizontalPodAutoscaler:

   kubectl apply -f kubernetes/hpa.yaml
   

Autoscaling mit einem Load Generator prüfen

Generieren Sie zum Testen der Autoscaling-Konfiguration eine Last für die Bereitstellungsanwendung. In dieser Anleitung wird ein Locust-Lastgenerator verwendet, um Anfragen an den Vorhersageendpunkt für das Modell zu senden.

1. Erstellen Sie den Lastgenerator:

   kubectl apply -f kubernetes/loadgenerator.yaml
   

   Warten Sie, bis die Lastgenerator-Pods bereit sind.

2. Machen Sie die Weboberfläche des Lastgenerators lokal verfügbar:

   kubectl port-forward svc/loadgenerator 8080
   

   Wenn eine Fehlermeldung angezeigt wird, versuchen Sie es noch einmal, wenn der Pod ausgeführt wird.

3. Öffnen Sie in einem Browser die Weboberfläche des Lastgenerators:

   • Wenn Sie eine lokale Shell verwenden, öffnen Sie einen Browser und rufen Sie http://127.0.0.1:8080 auf.
   • Wenn Sie Cloud Shell verwenden, klicken Sie auf Webvorschau und dann auf Port ändern. Geben Sie Port 8080 ein.

4. Klicken Sie auf den Tab Diagramme, um die Leistung im Zeitverlauf zu beobachten.

5. Öffnen Sie ein neues Terminalfenster und beobachten Sie die Anzahl der Replikate Ihrer horizontalen Pod-Autoscalings:

   kubectl get hpa -w
   

   Die Anzahl der Replikate erhöht sich, wenn die Last zunimmt. Das Hochskalieren kann etwa zehn Minuten dauern. Wenn neue Replikate gestartet werden, erhöht sich die Anzahl der erfolgreichen Anfragen im Locust-Diagramm.

   NAME           REFERENCE                 TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
   t5-inference   Deployment/t5-inference   71352001470m/7M   1         5        1           2m11s
   

Empfehlungen

• Erstellen Sie Ihr Modell mit derselben Version des Basis-Docker-Images, die Sie für die Bereitstellung verwenden.
• Wenn Ihr Modell spezielle Paketabhängigkeiten hat oder die Abhängigkeiten groß sind, erstellen Sie eine benutzerdefinierte Version Ihres Basis-Docker-Images.
• Beobachten Sie die Baumversion Ihrer Modellabhängigkeitspakete. Achten Sie darauf, dass Ihre Paketabhängigkeiten die Versionen der jeweils anderen unterstützen. Die Panda-Version 2.0.3 unterstützt beispielsweise die NumPy-Version 1.20.3 und höher.
• Führen Sie GPU-intensive Modelle auf GPU-Knoten und CPU-intensiven Modellen auf CPU aus. Dies kann die Stabilität der Modellbereitstellung verbessern und dafür sorgen, dass Sie Knotenressourcen effizient nutzen.