Esegui il deployment di Ray con accelerazione GPU per i carichi di lavoro AI su GKE

Crea un cluster GKE

Puoi eseguire il deployment del carico di lavoro in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi workload, consulta Scegliere una modalità operativa GKE.

Installa il plug-in KubeRay kubectl ray

Il plug-in kubectl ray semplifica i workflow comuni di Ray su Kubernetes. Per le istruzioni di installazione più recenti, consulta la documentazione di KubeRay.

1. Vai alla pagina delle release e scarica il file binario per la tua piattaforma. Ad esempio, per installare la versione 1.3.2 del plug-in kubectl ray su Linux amd64, esegui questi comandi:

   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
   

   Sostituisci ~/.local/bin con la directory in PATH.

2. Verifica l'installazione:

   kubectl ray version
   

   Se vedi un avviso come KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace., puoi ignorarlo tranquillamente. Se l'installazione è riuscita, l'output è la versione del plug-in kubectl ray.

Crea la classe di calcolo personalizzata nel cluster

Una classe di calcolo personalizzata in GKE ti consente di definire requisiti hardware specifici, come il tipo e il numero di GPU, in base alla priorità. GKE utilizza questa priorità quando esegue il provisioning dei nodi per i tuoi carichi di lavoro.

Per creare la classe di calcolo personalizzata di esempio per questa guida:

1. Salva la seguente specifica della classe di computing come 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. Crea la classe di calcolo eseguendo questo comando:

   kubectl apply -f nvidia-l4-compute-class.yaml
   

   Che cosa succede dopo aver applicato la classe di calcolo personalizzata? Dopo aver applicato il file YAML della classe di calcolo, GKE eseguirà automaticamente il provisioning dei nodi con una GPU NVIDIA L4 quando il cluster Ray li richiede. Dà la priorità alle VM spot come definito nel manifest. L'impostazione whenUnsatisfiable: DoNotScaleUp indica a GKE di non creare nodi che non soddisfano i requisiti specificati.

Crea e verifica il cluster Ray

Ora puoi creare il tuo cluster Ray sul tuo cluster GKE.

1. Crea il cluster Ray. Utilizza il comando kubectl ray create cluster per definire e creare il cluster Ray. Questo comando semplifica il processo gestendo la creazione delle risorse Kubernetes sottostanti.

     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"
   

   Il comando kubectl ray create cluster utilizza il plug-in KubeRay per tradurre le specifiche in una definizione di risorsa personalizzata RayCluster e la invia all'API Kubernetes per creare l'oggetto RayCluster. Questo oggetto funge da blueprint, indicando all'operatore Ray come eseguire il provisioning e gestire i componenti effettivi del cluster Ray (nodi head e worker) in GKE. Per impostazione predefinita, GKE pianifica il pod head su un nodo della serie di macchine E2.

   Il comando di esempio utilizza queste impostazioni:

   • kubectl ray create cluster my-ray-cluster: specifica il nome del cluster Ray che vuoi creare.
   • --worker-node-selectors: indica a Kubernetes di pianificare i pod worker sui nodi etichettati con cloud.google.com/compute-class=gpu-compute-class.

2. Verifica lo stato del cluster Ray. Utilizza questi comandi per verificare che il cluster Ray sia in esecuzione.

   • Controlla la risorsa RayCluster eseguendo questo comando:

     kubectl ray get cluster
     

     Questo comando elenca tutti i cluster Ray nello spazio dei nomi Kubernetes. Dovresti vedere my-ray-cluster nell'elenco. L'inizializzazione del cluster potrebbe richiedere alcuni minuti.

   • Controlla i pod Kubernetes eseguendo questo comando:

     kubectl get pods
     

     Questo comando elenca tutti i pod in esecuzione nello spazio dei nomi Kubernetes. Dovresti vedere i pod correlati al tuo cluster Ray:

     • Un pod per il nodo head di Ray, con un nome come my-ray-cluster-head-0.
     • Uno o più pod per i nodi worker Ray, con nomi come my-ray-cluster-worker-group-0-xxxxx. Il numero di pod worker dipende dalla configurazione iniziale del cluster Ray e da qualsiasi scalabilità automatica che potrebbe essersi verificata.

Invia un job Ray

Una volta pronto il cluster Ray, puoi inviare un job Ray al cluster Ray in esecuzione su GKE.

Per farlo, utilizza il comando kubectl ray session per avviare una sessione interattiva e il comando ray job submit per avviare l'esecuzione del job.

1. Avvia una sessione interattiva di Ray. Per stabilire una connessione locale al cluster Ray, esegui questo comando:

     kubectl ray session my-ray-cluster
   

   Questo comando avvia il port forwarding tra la tua macchina locale e il nodo head Ray nel tuo cluster GKE. Tieni presente che il terminale sarà occupato mentre questa sessione è attiva; per procedere, apri un'istanza del terminale separata.

2. Crea il codice campione da eseguire. Salva il seguente codice di esempio in un file denominato 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. Apri un nuovo terminale e invia il job Ray.

   1. Apri un nuovo terminale sulla tua macchina locale. Se hai creato un ambiente virtuale per l'installazione di Ray, assicurati di attivarlo anche in questo nuovo terminale.
   2. Vai alla directory in cui hai salvato il file sample_code.py.

   3. Esegui questo comando:

        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
      

      Il comando di esempio utilizza queste impostazioni:

      • --working-dir=.: specifica la directory corrente come directory di lavoro da rendere disponibile al job Ray sul cluster. Idealmente, questa directory contiene solo il codice sorgente dell'applicazione che vuoi eseguire su Ray. Nel nostro esempio, si tratta del file sample_code.py.
      • --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}': definisce l'ambiente di runtime per il job. Specifica la versione della libreria Python richiesta (requests==2.26.0) e imposta una variabile di ambiente (counter_name) per l'esecuzione del job.

4. Visualizza il job Ray. Puoi monitorare il job in uno di questi modi:

   • Dashboard Ray: apri il browser web e vai su http://localhost:8265. Questo URL apre la dashboard di Ray, dove puoi visualizzare informazioni sul job in esecuzione, inclusi stato, log e utilizzo delle risorse.
   • Esplora metriche: utilizza le dashboard delle metriche predefinite nella consoleGoogle Cloud . Per maggiori informazioni, consulta Raccogliere e visualizzare log e metriche per i cluster Ray su GKE.

5. Termina la sessione di Ray. Dopo aver terminato l'interazione con il cluster Ray o il monitoraggio del job, puoi terminare la sessione interattiva premendo Ctrl+C nel terminale in cui hai eseguito il comando kubectl ray session.