Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

GPU-beschleunigtes Ray für KI-Arbeitslasten in GKE bereitstellen

Autopilot Standard

Auf dieser Seite erfahren Sie, wie Sie einen GPU-fähigen Ray-Cluster in der Google Kubernetes Engine (GKE) einrichten und ausführen, um Ihre KI-/ML-Arbeitslasten zu skalieren.

Warum Ray verwenden?

Mit Ray in der GKE, unterstützt durch KubeRay, können Sie Python- und KI-Anwendungen skalieren. Ray übernimmt die Anwendungsskalierung und GKE verwaltet die zugrunde liegenden Server und Ressourcen.

Diese Kombination erleichtert die Verwaltung von Ressourcen, die automatische Anpassung der Kapazität, die Gewährleistung der Zuverlässigkeit und die Bereitstellung Ihrer Anwendungen in verschiedenen Umgebungen. Wenn Sie Ihre verteilten Ray-Anwendungen mit Ihrer vorhandenen Cloud-Infrastruktur und Ihren Tools in GKE verbinden, können Sie den Betrieb vereinfachen und eine robuste, skalierbare Plattform für komplexe Aufgaben mit Standard-Kubernetes-Methoden bereitstellen.

Weitere Informationen finden Sie im Blogpost Why GKE for your Ray AI workloads.

Hinweis

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

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 the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the GKE API, if it is 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.
Enable the API

Install the Google Cloud CLI.
Configure the gcloud CLI to use your federated identity.

For more information, see Sign in to the gcloud CLI with your federated identity.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
kubectl installieren: kubectl ist das primäre Befehlszeilentool für die Interaktion mit GKE-Clustern. Wenn Sie Cloud Shell verwenden, ist kubectl bereits installiert. Andernfalls installieren Sie es in Ihrem Terminal, indem Sie den Befehl gcloud components install kubectl ausführen.
Führen Sie den folgenden Befehl aus, um die Installation zu prüfen: kubectl version --client
Ray installieren: Wir empfehlen dringend, vor der Installation von Ray eine virtuelle Python-Umgebung (venv) zu erstellen und zu aktivieren, damit Sie die Abhängigkeiten isolieren können.
1. Installieren Sie Python.
2. Neue virtuelle Umgebung erstellen und aktivieren
3. Installieren Sie die neueste stabile Version von Ray, indem Sie den folgenden Befehl in Ihrer virtuellen Umgebung ausführen: pip install -U "ray[default]".
4. Führen Sie den folgenden Befehl aus, um die Installation zu prüfen: ray --version. Notieren Sie sich die Ray-Version (z. B. 2.44.1) in der Ausgabe.
Prüfen Sie, ob Ihr Google Cloud -Projekt ein ausreichendes Kontingent für L4-GPUs hat. Weitere Informationen finden Sie unter GPUs und Zuteilungskontingente.

GKE-Cluster erstellen

Sie können Ihre Arbeitslast 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

Im Autopilot-Modus verwaltet Google Ihre Clusterkonfiguration, einschließlich Skalierung, Sicherheit und anderer vorkonfigurierter Einstellungen. Autopilot-Cluster sind für die Ausführung der meisten Produktionsarbeitslasten optimiert und stellen Rechenressourcen basierend auf Ihren Kubernetes-Manifesten bereit.

Führen Sie im Terminal den folgenden gcloud container clusters create-auto-Befehl aus:
```
gcloud container clusters create-auto my-ray-enabled-cluster \
    --enable-ray-operator \
    --enable-ray-cluster-monitoring \
    --enable-ray-cluster-logging \
    --location=us-central1
```
Mit diesem Google Cloud CLI-Befehl wird ein Autopilot-Cluster mit dem Namen my-ray-enabled-cluster mit den folgenden Einstellungen erstellt:
- --enable-ray-operator: Installiert den Ray Operator im Cluster, wodurch die Verwaltung von Ray-Clustern in Kubernetes vereinfacht wird.
- --enable-ray-cluster-monitoring: richtet die Einbindung in Cloud Monitoring für Ray-Cluster-Messwerte ein.
- --enable-ray-cluster-logging: Konfiguriert die Integration mit Cloud Logging, um Logs aus Ihrem Ray-Cluster zu erfassen.
- --location=us-central1: Gibt die geografische Region an, in der der GKE-Cluster erstellt wird. Die Verfügbarkeit von Beschleunigern und die unterstützten Typen variieren je nach Standort. Weitere Informationen finden Sie unter GPU-Regionen und -Zonen.
In Autopilot-Clustern werden Knoten (einschließlich GPU-fähiger Knoten, die Compute-Klassen verwenden) automatisch bereitgestellt und skaliert, basierend auf den Anforderungen der Arbeitslast. So werden sowohl die Auslastung als auch die Kosten optimiert. Durch die automatische Bereitstellung und Skalierung von Ressourcen in Autopilot-Clustern wird die Ressourcenverwaltung vereinfacht und Sie können sich auf Ihre Modelle statt auf die Infrastruktur konzentrieren.

Wenn Sie einen GKE Standard-Cluster verwenden, können sich die Flags und Einstellungen zum Aktivieren von Ray unterscheiden. Weitere Informationen finden Sie unter Ray-Operator in GKE aktivieren.

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

gcloud container clusters get-credentials my-ray-enabled-cluster \
    --location=us-central1

Standard

Im Standardmodus haben Sie mehr Kontrolle über die zugrunde liegende Infrastruktur Ihres GKE-Cluster. Sie verwalten Knotenpools, Knotengrößen und andere Konfigurationen direkt, was eine bessere Anpassung ermöglicht. Standardcluster eignen sich für Arbeitslasten, die bestimmte Konfigurationen oder eine strenge Kontrolle über Ressourcen erfordern.

Führen Sie im Terminal den folgenden gcloud container clusters create-Befehl aus:
```
gcloud container clusters create my-ray-enabled-cluster \
    --addons=RayOperator \
    --enable-ray-cluster-monitoring \
    --enable-ray-cluster-logging \
    --location=us-central1 \
    --enable-autoprovisioning \
    --max-cpu=10 \
    --max-memory=64
```
Mit diesem Google Cloud CLI-Befehl wird ein Standard-Cluster mit dem Namen my-ray-enabled-cluster mit den folgenden Einstellungen erstellt:
- --addons=RayOperator: Installiert den Ray Operator auf dem Cluster, was die Verwaltung von Ray-Clustern in Kubernetes vereinfacht.
- --enable-ray-cluster-monitoring: richtet die Einbindung in Cloud Monitoring für Ray-Cluster-Messwerte ein.
- --enable-ray-cluster-logging: Konfiguriert die Integration mit Cloud Logging, um Logs aus Ihrem Ray-Cluster zu erfassen.
- --location=us-central1: gibt die geografische Region an, in der der GKE-Cluster erstellt wird. Die Verfügbarkeit von Beschleunigern und die unterstützten Typen variieren je nach Standort. Weitere Informationen finden Sie unter GPU-Regionen und ‑Zonen.
- --enable-autoprovisioning: erstellt und löscht automatisch Knotenpools und skaliert Knoten in diesen Pools basierend auf den Anforderungen Ihrer Arbeitslast.
- --max-cpu: maximale Anzahl von Kernen, auf die der Cluster skaliert werden kann.
- --max-memory: Die maximale Anzahl von Gigabyte Arbeitsspeicher, auf die der Cluster skaliert werden kann.

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

gcloud container clusters get-credentials my-ray-enabled-cluster \
    --location=us-central1

KubeRay-Plug-in `kubectl ray` installieren

Das kubectl ray-Plug-in vereinfacht gängige Ray-Workflows in Kubernetes. Die aktuelle Installationsanleitung finden Sie in der KubeRay-Dokumentation.

Rufen Sie die Seite mit den Releases auf und laden Sie die Binärdatei für Ihre Plattform herunter. Wenn Sie beispielsweise das kubectl ray-Plug-in in der Version 1.3.2 unter Linux amd64 installieren möchten, führen Sie die folgenden Befehle aus:
```
curl -LO https://github.com/ray-project/kuberay/releases/download/v1.3.2/kubectl-ray_v1.3.2_linux_amd64.tar.gz
tar -xvf kubectl-ray_v1.3.2_linux_amd64.tar.gz
cp kubectl-ray ~/.local/bin
```
Ersetzen Sie ~/.local/bin durch das Verzeichnis in Ihrem PATH.
Installation prüfen:
```
kubectl ray version
```
Wenn Sie eine Warnung wie KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace. sehen, können Sie sie ignorieren. Wenn die Installation erfolgreich war, wird die Version des kubectl ray-Plug-ins ausgegeben.

Benutzerdefinierte Compute-Klasse in Ihrem Cluster erstellen

Mit einer benutzerdefinierten Compute-Klasse in GKE können Sie bestimmte Hardwareanforderungen wie den GPU-Typ und die Anzahl nach Priorität definieren. GKE verwendet diese Priorität beim Bereitstellen von Knoten für Ihre Arbeitslasten.

So erstellen Sie die benutzerdefinierte Beispiel-Compute-Klasse für diese Anleitung:

Speichern Sie die folgende Compute-Klassenspezifikation als nvidia-l4-compute-class.yaml:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: gpu-compute-class
spec:
  priorities:
  - gpu:
      type: nvidia-l4
      count: 1
    spot: true
  - gpu:
      type: nvidia-l4
      count: 1
    spot: false
  nodePoolAutoCreation:
    enabled: true
  whenUnsatisfiable: DoNotScaleUp

Erstellen Sie die Compute-Klasse mit dem folgenden Befehl:
```
kubectl apply -f nvidia-l4-compute-class.yaml
```
Was passiert, nachdem Sie die benutzerdefinierte Compute-Klasse angewendet haben? Nachdem Sie die YAML-Datei für die Compute-Klasse angewendet haben, stellt GKE automatisch Knoten mit einer NVIDIA L4-GPU bereit, wenn Ihr Ray-Cluster diese anfordert. Spot-VMs werden gemäß Ihrem Manifest priorisiert. Mit der Einstellung whenUnsatisfiable: DoNotScaleUp wird GKE angewiesen, keine Knoten zu erstellen, die die angegebenen Anforderungen nicht erfüllen.

Ray-Cluster erstellen und überprüfen

Sie können jetzt Ihren Ray-Cluster in Ihrem GKE-Cluster erstellen.

Ray-Cluster erstellen Verwenden Sie den Befehl kubectl ray create cluster, um Ihren Ray-Cluster zu definieren und zu erstellen. Dieser Befehl vereinfacht den Prozess, da er die Erstellung der zugrunde liegenden Kubernetes-Ressourcen übernimmt.
```
  kubectl ray create cluster my-ray-cluster \
      --worker-replicas=1 \
      --worker-cpu=2 \
      --worker-memory=4Gi \
      --worker-gpu=1 \
      --worker-node-selectors="cloud.google.com/compute-class=gpu-compute-class"
```
Der Befehl kubectl ray create cluster verwendet das KubeRay-Plug-in, um Ihre Spezifikationen in eine benutzerdefinierte RayCluster-Ressourcendefinition zu übersetzen, und sendet sie an die Kubernetes API, um das RayCluster-Objekt zu erstellen. Dieses Objekt dient als Blaupause und teilt dem Ray-Operator mit, wie die tatsächlichen Ray-Clusterkomponenten (Head- und Worker-Knoten) in GKE bereitgestellt und verwaltet werden. Standardmäßig plant GKE den Head-Pod auf einem Knoten der E2-Maschinenserie.

Im Beispielbefehl werden die folgenden Einstellungen verwendet:
- kubectl ray create cluster my-ray-cluster: Gibt den Namen des Ray-Clusters an, den Sie erstellen möchten.
- --worker-node-selectors: weist Kubernetes an, Worker-Pods auf Knoten zu planen, die mit cloud.google.com/compute-class=gpu-compute-class gekennzeichnet sind.
Wichtig :Verwenden Sie für optimale Ergebnisse das Flag --ray-version mit dem Befehl kubectl ray create cluster, um Ihre lokalen Ray- und Python-Versionen mit den entsprechenden Versionen im Ray-Cluster abzugleichen. Wenn die Versionen eng aufeinander abgestimmt sind, wird die Stabilität in der Regel verbessert.
Ray-Clusterstatus prüfen Mit diesen Befehlen können Sie prüfen, ob Ihr Ray-Cluster ausgeführt wird.
- Prüfen Sie die RayCluster-Ressource mit diesem Befehl:
```
kubectl ray get cluster
```
  Mit diesem Befehl werden alle Ray-Cluster in Ihrem Kubernetes-Namespace aufgeführt. my-ray-cluster sollte aufgeführt sein. Es kann einige Minuten dauern, bis der Cluster initialisiert ist.
- Prüfen Sie die Kubernetes-Pods mit diesem Befehl:
```
kubectl get pods
```
  Mit diesem Befehl werden alle Pods aufgelistet, die in Ihrem Kubernetes-Namespace ausgeführt werden. Sie sollten Pods sehen, die sich auf Ihren Ray-Cluster beziehen:
  - Ein Pod für den Ray-Head-Knoten mit einem Namen wie my-ray-cluster-head-0.
  - Einen oder mehrere Pods für die Ray-Worker-Knoten mit Namen wie my-ray-cluster-worker-group-0-xxxxx. Die Anzahl der Worker-Pods hängt von der ursprünglichen Konfiguration Ihres Ray-Clusters und von eventuell erfolgtem Autoscaling ab.

Ray-Job senden

Sobald Ihr Ray-Cluster bereit ist, können Sie einen Ray-Job an Ihren laufenden Ray-Cluster in GKE senden.

Verwenden Sie dazu den Befehl kubectl ray session, um eine interaktive Sitzung zu starten, und den Befehl ray job submit, um die Jobausführung zu starten.

Interaktive Ray-Sitzung starten Führen Sie diesen Befehl aus, um eine lokale Verbindung zu Ihrem Ray-Cluster herzustellen:
```
  kubectl ray session my-ray-cluster
```
Mit diesem Befehl wird die Portweiterleitung zwischen Ihrem lokalen Computer und dem Ray-Head-Knoten in Ihrem GKE-Cluster initiiert. Beachten Sie, dass Ihr Terminal belegt ist, während diese Sitzung aktiv ist. Öffnen Sie eine separate Terminalinstanz, um fortzufahren.

Beispielcode zum Ausführen erstellen Speichern Sie den folgenden Beispielcode in einer Datei mit dem Namen sample_code.py.

  import ray
  import os
  import requests

  ray.init()

  @ray.remote
  class Counter:
      def __init__(self):
          # Used to verify runtimeEnv
          self.name = os.getenv("counter_name")
          assert self.name == "test_counter"
          self.counter = 0

      def inc(self):
          self.counter += 1

      def get_counter(self):
          return "{} got {}".format(self.name, self.counter)

  counter = Counter.remote()

  for _ in range(5):
          ray.get(counter.inc.remote())
          print(ray.get(counter.get_counter.remote()))

  # Verify that the correct runtime env was used for the job.
  assert requests.__version__ == "2.26.0"

Öffnen Sie ein neues Terminal und senden Sie den Ray-Job.
1. Öffnen Sie ein neues Terminal auf Ihrem lokalen Computer. Wenn Sie eine virtuelle Umgebung für Ihre Ray-Installation erstellt haben, müssen Sie sie auch in diesem neuen Terminal aktivieren.
2. Wechseln Sie in das Verzeichnis, in dem Sie die Datei sample_code.py gespeichert haben.
3. Führen Sie dazu diesen Befehl aus:
```
  ray job submit \
      --working-dir=. \
      --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}' \
      --address http://localhost:8265 python sample_code.py
```
  Im Beispielbefehl werden die folgenden Einstellungen verwendet:
  - --working-dir=.: Gibt das aktuelle Verzeichnis als Arbeitsverzeichnis an, das dem Ray-Job im Cluster zur Verfügung gestellt werden soll. Im Idealfall enthält dieses Verzeichnis nur den Anwendungsquellcode, den Sie in Ray ausführen möchten. In unserem Beispiel ist das die Datei sample_code.py.
  - --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}': definiert die Laufzeitumgebung für den Job. Sie gibt die erforderliche Python-Bibliotheksversion (requests==2.26.0) an und legt eine Umgebungsvariable (counter_name) für die Ausführung des Jobs fest.
Ray-Job ansehen Sie haben folgende Möglichkeiten, den Job zu überwachen:
- Ray-Dashboard: Öffnen Sie Ihren Webbrowser und rufen Sie http://localhost:8265 auf. Über diese URL wird das Ray-Dashboard geöffnet. Dort finden Sie Informationen zu Ihrem laufenden Job, einschließlich Status, Logs und Ressourcennutzung.
- Metrics Explorer: Verwenden Sie die vorgefertigten Messwert-Dashboards in derGoogle Cloud Console. Weitere Informationen finden Sie unter Logs und Messwerte für Ray-Cluster in GKE erfassen und ansehen.
Ray-Sitzung beenden Wenn Sie die Interaktion mit dem Ray-Cluster oder die Überwachung Ihres Jobs abgeschlossen haben, können Sie die interaktive Sitzung beenden, indem Sie im Terminal, in dem Sie den Befehl kubectl ray session ausgeführt haben, Ctrl+C drücken.

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud -Konto die auf dieser Seite verwendeten Ressourcen in Rechnung gestellt werden:

Wenn Sie die Kurzanleitung in einem neuen Google Cloud -Projekt bereitgestellt haben und das Projekt nicht mehr benötigen, löschen Sie es mit den folgenden Schritten:

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.

Wenn Sie kein neues Google Cloud -Projekt erstellt haben und den GKE-Cluster nicht mehr benötigen, können Sie ihn mit diesem Befehl löschen:

gcloud container clusters delete my-ray-enabled-cluster \
    --location=us-central1

Nächste Schritte

Weitere Beispiele, Best Practices und Tools für Ray in GKE:Weitere Informationen finden Sie im GitHub-Repository ai-on-gke.
Weitere Informationen zur Verwendung von Beschleunigern in GKE: Verwenden Sie GPUs für die parallele Verarbeitung bei Aufgaben für maschinelles Lernen und Datenanalyse. Verwenden Sie TPUs, um das Training und die Inferenz von umfangreichen Deep-Learning-Modellen zu beschleunigen.
Weitere Informationen zum Ray-Operator: Weitere Informationen zur Verwendung des Ray-Operators zum Verwalten von Ray-Bereitstellungen, einschließlich Ray-Jobs, finden Sie unter Ray on GKE.
Kueue für die Jobwarteschlange verwenden:Erfahren Sie, wie Kueue, ein natives Kubernetes-Jobwarteschlangensystem, Ihnen helfen kann, Ihre KI-/ML-Arbeitslasten zu verwalten und zu priorisieren, was die Ressourcennutzung verbessern kann. Weitere Informationen finden Sie unter GKE-Ressourcennutzung für gemischte KI-/ML-Trainings- und ‑Inferenzarbeitslasten optimieren.