Gemma mithilfe von TPUs in GKE mit JetStream bereitstellen

Autopilot Standard

In diesem Leitfaden erfahren Sie, wie Sie ein Gemma-Large Language Model (LLM) mit Tensor Processing Units (TPUs) in Google Kubernetes Engine (GKE) mit JetStream über MaxText bereitstellen. In dieser Anleitung laden Sie die Gemma 7B-Parameteranweisungen für die abgestimmten Modellgewichtungen in Cloud Storage herunter und stellen sie auf einem GKE-Autopilot oder -Standard mit einem Container, der JetStream ausführt, bereit.

Wenn Sie beim Bereitstellen Ihres Modells in JetStream die Skalierbarkeit, Robustheit und Kosteneffizienz der Kubernetes-Features benötigen, ist dieser Leitfaden ein guter Ausgangspunkt.

Hintergrund

Durch die Bereitstellung von Gemma über TPUs in GKE mit JetStream können Sie eine robuste, produktionsreife Bereitstellungslösung mit allen Vorteilen von verwaltetem Kubernetes erstellen, einschließlich Kosteneffizienz, Skalierbarkeit und höhere Verfügbarkeit. In diesem Abschnitt werden die in dieser Anleitung 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.

TPUs

TPUs sind von Google speziell entwickelte anwendungsspezifische integrierte Schaltungen (Application-Specific Integrated Circuits, ASICs), die verwendet werden, um das maschinelle Lernen und die KI-Modelle zu beschleunigen, die mit Frameworks wie folgenden erstellt wurden:TensorFlow, PyTorch undJAX.

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

Lernen Sie mehr über die aktuelle Verfügbarkeit von TPU-Versionen unter Cloud TPU-Systemarchitektur.
TPUs in GKE

In dieser Anleitung wird das Bereitstellen des Modells Gemma 7B beschrieben. GKE stellt das Modell auf TPUv5e-Knoten mit einem einzelnen Host bereit. Dabei werden TPU-Topologien basierend auf den Modellanforderungen für die Bereitstellung von Eingabeaufforderungen mit niedriger Latenz konfiguriert.

JetStream

JetStream ist ein von Google entwickeltes Open-Source-Framework zur Bereitstellung von Inferenzen. JetStream ermöglicht leistungsstarke, durchsatzintensive und speicheroptimierte Inferenz auf TPUs und GPUs. Es bietet erweiterte Leistungsoptimierungen, einschließlich Techniken zur kontinuierlichen Batch- und Quantisierung, um die LLM-Bereitstellung zu erleichtern. JetStream ermöglicht die PyTorch/XLA- und JAX-TPU-Bereitstellung, um eine optimale Leistung zu erzielen.

Weitere Informationen zu diesen Optimierungen finden Sie in den Projekt-Repositories JetStream PyTorch und JetStream MaxText.

MaxText

MaxText ist eine leistungsstarke, skalierbare und anpassbare JAX LLM-Implementierung, die auf Open-Source-JAX-Bibliotheken auf folgende Weise basiert: Flax, Orbax undOptax. Die nur Decoder-LLM-Implementierung von MaxText ist in Python geschrieben. Es nutzt den XLA-Compiler stark aus, um eine hohe Leistung zu erzielen, ohne benutzerdefinierte Kernel erstellen zu müssen.

Weitere Informationen zu den neuesten Modellen und Parametergrößen, die von MaxText unterstützt werden, finden Sie im Projekt-Repository MaxtText.

Ziele

Diese Anleitung richtet sich an Kunden von generativer KI, die JAX verwenden, neue oder bestehende Nutzer von GKE, ML-Entwicklern, MLOps-Entwicklern (DevOps) oder Plattformadministratoren, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen zu nutzen, um LLMs bereitzustellen.

Diese Anleitung umfasst die folgenden Schritte:

Bereiten Sie einen GKE Autopilot- oder Standardcluster mit der empfohlenen TPU-Topologie anhand der Modelleigenschaften vor.
JetStream-Komponenten in GKE bereitstellen
Anleitung zum optimierten Gemma 7B-Modell abrufen und veröffentlichen.
Stellen Sie das veröffentlichte Modell bereit und interagieren Sie damit.

Architektur

In diesem Abschnitt wird die in dieser Anleitung verwendete GKE-Architektur beschrieben. Die Architektur umfasst einen GKE Autopilot- oder Standardcluster, der TPUs bereitstellt und JetStream-Komponenten zum Bereitstellen und Bereitstellen der Modelle hostet.

Das folgende Diagramm zeigt die Komponenten dieser Architektur:

Architektur des GKE-Clusters mit TPU-Knotenpools mit einzelnen Hosts, die die Maxengine- und Max-HTTP-Komponenten enthalten.

Diese Architektur umfasst die folgenden Komponenten:

Regionaler GKE-Autopilot- oder Standard-Cluster.
Zwei TPU-Slice-Knotenpools mit einem Host, die die JetStream-Bereitstellung hosten.
Die Dienstkomponente verteilt eingehenden Traffic auf alle JetStream HTTP-Replikate.
JetStream HTTP ist ein HTTP-Server, der Anfragen als Wrapper für das erforderliche Format von JetStream akzeptiert und an den GRPC-Client von JetStream sendet.
Maxengine ist ein JetStream-Server, der Inferenzen mit kontinuierlicher Batchverarbeitung ausführt.

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.
  IAM aufrufen
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.

Prüfen Sie, ob Sie ein ausreichendes Kontingent für acht TPU v5e PodSlice Lite-Chips haben. In dieser Anleitung verwenden Sie On-Demand-Instanzen.
Erstellen Sie ein Kaggle-Konto, falls Sie noch keines haben.

Zugriff auf das Modell erhalten

Für den Zugriff auf das Gemma-Modell für die Bereitstellung in GKE müssen Sie zuerst die Lizenzeinwilligungsvereinbarung unterzeichnen.

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

Rufen Sie die Seite zur Einwilligung des Gemma-Modells 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.

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 CLUSTER_NAME=CLUSTER_NAME
export BUCKET_NAME=BUCKET_NAME
export REGION=REGION
export LOCATION=LOCATION
export CLUSTER_VERSION=CLUSTER_VERSION
```
Ersetzen Sie die folgenden Werte:
- PROJECT_ID: Ihre Google Cloud-Projekt-ID.
- CLUSTER_NAME: der Name Ihres GKE-Clusters.
- BUCKET_NAME: Der Name Ihres Cloud Storage-Buckets. Sie müssen das Präfix gs:// nicht angeben.
- REGION: Die Region, in der sich der GKE-Cluster, der Cloud Storage-Bucket und die TPU-Knoten befinden. Die Region enthält Zonen, in denen TPU v5e-Maschinentypen verfügbar sind, z. B. us-west1, us-west4, us-central1, us-east1, us-east5 oder europe-west4. Achten Sie bei Autopilot-Clustern darauf, dass Sie für die ausgewählte Region genügend zonale TPU v5e-Ressourcen haben.
- (Nur Standardcluster) LOCATION: Die Zone, in der die TPU-Ressourcen verfügbar sind (z. B. us-west4-a). Bei Autopilot-Clustern müssen Sie nicht die Zone angeben, sondern nur die Region.
- CLUSTER_VERSION: Die GKE-Version, die den gewünschten Maschinentyp unterstützen muss. Die GKE-Standardversion ist für Ihre Ziel-TPU möglicherweise nicht verfügbar. Eine Liste der für TPU-Maschinentypen verfügbaren GKE-Mindestversionen finden Sie unter TPU-Verfügbarkeit in GKE.

Google Cloud-Ressourcen erstellen und konfigurieren

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

GKE-Cluster erstellen

Sie können Gemma auf GPUs in einem TPUs-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} \
  --cluster-version=${CLUSTER_VERSION}

Standard

Einen regionalen GKE Standard-Cluster erstellen, der Workload Identity-Föderation für GKE verwendet.

gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --cluster-version=${CLUSTER_VERSION} \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${REGION}

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 gemma-7b-tpu-nodepool \
  --cluster=${CLUSTER_NAME} \
  --machine-type=ct5lp-hightpu-8t \
  --project=${PROJECT_ID} \
  --num-nodes=2 \
  --region=${REGION} \
  --node-locations=${LOCATION}

GKE erstellt einen TPU v5e-Knotenpool mit einer 2x4-Topologie und zwei Knoten.

Cloud Storage-Bucket erstellen

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

gcloud storage buckets create gs://${BUCKET_NAME} --location=${REGION}

Dadurch wird ein Cloud Storage-Bucket zum Speichern der Modelldateien erstellt, die Sie von Kaggle herunterladen.

Zugriffstoken in Cloud Shell hochladen

In Cloud Shell können Sie das Kaggle API-Token in Ihr Google Cloud-Projekt hochladen:

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.

Kubernetes-Secret für Kaggle-Anmeldedaten erstellen

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

Arbeitslastzugriff mit Identitätsföderation von Arbeitslasten für GKE konfigurieren

Weisen Sie der Anwendung ein Kubernetes-ServiceAccount zu und konfigurieren Sie dieses Kubernetes-Dienstkonto als IAM-Dienstkonto.

Erstellen Sie ein IAM-Dienstkonto für Ihre Anwendung:
```
gcloud iam service-accounts create wi-jetstream
```

Fügen Sie eine IAM-Richtlinienbindung für Ihr IAM-Dienstkonto hinzu, um Cloud Storage zu verwalten:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.objectUser

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.insightsCollectorService

Erlauben Sie dem Kubernetes-ServiceAccount, die Identität des IAM-Dienstkontos zu übernehmen. Fügen Sie dazu eine IAM-Richtlinienbindung zwischen den beiden Dienstkonten hinzu. Durch diese Bindung kann das Kubernetes-Dienstkonto als IAM-Dienstkonto verwendet werden.
```
gcloud iam service-accounts add-iam-policy-binding wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
```

Kennzeichnen Sie das Kubernetes-Dienstkonto mit der E-Mail-Adresse des IAM-Dienstkontos:

kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com

Modellprüfpunkte konvertieren

In diesem Abschnitt erstellen Sie einen Job für Folgendes:

Laden Sie den Basis-Orbax-Prüfpunkt von Kaggle herunter.
Laden Sie den Prüfpunkt in einen Cloud Storage-Bucket hoch.
Wandeln Sie den Prüfpunkt in einen MaxText-kompatiblen Prüfpunkt um.
Heben Sie den Scan des Prüfpunkts auf, der für die Bereitstellung verwendet werden soll.

Modellprüfpunkt-Konvertierungsjob bereitstellen

Folgen Sie dieser Anleitung, um die Prüfpunktdateien des Gemma 7B-Modells herunterzuladen und zu konvertieren.

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

apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-7b
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.2
        args:
        - -b=BUCKET_NAME
        - -m=google/gemma/maxtext/7b-it/2
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret

Wenden Sie das Manifest an:
```
kubectl apply -f job-7b.yaml
```
Warten Sie, bis der Pod, der den Job plant, ausgeführt wird:
```
kubectl get pod -w
```
Die Ausgabe sollte in etwa so aussehen (dies kann einige Minuten dauern):
```
NAME                  READY   STATUS              RESTARTS   AGE
data-loader-7b-abcd   0/1     ContainerCreating   0          28s
data-loader-7b-abcd   1/1     Running             0          51s
```
Bei Autopilot-Clustern kann es einige Minuten dauern, bis die erforderlichen TPU-Ressourcen bereitgestellt werden.

So rufen Sie die Logs des Jobs auf:

kubectl logs -f jobs/data-loader-7b

Wenn der Job abgeschlossen ist, sieht die Ausgabe in etwa so aus:

Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
+ echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items'

Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items

JetStream bereitstellen

In diesem Abschnitt stellen Sie den JetStream-Container für das Gemma-Modell bereit.

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 7B bereitzustellen.

Erstellen Sie das folgende jetstream-gemma-deployment.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: maxengine-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: maxengine-server
  template:
    metadata:
      labels:
        app: maxengine-server
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: maxengine-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.2
        args:
        - model_name=gemma-7b
        - tokenizer_path=assets/tokenizer.gemma
        - per_device_batch_size=4
        - max_prefill_predict_length=1024
        - max_target_length=2048
        - async_checkpointing=false
        - ici_fsdp_parallelism=1
        - ici_autoregressive_parallelism=-1
        - ici_tensor_parallelism=1
        - scan_layers=false
        - weight_dtype=bfloat16
        - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
        - prometheus_port=PROMETHEUS_PORT
        ports:
        - containerPort: 9000
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
        ports:
        - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: maxengine-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000
  - protocol: TCP
    name: jetstream-grpc
    port: 9000
    targetPort: 9000

Das Manifest legt die folgenden wichtigen Attribute fest:

tokenizer_path ist der Pfad zum Tokenizer Ihres Modells.
load_parameters_path: der Pfad im Cloud Storage-Bucket, in dem Ihre Prüfpunkte gespeichert sind.
per_device_batch_size: die Batchgröße für Decodierung pro Gerät, wobei ein TPU-Chip einem Gerät entspricht.
max_prefill_predict_length: die maximale Länge für das Vorausfüllen bei der automatischen Regression.
max_target_length: die maximale Sequenzlänge.
model_name ist der Modellname (gemma-7b).
ici_fsdp_parallelism: die Anzahl der Shards für die vollständig fragmentierte Datenparallelität (FSDP).
ici_tensor_parallelism: die Anzahl der Shards für die Tensor-Parallelität.
ici_autoregressive_parallelism: die Anzahl der Shards für die autoregressive Parallelität.
prometheus_port: Port, über den Prometheus-Messwerte verfügbar gemacht werden. Entfernen Sie dieses Argument, wenn keine Messwerte erforderlich sind.
scan_layers: boolesches Flag „Scan Layers“.
weight_dtype: der Datentyp für die Gewichtung (bfloat16).

Wenden Sie das Manifest an:

kubectl apply -f jetstream-gemma-deployment.yaml

Bereitstellung prüfen:
```
kubectl get deployment
```
Die Ausgabe sieht in etwa so aus:
```
NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
maxengine-server                  2/2     2            2           ##s
```
Bei Autopilot-Clustern kann es einige Minuten dauern, bis die erforderlichen TPU-Ressourcen bereitgestellt werden.

Prüfen Sie anhand der HTTP-Server-Logs, ob das Modell geladen und kompiliert wurde. Es kann einige Minuten dauern, bis der Server diesen Vorgang abgeschlossen hat.

kubectl logs deploy/maxengine-server -f -c jetstream-http

Die Ausgabe sieht in etwa so aus:

kubectl logs deploy/maxengine-server -f -c jetstream-http

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Rufen Sie die MaxEngine-Logs auf und prüfen Sie, ob die Kompilierung abgeschlossen ist:

kubectl logs deploy/maxengine-server -f -c maxengine-server

Die Ausgabe sieht in etwa so aus:

2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec
2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------

Modell bereitstellen

In diesem Abschnitt interagieren Sie mit dem Modell.

Portweiterleitung einrichten

Sie können auf das JetStream-Deployment über den ClusterIP-Dienst zugreifen, den Sie im vorherigen Schritt erstellt haben. Die ClusterIP-Dienste sind nur innerhalb des Clusters erreichbar. Führen Sie daher die folgenden Schritte aus, um von außerhalb des Clusters auf den Dienst zuzugreifen:

Führen Sie den folgenden Befehl aus, um eine Portweiterleitungssitzung einzurichten:

kubectl port-forward svc/jetstream-svc 8000:8000

Mithilfe von curl mit dem Modell interagieren

Prüfen Sie, ob Sie auf den JetStream-HTTP-Server zugreifen können. Öffnen Sie dazu ein neues Terminal und führen Sie den folgenden Befehl aus:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8000/generate \
--data \
'{
    "prompt": "What are the top 5 programming languages",
    "max_tokens": 200
}'

Die erste Anfrage kann aufgrund der Aufwärmphase des Modells einige Sekunden dauern. Die Ausgabe sieht in etwa so aus:

{
    "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools"
}

Optional: Über eine Gradio-Chat-Oberfläche mit dem Modell interagieren

In diesem Abschnitt erstellen Sie eine Webchat-Anwendung, mit der Sie mit Ihrem abgestimmten Modell für Anweisungen interagieren können.

Gradio ist eine Python-Bibliothek mit einem ChatInterface-Wrapper, der Benutzeroberflächen für Chatbots erstellt.

Chatoberfläche bereitstellen

Speichern Sie in Cloud Shell das folgende Manifest als gradio.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.3
        resources:
          requests:
            cpu: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://jetstream-http-svc:8000"
        - name: LLM_ENGINE
          value: "max"
        - name: MODEL_ID
          value: "gemma"
        - name: USER_PROMPT
          value: "<start_of_turn>user\nprompt<end_of_turn>\n"
        - name: SYSTEM_PROMPT
          value: "<start_of_turn>model\nprompt<end_of_turn>\n"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 7860
  type: ClusterIP

Wenden Sie das Manifest an:
```
kubectl apply -f gradio.yaml
```

Warten Sie, bis die Bereitstellung verfügbar ist:

kubectl wait --for=condition=Available --timeout=300s deployment/gradio

Chatoberfläche verwenden

Führen Sie in Cloud Shell den folgenden Befehl aus:
```
kubectl port-forward service/gradio 8080:8080
```
Dadurch wird eine Portweiterleitung von Cloud Shell zum Gradio-Dienst erstellt.
Klicken Sie oben rechts in der Cloud Shell-Taskleiste auf die Schaltfläche Webvorschau. Klicken Sie auf Vorschau auf Port 8080. Im Browser wird ein neuer Tab geöffnet.
Interagieren Sie über die Gradio-Chat-Oberfläche mit Gemma. Fügen Sie einen Prompt hinzu und klicken Sie auf Senden.

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

Führen Sie die folgenden Befehle aus und folgen Sie den Eingabeaufforderungen, um zu vermeiden, dass Ihrem Google Cloud-Konto die in dieser Anleitung erstellten Ressourcen in Rechnung gestellt werden:

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

gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

gcloud storage rm --recursive gs://BUCKET_NAME

Nächste Schritte

Erfahren Sie, wie Sie Gemma-Modelle in GKE ausführen und wie Sie optimierte KI-/ML-Arbeitslasten mit GKE-Plattformorchestrierungsfunktionen ausführen.
Mehr über TPUs in GKE erfahren
GitHub-Repository von JetStream ansehen
Erfahren Sie mehr über den Vertex AI Model Garden.

Gemma mithilfe von TPUs in GKE mit JetStream bereitstellen

Hintergrund

Gemma

TPUs

JetStream

MaxText

Ziele

Architektur

Hinweise

Check for the roles

Grant the roles

Zugriff auf das Modell erhalten

Lizenz-Einwilligungsvereinbarung unterzeichnen

Zugriffstoken erstellen

Umgebung vorbereiten

Google Cloud-Ressourcen erstellen und konfigurieren

GKE-Cluster erstellen

Autopilot

Standard

Cloud Storage-Bucket erstellen

Zugriffstoken in Cloud Shell hochladen

Kubernetes-Secret für Kaggle-Anmeldedaten erstellen

Arbeitslastzugriff mit Identitätsföderation von Arbeitslasten für GKE konfigurieren

Modellprüfpunkte konvertieren

Modellprüfpunkt-Konvertierungsjob bereitstellen

JetStream bereitstellen

Modell bereitstellen

Portweiterleitung einrichten

Mithilfe von curl mit dem Modell interagieren

Optional: Über eine Gradio-Chat-Oberfläche mit dem Modell interagieren

Chatoberfläche bereitstellen

Chatoberfläche verwenden

Probleme beheben

Bereinigen

Bereitgestellte Ressourcen löschen

Nächste Schritte