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

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.

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.

1. 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 Ihrer PATH.

2. 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 GPU-Typ und -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:

1. 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
   

2. 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 sie 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.

1. Ray-Cluster erstellen Verwenden Sie den Befehl kubectl ray create cluster, um Ihren Ray-Cluster zu definieren und zu erstellen. Dieser Befehl vereinfacht den Vorgang, 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"
   

   Mit dem Befehl kubectl ray create cluster wird das KubeRay-Plug-in verwendet, um Ihre Spezifikationen in eine benutzerdefinierte RayCluster-Ressourcendefinition zu übersetzen und an die Kubernetes API zu senden, 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 diese 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.

2. 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 dem folgenden Befehl:

     kubectl ray get cluster
     

     Mit diesem Befehl werden alle Ray-Cluster in Ihrem Kubernetes-Namespace aufgeführt. my-ray-cluster sollte angezeigt werden. 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 mit Ihrem Ray-Cluster zusammenhängen:

     • Ein Pod für den Ray-Head-Knoten mit einem Namen wie my-ray-cluster-head-0.
     • Ein 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 dem Autoscaling ab, das möglicherweise stattgefunden hat.

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 Ausführung des Jobs zu starten.

1. 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. Ihr Terminal ist belegt, solange diese Sitzung aktiv ist. Öffnen Sie eine separate Terminalinstanz, um fortzufahren.

2. 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"
   

3. Neues Terminal öffnen und Ray-Job senden

   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 zu dem 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 diese 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.

4. 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 können Sie Informationen zu Ihrem laufenden Job aufrufen, z. B. den Status, die Logs und die 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.

5. 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.