LLM mit mehreren GPUs in GKE bereitstellen

Autopilot Standard

---

In dieser Anleitung erfahren Sie, wie Sie ein großes Sprachmodell (LLM) mit GPUs in Google Kubernetes Engine (GKE) mit mehreren GPUs für effiziente und skalierbare Inferenz bereitstellen. In dieser Anleitung wird ein GKE-Cluster erstellt, das die mehrere L4-GPUs verwendet und die GKE-Infrastruktur vorbereitet, um eines der folgenden Modelle bereitzustellen:

• Llama 3 70b
• Mixtral 8x7b
• Falcon 40b

Je nach Datenformat des Modells variiert die Anzahl der GPUs. In dieser Anleitung verwendet jedes Modell zwei L4-GPUs. Weitere Informationen finden Sie unter Anzahl der GPUs berechnen.

Bevor Sie diese Anleitung in GKE durcharbeiten, sollten Sie GPUs in GKE durcharbeiten

Ziele

Diese Anleitung richtet sich an MLOps- oder DevOps-Entwickler oder Plattformadministratoren, die GKE-Orchestrierungsfunktionen zum Bereitstellen von LLMs verwenden möchten.

Diese Anleitung umfasst die folgenden Schritte:

1. Cluster und Knotenpools erstellen
2. Arbeitslast vorbereiten
3. Stellen Sie Ihre Arbeitslast bereit.
4. Mit der LLM-Oberfläche interagieren

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

• Aktivieren Sie die Google Kubernetes Engine API.
Google Kubernetes Engine API aktivieren
• Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.
  Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI die compute/region- und compute/zone-Attribute fest. Durch das Festlegen von Standardspeicherorten können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden.

• Für einige Modelle gelten zusätzliche Anforderungen. Sie müssen die folgenden Anforderungen erfüllen:

  • Verwenden Sie ein HuggingFace-Token, um auf Modelle von „Hugging Face“ zuzugreifen.
  • Akzeptieren Sie beim Mixtral 8x7b-Modell die Bedingungen für das Mistral Mixtral-Modell.
  • Beim Llama 3 70b-Modell benötigen Sie eine aktive Lizenz für die Meta-Llama-Modelle.
  Warnung: Der Zugriff und die Genehmigung für das Llama-Modell kann bis zu drei Tage dauern.

Umgebung vorbereiten

1. Starten Sie in der Google Cloud Console eine Cloud Shell-Instanz:
   Cloud Shell öffnen

2. Legen Sie die Standardumgebungsvariablen fest:

   gcloud config set project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export REGION=us-central1
   

   Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-Projekt-ID.

   Hinweis: Wenn Ihre Cloud Shell-Instanz während der Ausführung der Anleitung getrennt wird, wiederholen Sie den vorherigen Schritt.

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

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

   gcloud container clusters create-auto l4-demo \
     --project=${PROJECT_ID} \
     --region=${REGION} \
     --release-channel=rapid
   

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

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

   gcloud container clusters get-credentials l4-demo --region=${REGION}
   

Standard

1. Führen Sie in Cloud Shell den folgenden Befehl aus, um einen Standardcluster zu erstellen, der Workload Identity-Föderation für GKE verwendet:

   gcloud container clusters create l4-demo --location ${REGION} \
     --workload-pool ${PROJECT_ID}.svc.id.goog \
     --enable-image-streaming \
     --node-locations=$REGION-a \
     --workload-pool=${PROJECT_ID}.svc.id.goog \
     --machine-type n2d-standard-4 \
     --num-nodes 1 --min-nodes 1 --max-nodes 5 \
     --release-channel=rapid
   

   Hinweis: Das Flag --node-locations muss möglicherweise angepasst werden, je nach der ausgewählten Region. Prüfen Sie, welche Zonen, die die L4-GPUs haben, wenn Sie sie die Region us-central1 ändern.

   Die Erstellung eines Clusters kann einige Minuten dauern.

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

   gcloud container node-pools create g2-standard-24 --cluster l4-demo \
     --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
     --machine-type g2-standard-24 \
     --enable-autoscaling --enable-image-streaming \
     --num-nodes=0 --min-nodes=0 --max-nodes=3 \
     --node-locations $REGION-a,$REGION-c --region $REGION --spot
   

   GKE erstellt die folgenden Ressourcen für das LLM:

   • Ein öffentlicher Cluster der Google Kubernetes Engine (GKE) Standard Edition.
   • Ein Knotenpool mit dem Maschinentyp g2-standard-24, der auf 0 Knoten herunterskaliert wurde. GPUs werden Ihnen erst in Rechnung gestellt, wenn Sie Pods starten, die GPUs anfordern. Dieser Knotenpool bietet Spot-VMs, die günstiger als Standard-VMs von Compute Engine sind und keine Verfügbarkeit versprechen. Sie können das Flag --spot aus diesem Befehl und den cloud.google.com/gke-spot-Knotenselektor in der text-generation-inference.yaml-Konfiguration entfernen, um On-Demand-VMs zu verwenden.

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

   gcloud container clusters get-credentials l4-demo --region=${REGION}
   

Arbeitslast vorbereiten

Im folgenden Abschnitt wird gezeigt, wie Sie Ihre Arbeitslast abhängig vom Modell einrichten:

Llama 3 70b

1. Legen Sie die Standardumgebungsvariablen fest:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Ersetzen Sie HUGGING_FACE_TOKEN durch Ihr Hive-Face-Token.

2. Erstellen Sie ein Kubernetes-Secret für das HuggingFace-Token:

   kubectl create secret generic l4-demo \
       --from-literal=HUGGING_FACE_TOKEN=${HF_TOKEN} \
       --dry-run=client -o yaml | kubectl apply -f -
   

3. Erstellen Sie das folgende text-generation-inference.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: ghcr.io/huggingface/text-generation-inference:2.0.4
           resources:
             requests:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: meta-llama/Meta-Llama-3-70B-Instruct
           - name: NUM_SHARD
             value: "2"
           - name: MAX_INPUT_TOKENS
             value: "2048"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: l4-demo
                 key: HUGGING_FACE_TOKEN
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             - mountPath: /data
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 150Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In diesem Manifest:

   • NUM_SHARD muss 2 sein, da das Modell zwei NVIDIA L4-GPUs benötigt.
   • QUANTIZE ist auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell mit 4 Bit anstelle von 32 Bit geladen wird. Dadurch kann GKE den benötigten GPU-Arbeitsspeicher reduzieren und die Inferenzgeschwindigkeit verbessern. Die Modellgenauigkeit kann jedoch sinken. Informationen zur Berechnung der angeforderten GPUs finden Sie unter Anzahl der GPUs berechnen.

4. Wenden Sie das Manifest an:

   kubectl apply -f text-generation-inference.yaml
   

   Die Ausgabe sieht in etwa so aus:

   deployment.apps/llm created
   

5. Prüfen Sie den Status des Modells:

   kubectl get deploy
   

   Die Ausgabe sieht in etwa so aus:

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           20m
   

6. So rufen Sie die Logs des laufenden Deployments auf:

   kubectl logs -l app=llm
   

   Die Ausgabe sieht in etwa so aus:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Mixtral 8x7b

1. Legen Sie die Standardumgebungsvariablen fest:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Ersetzen Sie HUGGING_FACE_TOKEN durch Ihr Hive-Face-Token.

2. Erstellen Sie ein Kubernetes-Secret für das HuggingFace-Token:

   kubectl create secret generic l4-demo \
       --from-literal=HUGGING_FACE_TOKEN=${HF_TOKEN} \
       --dry-run=client -o yaml | kubectl apply -f -
   

3. Erstellen Sie das folgende text-generation-inference.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: ghcr.io/huggingface/text-generation-inference:1.4.3
           resources:
             requests:
               cpu: "5"
               memory: "40Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "5"
               memory: "40Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: mistralai/Mixtral-8x7B-Instruct-v0.1
           - name: NUM_SHARD
             value: "2"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: l4-demo
                 key: HUGGING_FACE_TOKEN          
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             - mountPath: /data
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 100Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In diesem Manifest:

   • NUM_SHARD muss 2 sein, da das Modell zwei NVIDIA L4-GPUs benötigt.
   • QUANTIZE ist auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell mit 4 Bit anstelle von 32 Bit geladen wird. Dadurch kann GKE den benötigten GPU-Arbeitsspeicher reduzieren und die Inferenzgeschwindigkeit verbessern. Dies kann jedoch die Modellgenauigkeit verringern. Informationen, wie Sie GPUs anfragen, finden Sie unter Anzahl der GPUs berechnen.

4. Wenden Sie das Manifest an:

   kubectl apply -f text-generation-inference.yaml
   

   Die Ausgabe sieht in etwa so aus:

   deployment.apps/llm created
   

5. Prüfen Sie den Status des Modells:

   watch kubectl get deploy
   

   Wenn die Bereitstellung bereit ist, sieht die Ausgabe in etwa so aus: Geben Sie CTRL + C ein, um die Beobachtung zu beenden.

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           10m
   

6. So rufen Sie die Logs des laufenden Deployments auf:

   kubectl logs -l app=llm
   

   Die Ausgabe sieht in etwa so aus:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Falcon 40b

1. Erstellen Sie das folgende text-generation-inference.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: ghcr.io/huggingface/text-generation-inference:1.4.3
           resources:
             requests:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: tiiuae/falcon-40b-instruct
           - name: NUM_SHARD
             value: "2"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             - mountPath: /data
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 175Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In diesem Manifest:

   • NUM_SHARD muss 2 sein, da das Modell zwei NVIDIA L4-GPUs benötigt.
   • QUANTIZE ist auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell mit 4 Bit anstelle von 32 Bit geladen wird. Dadurch kann GKE den benötigten GPU-Arbeitsspeicher reduzieren und die Inferenzgeschwindigkeit verbessern. Die Modellgenauigkeit kann jedoch sinken. Informationen, wie Sie GPUs anfragen, finden Sie unter Anzahl der GPUs berechnen.

2. Wenden Sie das Manifest an:

   kubectl apply -f text-generation-inference.yaml
   

   Die Ausgabe sieht in etwa so aus:

   deployment.apps/llm created
   

3. Prüfen Sie den Status des Modells:

   watch kubectl get deploy
   

   Wenn die Bereitstellung bereit ist, sieht die Ausgabe in etwa so aus: Geben Sie CTRL + C ein, um die Beobachtung zu beenden.

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           10m
   

4. So rufen Sie die Logs des laufenden Deployments auf:

   kubectl logs -l app=llm
   

   Die Ausgabe sieht in etwa so aus:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Service vom Typ ClusterIP erstellen

1. Erstellen Sie das folgende llm-service.yaml-Manifest:

   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: llm
     type: ClusterIP
     ports:
       - protocol: TCP
         port: 80
         targetPort: 8080
   

2. Wenden Sie das Manifest an:

   kubectl apply -f llm-service.yaml
   

Chatoberfläche bereitstellen

Webanwendung mit Gradio erstellen, um mit Ihrem Modell zu interagieren. Gradio ist eine Python-Bibliothek mit einem ChatInterface-Wrapper, der Benutzeroberflächen für Chatbots erstellt.

Llama 3 70b

1. Erstellen Sie eine Datei mit dem Namen gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy: 
       type: Recreate
     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://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "meta-llama/Meta-Llama-3-70B-Instruct"
           - name: USER_PROMPT
             value: "<|begin_of_text|><|start_header_id|>user<|end_header_id|> prompt <|eot_id|><|start_header_id|>assistant<|end_header_id|>"
           - name: SYSTEM_PROMPT
             value: "prompt <|eot_id|>"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860

2. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

3. Suchen Sie die externe IP-Adresse des Dienstes:

   kubectl get svc
   

   Die Ausgabe sieht in etwa so aus:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Kopieren Sie die externe IP-Adresse aus der Spalte EXTERNAL-IP.

5. Rufen Sie die Modellschnittstelle über Ihren Webbrowser auf, indem Sie die externe IP-Adresse mit dem freigegebenen Port verwenden:

   http://EXTERNAL_IP
   

Mixtral 8x7b

1. Erstellen Sie eine Datei mit dem Namen gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy: 
       type: Recreate
     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.0
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "mixtral-8x7b"
           - name: USER_PROMPT
             value: "[INST] prompt [/INST]"
           - name: SYSTEM_PROMPT
             value: "prompt"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860

2. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

3. Suchen Sie die externe IP-Adresse des Dienstes:

   kubectl get svc
   

   Die Ausgabe sieht in etwa so aus:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Kopieren Sie die externe IP-Adresse aus der Spalte EXTERNAL-IP.

5. Rufen Sie die Modellschnittstelle über Ihren Webbrowser auf, indem Sie die externe IP-Adresse mit dem freigegebenen Port verwenden:

   http://EXTERNAL_IP
   

Falcon 40b

1. Erstellen Sie eine Datei mit dem Namen gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy: 
       type: Recreate
     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.0
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "falcon-40b-instruct"
           - name: USER_PROMPT
             value: "User: prompt"
           - name: SYSTEM_PROMPT
             value: "Assistant: prompt"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860

2. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

3. Suchen Sie die externe IP-Adresse des Dienstes:

   kubectl get svc
   

   Die Ausgabe sieht in etwa so aus:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Kopieren Sie die externe IP-Adresse aus der Spalte EXTERNAL-IP.

5. Rufen Sie die Modellschnittstelle über Ihren Webbrowser auf, indem Sie die externe IP-Adresse mit dem freigegebenen Port verwenden:

   http://EXTERNAL_IP
   

Erfolgreich: Sie haben jetzt eine LLM mit L4-GPUs in GKE bereitgestellt.

Anzahl der GPUs berechnen

Die Anzahl der GPUs hängt vom Wert der Konfiguration QUANTIZE ab. In dieser Anleitung ist QUANTIZE auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell in 4 Bit geladen wird.

Ein Parametermodell mit 70 Milliarden Attributen würde mindestens 40 GB GPU-Arbeitsspeicher benötigen, was 70 Milliarden Mal 4 Bit (70 Milliarden x 4 Bits= 35 GB) entspricht und 5 GB Overhead berücksichtigt. In diesem Fall hätte eine einzelne L4-GPU nicht genügend Arbeitsspeicher. Daher werden in den Beispielen dieser Anleitung zwei L4-GPUs des Arbeitsspeichers (2 x 24 = 48 GB) verwendet. Diese Konfiguration ist ausreichend, um Falcon 40b oder Llama 3 70b in L4-GPUs auszuführen.

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.

Cluster löschen

Um zu vermeiden, dass Ihrem Google Cloud-Konto Gebühren für die Ressourcen, die Sie in dieser Anleitung erstellt haben, belastet werden, löschen Sie den GKE-Cluster:

gcloud container clusters delete l4-demo --region ${REGION}

Nächste Schritte

• Weitere Informationen zu G2-VMs mit NVIDIA L4-GPUs
• Modell mit GPUs im GKE Standard-Modus trainieren