Gestisci LLM scalabili su GKE utilizzando TorchServe

prepara l'ambiente

Clona il repository di esempio e apri la directory del tutorial:

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

Crea il cluster

Esegui questo comando:

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

Sostituisci quanto segue:

• RELEASE_CHANNEL: il canale di rilascio per il tuo cluster. Deve essere rapid, regular o stable. Scegli un canale con GKE versione 1.28.3-gke.1203000 o successiva per utilizzare GPU L4. A vedere le versioni disponibili in un canale specifico, Visualizza le versioni predefinite e disponibili per i canali di rilascio.
• CLUSTER_VERSION: la versione GKE da per gli utilizzi odierni. Deve essere 1.28.3-gke.1203000 o una versione successiva.

Il completamento di questa operazione richiede diversi minuti.

Crea un repository Artifact Registry

1. Crea un nuovo repository standard Artifact Registry con il formato Docker nella stessa regione del tuo cluster:

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

2. Verifica il nome del repository:

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

   L'output è simile al seguente:

   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'
   

Crea un pacchetto del modello

In questa sezione, pacchettizzerai il modello e il framework di pubblicazione in un'unica dell'immagine container utilizzando Cloud Build ed esegui il push dell'immagine risultante repository Artifact Registry.

1. Esamina il Dockerfile per trovare l'immagine container:

   # 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/
   

   Questo Dockerfile definisce il seguente processo di compilazione in più fasi:

   1. Scarica gli artefatti del modello dal repository di Hugging Face.
   2. pacchettizza il modello utilizzando Archivio di PyTorch lo strumento a riga di comando gcloud. Questo crea un file di archivio dei modelli (.mar) che il server di inferenza per caricare il modello.
   3. Crea l'immagine finale con PyTorch Serve.

2. Crea ed esegui il push dell'immagine con 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
   

   Il completamento del processo di compilazione richiede diversi minuti. Se utilizzi un modello più grande maggiore di t5-small, il processo di compilazione potrebbe richiedere molto di più nel tempo.

3. Verifica che l'immagine sia nel repository:

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

   Sostituisci PROJECT_ID con il tuo Google Cloud dell'ID progetto.

   L'output è simile al seguente:

   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
   

esegui il deployment del modello in pacchetto su GKE

Per eseguire il deployment dell'immagine, modifica il manifest di Kubernetes nel repository di esempio in in base al tuo ambiente.

1. Esamina il manifest per il carico di lavoro di inferenza:

   # 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. Sostituisci PROJECT_ID con il tuo Google Cloud ID progetto:

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

   Ciò garantisce che il percorso dell'immagine container nella specifica del deployment corrisponde al percorso dell'immagine del modello T5 in Artifact Registry.

3. Crea le risorse Kubernetes:

   kubectl create -f kubernetes/serving-gpu.yaml
   

Per verificare che il deployment del modello sia andato a buon fine, segui questi passaggi:

1. Visualizza lo stato del deployment e del servizio:

   kubectl get -f kubernetes/serving-gpu.yaml
   

   Attendi finché l'output non mostra pod pronti, come in questo caso. A seconda in base alle dimensioni dell'immagine, il primo pull dell'immagine potrebbe richiedere diversi minuti.

   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. Apri una porta locale per il servizio t5-inference:

   kubectl port-forward svc/t5-inference 8080
   

3. Apri una nuova finestra del terminale e invia una richiesta di prova al servizio:

   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"
   

   Se la richiesta di test non va a buon fine e la connessione al pod si chiude, controlla i log:

   kubectl logs deployments/t5-inference
   

   Se l'output è simile al seguente, l'installazione di TorchServe non è riuscita alcune dipendenze del modello:

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

   Per risolvere il problema, riavvia il deployment:

   kubectl rollout restart deployment t5-inference
   

   Il controller Deployment crea un nuovo pod. Ripeti i passaggi precedenti per aprire una porta sul nuovo pod.

Accedi al modello di cui è stato eseguito il deployment utilizzando l'applicazione web

1. Crea ed esegui il push dell'applicazione web Fast Dash come immagine container in Artifact Registry:

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

2. Apri kubernetes/application.yaml in un editor di testo e sostituisci PROJECT_ID nel campo image: con il tuo dell'ID progetto. In alternativa, esegui questo comando:

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

3. Crea le risorse Kubernetes:

   kubectl create -f kubernetes/application.yaml
   

   Il provisioning completo del deployment e del servizio potrebbe richiedere del tempo.

4. Per verificare lo stato, esegui questo comando:

   kubectl get -f kubernetes/application.yaml
   

   Attendi finché l'output mostra i pod pronti, in modo simile al seguente:

   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. L'applicazione web è ora in esecuzione, anche se non è esposta su un server Indirizzo IP. Per accedere all'applicazione web, apri una porta locale:

   kubectl port-forward service/fastdash 8050
   

6. Apri l'interfaccia web in un browser:

   • Se utilizzi una shell locale, apri un browser e vai su http://127.0.0.1:8050.
   • Se utilizzi Cloud Shell, fai clic su Anteprima web, quindi fai clic su Cambia porta. Specifica la porta 8050.

7. Per inviare una richiesta al modello T5, specifica i valori in TEXT, FROM LANGUAGE e TO LANGUAGE nell'interfaccia web e fai clic su Invia. Per un elenco delle lingue disponibili, vedi Documentazione T5.

Abilita la scalabilità automatica per il modello

Questa sezione mostra come abilitare la scalabilità automatica per il modello in base alle metriche Da Google Cloud Managed Service per Prometheus nel seguente modo:

1. Installa l'adattatore Stackdriver per metriche personalizzate
2. Applica le configurazioni PodMonitoring e HorizontalPodAutoscalaling

Google Cloud Managed Service per Prometheus è abilitato per impostazione predefinita in Autopilot con la versione 1.25 e successive.

Installa l'adattatore Stackdriver per metriche personalizzate

Questo adattatore consente al cluster di utilizzare le metriche di Prometheus per rendere Kubernetes di scalabilità automatica.

1. Distribuisci l'adattatore:

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

2. Crea un account di servizio IAM che l'adattatore possa utilizzare:

   gcloud iam service-accounts create monitoring-viewer
   

3. Concedi all'account di servizio IAM il ruolo monitoring.viewer in il progetto e il ruolo iam.workloadIdentityUser:

   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]"
   

   Sostituisci PROJECT_ID con il tuo Google Cloud dell'ID progetto.

4. Annota l'account di servizio Kubernetes dell'adattatore per consentirne l'identità l'account di servizio IAM:

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

5. Riavvia l'adattatore per propagare le modifiche:

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

Applica le configurazioni PodMonitoring e HorizontalPodAutoscalaling

PodMonitoring è una risorsa personalizzata di Google Cloud Managed Service per Prometheus che consente l'importazione delle metriche e lo scraping dei target in uno spazio dei nomi specifico.

1. Esegui il deployment della risorsa PodMonitoring nello stesso spazio dei nomi di TorchServe Deployment:

   kubectl apply -f kubernetes/pod-monitoring.yaml
   

2. Esamina il manifest HorizontalPodAutoscaler:

   # 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"
   

   HorizontalPodAutoscaler scala la quantità di pod del modello T5 in base alla durata cumulativa della coda di richieste. La scalabilità automatica si basa ts_queue_latency_microseconds metrica, che mostra la coda cumulativa in microsecondi.

3. Crea HorizontalPodAutoscaler:

   kubectl apply -f kubernetes/hpa.yaml
   

Verificare la scalabilità automatica utilizzando un generatore di carico

Per testare la configurazione della scalabilità automatica, genera il carico per la pubblicazione un'applicazione. Questo tutorial utilizza un generatore di carico di Locust per inviare richieste ai endpoint di previsione per il modello.

1. Crea il generatore di carico:

   kubectl apply -f kubernetes/loadgenerator.yaml
   

   Attendi che i pod del generatore di carico siano pronti.

2. Esponi localmente l'interfaccia web del generatore di carico:

   kubectl port-forward svc/loadgenerator 8080
   

   Se vedi un messaggio di errore, riprova mentre il pod è in esecuzione.

3. In un browser, apri l'interfaccia web del generatore di carico:

   • Se utilizzi una shell locale, apri un browser e vai su http://127.0.0.1:8080.
   • Se utilizzi Cloud Shell, fai clic su Anteprima web, quindi Fai clic su Cambia porta. Inserisci la porta 8080.

4. Fai clic sulla scheda Grafici per osservare il rendimento nel tempo.

5. Apri una nuova finestra del terminale e osserva il numero di repliche del tuo Horizontal Pod Autoscaler:

   kubectl get hpa -w
   

   Il numero di repliche aumenta con l'aumento del carico. La scalabilità potrebbe richiede circa dieci minuti. All'avvio delle nuove repliche, il numero delle richieste andate a buon fine nel grafico a locusta aumenta.

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

Consigli

• Crea il tuo modello con la stessa versione dell'immagine Docker di base che utilizzerai per la pubblicazione.
• Se il modello ha dipendenze speciali per i pacchetti o se la dimensione se le dipendenze sono grandi, crea una versione personalizzata dell'immagine Docker di base.
• Osserva la versione ad albero dei pacchetti di dipendenze del modello. Assicurati che le dipendenze dei pacchetti si supportano reciprocamente e versioni successive. Ad esempio, versione Panda 2.0.3 supporta NumPy versione 1.20.3 e successive.
• Esegui modelli che usano molta GPU su nodi GPU e modelli che usano CPU ad alta intensità sulla CPU. Questo migliorare la stabilità della pubblicazione del modello e assicurarti di per utilizzare in modo efficiente le risorse dei nodi.