In diesem Dokument wird beschrieben, wie Sie das Laden großer KI-Modellgewichtungen aus Cloud Storage beschleunigen, indem Sie Run:ai Model Streamer mit dem vLLM-Inferenzserver in Google Kubernetes Engine (GKE) verwenden.
Bei der Lösung in diesem Dokument wird davon ausgegangen, dass Sie Ihr KI-Modell und die Gewichte im safetensors-Format bereits in einen Cloud Storage-Bucket geladen haben.
Wenn Sie Ihrer vLLM-Bereitstellung das Flag --load-format=runai_streamer hinzufügen, können Sie den Run:ai Model Streamer verwenden, um die Effizienz des Modelldownloads für Ihre KI-Arbeitslasten in GKE zu verbessern.
Dieses Dokument richtet sich an die folgenden Nutzer:
- ML-Entwickler, die große KI-Modelle so schnell wie möglich aus dem Objektspeicher in GPU-/TPU-Knoten laden müssen.
- Plattformadministratoren und ‑operatoren, die die Infrastruktur für die Modellbereitstellung in GKE automatisieren und optimieren.
- Cloud-Architekten, die spezielle Tools zum Laden von Daten für KI-/ML-Arbeitslasten evaluieren.
Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die in Google Cloud Inhalten verwiesen wird, finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.
Übersicht
Die in diesem Dokument beschriebene Lösung verwendet drei Kernkomponenten – Run:ai Model Streamer, vLLM und das Dateiformat safetensors –, um das Laden von Modellgewichtungen aus Cloud Storage auf GPU- oder TPU-Knoten zu beschleunigen.
Run:ai Model Streamer
Run:ai Model Streamer ist ein Open-Source-Python SDK, das das Laden großer KI-Modelle auf Beschleuniger beschleunigt. Modellgewichtungen werden direkt aus dem Speicher, z. B. Cloud Storage-Buckets, in den GPU- oder TPU-Arbeitsspeicher gestreamt. Der Modell-Streamer eignet sich besonders für den Zugriff auf safetensors-Dateien in Cloud Storage.
Safetensors
safetensors ist ein Dateiformat zum Speichern von Tensoren, den zentralen Datenstrukturen in KI-Modellen, das sowohl die Sicherheit als auch die Geschwindigkeit verbessert. safetensors ist als Alternative zum Pickle-Format von Python konzipiert und ermöglicht durch einen Zero-Copy-Ansatz schnelle Ladezeiten. Bei diesem Ansatz sind die Tensoren direkt über die Quelle zugänglich, ohne dass die gesamte Datei zuerst in den lokalen Speicher geladen werden muss.
vLLM
vLLM ist eine Open-Source-Bibliothek für LLM-Inferenz und ‑Bereitstellung. Es ist ein leistungsstarker Inferenzserver, der für das schnelle Laden großer KI-Modelle optimiert ist. In diesem Dokument ist vLLM die Core-Engine, die Ihr KI-Modell in GKE ausführt und eingehende Inferenzanfragen verarbeitet. Für die integrierte Authentifizierungsunterstützung von Run:ai Model Streamer für Cloud Storage ist vLLM-Version 0.11.1 oder höher für GPUs und 0.18.0 oder höher für TPUs erforderlich.
Wie Run:ai Model Streamer das Laden von KI-Modellen beschleunigt
Wenn Sie eine LLM-basierte KI-Anwendung für die Inferenz starten, kommt es oft zu einer erheblichen Verzögerung, bevor das Modell einsatzbereit ist. Diese Verzögerung, die als Kaltstart bezeichnet wird, tritt auf, weil die gesamte mehrere Gigabyte große Modelldatei von einem Speicherort wie einem Cloud Storage-Bucket auf das lokale Laufwerk Ihres Computers heruntergeladen werden muss. Die Datei wird dann in den Speicher Ihres Beschleunigers geladen. Während dieses Ladevorgangs ist der teure Beschleuniger inaktiv, was ineffizient und kostspielig ist.
Anstelle des Prozesses „Herunterladen und dann laden“ streamt der Modell-Streamer das Modell direkt aus Ihrem Cloud Storage in den GPU- oder TPU-Arbeitsspeicher. Der Streamer verwendet ein leistungsstarkes Backend, um mehrere Teile des Modells, sogenannte Tensoren, parallel zu lesen. Das gleichzeitige Lesen von Tensoren ist deutlich schneller als das sequenzielle Laden der Datei.
Architektur
Der Run:ai Model Streamer lässt sich in vLLM in der GKE einbinden, um das Laden von KI-Modellen zu beschleunigen. Dazu werden Modellgewichtungen direkt von Cloud Storage in den Beschleunigerspeicher gestreamt, ohne die lokale Festplatte zu verwenden.
Das folgende Diagramm zeigt diese Architektur:
Diese Architektur umfasst die folgenden Komponenten und den folgenden Workflow:
- Cloud Storage-Bucket: Hier werden die KI-Modellgewichte im
safetensors-Format gespeichert. - GKE-Pod mit GPUs oder TPUs: Führt den vLLM-Inferenzserver aus.
- vLLM-Inferenzserver: mit dem Flag
--load-format=runai_streamerkonfiguriert, das die Modell-Streamer-Funktion aktiviert. - Run:ai Model Streamer: Wenn vLLM gestartet wird, liest der Model Streamer Modellgewichtungen aus dem angegebenen
gs://-Pfad im Cloud Storage-Bucket. Anstatt Dateien auf die Festplatte herunterzuladen, werden Tensordaten direkt in den Beschleunigerspeicher des GKE-Pods gestreamt, wo sie sofort für die Inferenz in vLLM verfügbar sind. - Cloud Storage Rapid Cache (optional): Wenn diese Option aktiviert ist, speichert Rapid Cache Bucket-Daten in derselben Zone wie die GKE-Knoten, was den Datenzugriff für den Streamer weiter beschleunigt.
Vorteile
- Kürzere Kaltstartzeiten:Der Modellstreamer verkürzt die Zeit, die Modelle zum Starten benötigen, erheblich. Die Modellgewichtungen werden bis zu sechsmal schneller geladen als mit herkömmlichen Methoden. Weitere Informationen finden Sie unter Run:ai Model Streamer-Benchmarks.
- Verbesserte Nutzung von Beschleunigern:Durch die Minimierung von Verzögerungen beim Laden von Modellen können Beschleuniger wie GPUs und TPUs mehr Zeit für tatsächliche Inferenzaufgaben aufwenden, was die Gesamteffizienz und Verarbeitungskapazität steigert.
- Optimierter Workflow:Die in diesem Dokument beschriebene Lösung lässt sich in GKE einbinden, sodass Inferenzserver wie vLLM oder SGLang direkt auf Modelle in Cloud Storage-Buckets zugreifen können.
Hinweis
Führen Sie die folgenden Schritte aus.
Projekt auswählen oder erstellen und APIs aktivieren
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator role
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
Verify that billing is enabled for your Google Cloud project.
Enable the Kubernetes Engine, Cloud Storage, Compute Engine, IAM APIs, if any are not already enabled.
Roles required to enable APIs
To enable APIs, you need the serviceusage.services.enable permission. If you
created the project, then you likely already have this permission through the
Owner role (roles/owner). Otherwise, you can get this permission through the
Service Usage Admin role (roles/serviceusage.serviceUsageAdmin).
Learn how to grant roles.
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator role
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
Verify that billing is enabled for your Google Cloud project.
Enable the Kubernetes Engine, Cloud Storage, Compute Engine, IAM APIs, if any are not already enabled.
Roles required to enable APIs
To enable APIs, you need the serviceusage.services.enable permission. If you
created the project, then you likely already have this permission through the
Owner role (roles/owner). Otherwise, you can get this permission through the
Service Usage Admin role (roles/serviceusage.serviceUsageAdmin).
Learn how to grant roles.
Cloud Shell einrichten
In diesem Dokument werden die Google Cloud CLI- und kubectl-Befehle verwendet, um die für diese Lösung erforderlichen Ressourcen zu erstellen und zu verwalten. Sie können diese Befehle in Cloud Shell ausführen, indem Sie oben in der Google Cloud Console auf Cloud Shell aktivieren klicken.
Aktivieren Sie Cloud Shell in der Google Cloud Console.
Alternativ können Sie die gcloud CLI in Ihrer lokalen Shell-Umgebung installieren und initialisieren, um die Befehle auszuführen. Wenn Sie ein lokales Shell-Terminal verwenden möchten, führen Sie den Befehl gcloud auth login aus, um sich bei Google Cloudzu authentifizieren.
IAM-Rollen zuweisen
Ihr Google Cloud -Konto muss die folgenden IAM-Rollen für Ihr Projekt haben, damit Sie einen GKE-Cluster erstellen und Cloud Storage verwalten können:
roles/container.adminroles/storage.admin
Führen Sie die folgenden Befehle aus, um diese Rollen zuzuweisen:
gcloud projects add-iam-policy-binding PROJECT_ID \
--member="user:$(gcloud config get-value account)" \
--role="roles/container.admin"
gcloud projects add-iam-policy-binding PROJECT_ID \
--member="user:$(gcloud config get-value account)" \
--role="roles/storage.admin"
Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.
Umgebung vorbereiten
In diesem Abschnitt erfahren Sie, wie Sie Ihren GKE-Cluster einrichten und Berechtigungen für den Zugriff auf Ihr Modell in Cloud Storage konfigurieren.
GKE-Cluster erstellen
Der Run:ai Model Streamer kann sowohl mit GKE Autopilot- als auch mit Standard-Clustern verwendet werden. Wählen Sie den Clustermodus aus, der Ihren Anforderungen am besten entspricht.
Legen Sie Variablen für Ihren Projekt- und Clusternamen fest:
export PROJECT_ID=PROJECT_ID export CLUSTER_NAME=CLUSTER_NAMEErsetzen Sie Folgendes:
PROJECT_ID: Projekt-ID in Google Cloud . Sie können Ihre Projekt-ID mit dem Befehlgcloud config get-value projectermitteln.CLUSTER_NAMEist der Name Ihres Clusters. Beispiel:run-ai-test.
Erstellen Sie entweder einen Autopilot- oder einen Standardcluster:
Autopilot
So erstellen Sie einen GKE Autopilot-Cluster:
Region für den Cluster festlegen:
export REGION=REGIONErsetzen Sie
REGIONdurch die Region, in der Sie den Cluster erstellen möchten. Für eine optimale Leistung sollten Sie dieselbe Region wie für Ihren Cloud Storage-Bucket verwenden.Erstellen Sie den Cluster:
gcloud container clusters create-auto $CLUSTER_NAME \ --project=$PROJECT_ID \ --location=$REGION
Bei Autopilot-Clustern werden Knoten automatisch basierend auf den Anforderungen der Arbeitslast bereitgestellt. Wenn Sie den vLLM-Server in einem späteren Schritt bereitstellen, stellt Autopilot die GPU- oder TPU-Knoten bei Bedarf bereit. Weitere Informationen finden Sie unter Automatische Erstellung von Knotenpools.
Standard
So erstellen Sie einen GKE-Standardcluster:
Legen Sie die Zone für Ihren Cluster fest:
export ZONE=ZONEErsetzen Sie
ZONEdurch die Zone, in der Sie den Cluster erstellen möchten. Verwenden Sie für eine optimale Leistung eine Zone in derselben Region wie Ihr Cloud Storage-Bucket.Erstellen Sie den Cluster:
gcloud container clusters create $CLUSTER_NAME \ --project=$PROJECT_ID \ --zone=$ZONE \ --workload-pool=$PROJECT_ID.svc.id.goog \ --num-nodes=1
Knotenpool erstellen
Wenn Sie einen Standardcluster erstellt haben, müssen Sie einen Knotenpool mit GPUs oder TPUs erstellen. Autopilot-Cluster stellen Knoten automatisch basierend auf den Arbeitslastanforderungen bereit. Erstellen Sie einen Knotenpool basierend auf dem Beschleuniger, den Sie verwenden möchten:
* {GPU}
Create a node pool with one G2 machine (NVIDIA L4 GPU):
```sh
gcloud container node-pools create g2-gpu-pool \
--cluster=$CLUSTER_NAME \
--zone=$ZONE \
--machine-type=g2-standard-16 \
--num-nodes=1 \
--accelerator=type=nvidia-l4
```
* {TPU}
Create a node pool with TPU v7x nodes:
```sh
gcloud container node-pools create tpu7x-pool \
--cluster=$CLUSTER_NAME \
--zone=$ZONE \
--machine-type=tpu7x-standard-4t \
--num-nodes=1
```
Workload Identity Federation for GKE konfigurieren
Konfigurieren Sie Workload Identity Federation for GKE, damit Ihre GKE-Arbeitslasten sicher auf das Modell in Ihrem Cloud Storage-Bucket zugreifen können.
Legen Sie Variablen für Ihr Kubernetes-Dienstkonto und Ihren Namespace fest:
export KSA_NAME=KSA_NAME export NAMESPACE=NAMESPACEErsetzen Sie Folgendes:
NAMESPACE: Der Namespace, in dem Ihre Arbeitslasten ausgeführt werden sollen. Achten Sie darauf, für alle Ressourcen in diesem Dokument denselben Namespace zu verwenden.KSA_NAME: der Name des Kubernetes-Dienstkontos, das Ihr Pod zur Authentifizierung bei Google Cloud -APIs verwenden kann.
Erstellen Sie einen Kubernetes-Namespace:
kubectl create namespace $NAMESPACEErstellen Sie ein Kubernetes-Dienstkonto (KSA):
kubectl create serviceaccount $KSA_NAME \ --namespace=$NAMESPACEErteilen Sie Ihrem KSA die erforderlichen Berechtigungen:
Legen Sie die Umgebungsvariablen fest:
export BUCKET_NAME=BUCKET_NAME export PROJECT_ID=PROJECT_ID export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \ --format 'get(projectNumber)')Ersetzen Sie Folgendes:
BUCKET_NAME: der Name Ihres Cloud Storage-Bucket, der Ihresafetensors-Dateien enthält.PROJECT_ID: Projekt-ID in Google Cloud .
Die
PROJECT_NUMBER,PROJECT_ID,NAMESPACEundKSA_NAMEwerden in den folgenden Schritten verwendet, um die Prinzipal-ID der Workload Identity Federation for GKE für Ihr Projekt zu erstellen.Weisen Sie Ihrem KSA die Rolle
roles/storage.bucketViewerzu, um Objekte in Ihrem Cloud Storage-Bucket aufzurufen:gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \ --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/$NAMESPACE/sa/$KSA_NAME" \ --role="roles/storage.bucketViewer"Weisen Sie Ihrem KSA die Rolle
roles/storage.objectUserzu, um Objekte in Ihrem Cloud Storage-Bucket zu lesen, zu schreiben und zu löschen:gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \ --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/$NAMESPACE/sa/$KSA_NAME" \ --role="roles/storage.objectUser"
Sie haben jetzt einen GKE-Cluster mit GPUs oder TPUs eingerichtet und Workload Identity Federation for GKE konfiguriert. Dadurch wird einem Kubernetes-Dienstkonto die erforderlichen Berechtigungen für den Zugriff auf Ihr KI-Modell in Cloud Storage gewährt. Nachdem Sie den Cluster und die Berechtigungen eingerichtet haben, können Sie den vLLM-Inferenzserver bereitstellen. Dieser verwendet das Dienstkonto, um Modellgewichte mit dem Run:ai Model Streamer zu streamen.
vLLM mit dem Run:ai Model Streamer bereitstellen
Stellen Sie einen Pod bereit, auf dem der vLLM OpenAI-kompatible Server ausgeführt wird und der mit dem Flag --load-format=runai_streamer konfiguriert ist, um den Run:ai Model Streamer zu verwenden. Die vLLM-Version muss 0.11.1 oder höher für GPUs und 0.18.0 oder höher für TPUs sein.
Die folgenden Beispielmanifeste zeigen, wie vLLM mit aktiviertem Modell-Streamer für ein kleines Modell wie gemma-2-9b-it konfiguriert wird.
Das Flag --model-loader-extra-config={"distributed":true} ermöglicht das verteilte Laden von Modellgewichten und wird empfohlen, um die Leistung beim Laden von Modellen aus dem Objektspeicher zu verbessern.
Weitere Informationen finden Sie unter Tensor-Parallelismus und Abstimmbare Parameter.
Wählen Sie das Beispielmanifest basierend auf dem Accelerator aus, den Sie verwenden möchten:
GPU
Im folgenden Beispielmanifest wird eine einzelne NVIDIA L4-GPU verwendet. Wenn Sie ein großes Modell verwenden, für das mehrere GPUs erforderlich sind, erhöhen Sie den Wert von
--tensor-parallel-sizeauf die erforderliche Anzahl von GPUs.Speichern Sie das folgende Manifest als
vllm-deployment.yaml. Das Manifest ist so konzipiert, dass es sowohl in Autopilot- als auch in Standard-Clustern flexibel eingesetzt werden kann.apiVersion: apps/v1 kind: Deployment metadata: name: vllm-streamer-deployment namespace: NAMESPACE spec: replicas: 1 selector: matchLabels: app: vllm-streamer template: metadata: labels: app: vllm-streamer spec: serviceAccountName: KSA_NAME containers: - name: vllm-container image: vllm/vllm-openai:v0.11.1 command: - python3 - -m - vllm.entrypoints.openai.api_server args: - --model=gs://BUCKET_NAME/PATH_TO_MODEL - --load-format=runai_streamer - --model-loader-extra-config={"distributed":true} - --host=0.0.0.0 - --port=8000 - --disable-log-requests - --tensor-parallel-size=1 ports: - containerPort: 8000 name: api # startupProbe allows for longer startup times for large models startupProbe: httpGet: path: /health port: 8000 failureThreshold: 60 # 60 * 10s = 10 minutes timeout periodSeconds: 10 initialDelaySeconds: 30 readinessProbe: httpGet: path: /health port: 8000 failureThreshold: 3 periodSeconds: 10 resources: limits: nvidia.com/gpu: "1" requests: nvidia.com/gpu: "1" volumeMounts: - mountPath: /dev/shm name: dshm nodeSelector: cloud.google.com/gke-accelerator: nvidia-l4 volumes: - emptyDir: medium: Memory name: dshmErsetzen Sie Folgendes:
NAMESPACE: Ihr Kubernetes-Namespace.KSA_NAME: Der Name Ihres Kubernetes-Dienstkontos.BUCKET_NAME: Name Ihres Cloud Storage-Buckets.PATH_TO_MODEL: der Pfad zu Ihrem Modellverzeichnis im Bucket, z. B.models/my-llama.
TPU
Im folgenden Beispielmanifest werden TPU v7x-Knoten verwendet.
Speichern Sie das folgende Manifest als
vllm-deployment.yaml.apiVersion: apps/v1 kind: Deployment metadata: name: tpu-vllm namespace: NAMESPACE spec: replicas: 1 selector: matchLabels: app: tpu-vllm template: metadata: labels: app: tpu-vllm spec: serviceAccountName: KSA_NAME containers: - name: vllm-container image: vllm/vllm-tpu:v0.18.0 resources: limits: google.com/tpu: "4" command: ["sh", "-c"] args: - >- python3 -m vllm.entrypoints.openai.api_server --model=gs://BUCKET_NAME/PATH_TO_MODEL --load-format=runai_streamer --tensor-parallel-size=8 --port=8000 ports: - containerPort: 8000 env: - name: VLLM_XLA_CACHE_PATH value: "gs://BUCKET_NAME/PATH_TO_CACHE" nodeSelector: cloud.google.com/gke-tpu-accelerator: tpu7x cloud.google.com/gke-tpu-topology: 2x2x1Ersetzen Sie Folgendes:
NAMESPACE: Ihr Kubernetes-Namespace.KSA_NAME: Der Name Ihres Kubernetes-Dienstkontos.BUCKET_NAME: Name Ihres Cloud Storage-Buckets.PATH_TO_MODEL: Der Pfad zu Ihrem Modellverzeichnis im Bucket, z. B.models/my-llama.PATH_TO_CACHE: Der Pfad zu Ihrem XLA-Kompilierungscache-Verzeichnis im Bucket, z. B.models/xla-cache.
Wenden Sie das Manifest an, um das Deployment zu erstellen:
kubectl create -f vllm-deployment.yaml
Mit dem Tool GKE Inference Quickstart können Sie weitere vLLM-Manifeste generieren.
Deployment prüfen
Prüfen Sie den Status der Bereitstellung:
kubectl get deployments -n NAMESPACERufen Sie den Namen des Pods ab:
kubectl get pods -n NAMESPACE | grep vllm-streamerNotieren Sie sich den Namen des Pods, der mit
vllm-streamer-deploymentbeginnt.Prüfen Sie in den Pod-Logs, ob der Modell-Streamer das Modell und die Gewichtungen herunterlädt:
kubectl logs -f POD_NAME -n NAMESPACEErsetzen Sie
POD_NAMEdurch den Namen des Pods aus dem vorherigen Schritt. Erfolgreiche Streaming-Logs sehen etwa so aus:[RunAI Streamer] Overall time to stream 15.0 GiB of all files: 13.4s, 1.1 GiB/s
Optional: Leistung mit Rapid Cache steigern
Cloud Storage Rapid Cache kann das Laden von Modellen weiter beschleunigen, indem Daten näher an Ihren GKE-Knoten im Cache gespeichert werden. Das Caching ist besonders nützlich, wenn Sie mehrere Knoten in derselben Zone horizontal skalieren.
Sie aktivieren Rapid Cache für einen bestimmten Cloud Storage-Bucket in einer bestimmten Google Cloud Zone. Zur Verbesserung der Leistung muss die Zone des Cache mit der Zone übereinstimmen, in der Ihre GKE-Inferenz-Pods ausgeführt werden. Ihr Ansatz hängt davon ab, ob Ihre Pods in vorhersehbaren Zonen ausgeführt werden.
Aktivieren Sie für zonale GKE Standard-Cluster, in denen Sie wissen, in welcher Zone Ihre Pods ausgeführt werden, Rapid Cache für diese Zone.
Für regionale GKE-Cluster (sowohl Autopilot als auch Standard), in denen Pods über mehrere Zonen hinweg geplant werden können, haben Sie die folgenden Optionen:
- Caching in allen Zonen aktivieren: Aktivieren Sie Rapid Cache in jeder Zone innerhalb der Region des Clusters. So ist ein Cache verfügbar, unabhängig davon, wo GKE Ihre Pods plant. Beachten Sie, dass für jede Zone, in der das Caching aktiviert ist, Kosten anfallen. Weitere Informationen finden Sie unter Rapid Cache-Preise.
- Pods in einer bestimmten Zone platzieren: Verwenden Sie eine
nodeSelector- odernodeAffinity-Regel in Ihrem Arbeitslastmanifest, um Ihre Pods auf eine einzelne Zone zu beschränken. Anschließend können Sie Rapid Cache nur in dieser Zone aktivieren. Dies ist ein kostengünstigerer Ansatz, wenn Ihre Arbeitslast auf eine einzelne Zone beschränkt werden kann.
Führen Sie die folgenden Befehle aus, um Rapid Cache für die Zone zu aktivieren, in der sich Ihr GKE-Cluster befindet:
# Enable the cache
gcloud storage buckets anywhere-caches create gs://$BUCKET_NAME $ZONE
# Check the status of the cache
gcloud storage buckets anywhere-caches describe $BUCKET_NAME/$ZONE
Bereinigen
Damit Ihrem Google Cloud -Konto die in diesem Dokument verwendeten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder das Projekt löschen, das die Ressourcen enthält, oder das Projekt beibehalten und die einzelnen Ressourcen löschen.
So löschen Sie die einzelnen Ressourcen:
Löschen Sie den GKE-Cluster. Durch diese Aktion werden alle Knoten und Arbeitslasten entfernt.
gcloud container clusters delete CLUSTER_NAME --location=ZONE_OR_REGIONErsetzen Sie Folgendes:
CLUSTER_NAME: Der Name Ihres Clusters.ZONE_OR_REGION: Die Zone oder Region Ihres Clusters.
Deaktivieren Sie Rapid Cache, falls Sie es aktiviert haben, um laufende Kosten zu vermeiden. Weitere Informationen finden Sie unter Cache deaktivieren.
Nächste Schritte
- Hugging Face-Modelle in Cloud Storage laden (experimentell)
- LLM mit mehreren GPUs in GKE bereitstellen
- Weitere Informationen zu GPUs in GKE
- Weitere Informationen zu TPUs in GKE
- GKE-Speicher – Übersicht
- Informationen zum Konfigurieren der Identitätsföderation von Arbeitslasten