Offene Gemma-Modelle mithilfe von TPUs in GKE mit Saxml bereitstellen

Standard

In diesem Leitfaden wird beschrieben, wie Sie ein offenes Gemma- Large Language Model (LLM) mit Tensor Processing Units (TPUs) auf Google Kubernetes Engine (GKE) mit Saxml bereitstellen. In dieser Anleitung laden Sie die mit 2B- und 7B-Parameteranweisungen angepassten Gemma-Modelle in Cloud Storage herunter und stellen sie in einem GKE-Standardcluster mithilfe von Containern bereit, die Saxml ausführen.

Dieser Leitfaden ist ein guter Ausgangspunkt, wenn Sie die Skalierbarkeit, Robustheit und Kosteneffizienz benötigen, die Kubernetes-Features bei der Bereitstellung Ihres Modells auf Saxml bieten.

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 TPUs in GKE mit Saxml bereitstellen, können Sie eine robuste, produktionsbereite Inferenzbereitstellungslösung mit allen Vorteilen des verwalteten Kubernetes implementieren, darunter effizientere 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 generativer KI-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 für die Textgenerierung verwenden. Außerdem können Sie diese Modelle für spezielle Aufgaben optimieren.

Weitere Informationen finden Sie in der Gemma-Dokumentation.

TPUs

TPUs sind von Google speziell entwickelte anwendungsspezifische integrierte Schaltkreise (ASICs), die verwendet werden, um Datenverarbeitungs-Frameworks wie TensorFlow, PyTorch und JAX zu beschleunigen.

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 werden die Modelle Gemma 2B und Gemma 7B bereitgestellt. GKE hostet diese Modelle auf den folgenden TPU v5e-Knotenpools mit nur einem Host:

Gemma 2B: Abgestimmtes Anleitungsmodell, das in einem TPU v5e-Knotenpool mit 1x1-Topologie gehostet wird, die einen TPU-Chip darstellt. Der Maschinentyp für die Knoten ist ct5lp-hightpu-1t.
Gemma 7B: Abgestimmtes Anleitungsmodell, das in einem TPU v5e-Knotenpool mit 2x2-Topologie gehostet wird, die vier TPU-Chips darstellt. Der Maschinentyp für die Knoten ist ct5lp-hightpu-4t

Saxml

Saxml ist ein experimentelles System, das Paxml-, JAX- und PyTorch-Modelle zur Inferenz bereitstellt. Das Saxml-System umfasst die folgenden Komponenten:

Saxml-Zelle oder Sax-Cluster: Je ein Administratorserver und eine Gruppe Modellserver. Der Administratorserver verfolgt die Modellserver, weist den bereitzustellenden Modellservern veröffentlichte Modelle zu und unterstützt Clients bei der Suche nach Modellservern, die bestimmte veröffentlichte Modelle bereitstellen.
Saxml-Client: Die für Nutzer sichtbare Programmierschnittstelle für das Saxml-System. Der Saxml-Client enthält ein Befehlszeilentool (saxutil) und eine Reihe von Clientbibliotheken in Python, C++ und Go.

In dieser Anleitung verwenden Sie auch den Saxml-HTTP-Server. Der Saxml HTTP Server ist ein benutzerdefinierter HTTP-Server, der die Saxml Python-Clientbibliothek kapselt und REST APIs für die Interaktion mit dem Saxml-System bereitstellt. Die REST APIs umfassen Endpunkte zum Veröffentlichen, Auflisten, Aufheben der Veröffentlichung von Modellen und Generieren von Vorhersagen.

Ziele

Diese Anleitung richtet sich an Kunden von generativer KI, die JAX verwenden, sowie an neue oder bestehende Nutzer von GKE, die Funktionen zur Containerorchestrierung von Kubernetes für die Bereitstellung von Gemma verwenden möchten, z. B. ML-Entwickler, MLOps-Entwickler (DevOps) und Plattformadministratoren.

Diese Anleitung umfasst die folgenden Schritte:

Bereiten Sie einen GKE-Standardcluster mit der empfohlenen TPU-Topologie anhand der Modelleigenschaften vor.
Stellen Sie die Saxml-Komponenten in GKE bereit.
Gemma 2B- oder Gemma 7B-Parametermodell abrufen und veröffentlichen.
Stellen Sie die veröffentlichten Modelle bereit und interagieren Sie mit diesen.

Architektur

In diesem Abschnitt wird die in dieser Anleitung verwendete GKE-Architektur beschrieben. Die Architektur umfasst einen GKE-Standardcluster, der TPUs bereitstellt und Saxml-Komponenten hostet, um Gemma 2B- oder 7B-Modelle bereitzustellen. Das folgende Diagramm zeigt die Komponenten dieser Architektur:

Diagramm der in dieser Anleitung bereitgestellten Architektur

Diese Architektur umfasst die folgenden Komponenten:

Einen zonalen GKE-Standardcluster.
Ein TPU-Slice-Knotenpool mit einem einzelnen Host, der von dem bereitzustellenden Gemma-Modell abhängt:
- Gemma 2B: Konfiguriert mit einer TPU v5e mit einer 1x1-Topologie. Eine Instanz des Saxml Model-Servers ist für die Verwendung dieses Knotenpools konfiguriert.
- Gemma 7B: Konfiguriert mit einer TPU v5e mit einer 2x2-Topologie. Eine Instanz des Saxml Model-Servers ist für die Verwendung dieses Knotenpools konfiguriert.
Ein Standard-CPU-Knotenpool, in dem der Saxml Admin-Server und der Saxml-HTTP-Server bereitgestellt werden.
Zwei Cloud Storage-Buckets:
- Ein Cloud Storage-Bucket speichert den von einem Admin-Server verwalteten Status.
- Ein Cloud Storage-Bucket speichert die Prüfpunkte des Gemma-Modells.

Diese Architektur hat folgende Merkmale:

Eine öffentliche Artifact Registry verwaltet die Container-Images für die Saxml-Komponenten.
Der GKE-Cluster verwendet Workload Identity Federation for GKE. Alle Saxml-Komponenten verwenden eine Identitätsföderation von Arbeitslasten, die ein IAM-Dienstkonto einbindet, um auf externe Dienste wie Cloud Storage-Buckets zuzugreifen.
Die von Saxml-Komponenten generierten Logs sind in Cloud Logging eingebunden.
Mit Cloud Monitoring können Sie die Leistungsmesswerte von GKE-Knotenpools analysieren, die in dieser Anleitung erstellt wurden.

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.

Achten Sie darauf, dass Sie genügend Kontingente für 5 TPU v5e-Chips haben. In dieser Anleitung verwenden Sie On-Demand-Instanzen.
Erstellen Sie ein Kaggle-Konto, falls Sie noch keines haben.

Umgebung für Gemma vorbereiten

Cloud Shell starten

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.

Starten Sie in der Google Cloud Console eine Cloud Shell-Instanz:
Cloud Shell öffnen
Legen Sie die Standardumgebungsvariablen fest:
```
gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=saxml-tpu
```
Ersetzen Sie die folgenden Werte:
- PROJECT_ID: Ihre Google Cloud-Projekt-ID.
- LOCATION: Der Name der Compute Engine-Zone, in der die TPU v5e-Maschinentypen verfügbar sind.

GKE-Standardcluster erstellen

In diesem Abschnitt erstellen Sie den GKE-Cluster und den Knotenpool.

Gemma 2B-it

Erledigen Sie mit Cloud Shell Folgendes:

Erstellen Sie einen Standard-Cluster, der die Workload Identity Federation for GKE verwendet:

gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --release-channel=rapid \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${LOCATION}

Die Erstellung eines Clusters kann einige Minuten dauern.

Erstellen Sie einen TPU v5e-Knotenpool mit einer 1x1-Topologie und einem Knoten:

gcloud container node-pools create tpu-v5e-1x1 \
    --cluster=${CLUSTER_NAME} \
    --machine-type=ct5lp-hightpu-1t \
    --num-nodes=1 \
    --location=${LOCATION}

Sie stellen das Gemma 2B-Modell in diesem Knotenpool bereit.

Gemma 7B-it

Erledigen Sie mit Cloud Shell Folgendes:

Erstellen Sie einen Standard-Cluster, der die Workload Identity Federation for GKE verwendet:

gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --release-channel=rapid \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${LOCATION}

Die Erstellung eines Clusters kann einige Minuten dauern.

Erstellen Sie einen TPU v5e-Knotenpool mit einer 2x2-Topologie und einem Knoten:

gcloud container node-pools create tpu-v5e-2x2 \
    --cluster=${CLUSTER_NAME} \
    --machine-type=ct5lp-hightpu-4t \
    --num-nodes=1 \
    --location=${LOCATION}

Sie stellen das Gemma 7B-Modell in diesem Knotenpool bereit.

Cloud Storage-Buckets erstellen

Erstellen Sie zwei Cloud Storage-Buckets zum Verwalten des Status des Saxml Admin-Servers und der Modellprüfpunkte.

Führen Sie in Cloud Shell folgenden Befehl aus:

Erstellen Sie einen Cloud Storage-Bucket zum Speichern von Saxml Admin-Serverkonfigurationen.
```
gcloud storage buckets create gs://ADMIN_BUCKET_NAME
```
Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Cloud Storage-Buckets, in dem der Saxml-Admin-Server gespeichert ist.
Erstellen Sie einen Cloud Storage-Bucket zum Speichern von Modellprüfpunkten:
```
gcloud storage buckets create gs://CHECKPOINTS_BUCKET_NAME
```
Ersetzen Sie CHECKPOINTS_BUCKET_NAME durch den Namen des Cloud Storage-Buckets, in dem die Modellprüfpunkte gespeichert sind.

Arbeitslastzugriff mit Workload Identity Federation for GKE konfigurieren

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

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

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

Erstellen Sie ein Kubernetes-ServiceAccount für die Anwendung:
```
gcloud iam service-accounts create wi-sax
```

Fügen Sie eine IAM-Richtlinienbindung für Ihr IAM-Dienstkonto zum Lesen und Schreiben in Cloud Storage hinzu:

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

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-sax@${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-sax@${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-sax@${PROJECT_ID}.iam.gserviceaccount.com

Zugriff auf das Modell erhalten

Damit Sie auf die Gemma-Modelle für die Bereitstellung in GKE zugreifen können, müssen Sie sich in der Kaggle-Plattform anmelden, die Lizenz-Einwilligungsvereinbarung unterzeichnen und ein Kaggle-API-Token erwerben. In dieser Anleitung verwenden Sie ein Kubernetes Secret für die Kaggle-Anmeldedaten.

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 das Erteilen der 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.

Kaggle lädt eine Datei mit dem Namen kaggle.json herunter.

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=${LOCATION}

Erstellen Sie ein Secret zum Speichern der Kaggle-Anmeldedaten:

kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json

Saxml bereitstellen

In diesem Abschnitt stellen Sie den Saxml-Admin-Server, Modellserver und den HTTP-Server bereit.

Saxml-Admin-Server bereitstellen

Erstellen Sie das folgende saxml-admin-server.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-admin-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sax-admin-server
  template:
    metadata:
      labels:
        app: sax-admin-server
    spec:
      hostNetwork: false
      containers:
      - name: sax-admin-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-admin-server:v1.2.0
        securityContext:
          privileged: true
        ports:
        - containerPort: 10000
        env:
        - name: GSBUCKET
          value: ADMIN_BUCKET_NAME

Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

Wenden Sie das Manifest an:

kubectl apply -f saxml-admin-server.yaml

Prüfen Sie die Bereitstellung des Administratorservers:

kubectl get deployment

Die Ausgabe sieht dann ungefähr so aus:

NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
sax-admin-server                  1/1     1            1           ##s

Saxml-Modellserver bereitstellen

Folgen Sie dieser Anleitung, um den Modellserver für das Modell Gemma 2B oder für Gemma 7B bereitzustellen.

Gemma 2B-it

Erstellen Sie das folgende saxml-model-server-1x1.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-model-server-v5e-1x1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b-it
        ai.gke.io/inference-server: saxml
        examples.ai.gke.io/source: user-guide
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 1x1
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      hostNetwork: false
      restartPolicy: Always
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
        args:
        - "--jax_platforms=tpu"
        - "--platform_chip=tpuv5e"
        - "--platform_topology=1x1"
        - "--port=10001"
        - "--sax_cell=/sax/test"
        ports:
        - containerPort: 10001
        securityContext:
          privileged: true
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
        resources:
          requests:
            google.com/tpu: 1
          limits:
            google.com/tpu: 1

Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

Wenden Sie das Manifest an:

kubectl apply -f saxml-model-server-1x1.yaml

Prüfen Sie den Status der Bereitstellung des Modellservers:

kubectl get deployment

Die Ausgabe sieht dann ungefähr so aus:

NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-1x1                          1/1     Running   0          ##s

Gemma 7B-it

Erstellen Sie das folgende saxml-model-server-2x2.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-model-server-v5e-2x2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b-it
        ai.gke.io/inference-server: saxml
        examples.ai.gke.io/source: user-guide
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x2
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      hostNetwork: false
      restartPolicy: Always
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
        args:
        - "--jax_platforms=tpu"
        - "--platform_chip=tpuv5e"
        - "--platform_topology=2x2"
        - "--port=10001"
        - "--sax_cell=/sax/test"
        ports:
        - containerPort: 10001
        securityContext:
          privileged: true
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4

Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

Wenden Sie das Manifest an:

kubectl apply -f saxml-model-server-2x2.yaml

Prüfen Sie den Status der Bereitstellung des Modellservers:

kubectl get deployment

Die Ausgabe sieht dann ungefähr so aus:

NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-2x2                          1/1     Running   0          ##s

Saxml-HTTP-Server bereitstellen

In diesem Abschnitt stellen Sie den Saxml-HTTP-Server bereit und erstellen einen Cluster-IP-Dienst, mit dem Sie auf den Server zugreifen.

Erstellen Sie das folgende saxml-http.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-http
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sax-http
  template:
    metadata:
      labels:
        app: sax-http
    spec:
      hostNetwork: false
      containers:
      - name: sax-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-http:v1.2.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8888
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
---
apiVersion: v1
kind: Service
metadata:
  name: sax-http-svc
spec:
  selector:
    app: sax-http
  ports:
  - protocol: TCP
    port: 8888
    targetPort: 8888
  type: ClusterIP

Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Cloud Storage-Buckets, in dem der Saxml-Admin-Server gespeichert ist.

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

Prüfen Sie den Status der Saxml-HTTP-Serverbereitstellung:

kubectl get deployment

Gemma 2B-it

Die Ausgabe sieht dann ungefähr so aus:

  NAME                                              READY   STATUS    RESTARTS   AGE
  sax-admin-server                                  1/1     Running   0          ##m
  sax-model-server-v5e-1x1                          1/1     Running   0          ##m
  sax-http                                          1/1     Running   0          ##s

Gemma 7B-it

Die Ausgabe sieht dann ungefähr so aus:

  NAME                                              READY   STATUS    RESTARTS   AGE
  sax-admin-server                                  1/1     Running   0          ##m
  sax-model-server-v5e-2x2                          1/1     Running   0          ##m
  sax-http                                          1/1     Running   0          ##s

Modellprüfpunkt herunterladen

In diesem Abschnitt führen Sie einen Kubernetes-Job aus, der den Modellprüfpunkt abruft, herunterlädt und speichert. Folgen Sie der Anleitung für das Gemma-Modell, das Sie verwenden möchten:

Gemma 2B-it

Erstellen Sie das folgende job-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}') && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \

    gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-2b
  labels:
    app: data-loader-2b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-2b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
        command:
        - /scripts/fetch_model.sh
        env:
        - name: BUCKET_NAME
          value: CHECKPOINTS_BUCKET_NAME
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/pax/2b-it/2"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts

Ersetzen Sie CHECKPOINTS_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

Wenden Sie das Manifest an:
```
kubectl apply -f job-2b.yaml
```

Warten Sie, bis der Job abgeschlossen ist:

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

Die Ausgabe sieht dann ungefähr so aus:

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

Prüfen Sie, ob der Job erfolgreich abgeschlossen wurde:

kubectl get job/data-loader-2b

Die Ausgabe sieht dann ungefähr so aus:

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

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

kubectl logs --follow job/data-loader-2b

Der Job lädt den Prüfpunkt auf gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000 hoch.

Gemma 7B-it

Erstellen Sie das folgende job-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}') && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \

    gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-7b
  labels:
    app: data-loader-7b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-7b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
        command:
        - /scripts/fetch_model.sh
        env:
        - name: BUCKET_NAME
          value: CHECKPOINTS_BUCKET_NAME
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/pax/7b-it/2"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts

Ersetzen Sie CHECKPOINTS_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie dabei das Präfix gs:// an.

Wenden Sie das Manifest an:
```
kubectl apply -f job-7b.yaml
```

Warten Sie, bis der Job abgeschlossen ist:

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

Die Ausgabe sieht dann ungefähr so aus:

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

Prüfen Sie, ob der Job erfolgreich abgeschlossen wurde:

kubectl get job/data-loader-7b

Die Ausgabe sieht dann ungefähr so aus:

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

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

kubectl logs --follow job/data-loader-7b

Der Job lädt den Prüfpunkt auf gs://CHECKPOINTS_BUCKET_NAME/gemma_7b_it/checkpoint_00000000 hoch.

Saxml-HTTP-Server freigeben

Sie können über den ClusterIP-Dienst, den Sie beim Bereitstellen des Saxml-HTTP-Servers erstellt haben, auf den Saxml-HTTP-Server zugreifen. 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:

Richten Sie eine Portweiterleitungssitzung ein:

kubectl port-forward service/sax-http-svc 8888:8888

Prüfen Sie, ob Sie auf den Saxml-HTTP-Server zugreifen können. Öffnen Sie dazu ein neues Terminal und führen Sie den folgenden Befehl aus:
```
curl -s localhost:8888
```
Die Ausgabe sieht dann ungefähr so aus:
```
{
    "Message": "HTTP Server for SAX Client"
}
```

Der Saxml-HTTP-Server kapselt die Clientschnittstelle zum Saxml-System und und stellt sie über eine Reihe von REST APIs zur Verfügung. Sie verwenden diese APIs für die Veröffentlichung, Verwaltung und Kontrolle von Gemma 2B- und Gemma 7B-Modellen.

Gemma-Modell veröffentlichen

Als Nächstes können Sie das Gemma-Modell auf einem Modellserver veröffentlichen, der in einem TPU-Slice-Knotenpool ausgeführt wird. Sie verwenden die publish API des Saxml HTTP-Servers, um ein Modell zu veröffentlichen. Führen Sie die folgenden Schritte aus, um das Parametermodell Gemma 2B oder 7B zu veröffentlichen.

Weitere Informationen über die Saxml-HTTP-Server-API finden Sie unter Saxml-HTTP-APIs

Gemma 2B-it

Prüfen Sie, ob Ihre Portweiterleitungssitzung noch aktiv ist:
```
curl -s localhost:8888
```

Veröffentlichen Sie den Parameter „Gemma 2B“:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/publish \
--data \
'{
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "replicas": "1"
}'

Die Ausgabe sieht dann ungefähr so aus:

{
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "replicas": 1
}

Sehen Sie sich den nächsten Schritt an, um den Fortschritt der Bereitstellung zu überwachen.

Überwachen Sie den Fortschritt, wozu Sie Logs in einem Modellserver-Pod des Deployments sax-model-server-v5e-1x1 beobachten.

kubectl logs --follow deployment/sax-model-server-v5e-1x1

Diese Bereitstellung kann bis zu fünf Minuten dauern. Warten Sie, bis eine Meldung wie die folgende angezeigt wird:

I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma2bfp16

Prüfen Sie, ob Sie auf das Modell zugreifen können. Lassen Sie dazu die Modellinformationen anzeigen:

curl --request GET \
--header "Content-type: application/json" \
-s \
localhost:8888/listcell \
--data \
'{
    "model": "/sax/test/gemma2bfp16"
}'

Die Ausgabe sieht dann ungefähr so aus:

{
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "max_replicas": 1,
    "active_replicas": 1
}

Gemma 7B-it

Prüfen Sie, ob Ihre Portweiterleitungssitzung noch aktiv ist:
```
curl -s localhost:8888
```

Veröffentlichen Sie den Parameter Gemma 7B:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/publish \
--data \
'{
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "replicas": "1"
}'

Die Ausgabe sieht dann ungefähr so aus:

{
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "replicas": 1
}

Sehen Sie sich den nächsten Schritt an, um den Fortschritt der Bereitstellung zu überwachen.

Überwachen Sie den Fortschritt, wozu Sie Logs in einem Modellserver-Pod des Deployments sax-model-server-v5e-2x2 beobachten.

kubectl logs --follow deployment/sax-model-server-v5e-2x2

Warten Sie, bis eine Meldung wie die folgende angezeigt wird:

I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma7bfp16

Prüfen Sie anhand der Modellinformationen, ob das Modell veröffentlicht wurde:

curl --request GET \
--header "Content-type: application/json" \
-s \
localhost:8888/listcell \
--data \
'{
    "model": "/sax/test/gemma7bfp16"
}'

Die Ausgabe sieht in etwa so aus:

{
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "max_replicas": 1,
    "active_replicas": 1
}

Modell verwenden

Sie können mit den Modellen Gemma 2B oder 7B interagieren. Verwenden Sie die generate API des Saxml-HTTP-Datei-Servers, um einen Prompt an das Modell zu senden.

Gemma 2B-it

Stellen Sie eine Prompt-Anfrage mithilfe des generate-Endpunkts des Saxml-HTTP-Servers bereit:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma2bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

Im Folgenden finden Sie ein Beispiel für die Modellantwort. Die tatsächliche Ausgabe variiert je nach dem von Ihnen gesendeten Prompt:

[
    [
        "\n\n1. **Python**\n2. **JavaScript**\n3. **Java**\n4. **C++**\n5. **Go**",
        -3.0704939365386963
    ]
]

Sie können den Befehl mit verschiedenen query-Parametern ausführen. Weitere Parameter wie temperature, top_k und topc_p können Sie auch mit der generate API ändern. Weitere Informationen über die Saxml-HTTP-Server-API finden Sie unter Saxml-HTTP-APIs.

Gemma 7B-it

Stellen Sie eine Prompt-Anfrage mithilfe des generate-Endpunkts des Saxml-HTTP-Servers bereit:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma7bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

Im Folgenden finden Sie ein Beispiel für die Modellantwort. Die Ausgabe kann in jedem von Ihnen bereitgestellten Prompt variieren:

[
    [
        "\n\n**1. JavaScript**\n\n* Most widely used language on the web.\n* Used for front-end development, such as websites and mobile apps.\n* Extensive libraries and frameworks available.\n\n**2. Python**\n\n* Known for its simplicity and readability.\n* Versatile, used for various tasks, including data science, machine learning, and web development.\n* Large and active community.\n\n**3. Java**\n\n* Object-oriented language widely used in enterprise applications.\n* Used for web applications, mobile apps, and enterprise software.\n* Strong ecosystem and support.\n\n**4. Go**\n\n",
        -16.806324005126953
    ]
]

Sie können den Befehl mit verschiedenen query-Parametern ausführen. Sie können auch zusätzliche Parameter wie temperature, top_k, topc_p mithilfe der generate API erstellen. Weitere Informationen über die Saxml-HTTP-Server-API finden Sie unter Saxml-HTTP-APIs.

Veröffentlichung des Modells aufheben

So heben Sie die Veröffentlichung Ihres Modells auf:

Gemma 2B-it

Führen Sie den folgenden Befehl aus, um die Veröffentlichung des Gemma 2B-it-Modells aufzuheben:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma2bfp16"
}'

Die Ausgabe sieht dann ungefähr so aus:

{
    "model": "/sax/test/gemma2bfp16"
}

Sie können den Befehl mit verschiedenen Eingabeaufforderungen ausführen, die im query-Parameter übergeben werden.

Gemma 7B-it

Führen Sie den folgenden Befehl aus, um die Veröffentlichung des Gemma 7B-it-Modells aufzuheben:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma7bfp16"
}'

Die Ausgabe sieht dann ungefähr so aus:

{
    "model": "/sax/test/gemma7bfp16"
}

Sie können den Befehl mit verschiedenen Eingabeaufforderungen ausführen, die im query-Parameter übergeben werden.

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} --location=${LOCATION}
gcloud iam service-accounts delete --quiet wi-sax@${PROJECT_ID}.iam.gserviceaccount.com
gcloud storage rm --recursive gs://ADMIN_BUCKET_NAME
gcloud storage rm --recursive gs://CHECKPOINTS_BUCKET_NAME

Ersetzen Sie Folgendes:

ADMIN_BUCKET_NAME: der Name des Cloud Storage-Bucket, in dem der Saxml-Admin-Server gespeichert ist.
CHECKPOINTS_BUCKET_NAME: der Name des Cloud Storage-Bucket, in dem die Modellprüfpunkte gespeichert sind.

Nächste Schritte

Mehr über TPUs in GKE erfahren
Lernen Sie das GitHub-Repository für Saxml und die Saxml HTTP APIs kennen.
Erfahren Sie mehr über den Vertex AI Model Garden.
Erfahren Sie, wie Sie optimierte KI-/ML-Arbeitslasten über Funktionen für die GKE-Plattformorchestrierung ausführen.
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center

Offene Gemma-Modelle mithilfe von TPUs in GKE mit Saxml bereitstellen

Hintergrund

Gemma

TPUs

Saxml

Ziele

Architektur

Hinweise

Check for the roles

Grant the roles

Umgebung für Gemma vorbereiten

Cloud Shell starten

GKE-Standardcluster erstellen

Gemma 2B-it

Gemma 7B-it

Cloud Storage-Buckets erstellen

Arbeitslastzugriff mit Workload Identity Federation for GKE konfigurieren

Zugriff auf das Modell erhalten

Lizenz-Einwilligungsvereinbarung unterzeichnen

Zugriffstoken erstellen

Zugriffstoken in Cloud Shell hochladen

Kubernetes-Secret für Kaggle-Anmeldedaten erstellen

Saxml bereitstellen

Saxml-Admin-Server bereitstellen

Saxml-Modellserver bereitstellen

Gemma 2B-it

Gemma 7B-it

Saxml-HTTP-Server bereitstellen

Gemma 2B-it

Gemma 7B-it

Modellprüfpunkt herunterladen

Gemma 2B-it

Gemma 7B-it

Saxml-HTTP-Server freigeben

Gemma-Modell veröffentlichen

Gemma 2B-it

Gemma 7B-it

Modell verwenden

Gemma 2B-it

Gemma 7B-it

Veröffentlichung des Modells aufheben

Gemma 2B-it

Gemma 7B-it

Probleme beheben

Bereinigen

Bereitgestellte Ressourcen löschen

Nächste Schritte