DataWorks:Développement avancé de notebooks

Référencer des ressources de projet (fichiers .py)

Encapsulez les fonctions ou classes courantes dans des fichiers .py et référencez-les en tant que ressources MaxCompute à l'aide de ##@resource_reference{"custom_name.py"}.

1. Créer et publier une ressource Python

   1. Dans le volet de navigation de gauche de DataStudio DataWorks, cliquez sur l'icône pour accéder à la Resource Management.

   2. Dans l'arborescence Resource Management, cliquez avec le bouton droit sur le répertoire cible ou cliquez sur + dans le coin supérieur droit. Sélectionnez New Resource > MaxCompute Python, et nommez la ressource my_utils.py.

   3. Dans la section Document Content, cliquez sur Online Editing, collez le code de votre fonction utilitaire déboguée dans l'éditeur, puis cliquez sur Save.

      # my_utils.py
      def greet(name):
          return f"Hello, {name} from resource file!"

   4. Dans la barre d'outils, cliquez sur Save puis sur Publish. Cela rend la ressource visible pour les tâches de développement et de production.

2. Référencer la ressource dans un notebook

   À la première ligne d'une cellule Python de votre notebook, utilisez la syntaxe ##@resource_reference pour référencer la ressource publiée.

   ##@resource_reference{"my_utils.py"}
   # If the resource is in a directory, such as my_folder/my_utils.py, you still use ##@resource_reference{"my_utils.py"} without the directory name.
   from my_utils import greet
   message = greet('DataWorks')
   print(message)

3. Déboguer et exécuter dans l'environnement de développement

   Exécutez la cellule Python. Le résultat suivant s'affiche :

   Hello, DataWorks from resource file!

   Important

   Lorsque vous déboguez et exécutez dans l'environnement de développement, le système détecte la déclaration ##@resource_reference et télécharge le fichier cible depuis Resource Management vers workspace/_dataworks/resource_references dans votre répertoire personnel.

   Si une erreur ModuleNotFoundError survient, cliquez sur le bouton Restart dans la barre d'outils de l'éditeur pour recharger la ressource, puis réessayez.

4. Publier dans l'environnement de production et vérifier

   Après avoir Save et Publish ce nœud Notebook, accédez à Operation and Maintenance Center > Auto Triggered Task et cliquez sur Test pour l'exécuter. Une fois la tâche exécutée avec succès, vous verrez la sortie Hello, DataWorks from resource file! dans les journaux.

   Important

   Si une erreur There is no file with id ... apparaît, assurez-vous d'avoir d'abord publié la ressource Python dans l'environnement de production.

Pour plus d'opérations, consultez Ressources et fonctions MaxCompute .

Lire et écrire des jeux de données (OSS/NAS)

Lisez et écrivez de gros fichiers stockés sur OSS ou NAS lors de l'exécution des tâches du notebook.

Pour plus d'opérations, consultez Utiliser des jeux de données dans un environnement de développement personnel .

Référencer des paramètres d'espace de travail

Outre les paramètres de planification, DataWorks fournit des Workspace Parameters pour réutiliser les configurations globales et isoler les environnements entre les tâches et les nœuds. Référencez-les dans les cellules SQL et Python en utilisant ${workspace.param}, où param est le nom du paramètre.

1. Créer des Workspace Parameters : dans DataWorks, accédez à Operation and Maintenance Center > Scheduling Settings > Workspace Parameters pour créer les paramètres.

2. Référencer des Workspace Parameters :

• Référencez un Workspace Parameter dans une cellule SQL.

  SELECT '${workspace.param}';

  Lorsque la requête s'exécute avec succès, elle affiche la valeur résolue du paramètre.

• Référencez un Workspace Parameter dans une cellule Python.

  print('${workspace.param}')

  Lorsque le code s'exécute avec succès, il affiche la valeur résolue du paramètre.

Pour plus de détails, consultez Utiliser les paramètres d'espace de travail .

Se connecter à MaxCompute

• %odps : Obtenir un objet d'entrée PyODPS

  Aucune AccessKey codée en dur n'est requise.

  1. Utilisez une commande magique pour créer une connexion MaxCompute. Saisissez %odps. Un sélecteur de ressources de calcul MaxCompute apparaît dans le coin inférieur droit (et sélectionne automatiquement une ressource de calcul). Vous pouvez cliquer sur le nom du projet MaxCompute dans le coin inférieur droit pour changer de projets MaxCompute.

     o=%odps 

  2. Utilisez la ressource de calcul MaxCompute retournée pour exécuter un script PyODPS.

     Par exemple, pour obtenir toutes les tables du projet actuel :

     with o.execute_sql('show tables').open_reader() as reader:
         print(reader.raw)

• %maxframe : Établir une connexion MaxFrame

  Crée une session MaxFrame pour le traitement distribué de données de type pandas sur MaxCompute.

  # Connect to and access the MaxCompute MaxFrame session.
  mf_session = %maxframe
  df = mf_session.read_odps_table('your_mc_table')
  print(df.head())
  # After development and debugging, destroy the session to release resources.
  mf_session.destroy()

Se connecter aux ressources de calcul Spark

DataWorks Notebook prend en charge plusieurs moteurs Spark, chacun ayant des méthodes de connexion, des contextes d'exécution et des cycles de vie des ressources différents.

Se connecter à une ressource de calcul Lindorm Ray

Le groupe de ressources Ray du moteur de calcul Lindorm offre une puissance de calcul distribuée pour les charges de travail IA de bout en bout. Utilisez-le pour le développement interactif de notebooks, puis publiez-le en tant que tâche de production planifiée.

1. Établir une connexion : exécutez la commande magique %lindorm_ray dans une cellule Python. Après l'exécution de la commande, un sélecteur de ressources de calcul apparaît dans le coin inférieur droit de la cellule. Sélectionnez votre ressource de calcul Lindorm et le groupe de ressources Ray que vous avez créé.

   # Connect to the specified Lindorm Ray resource group.
   %lindorm_ray

   Important

   • Une fois connecté à une ressource de calcul Lindorm Ray, vous ne pouvez plus exécuter de cellules SQL dans le même notebook. Le moteur Lindorm Ray se concentre sur l'exécution de code Python et Ray.

   • Si vous exécutez la même cellule de code plusieurs fois, le système termine automatiquement la tâche Ray précédente et en démarre une nouvelle. Cela évite le gaspillage de ressources et les conflits de tâches.

2. Exécuter du code Ray : après une connexion réussie, vous pouvez écrire et exécuter directement du code Ray dans une nouvelle cellule Python. Les journaux sont diffusés en temps réel dans la zone de sortie de la cellule pour un débogage interactif.

   L'exemple suivant définit une tâche distante simple à l'aide du décorateur @ray.remote. La tâche s'exécute sur le cluster Ray, et les journaux ainsi que le résultat final sont renvoyés dans la zone de sortie de la cellule.

   import ray
   import time
   @ray.remote
   def hello_world():
     print("Hello from Lindorm Ray!")
     time.sleep(5)
     return "Task finished."
   # Submit the remote task.
   result_ref = hello_world.remote()
   print(ray.get(result_ref))

3. (Facultatif) Spécifier des paramètres de démarrage personnalisés : pour configurer des paramètres supplémentaires pour l'environnement Ray, tels que l'installation de packages Python tiers ou le téléchargement de fichiers de code locaux, utilisez %%lindorm_ray pour établir la connexion.

   • Exemple 1 : Installer des dépendances

     Utilisez le paramètre pip pour installer le package jieba dans l'environnement Ray.

     %%lindorm_ray
     {
       "runtime_env": {
         "pip": ["jieba"]
       }
     }

     Une fois l'environnement prêt, importez et utilisez le package dans les tâches Ray suivantes. L'exemple ci-dessous montre comment appeler jieba dans une fonction distante pour la segmentation de mots chinois :

     import ray 
     @ray.remote
     def do_work(x):
         import jieba
         return "/".join(jieba.cut(x))
     print(ray.get(do_work.remote("Welcome to the DataWorks LindormRay solution")))

   • Exemple 2 : Télécharger et utiliser des ressources DataWorks

     Utilisez le paramètre working_dir pour télécharger des ressources depuis Resource Management vers le cluster Ray afin de les importer dans vos tâches.

     Important

     • Lorsque vous utilisez working_dir pour télécharger des ressources, les fichiers sont transférés directement de votre environnement de développement vers le cluster Ray. Une limite de taille de 100 Mo s'applique. Si le package de ressources est trop volumineux, le téléchargement peut échouer ou le nœud Ray peut devenir instable.

     • Pour les ressources ou dépendances volumineuses (plus de 100 Mo), téléchargez-les sur OSS et récupérez-les depuis OSS dans votre code, ou empaquetez-les dans une image personnalisée pour une meilleure stabilité et performance.

     # Reference and declare the path for a resource from Resource Management.
     %%lindorm_ray
     {
         "runtime_env": {
             "working_dir": "/mnt/workspace/_dataworks/resource_references"
         }
     }

     Supposons que vous ayez téléchargé un fichier nommé ray_resource.py dans Resource Management dans DataWorks. Lorsque vous exécutez la cellule suivante, le système analyse la déclaration ##@resource_reference et télécharge la ressource correspondante vers /mnt/workspace/_dataworks/resource_references.

     Exemple de code dans ray_resource.py :

     def fun():
         print("This is a test function in ray_resource.py")

     Important

     Dans l'environnement de développement, après avoir exécuté la cellule contenant ##@resource_reference, vous devez réexécuter la cellule %%lindorm_ray précédente. La réexécution de cette cellule inclut les ressources téléchargées dans le working_dir et les transfère vers le cluster Ray. Vous n'avez pas besoin de réexécuter la cellule dans l'environnement de production.

     import ray 
     ##@resource_reference{"ray_resource.py"}
     @ray.remote
     def do_work(x):
         print('Ray says:', x)
         from ray_resource import fun
         fun()
         return x
     worker = do_work.remote("Welcome to the DataWorks LindormRay solution")
     print(ray.get(worker))

4. Planification et exploitation en production : après le développement et le débogage, validez et publiez ce nœud de notebook. Il sera planifié périodiquement en tant que nœud Lindorm Ray dans un DAG.

   • Paramétrage : votre code peut utiliser les paramètres de planification DataWorks standard, tels que ${bizdate}.

   • Consultation des journaux : en production, le système charge uniquement le premier 1 Mo de journaux par défaut pour éviter les problèmes de performance. Si les journaux sont tronqués, la sortie fournit un lien pour consulter les journaux complets de la tâche dans la console Lindorm.

   • Libération des ressources : après la fin d'une tâche de production planifiée, la tâche Lindorm Ray passe à un état terminal et libère les ressources. Pendant le développement interactif, terminez la tâche en redémarrant le noyau ou en fermant le notebook.

Annexe : Référence rapide des commandes magiques