Offene Gemma-Modelle mit GPUs in GKE mit Triton und TensorRT-LLM bereitstellen

Autopilot Standard

In dieser Anleitung erfahren Sie, wie Sie ein Gemma Large Language Model (LLM) mit grafischen Verarbeitungseinheiten (GPUs) in Google Kubernetes Engine (GKE) mit NVIDIA Triton und TensorRT-LLM-Bereitstellungsstack für effiziente GPU-basierte Inferenz mit Kubernetes-Orchestrierung bereitstellen. In dieser Anleitung laden Sie die für die 2B- und 7B-Parameteranweisung abgestimmten Gemma-Modelle herunter und stellen sie in einem GKE Autopilot-Cluster oder einem Standard-Cluster mithilfe eines Containers bereit, auf dem Triton und TensorRT-LLM ausgeführt werden.

Dieser Leitfaden ist ein guter Ausgangspunkt, wenn Sie bei der Bereitstellung und Zugänglichmachung Ihrer KI/ML-Arbeitslasten die detaillierte Kontrolle, Skalierbarkeit, Robustheit, Übertragbarkeit und Kosteneffizienz von verwaltetem Kubernetes benötigen. Wenn Sie eine einheitliche verwaltete KI-Plattform benötigen, um ML-Modelle schnell und kostengünstig zu erstellen und bereitzustellen, empfehlen wir Ihnen, unsere Bereitstellungslösung Vertex AI zu testen.

Hintergrund

Wenn Sie Gemma mithilfe von GPUs in GKE mit Triton und TensorRT-LLM bereitstellen, können Sie eine robuste, produktionsbereite Inferenzbereitstellungslösung mit allen Vorteilen des verwalteten Kubernetes implementieren, einschließlich effizienter Skalierbarkeit und höherer Verfügbarkeit. In diesem Abschnitt werden die in diesem Leitfaden verwendeten Schlüsseltechnologien beschrieben.

Gemma

Gemma ist eine Reihe offen verfügbarer, einfacher und auf künstliche Intelligenz basierender Modelle, die unter einer offenen Lizenz veröffentlicht wurden. Diese KI-Modelle können in Ihren Anwendungen, Geräten, Mobilgeräten oder gehosteten Diensten ausgeführt werden. Sie können die Gemma-Modelle zur Textgenerierung verwenden. Sie können diese Modelle jedoch auch für spezielle Aufgaben optimieren.

Weitere Informationen finden Sie in der Gemma-Dokumentation.

GPUs

Mit GPUs können Sie bestimmte Arbeitslasten wie maschinelles Lernen und Datenverarbeitung beschleunigen, die auf Ihren Knoten ausgeführt werden. GKE bietet eine Reihe von Maschinentypoptionen für die Knotenkonfiguration, einschließlich Maschinentypen mit NVIDIA H100-, L4- und A100-GPUs.

Bevor Sie GPUs in GKE verwenden, sollten Sie den folgenden Lernpfad durcharbeiten:

TensorRT-LLM

NVIDIA TensorRT-LLM (TRT-LLM) ist ein Toolkit mit einer Python API zum Zusammenstellen optimierter Lösungen, mit denen LLMs definiert und TensorRT-Engines erstellt werden können, die auf NVIDIA-GPUs effizient Inferenzen ausführen. TensorRT-LLM bietet unter anderem folgende Funktionen:

Optimierte Transformer-Implementierung mit Ebenenfusionen, Aktivierungs-Caching, Wiederverwendung von Zwischenspeicher und PagedAttention
In-Flight- oder kontinuierliche Batchverarbeitung zur Verbesserung des Gesamtbereitstellungsdurchsatzes
Tensor-Parallelität und Pipeline-Parallelität für die verteilte Bereitstellung auf mehreren GPUs
Quantisierung (FP16, FP8, INT8)

Weitere Informationen finden Sie in der TensorRT-LLM-Dokumentation.

Triton

NVIDIA Triton Inference Server ist ein Open-Source-Inferenzserver für KI/ML-Anwendungen. Triton unterstützt Hochleistungsinferenz sowohl auf NVIDIA-GPUs als auch auf CPUs mit optimierten Back-Ends, einschließlich TensorRT und TensorRT-LLM. Triton bietet unter anderem folgende Funktionen:

Inferenz mit mehreren GPUs und Knoten
Gleichzeitige Ausführung mehrerer Modelle
Modellsortierung oder -verkettung
Statisches, dynamisches und kontinuierliches oder In-Flight-Batching von Vorhersageanfragen

Weitere Informationen finden Sie in der Triton-Dokumentation.

Lernziele

Dieser Leitfaden richtet sich an Kunden von generativer KI, die PyTorch verwenden, neue oder bestehende Nutzer von GKE, ML-Entwickler, MLOps-Entwickler (DevOps) oder Plattformadministratoren, die daran interessiert sind, Funktionen zur Kubernetes-Containerorchestrierung für die Bereitstellung von LLMs auf H100-, A100- und L4-GPU-Hardware zu nutzen.

Sie sollten am Ende dieses Leitfadens in der Lage sein, die folgenden Schritte auszuführen:

Ihre Umgebung mit einem GKE-Cluster im Autopilot-Modus vorbereiten.
Stellen Sie einen Container mit Triton und TritonRT-LLM in Ihrem Cluster bereit.
Verwenden Sie Triton und TensorRT-LLM, um das Gemma 2B- oder 7B-Modell über curl bereitzustellen.

Hinweise

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.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.
Grant the roles
1. In the Google Cloud console, go to the IAM page.
  Zu IAM
2. Wählen Sie das Projekt aus.
3. Klicken Sie auf Zugriff erlauben.
4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Dies ist in der Regel die E-Mail-Adresse eines Google-Kontos.
5. Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
6. Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
7. Klicken Sie auf Speichern.

Erstellen Sie ein Kaggle-Konto, falls Sie noch keines haben.
Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für GPUs hat. Weitere Informationen finden Sie unter GPUs und Zuteilungskontingente.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die in Google Cloud gehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich kubectl und gcloud CLI.

So richten Sie Ihre Umgebung mit Cloud Shell ein:

Starten Sie in der Google Cloud Console eine Cloud Shell-Sitzung. Klicken Sie dazu in der Google Cloud Console auf Cloud Shell aktivieren. Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.
Legen Sie die Standardumgebungsvariablen fest:
```
gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=triton
```
Ersetzen Sie die folgenden Werte:
- PROJECT_ID: Ihre Google Cloud-Projekt-ID.
- REGION ist eine Region, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1 für L4-GPU.

Zugriff auf das Modell erhalten

Damit Sie auf die Gemma-Modelle zugreifen können, müssen Sie sich bei der Kaggle-Plattform anmelden und ein Kaggle API-Token abrufen.

Sie müssen die Einwilligungsvereinbarung unterzeichnen, um Gemma verwenden zu können. Gehen Sie dazu so vor:

Rufen Sie die Seite zur Modelleinwilligung auf Kaggle.com auf.
Melden Sie sich bei Kaggle an, falls Sie dies noch nicht getan haben.
Klicken Sie auf Zugriffsanfrage.
Wählen Sie im Abschnitt Konto zur Einwilligung die Option Über Kaggle-Konto verifizieren aus, um Ihr Kaggle-Konto für die Einwilligung zu verwenden.
Akzeptieren Sie die Nutzungsbedingungen des Modells.

Zugriffstoken erstellen

Für den Zugriff auf das Modell über Kaggle benötigen Sie ein Kaggle API-Token. Führen Sie die folgenden Schritte aus, um ein neues Token zu generieren, falls Sie noch keines haben:

Rufen Sie in Ihrem Browser die Kaggle-Einstellungen auf.
Klicken Sie im Abschnitt API auf Neues Token erstellen.

Eine Datei mit dem Namen kaggle.json wird heruntergeladen.

Zugriffstoken in Cloud Shell hochladen

Laden Sie in Cloud Shell das Kaggle API-Token in Ihr Google Cloud-Projekt hoch:

Klicken Sie in Cloud Shell auf Mehr > Hochladen.
Wählen Sie "Datei" aus und klicken Sie auf Dateien auswählen.
Öffnen Sie die Datei kaggle.json.
Klicken Sie auf Hochladen.

Google Cloud-Ressourcen erstellen und konfigurieren

Folgen Sie dieser Anleitung, um die erforderlichen Ressourcen zu erstellen.

GKE-Cluster und -Knotenpool erstellen

Sie können Gemma auf GPUs in einem GKE-Cluster im Autopilot- oder Standardmodus bereitstellen. Für eine vollständig verwaltete Kubernetes-Umgebung empfehlen wir die Verwendung eines Autopilot-Clusters. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

Autopilot

Führen Sie in Cloud Shell den folgenden Befehl aus:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.28

GKE erstellt einen Autopilot-Cluster mit CPU- und GPU-Knoten, wie von den bereitgestellten Arbeitslasten angefordert.

Standard

Führen Sie in Cloud Shell den folgenden Befehl aus, um einen Standardcluster zu erstellen:

gcloud container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --location=${REGION}-a \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --release-channel=rapid \
    --machine-type=e2-standard-4 \
    --num-nodes=1

Die Erstellung eines Clusters kann einige Minuten dauern.

Führen Sie den folgenden Befehl aus, um einen Knotenpool für Ihren Cluster zu erstellen:

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
    --project=${PROJECT_ID} \
    --location=${REGION}-a \
    --cluster=${CLUSTER_NAME} \
    --machine-type=g2-standard-12 \
    --num-nodes=1

GKE erstellt einen einzelnen Knotenpool mit einem L4-GPU-Knoten.

Kubernetes-Secret für Kaggle-Anmeldedaten erstellen

In dieser Anleitung verwenden Sie ein Kubernetes Secret für die Kaggle-Anmeldedaten.

Gehen Sie in Cloud Shell so vor:

Konfigurieren Sie kubectl für die Kommunikation mit Ihrem Cluster:

gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}

Erstellen Sie ein Secret zum Speichern der Kaggle-Anmeldedaten:

kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json \
    --dry-run=client -o yaml | kubectl apply -f -

PersistentVolume-Ressource zum Speichern von Prüfpunkten erstellen

In diesem Abschnitt erstellen Sie ein PersistentVolume, das auf einem nichtflüchtigen Speicher basiert, um die Modellprüfpunkte zu speichern.

Erstellen Sie das folgende trtllm_checkpoint_pv.yaml-Manifest:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: model-data
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 100G

Wenden Sie das Manifest an:

kubectl apply -f trtllm_checkpoint_pv.yaml

TensorRT-LLM-Engine-Dateien für Gemma herunterladen

In diesem Abschnitt führen Sie einen Job aus, um die TensorRT-LLM-Engine-Dateien herunterzuladen und die Dateien im zuvor erstellten PersistentVolume zu speichern. Der Job bereitet auch Konfigurationsdateien für die Bereitstellung des Modells auf dem Triton-Server im nächsten Schritt vor. Das kann einige Minuten dauern.

Gemma 2B-it

Die TensorRT-LLM-Engine wird aus dem Gemma 2B-it-PyTorch-Prüfpunkt von Gemma (nach Anleitung eingestellt) mit bfloat16-Aktivierung, Eingabesequenzlänge=2048 und Ausgabesequenzlänge=1.024 gezielten L4-GPUs erstellt. Sie können das Modell auf einer einzelnen L4-GPU bereitstellen.

Erstellen Sie das folgende job-download-gemma-2b.yaml-Manifest:

apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    ACTIVATION_DTYPE=bfloat16 && \

    TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
    ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
    TRITON_MODEL_REPO=/data/triton/model_repository && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    mkdir -p ${ENGINE_PATH} && \
    mkdir -p ${TRITON_MODEL_REPO} && \

    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \

    # copying configuration files
    echo -e "\nCreating configuration files" && \
    cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \

    # updating configuration files
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \

    echo -e "\nCompleted extraction to ${ENGINE_PATH}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-gemma-2b
  labels:
    app: data-loader-gemma-2b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-gemma-2b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        command:
        - /scripts/fetch_model.sh
        env:
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/tensorrtllm/2b-it/2"
        - name: WORLD_SIZE
          value: "1"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"

Wenden Sie das Manifest an:

kubectl apply -f job-download-gemma-2b.yaml

So rufen Sie die Logs für den Job auf:

kubectl logs -f job/data-loader-gemma-2b

Die Ausgabe der Logs sieht in etwa so aus:

...
Creating configuration files
+ echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/2b/bfloat16/1-gpu/'
+ echo -e '\nCreating configuration files'
...

Warten Sie, bis der Job abgeschlossen ist:

kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-2b

Die Ausgabe sieht in etwa so aus:

job.batch/data-loader-gemma-2b condition met

Überprüfen Sie, ob der Job erfolgreich abgeschlossen wurde. Dies kann einige Minuten dauern:

kubectl get job/data-loader-gemma-2b

Die Ausgabe sieht in etwa so aus:

NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-2b   1/1           ##s        #m##s

Gemma 7B-it

Die TensorRT-LLM-Engine wird aus dem Gemma 7B-it-PyTorch-Prüfpunkt von Gemma (nach Anleitung eingestellt) mit bfloat16-Aktivierung, Eingabesequenzlänge=1024 und Ausgabesequenzlänge=512 gezielten L4-GPUs erstellt. Sie können das Modell auf einer einzelnen L4-GPU bereitstellen.

Erstellen Sie das folgende job-download-gemma-7b.yaml-Manifest:

apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    ACTIVATION_DTYPE=bfloat16 && \

    TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
    ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
    TRITON_MODEL_REPO=/data/triton/model_repository && \

    mkdir -p ${ENGINE_PATH} && \
    mkdir -p ${TRITON_MODEL_REPO} && \

    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \

    # copying configuration files
    echo -e "\nCreating configuration files" && \
    cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \

    # updating configuration files
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \

    echo -e "\nCompleted extraction to ${ENGINE_PATH}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-gemma-7b
  labels:
    app: data-loader-gemma-7b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-gemma-7b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        command:
        - /scripts/fetch_model.sh
        env:
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/tensorrtllm/7b-it/2"
        - name: WORLD_SIZE
          value: "1"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"

Wenden Sie das Manifest an:

kubectl apply -f job-download-gemma-7b.yaml

So rufen Sie die Logs für den Job auf:

kubectl logs -f job/data-loader-gemma-7b

Die Ausgabe der Logs sieht in etwa so aus:

...
Creating configuration files
+ echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/7b/bfloat16/1-gpu/'
+ echo -e '\nCreating configuration files'
...

Warten Sie, bis der Job abgeschlossen ist:

kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-7b

Die Ausgabe sieht in etwa so aus:

job.batch/data-loader-gemma-7b condition met

Überprüfen Sie, ob der Job erfolgreich abgeschlossen wurde. Dies kann einige Minuten dauern:

kubectl get job/data-loader-gemma-7b

Die Ausgabe sieht in etwa so aus:

NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-7b   1/1           ##s        #m##s

Prüfen Sie, ob der Job erfolgreich abgeschlossen wurde, bevor Sie mit dem nächsten Abschnitt fortfahren.

Triton bereitstellen

In diesem Abschnitt stellen Sie einen Container bereit, der Triton mit dem TensorRT-LLM-Backend verwendet, um das gewünschte Gemma-Modell bereitzustellen.

Erstellen Sie das folgende deploy-triton-server.yaml-Manifest:

apiVersion: v1
kind: ConfigMap
metadata:
  name: launch-tritonserver
data:
  entrypoint.sh: |-
    #!/usr/bin/bash -x
    # Launch Triton Inference server

    WORLD_SIZE=1
    TRITON_MODEL_REPO=/data/triton/model_repository

    python3 /tensorrtllm_backend/scripts/launch_triton_server.py \
      --world_size ${WORLD_SIZE} \
      --model_repo ${TRITON_MODEL_REPO}

    tail -f /dev/null
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: triton-gemma-deployment
  labels:
    app: gemma-server
    version: v1 
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server 
      version: v1
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma
        ai.gke.io/inference-server: triton
        examples.ai.gke.io/source: user-guide
        version: v1
    spec:
      containers:
      - name: inference-server 
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        imagePullPolicy: IfNotPresent
        resources:
          requests:
            ephemeral-storage: "40Gi"
            memory: "40Gi"
            nvidia.com/gpu: 1
          limits:
            ephemeral-storage: "40Gi"
            memory: "40Gi"
            nvidia.com/gpu: 1
        command:
        - /scripts/entrypoint.sh
        volumeMounts:
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
        ports:
          - containerPort: 8000
            name: http
          - containerPort: 8001
            name: grpc
          - containerPort: 8002
            name: metrics
        livenessProbe:
          failureThreshold: 60
          initialDelaySeconds: 600
          periodSeconds: 5
          httpGet:
            path: /v2/health/live
            port: http
        readinessProbe:
          failureThreshold: 60
          initialDelaySeconds: 600
          periodSeconds: 5
          httpGet:
            path: /v2/health/ready
            port: http
      securityContext:
        runAsUser: 1000
        fsGroup: 1000
      volumes:
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: launch-tritonserver
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"
---
apiVersion: v1
kind: Service
metadata:
  name: triton-server
  labels:
    app: gemma-server 
spec:
  type: ClusterIP
  ports:
    - port: 8000
      targetPort: http
      name: http-inference-server
    - port: 8001
      targetPort: grpc
      name: grpc-inference-server
    - port: 8002
      targetPort: metrics
      name: http-metrics
  selector:
    app: gemma-server

Wenden Sie das Manifest an:

kubectl apply -f deploy-triton-server.yaml

Warten Sie, bis die Bereitstellung verfügbar ist:

kubectl wait --for=condition=Available --timeout=900s deployment/triton-gemma-deployment

So rufen Sie die Logs aus dem Manifest auf:

kubectl logs -f -l app=gemma-server

Die Deployment-Ressource startet den Triton-Server und lädt die Modelldaten. Dieser Vorgang kann einige Minuten dauern (bis zu 20 Minuten oder länger). Die Ausgabe sieht etwa so aus:

I0216 03:24:57.387420 29 server.cc:676]
+------------------+---------+--------+
| Model            | Version | Status |
+------------------+---------+--------+
| ensemble         | 1       | READY  |
| postprocessing   | 1       | READY  |
| preprocessing    | 1       | READY  |
| tensorrt_llm     | 1       | READY  |
| tensorrt_llm_bls | 1       | READY  |
+------------------+---------+--------+

....
....
....

I0216 03:24:57.425104 29 grpc_server.cc:2519] Started GRPCInferenceService at 0.0.0.0:8001
I0216 03:24:57.425418 29 http_server.cc:4623] Started HTTPService at 0.0.0.0:8000
I0216 03:24:57.466646 29 http_server.cc:315] Started Metrics Service at 0.0.0.0:8002

Modell bereitstellen

In diesem Abschnitt interagieren Sie mit dem Modell.

Portweiterleitung einrichten

Führen Sie den folgenden Befehl aus, um die Portweiterleitung zum Modell einzurichten:

kubectl port-forward service/triton-server 8000:8000

Die Ausgabe sieht in etwa so aus:

Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
Handling connection for 8000

Mithilfe von curl mit dem Modell interagieren

In diesem Abschnitt wird gezeigt, wie Sie einen einfachen Smoke Test machen, um das bereitgestellte Modell für eine Anleitung zu prüfen. Der Einfachheit halber wird in diesem Abschnitt der Testansatz nur mit dem abgestimmten 2B-Anweisungsmodell beschrieben.

Verwenden Sie in einer neuen Terminalsitzung curl, um mit Ihrem Modell zu chatten:

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST localhost:8000/v2/models/ensemble/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "text_input": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "temperature": 0.9,
    "max_tokens": 128
}
EOF

Die folgende Ausgabe zeigt ein Beispiel für die Modellantwort:

{
  "context_logits": 0,
  "cum_log_probs": 0,
  "generation_logits": 0,
  "model_name": "ensemble",
  "model_version": "1",
  "output_log_probs": [0.0,0.0,...],
  "sequence_end": false,
  "sequence_id": 0,
  "sequence_start": false,
  "text_output":"Python.\n\nPython is an excellent choice for beginners due to its simplicity, readability, and extensive documentation. Its syntax is close to natural language, making it easier for beginners to understand and write code. Python also has a vast collection of libraries and tools that make it versatile for various projects. Additionally, Python's dynamic nature allows for easier learning and experimentation, making it a perfect choice for newcomers to get started.Here are some specific reasons why Python is a good choice for beginners:\n\n- Simple and Easy to Read: Python's syntax is designed to be close to natural language, making it easier for"
}

Probleme beheben

Wenn Sie die Empty reply from server-Meldung erhalten, hat der Container möglicherweise die Modelldaten noch nicht ganz heruntergeladen. Prüfen Sie die Logs des Pods noch einmal auf die Connected-Meldung, die angibt, dass das Modell einsatzbereit ist.
Wenn Connection refused angezeigt wird, prüfen Sie, ob die Portweiterleitung aktiv ist.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Bereitgestellte Ressourcen löschen

Mit dem folgenden Befehl vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Anleitung erstellten Ressourcen in Rechnung gestellt werden:

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

Nächste Schritte

GPUs in GKE
GPU-Arbeitslasten in Autopilot bereitstellen
GPU-Arbeitslasten in Standard bereitstellen
GitHub-Repository und die Dokumentation zu TensorRT-LLM ansehen.
Erfahren Sie mehr über den Vertex AI Model Garden.
Erfahren Sie, wie Sie optimierte KI-/ML-Arbeitslasten über Funktionen zur GKE-Plattformorchestrierung ausführen.

Offene Gemma-Modelle mit GPUs in GKE mit Triton und TensorRT-LLM bereitstellen

Hintergrund

Gemma

GPUs

TensorRT-LLM

Triton

Lernziele

Hinweise

Check for the roles

Grant the roles

Umgebung vorbereiten

Zugriff auf das Modell erhalten

Lizenz-Einwilligungsvereinbarung unterzeichnen

Zugriffstoken erstellen

Zugriffstoken in Cloud Shell hochladen

Google Cloud-Ressourcen erstellen und konfigurieren

GKE-Cluster und -Knotenpool erstellen

Autopilot

Standard

Kubernetes-Secret für Kaggle-Anmeldedaten erstellen

PersistentVolume-Ressource zum Speichern von Prüfpunkten erstellen

TensorRT-LLM-Engine-Dateien für Gemma herunterladen

Gemma 2B-it

Gemma 7B-it

Triton bereitstellen

Modell bereitstellen

Portweiterleitung einrichten

Mithilfe von curl mit dem Modell interagieren

Probleme beheben

Bereinigen

Bereitgestellte Ressourcen löschen

Nächste Schritte