Déployer Ray accéléré par GPU pour les charges de travail d'IA sur GKE

Créer un cluster GKE

Vous pouvez déployer votre charge de travail dans un cluster GKE Autopilot ou GKE Standard. Nous vous recommandons d'utiliser un cluster Autopilot pour une expérience Kubernetes entièrement gérée. Pour choisir le mode de fonctionnement GKE le mieux adapté à vos charges de travail, consultez la section Choisir un mode de fonctionnement GKE.

Installer le plug-in kubectl ray KubeRay

Le plug-in kubectl ray simplifie les workflows Ray sur Kubernetes courants. Pour obtenir les dernières instructions d'installation, consultez la documentation de KubeRay.

1. Accédez à la page des versions et téléchargez le fichier binaire pour votre plate-forme. Par exemple, pour installer le plug-in kubectl ray version 1.3.2 sur Linux amd64, exécutez les commandes suivantes :

   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
   

   Remplacez ~/.local/bin par le répertoire de votre PATH.

2. Vérifiez votre installation :

   kubectl ray version
   

   Si un avertissement tel que KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace. s'affiche, vous pouvez l'ignorer sans problème. Si l'installation a réussi, la sortie correspond à la version du plug-in kubectl ray.

Créez la classe de calcul personnalisée dans votre cluster.

Dans GKE, une classe de calcul personnalisée vous permet de définir des exigences matérielles spécifiques, comme le type et le nombre de GPU, par priorité. GKE utilise cette priorité lors du provisionnement des nœuds pour vos charges de travail.

Pour créer l'exemple de classe de calcul personnalisée pour ce guide, procédez comme suit :

1. Enregistrez la spécification de classe de calcul suivante sous 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. Créez la classe de calcul en exécutant la commande suivante :

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

   Que se passe-t-il une fois que vous avez appliqué la classe de calcul personnalisée ? Après avoir appliqué le fichier YAML de la classe de calcul, GKE provisionnera automatiquement des nœuds avec un GPU NVIDIA L4 lorsque votre cluster Ray les demandera. Il donnera la priorité aux Spot VM, comme défini dans votre fichier manifeste. Le paramètre whenUnsatisfiable: DoNotScaleUp indique à GKE de ne pas créer de nœuds qui ne répondent pas aux exigences spécifiées.

Créer et valider le cluster Ray

Vous pouvez maintenant créer votre cluster Ray sur votre cluster GKE.

1. Créez le cluster Ray. Utilisez la commande kubectl ray create cluster pour définir et créer votre cluster Ray. Cette commande simplifie le processus en gérant la création des ressources Kubernetes sous-jacentes.

     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"
   

   La commande kubectl ray create cluster utilise le plug-in KubeRay pour traduire vos spécifications en définition de ressource personnalisée RayCluster et l'envoie à l'API Kubernetes pour créer l'objet RayCluster. Cet objet sert de plan, indiquant à l'opérateur Ray comment provisionner et gérer les composants réels du cluster Ray (nœuds principaux et de calcul) dans GKE. Par défaut, GKE planifie le pod principal sur un nœud de la série de machines E2.

   L'exemple de commande utilise les paramètres suivants :

   • kubectl ray create cluster my-ray-cluster : spécifie le nom du cluster Ray que vous souhaitez créer.
   • --worker-node-selectors : indique à Kubernetes de planifier les pods de nœuds de calcul sur les nœuds portant le libellé cloud.google.com/compute-class=gpu-compute-class.

2. Vérifiez l'état du cluster Ray. Utilisez ces commandes pour vérifier que votre cluster Ray est opérationnel.

   • Vérifiez la ressource RayCluster en exécutant la commande suivante :

     kubectl ray get cluster
     

     Cette commande liste tous les clusters Ray de votre espace de noms Kubernetes. Vous devriez voir my-ray-cluster dans la liste. L'initialisation du cluster peut prendre quelques minutes.

   • Vérifiez les pods Kubernetes en exécutant cette commande :

     kubectl get pods
     

     Cette commande liste tous les pods en cours d'exécution dans votre espace de noms Kubernetes. Vous devriez voir les pods associés à votre cluster Ray :

     • Un pod pour le nœud principal Ray, avec un nom tel que my-ray-cluster-head-0.
     • Un ou plusieurs pods pour les nœuds de calcul Ray, avec des noms tels que my-ray-cluster-worker-group-0-xxxxx. Le nombre de pods de nœuds de calcul dépend de la configuration initiale de votre cluster Ray et de tout autoscaling qui a pu se produire.

Envoyer un job Ray

Une fois votre cluster Ray prêt, vous pouvez envoyer un job Ray à votre cluster Ray en cours d'exécution sur GKE.

Pour ce faire, utilisez la commande kubectl ray session afin de démarrer une session interactive, et la commande ray job submit pour lancer l'exécution du job.

1. Démarrez une session interactive Ray. Pour établir une connexion locale à votre cluster Ray, exécutez cette commande :

     kubectl ray session my-ray-cluster
   

   Cette commande lance le transfert de port entre votre machine locale et le nœud de tête Ray de votre cluster GKE. Notez que votre terminal sera occupé pendant que cette session est active. Pour continuer, ouvrez une instance de terminal distincte.

2. Créez l'exemple de code à exécuter. Enregistrez l'exemple de code suivant dans un fichier nommé 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. Ouvrez un nouveau terminal et envoyez le job Ray.

   1. Ouvrez un nouveau terminal sur votre machine locale. Si vous avez créé un environnement virtuel pour votre installation Ray, assurez-vous de l'activer également dans ce nouveau terminal.
   2. Accédez au répertoire dans lequel vous avez enregistré le fichier sample_code.py.

   3. Exécutez la commande suivante :

        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
      

      L'exemple de commande utilise les paramètres suivants :

      • --working-dir=. : spécifie le répertoire actuel comme répertoire de travail à mettre à la disposition du job Ray sur le cluster. Idéalement, ce répertoire ne contient que le code source de l'application que vous souhaitez exécuter sur Ray. Dans notre exemple, il s'agit du fichier sample_code.py.
      • --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}' : définit l'environnement d'exécution du job. Il spécifie la version requise de la bibliothèque Python (requests==2.26.0) et définit une variable d'environnement (counter_name) pour l'exécution du job.

4. Affichez le job Ray. Vous pouvez surveiller le job de l'une des manières suivantes :

   • Tableau de bord Ray : ouvrez votre navigateur Web et accédez à http://localhost:8265. Cette URL ouvre le tableau de bord Ray, où vous pouvez consulter des informations sur votre job en cours d'exécution, y compris son état, ses journaux et son utilisation des ressources.
   • Explorateur de métriques : utilisez les tableaux de bord de métriques prédéfinis dans la consoleGoogle Cloud . Pour en savoir plus, consultez Collecter et afficher les journaux et les métriques des clusters Ray sur GKE.

5. Mettez fin à la session Ray. Une fois que vous avez terminé d'interagir avec le cluster Ray ou de surveiller votre job, vous pouvez mettre fin à la session interactive en appuyant sur Ctrl+C dans le terminal où vous avez exécuté la commande kubectl ray session.