Menyajikan LLM yang skalabel di GKE dengan TorchServe

Tutorial ini menunjukkan cara men-deploy dan menyajikan model machine learning (ML) yang skalabel ke cluster Google Kubernetes Engine (GKE) menggunakan framework TorchServe. Anda menayangkan model PyTorch yang telah dilatih sebelumnya yang menghasilkan prediksi berdasarkan permintaan pengguna. Setelah men-deploy model, Anda akan mendapatkan URL prediksi yang digunakan aplikasi Anda untuk mengirim permintaan prediksi. Metode ini memungkinkan Anda menskalakan model dan aplikasi web secara terpisah. Saat Anda men-deploy workload dan aplikasi ML di Autopilot, GKE akan memilih jenis dan ukuran mesin pokok yang paling efisien untuk menjalankan workload.

Tutorial ini ditujukan bagi engineer Machine Learning (ML), Admin dan operator platform, serta spesialis Data dan AI yang tertarik untuk menggunakan GKE Autopilot guna mengurangi overhead administratif untuk konfigurasi, penskalaan, dan upgrade node. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami referensikan dalam konten, lihat Peran dan tugas pengguna GKE umum. Google Cloud

Sebelum membaca halaman ini, pastikan Anda sudah memahami mode Autopilot GKE.

Tentang aplikasi tutorial

Aplikasi ini adalah aplikasi web Python kecil yang dibuat menggunakan framework Fast Dash. Anda menggunakan aplikasi untuk mengirim permintaan prediksi ke model T5. Aplikasi ini merekam input teks dan pasangan bahasa pengguna, lalu mengirimkan informasi tersebut ke model. Model menerjemahkan teks dan menampilkan hasilnya ke aplikasi, yang menampilkan hasilnya kepada pengguna. Untuk mengetahui informasi selengkapnya tentang Fast Dash, lihat dokumentasi Fast Dash.

Menyiapkan lingkungan

Clone repositori contoh dan buka direktori tutorial:

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

Membuat cluster

Jalankan perintah berikut:

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

Ganti kode berikut:

  • RELEASE_CHANNEL: saluran rilis untuk cluster Anda. Harus salah satu dari rapid, regular, atau stable. Pilih saluran yang memiliki GKE versi 1.28.3-gke.1203000 atau yang lebih baru untuk menggunakan GPU L4. Untuk melihat versi yang tersedia di saluran tertentu, lihat Melihat versi default dan yang tersedia untuk saluran rilis.
  • CLUSTER_VERSION: versi GKE yang akan digunakan. Harus 1.28.3-gke.1203000 atau setelahnya.

Operasi ini memerlukan waktu beberapa menit hingga selesai.

Membuat repositori Artifact Registry

  1. Buat repositori standar Artifact Registry baru dengan format Docker di region yang sama dengan cluster Anda:

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

  2. Verifikasi nama repositori:

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

    Outputnya mirip dengan hal berikut ini:

    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'

Mengemas model

Di bagian ini, Anda akan memaketkan model dan framework penayangan dalam satu image container menggunakan Cloud Build dan mengirimkan image yang dihasilkan ke repositori Artifact Registry.

  1. Tinjau Dockerfile untuk image 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.12.0-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/

    Dockerfile ini menentukan proses build multi-tahap berikut:

    1. Download artefak model dari repositori Hugging Face.
    2. Kemasi model menggunakan alat PyTorch Serving Archive. Tindakan ini akan membuat file arsip model (.mar) yang digunakan server inferensi untuk memuat model.
    3. Bangun image akhir dengan PyTorch Serve.

  2. Bangun dan kirim image menggunakan 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

    Proses build memerlukan waktu beberapa menit hingga selesai. Jika Anda menggunakan ukuran model yang lebih besar daripada t5-small, proses build mungkin memerlukan waktu yang jauh lebih lama.

  3. Periksa apakah image ada di repositori:

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

    Ganti PROJECT_ID dengan project ID Google Cloud Anda.

    Outputnya mirip dengan hal berikut ini:

    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

Men-deploy model yang dikemas ke GKE

Untuk men-deploy image, tutorial ini menggunakan Deployment Kubernetes. Deployment adalah objek Kubernetes API yang memungkinkan Anda menjalankan beberapa replika Pod yang didistribusikan di antara node dalam cluster.

Ubah manifes Kubernetes di repositori contoh agar sesuai dengan lingkungan Anda.

  1. Tinjau manifes untuk workload inferensi:

    # 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. Ganti PROJECT_ID dengan project ID Google Cloud Anda:

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

    Hal ini memastikan bahwa jalur image container dalam spesifikasi Deployment cocok dengan jalur ke image model T5 Anda di Artifact Registry.

  3. Buat resource Kubernetes:

    kubectl create -f kubernetes/serving-gpu.yaml

Untuk memverifikasi bahwa model berhasil di-deploy, lakukan hal berikut:

  1. Dapatkan status Deployment dan Layanan:

    kubectl get -f kubernetes/serving-gpu.yaml

    Tunggu hingga output menampilkan Pod yang siap, seperti berikut. Bergantung pada ukuran image, penarikan image pertama mungkin memerlukan waktu beberapa menit.

    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. Buka port lokal untuk Layanan t5-inference:

    kubectl port-forward svc/t5-inference 8080

  3. Buka jendela terminal baru dan kirim permintaan pengujian ke Layanan:

    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"

    Jika permintaan pengujian gagal dan koneksi Pod ditutup, periksa log:

    kubectl logs deployments/t5-inference

    Jika outputnya mirip dengan berikut ini, TorchServe gagal menginstal beberapa dependensi model:

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

    Untuk mengatasi masalah ini, mulai ulang Deployment:

    kubectl rollout restart deployment t5-inference

    Pengontrol Deployment membuat Pod baru. Ulangi langkah-langkah sebelumnya untuk membuka port di Pod baru.

Mengakses model yang di-deploy menggunakan aplikasi web

Untuk mengakses model yang di-deploy dengan aplikasi web Fast Dash, selesaikan langkah-langkah berikut:

  1. Bangun dan kirim aplikasi web Fast Dash sebagai image container di Artifact Registry:

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

  2. Buka kubernetes/application.yaml di editor teks dan ganti PROJECT_ID di kolom image: dengan project ID Anda. Atau, jalankan perintah berikut:

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

  3. Buat resource Kubernetes:

    kubectl create -f kubernetes/application.yaml

    Deployment dan Layanan mungkin memerlukan waktu beberapa saat untuk disediakan sepenuhnya.

  4. Untuk memeriksa status, jalankan perintah berikut:

    kubectl get -f kubernetes/application.yaml

    Tunggu hingga output menampilkan Pod yang siap, seperti berikut:

    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. Aplikasi web kini berjalan, meskipun tidak diekspos di alamat IP eksternal. Untuk mengakses aplikasi web, buka port lokal:

    kubectl port-forward service/fastdash 8050

  6. Di browser, buka antarmuka web:

    • Jika Anda menggunakan shell lokal, buka browser, lalu buka http://127.0.0.1:8050.
    • Jika Anda menggunakan Cloud Shell, klik Web preview, lalu klik Change port. Tentukan port 8050.

  7. Untuk mengirim permintaan ke model T5, tentukan nilai di kolom TEXT, FROM LANG, dan TO LANG di antarmuka web, lalu klik Submit. Untuk mengetahui daftar bahasa yang tersedia, lihat dokumentasi T5.

Mengaktifkan penskalaan otomatis untuk model

Bagian ini menunjukkan cara mengaktifkan penskalaan otomatis untuk model berdasarkan metrik dari Google Cloud Managed Service for Prometheus dengan melakukan hal berikut:

  1. Menginstal Adaptor Metrik Kustom Stackdriver
  2. Menerapkan konfigurasi PodMonitoring dan HorizontalPodAutoscaling

Google Cloud Managed Service for Prometheus diaktifkan secara default di cluster Autopilot yang menjalankan versi 1.25 dan yang lebih baru.

Menginstal Adaptor Metrik Kustom Stackdriver

Adaptor ini memungkinkan cluster Anda menggunakan metrik dari Prometheus untuk membuat keputusan penskalaan otomatis Kubernetes.

  1. Deploy adaptor:

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

  2. Buat akun layanan IAM yang akan digunakan oleh adapter:

    gcloud iam service-accounts create monitoring-viewer

  3. Beri akun layanan IAM peran monitoring.viewer pada project dan peran 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]"

    Ganti PROJECT_ID dengan project ID Google Cloud Anda.

  4. Anotasikan ServiceAccount Kubernetes adaptor agar dapat meniru identitas akun layanan 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. Mulai ulang adaptor untuk menerapkan perubahan:

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

Menerapkan konfigurasi PodMonitoring dan HorizontalPodAutoscaling

PodMonitoring adalah resource kustom Google Cloud Managed Service for Prometheus yang memungkinkan penyerapan metrik dan scraping target di namespace tertentu.

  1. Deploy resource PodMonitoring di namespace yang sama dengan Deployment TorchServe:

    kubectl apply -f kubernetes/pod-monitoring.yaml

  2. Tinjau manifes 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 menskalakan jumlah Pod model T5 berdasarkan durasi kumulatif antrean permintaan. Penskalaan otomatis didasarkan pada metrik ts_queue_latency_microseconds, yang menunjukkan durasi antrean kumulatif dalam mikrodetik.

  3. Buat HorizontalPodAutoscaler:

    kubectl apply -f kubernetes/hpa.yaml

Memverifikasi penskalaan otomatis menggunakan generator beban

Untuk menguji konfigurasi penskalaan otomatis, buat beban untuk aplikasi penayangan. Tutorial ini menggunakan generator beban Locust untuk mengirim permintaan ke endpoint prediksi untuk model.

  1. Buat generator beban:

    kubectl apply -f kubernetes/loadgenerator.yaml

    Tunggu hingga Pod generator beban siap.

  2. Ekspos antarmuka web generator beban secara lokal:

    kubectl port-forward svc/loadgenerator 8080

    Jika Anda melihat pesan error, coba lagi saat Pod berjalan.

  3. Di browser, buka antarmuka web generator beban:

    • Jika Anda menggunakan shell lokal, buka browser, lalu buka http://127.0.0.1:8080.
    • Jika Anda menggunakan Cloud Shell, klik Web preview, lalu klik Change port. Masukkan port 8080.

  4. Klik tab Diagram untuk mengamati performa dari waktu ke waktu.

  5. Buka jendela terminal baru dan lihat jumlah replika autoscaler Pod horizontal Anda:

    kubectl get hpa -w

    Jumlah replika meningkat seiring dengan bertambahnya beban. Peningkatan skala mungkin memerlukan waktu sekitar sepuluh menit. Saat replika baru dimulai, jumlah permintaan yang berhasil dalam diagram Locust akan meningkat.

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

Rekomendasi

  • Bangun model Anda dengan versi image Docker dasar yang sama yang akan Anda gunakan untuk penayangan.
  • Jika model Anda memiliki dependensi paket khusus, atau jika ukuran dependensi Anda besar, buat versi kustom image Docker dasar Anda.
  • Pantau paket dependensi model versi pohon Anda. Pastikan dependensi paket Anda mendukung versi satu sama lain. Misalnya, Panda versi 2.0.3 mendukung NumPy versi 1.20.3 dan yang lebih baru.
  • Jalankan model intensif GPU pada node GPU dan model intensif CPU pada CPU. Hal ini dapat meningkatkan stabilitas penayangan model dan memastikan Anda menggunakan resource node secara efisien.

Mengamati performa model

Untuk mengamati performa model, Anda dapat menggunakan integrasi dasbor TorchServe di Cloud Monitoring. Dengan dasbor ini, Anda dapat melihat metrik performa penting seperti throughput token, latensi permintaan, dan tingkat error.

Untuk menggunakan dasbor TorchServe, Anda harus mengaktifkan Google Cloud Managed Service for Prometheus, yang mengumpulkan metrik dari TorchServe, di cluster GKE Anda. TorchServe mengekspos metrik dalam format Prometheus secara default; Anda tidak perlu menginstal eksportir tambahan.

Kemudian, Anda dapat melihat metrik menggunakan dasbor TorchServe. Untuk mengetahui informasi tentang cara menggunakan Google Cloud Managed Service for Prometheus untuk mengumpulkan metrik dari model Anda, lihat panduan kemampuan pengamatan TorchServe dalam dokumentasi Cloud Monitoring.