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

Cluster im GKE-Autopilot-Modus erstellen

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.

1. Führen Sie im Terminal den folgenden 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: Der Ray-Operator wird auf dem Cluster installiert, was die Verwaltung von Ray-Clustern in Kubernetes vereinfacht.
   • --enable-ray-cluster-monitoring: Richtet die Integration mit Cloud Monitoring für Ray-Clustermesswerte ein.
   • --enable-ray-cluster-logging: Konfiguriert die Einbindung in Cloud Logging, um Protokolle aus Ihrem Ray-Cluster zu erfassen.
   • --location=us-central1: Gibt die Region an, in der der GKE-Cluster erstellt werden soll. Die Verfügbarkeit und die unterstützten Typen von Accelerators 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) basierend auf den Arbeitslastanforderungen automatisch bereitgestellt und skaliert, um sowohl die Auslastung als auch die Kosten zu optimieren. Diese automatische Bereitstellung und Skalierung von Ressourcen in Autopilot-Clustern vereinfacht die Ressourcenverwaltung und ermöglicht es Ihnen, sich auf Ihre Modelle statt auf die Infrastruktur zu konzentrieren.

   Wenn Sie einen GKE Standard-Cluster verwenden, sind die Flags und Einstellungen zum Aktivieren von Ray möglicherweise unterschiedlich. Weitere Informationen finden Sie unter Ray-Operator in GKE aktivieren.

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

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

KubeRay kubectl ray-Plug-in installieren

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

1. Rufe die Release-Seite auf und lade die Binärdatei für deine Plattform herunter. Wenn Sie beispielsweise die kubectl ray-Plug-in-Version 1.3.2 auf 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 PATH.

2. Installation prüfen:

   kubectl ray version
   

   Wenn eine Warnung wie KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace. angezeigt wird, 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 GPU-Anzahl nach Priorität definieren. Autopilot verwendet diese Priorität bei der Bereitstellung von Knoten für Ihre Arbeitslasten.

So erstellen Sie die Beispiel-Compute-Klasse für diesen Leitfaden:

1. Speichern Sie die folgende Compute-Klassen-Spezifikation 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: 4
       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 ich die benutzerdefinierte Compute-Klasse angewendet habe? Nachdem Sie die YAML-Datei der Compute-Klasse angewendet haben, stellt Autopilot automatisch Knoten mit einer NVIDIA L4-GPU bereit, wenn Ihr Ray-Cluster sie anfordert. Dabei werden Spot-VMs gemäß der Definition in 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 prüfen

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

1. Erstellen Sie den Ray-Cluster. Verwenden Sie den Befehl kubectl ray create cluster, um den Ray-Cluster zu definieren und zu erstellen. Dieser Befehl vereinfacht den Vorgang, da die zugrunde liegende Erstellung von Kubernetes-Ressourcen übernommen wird.

     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 Ressourcendefinition vom Typ RayCluster zu übersetzen und an die Kubernetes API zu senden, um das RayCluster-Objekt zu erstellen. Dieses Objekt dient als Blaupause und gibt dem Ray-Operator an, 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 aus der E2-Maschinenreihe.

   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: Kubernetes wird angewiesen, Worker-Pods auf Knoten zu planen, die mit cloud.google.com/compute-class=gpu-compute-class gekennzeichnet sind.

2. Prüfen Sie den Status des Ray-Clusters. Mit diesen Befehlen können Sie prüfen, ob Ihr Ray-Cluster aktiv ist.

   • 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 aufgelistet. my-ray-cluster sollte aufgeführt sein. Es kann einige Minuten dauern, bis der Cluster initialisiert ist.

   • Prüfen Sie die Kubernetes-Pods mit dem folgenden 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 verknüpft sind:

     • Einen Pod für den Ray-Hauptknoten 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 durchgeführtem 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.

1. Starten Sie eine interaktive Ray-Sitzung. 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-Leitknoten in Ihrem GKE-Cluster gestartet. Hinweis: Ihr Terminal ist belegt, solange diese Sitzung aktiv ist. Öffnen Sie eine separate Terminalinstanz, um fortzufahren.

2. Erstellen Sie den ausführbaren Beispielcode. 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. Öffnen Sie ein neues Terminal und reichen Sie den Ray-Job ein.

   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. Rufen Sie das Verzeichnis auf, 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. Idealerweise enthält dieses Verzeichnis nur den Quellcode der Anwendung, den Sie mit 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, in dem Sie Informationen zu Ihrem laufenden Job sehen, einschließlich Status, Protokollen und Ressourcennutzung.
   • Metrics Explorer: Verwenden Sie die vordefinierten Messwert-Dashboards in derGoogle Cloud Console. Weitere Informationen finden Sie unter Logs und Messwerte für Ray-Cluster in GKE erfassen und ansehen.

5. Beenden Sie die Ray-Sitzung. Wenn Sie die Interaktion mit dem Ray-Cluster beendet oder Ihren Job überwacht haben, können Sie die interaktive Sitzung beenden, indem Sie in dem Terminal, in dem Sie den Befehl kubectl ray session ausgeführt haben, die Taste Ctrl+C drücken.