Développer une tâche sur Azure Databricks à l’aide des packs de ressources Databricks

Article
05/02/2024

Les packs de ressources Databricks, ou simplement packs, vous permettent de valider, de déployer et d'exécuter par programmation des flux de travail Azure Databricks, notamment les tâches Azure Databricks. Vous pouvez également utiliser les packs pour gérer de manière programmatique les pipelines Delta Live Tables et utiliser des piles MLOps. Consultez Que sont les packs de ressources Databricks ?.

Cet article décrit les étapes que vous pouvez effectuer à partir d'une configuration de développement locale pour utiliser un pack qui gère par programme une tâche. Voir Introduction aux workflows Azure Databricks.

Si vous avez des tâches existantes créées à l'aide de l'interface utilisateur ou de l'API flux de travail Azure Databricks que vous souhaitez déplacer vers des packs, vous devez les recréer en tant que fichiers de configuration du pack. Pour ce faire, Databricks vous recommande de créer d'abord un pack en suivant les étapes ci-dessous et de vérifier si le pack fonctionne. Vous pouvez ensuite ajouter des définitions de tâches, des notebooks et d'autres sources au pack. Consultez Ajouter une définition de tâche existante à un pack.

En plus d’utiliser l’interface CLI Databricks pour exécuter une tâche déployée par un pack, vous pouvez également afficher et exécuter ces tâches dans l’interface utilisateur Azure Databricks Jobs UI. Consultez Afficher et exécuter un travail créé avec un pack de ressources Databricks.

Spécifications

Databricks CLI version 0.218 ou ultérieure. Pour vérifier la version de Databricks CLI installée, exécutez la commande databricks -v. Pour installer l’interface CLI Databricks, consultez Installer ou mettre à jour l’interface CLI Databricks.

Décision : créer le pack manuellement ou à l’aide d’un modèle

Déterminez si vous souhaitez créer un exemple de pack à l’aide d’un modèle ou manuellement :

Créer l’offre groupée à l’aide d’un modèle
Créer l’offre groupée manuellement

Créer l’offre groupée à l’aide d’un modèle

Dans ces étapes, vous créez le pack à l’aide du modèle de pack par défaut Azure Databricks pour Python, qui se compose d’un code de notebook ou Python, associé à la définition d’un travail pour l’exécuter. Validez, déployez et exécutez ensuite la tâche déployée dans votre espace de travail Azure Databricks. L’espace de travail distant doit disposer de fichiers d’espace de travail activés. Consultez l’article Que sont les fichiers d’espace de travail ?.

Étape 1 : Configurer l’authentification

Dans cette étape, vous configurez l’authentification entre l’interface CLI Databricks sur votre machine de développement et votre espace de travail Azure Databricks. Cet article suppose que vous voulez utiliser l’authentification utilisateur à machine (U2M) OAuth et un profil de configuration Azure Databricks correspondant nommé DEFAULT pour l’authentification.

Remarque

L’authentification U2M est appropriée pour tester ces étapes en temps réel. Pour les workflows entièrement automatisés, Databricks vous recommande d’utiliser à la place l’authentification machine à machine (M2M) OAuth. Consultez les instructions de configuration de l’authentification M2M dans Authentification.

Utilisez l’interface CLI Databricks pour lancer la gestion des jetons OAuth localement en exécutant la commande suivante pour chaque espace de travail cible.

Dans la commande suivante, remplacez <workspace-url> par votre URL d’espace de travail Azure Databricks, par exemple https://adb-1234567890123456.7.azuredatabricks.net.
```
databricks auth login --host <workspace-url>
```
L’interface CLI Databricks vous invite à enregistrer les informations que vous avez entrées en tant que profil de configuration Azure Databricks. Appuyez sur Enter pour accepter le nom de profil suggéré, ou entrez le nom d’un profil nouveau ou existant. Tout profil existant portant le même nom est remplacé par les informations que vous avez entrées. Vous pouvez utiliser des profils pour changer rapidement de contexte d’authentification entre plusieurs espaces de travail.

Pour obtenir la liste des profils existants, dans un autre terminal ou une autre invite de commandes, utilisez l’interface CLI Databricks pour exécuter la commande databricks auth profiles. Pour voir les paramètres existants d’un profil spécifique, exécutez la commande databricks auth env --profile <profile-name>.
Dans votre navigateur web, suivez les instructions à l’écran pour vous connecter à votre espace de travail Azure Databricks.
Pour voir la valeur du jeton OAuth actuel d’un profil et l’horodatage de l’expiration à venir du jeton, exécutez une des commandes suivantes :
- databricks auth token --host <workspace-url>
- databricks auth token -p <profile-name>
- databricks auth token --host <workspace-url> -p <profile-name>
Si vous avez plusieurs profils avec la même valeur pour --host, il peut être nécessaire de spécifier aussi les options --host et -p pour permettre à l’interface CLI Databricks de trouver les informations du jeton OAuth correspondant.

Étape 2 : Créer le pack

Un pack contient les artefacts que vous souhaitez déployer et les paramètres des workflows que vous souhaitez exécuter.

Utilisez votre terminal ou invite de commandes pour basculer vers un répertoire sur votre ordinateur de développement local qui contiendra le pack généré du modèle.
Utilisez l’interface CLI Dataricks pour exécuter la commandebundle init :
```
databricks bundle init
```
Pour Template to use, conservez la valeur par défaut default-python en appuyant surEnter.
Pour Unique name for this project, laissez la valeur par défaut de my_project, ou tapez une valeur différente, puis appuyez surEnter . Cela détermine le nom du répertoire racine de ce bundle. Ce répertoire racine est créé dans votre répertoire de travail actuel.
Pour Include a stub (sample) notebook, sélectionnez yes et appuyez sur Enter.
Pour Include a stub (sample) DLT pipeline, sélectionnez no et appuyez sur Enter. Cela indique à l’interface CLI Databricks de ne pas définir d’exemple de pipeline Delta Live Tables dans votre pack.
Pour Include a stub (sample) Python package, sélectionnez no et appuyez sur Enter. Cela indique à l’interface CLI Databricks de ne pas ajouter d’exemples de fichiers de paquet wheel Python ni d’instructions de build associées à votre pack.

Étape 3 : Explorer le pack

Pour afficher les fichiers générés par le modèle, basculez vers le répertoire racine de votre bundle nouvellement créé et ouvrez ce répertoire avec votre IDE préféré, par exemple Visual Studio Code. Les fichiers d’intérêt particulier sont les suivants :

databricks.yml : ce fichier spécifie le nom programmatique du pack, inclut une référence à la définition de tâche et spécifie les paramètres relatifs à l’espace de travail cible.
resources/<project-name>_job.yml : ce fichier spécifie les paramètres du travail, y compris une tâche de notebook par défaut.
src/notebook.ipynb : ce fichier est un échantillon de notebook qui, lors de l’exécution, initialise simplement un RDD contenant les nombres 1 à 10.

Pour la personnalisation des tâches, les mappages dans une déclaration de tâche correspondent à la charge utile de la demande de l'opération de création de tâche telle que définie dans POST /api/2.1/jobs/create dans la référence de l'API REST, exprimée au format YAML.

Conseil

Vous pouvez définir, combiner et remplacer les paramètres des nouveaux clusters de travaux dans des packs à l’aide des techniques décrites dans Remplacer les paramètres de cluster dans les packs de ressources Databricks.

Étape 4 : valider le fichier de configuration du pack du projet

Dans cette étape, vous vérifiez si la configuration du pack est valide.

À partir du répertoire racine, utilisez l’interface CLI Databricks pour exécuter la commandebundle validate, comme suit :
```
databricks bundle validate
```
Si un résumé de la configuration de l’offre groupée est retourné, la validation a réussi. Si des erreurs sont renvoyées, corrigez-les , puis répétez cette étape.

Si vous apportez des modifications à votre pack après cette étape, vous devez répéter cette étape pour vérifier si les paramètres de votre pack sont toujours valides.

Étape 5 : Déployer le projet local sur l’espace de travail distant

Au cours de cette étape, vous allez déployer le notebook local dans votre espace de travail Azure Databricks distant et créer le travail Azure Databricks dans votre espace de travail.

À partir du pack racine, utilisez l'interface CLI Databricks pour exécuter la commande bundle deploy, comme suit :
```
databricks bundle deploy -t dev
```
Vérifiez si le notebook local a été déployés : dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Espace de travail.
Cliquez sur le dossier Utilisateurs ><your-username>> .bundle ><project-name>> dev > fichiers > src . Le notebook doit se trouver dans ce dossier.
Vérifiez si le travail a été créé : dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Flux de travail.
Sous l’onglet Travaux, cliquez sur [dev <your-username>] <project-name>_job.
Cliquez sur l'onglet Tâches. Il devrait y avoir un travail : notebook_task.

Si vous apportez des modifications à votre pack après cette étape, vous devez répéter les étapes 4 à 5 pour vérifier si la configuration de votre pack est toujours valide, puis redéployer le projet.

Étape 6 : Exécuter le projet déployé

Dans cette étape, vous allez exécuter le travail Azure Databricks dans votre espace de travail.

À partir du répertoire racine, utilisez l’interface CLI Databricks pour exécuter la commandebundle run, comme suit, en remplaçant<project-name> par le nom de votre projet à l’étape 2 :
```
databricks bundle run -t dev <project-name>_job
```
Copiez la valeur Run URL qui apparaît dans votre terminal et collez cette valeur dans votre navigateur web pour ouvrir votre espace de travail Azure Databricks.
Dans votre espace de travail Azure Databricks, une fois que la tâche du travail est terminée avec succès et affiche une barre de titre verte, cliquez sur la tâche du travail pour afficher les résultats.

Si vous apportez des modifications à votre pack après cette étape, vous devez répéter les étapes 4 à 6 pour vérifier si la configuration de votre pack est toujours valide, puis redéployer le projet et exécuter le projet redéployé.

Étape 7 : Nettoyer

Au cours de cette étape, vous allez supprimer le notebook déployé et le travail de votre espace de travail.

À partir du répertoire racine, utilisez l’interface CLI Databricks pour exécuter la commande bundle destroy, comme suit :
```
databricks bundle destroy
```
Confirmez la demande de suppression de travail : lorsque l’option de détruire définitivement des ressources s’affiche, tapez y et appuyez sur Enter.
Confirmez la demande de suppression de notebook : lorsque l’option de détruire définitivement le dossier précédemment déployé et tous ses fichiers s’affiche, tapez y et appuyez sur Enter.
Si vous souhaitez également supprimer le pack de votre ordinateur de développement, vous pouvez maintenant supprimer le répertoire local de l’étape 2.

Vous avez atteint la fin des étapes de création d’un pack à l’aide d’un modèle.

Créer l’offre groupée manuellement

Dans ces étapes, vous créez un pack à partir de zéro. Ce pack simple se compose de deux notebooks et de la définition d’un travail Azure Databricks pour exécuter ces notebooks. Vous validez, déployez et exécutez ensuite les notebooks déployés à partir du travail au sein de votre espace de travail Azure Databricks. Ces étapes automatisent le démarrage rapide intitulé Créer votre premier flux de travail avec un travail Azure Databricks.

Étape 1 : créer le pack

Un pack contient les artefacts que vous souhaitez déployer et les paramètres des workflows que vous souhaitez exécuter.

Créez ou identifiez un répertoire vide sur votre ordinateur de développement.
Basculez vers le répertoire vide de votre terminal ou ouvrez le répertoire vide dans votre IDE.

Conseil

Votre répertoire vide peut être associé à un dépôt cloné géré par un fournisseur Git. Cela vous permet de gérer votre pack avec un contrôle de version externe et de collaborer plus facilement avec d’autres développeurs et professionnels de l’informatique sur votre projet. Toutefois, pour simplifier cette démonstration, un dépôt cloné n’est pas utilisé ici.

Si vous choisissez de cloner un référentiel pour cette démonstration, Databricks recommande qu’il soit vide ou qu’il ne contienne que des fichiers de base, tels que README et .gitignore. Sinon, tous les fichiers préexistants dans le dépôt peuvent être synchronisés inutilement avec votre espace de travail Azure Databricks.

Étape 2 : ajouter des notebooks au projet

Au cours de cette étape, vous ajoutez deux notebooks à votre projet. Le premier notebook obtient une liste des noms de bébé en vogue depuis 2007 provenant de sources de données publiques du Département de la Santé de l’État de New York. Voir Baby Names: Trending by Name: Beginning 2007 sur le site web du département. Le premier notebook enregistre ensuite ces données dans votre volume Azure Databricks Unity Catalog nommé my-volume dans un schéma nommé default dans un catalogue nommé main. Le deuxième notebook interroge les données enregistrées et affiche les nombres agrégés de noms de bébé par prénom et sexe pour 2014.

À partir de la racine du répertoire, créez le premier notebook, un fichier nommé retrieve-baby-names.py.

Ajoutez le code suivant au fichier retrieve-baby-names.py :

# Databricks notebook source
import requests

response = requests.get('http://health.data.ny.gov/api/views/jxy9-yhdk/rows.csv')
csvfile = response.content.decode('utf-8')
dbutils.fs.put("/Volumes/main/default/my-volume/babynames.csv", csvfile, True)

Créez le deuxième notebook, un fichier nommé filter-baby-names.py, dans le même répertoire.

Ajoutez le code suivant au fichier filter-baby-names.py :

# Databricks notebook source
babynames = spark.read.format("csv").option("header", "true").option("inferSchema", "true").load("/Volumes/main/default/my-volume/babynames.csv")
babynames.createOrReplaceTempView("babynames_table")
years = spark.sql("select distinct(Year) from babynames_table").toPandas()['Year'].tolist()
years.sort()
dbutils.widgets.dropdown("year", "2014", [str(x) for x in years])
display(babynames.filter(babynames.Year == dbutils.widgets.get("year")))

Étape 3 : ajouter un fichier de schéma de configuration du pack au projet

Si vous utilisez un IDE tel que Visual Studio Code, PyCharm Professional ou IntelliJ IDEA Ultimate qui prend en charge les fichiers YAML et les fichiers de schéma JSON, vous pouvez non seulement utiliser votre IDE pour créer le fichier de schéma de configuration du pack, mais pour vérifier la syntaxe et la mise en forme du fichier de configuration du pack de votre projet et fournir des indicateurs de saisie semi-automatique du code, comme suit. Remarque : bien que le fichier de configuration du pack que vous allez créer plus tard à l'étape 5 est basé sur YAML, le fichier de schéma de configuration du pack dans cette étape est basé sur JSON.

Visual studio code

Ajoutez la prise en charge du serveur de langage YAML à Visual Studio Code, par exemple en installant l’extension YAML à partir de la place de marché Visual Studio Code.
Générez le fichier de schéma JSON de configuration du pack de ressources Databricks en utilisant l’interface CLI Databricks pour exécuter la commande bundle schema et rediriger la sortie vers un fichier JSON. Par exemple, générez un fichier nommé bundle_config_schema.json dans le répertoire actif, comme suit :
```
databricks bundle schema > bundle_config_schema.json
```
Remarque : plus loin à l'étape 5, vous allez ajouter le commentaire suivant au début de votre fichier de configuration du pack, qui associe votre fichier de configuration du pack au fichier de schéma JSON spécifié :
```
# yaml-language-server: $schema=bundle_config_schema.json
```
Remarque

Dans le commentaire précédent, si votre fichier de schéma JSON de configuration du pack de ressources Databricks se trouve dans un chemin d’accès différent, remplacez bundle_config_schema.json par le chemin d’accès complet à votre fichier de schéma.

Pycharm professsional

Générez le fichier de schéma JSON de configuration du pack de ressources Databricks en utilisant l’interface CLI Databricks pour exécuter la commande bundle schema et rediriger la sortie vers un fichier JSON. Par exemple, générez un fichier nommé bundle_config_schema.json dans le répertoire actif, comme suit :
```
databricks bundle schema > bundle_config_schema.json
```
Configurez PyCharm pour reconnaître le fichier de schéma JSON de configuration du pack, puis effectuez le mappage de schéma JSON en suivant les instructions fournies dans Configurer un schéma JSON personnalisé.
Notez que plus loin à l'étape 5, vous allez utiliser PyCharm pour créer ou ouvrir un fichier de configuration du pack. Par convention, ce fichier est nommé databricks.yml.

Intellij idea ultimate

Générez le fichier de schéma JSON de configuration du pack de ressources Databricks en utilisant l’interface CLI Databricks pour exécuter la commande bundle schema et rediriger la sortie vers un fichier JSON. Par exemple, générez un fichier nommé bundle_config_schema.json dans le répertoire actif, comme suit :
```
databricks bundle schema > bundle_config_schema.json
```
Configurez IntelliJ IDEA pour reconnaître le fichier de schéma JSON de configuration du pack, puis effectuez le mappage de schéma JSON, en suivant les instructions fournies dans Configurer un schéma JSON personnalisé.
Notez que plus loin à l'étape 5, vous allez utiliser IntelliJ IDEA pour créer ou ouvrir un fichier de configuration du pack. Par convention, ce fichier est nommé databricks.yml.

Étape 4 : configurer l’authentification

Remarque

Utilisez l’interface CLI Databricks pour lancer la gestion des jetons OAuth localement en exécutant la commande suivante pour chaque espace de travail cible.

Dans la commande suivante, remplacez <workspace-url> par votre URL d’espace de travail Azure Databricks, par exemple https://adb-1234567890123456.7.azuredatabricks.net.
```
databricks auth login --host <workspace-url>
```
L’interface CLI Databricks vous invite à enregistrer les informations que vous avez entrées en tant que profil de configuration Azure Databricks. Appuyez sur Enter pour accepter le nom de profil suggéré, ou entrez le nom d’un profil nouveau ou existant. Tout profil existant portant le même nom est remplacé par les informations que vous avez entrées. Vous pouvez utiliser des profils pour changer rapidement de contexte d’authentification entre plusieurs espaces de travail.

Pour obtenir la liste des profils existants, dans un autre terminal ou une autre invite de commandes, utilisez l’interface CLI Databricks pour exécuter la commande databricks auth profiles. Pour voir les paramètres existants d’un profil spécifique, exécutez la commande databricks auth env --profile <profile-name>.
Dans votre navigateur web, suivez les instructions à l’écran pour vous connecter à votre espace de travail Azure Databricks.
Pour voir la valeur du jeton OAuth actuel d’un profil et l’horodatage de l’expiration à venir du jeton, exécutez une des commandes suivantes :
- databricks auth token --host <workspace-url>
- databricks auth token -p <profile-name>
- databricks auth token --host <workspace-url> -p <profile-name>
Si vous avez plusieurs profils avec la même valeur pour --host, il peut être nécessaire de spécifier aussi les options --host et -p pour permettre à l’interface CLI Databricks de trouver les informations du jeton OAuth correspondant.

Étape 5 : ajouter un fichier de configuration du pack au projet

Dans cette étape, vous définissez la façon dont vous souhaitez déployer et exécuter les deux notebooks. Pour cette démonstration, vous allez utiliser un travail Azure Databricks pour exécuter le premier notebook, puis le deuxième notebook. Étant donné que le premier notebook enregistre les données et que le deuxième notebook interroge les données enregistrées, il faut que le premier notebook finisse son exécution avant que le deuxième notebook ne démarre. Vous modélisez ces objectifs dans un fichier de paramètres du pack dans votre projet.

À partir de la racine du répertoire, créez le fichier de configuration du pack, un fichier nommé databricks.yml.
Ajoutez le code suivant au fichier databricks.yml, en remplaçant <workspace-url> par votre URL par espace de travail, par exemple https://adb-1234567890123456.7.azuredatabricks.net. Cette URL doit correspondre à celle de votre fichier .databrickscfg :

Conseil

La première ligne, en commençant par # yaml-language-server, est requise uniquement si votre IDE le prend en charge. Pour plus d'informations, consultez l'étape 3 précédente.

# yaml-language-server: $schema=bundle_config_schema.json
bundle:
  name: baby-names

resources:
  jobs:
    retrieve-filter-baby-names-job:
      name: retrieve-filter-baby-names-job
      job_clusters:
        - job_cluster_key: common-cluster
          new_cluster:
            spark_version: 12.2.x-scala2.12
            node_type_id: Standard_DS3_v2
            num_workers: 1
      tasks:
        - task_key: retrieve-baby-names-task
          job_cluster_key: common-cluster
          notebook_task:
            notebook_path: ./retrieve-baby-names.py
        - task_key: filter-baby-names-task
          depends_on:
            - task_key: retrieve-baby-names-task
          job_cluster_key: common-cluster
          notebook_task:
            notebook_path: ./filter-baby-names.py

targets:
  development:
    workspace:
      host: <workspace-url>

Conseil

Étape 6 : valider le fichier de configuration du pack du projet

Dans cette étape, vous vérifiez si la configuration du pack est valide.

Utilisez l'interface Databricks CLI pour exécuter la commande bundle validate comme suit :
```
databricks bundle validate
```
Si un résumé de la configuration de l’offre groupée est retourné, la validation a réussi. Si des erreurs sont renvoyées, corrigez-les , puis répétez cette étape.

Si vous apportez des modifications à votre pack après cette étape, vous devez répéter cette étape pour vérifier si les paramètres de votre pack sont toujours valides.

Étape 7 : déployer le projet local sur l’espace de travail distant

Au cours de cette étape, vous allez déployer les deux notebooks locaux dans votre espace de travail Azure Databricks distant et créer le travail Azure Databricks dans votre espace de travail.

Utilisez l'interface Databricks CLI pour exécuter la commande bundle deploy comme suit :
```
databricks bundle deploy -t development
```
Vérifiez si les deux notebooks locaux ont été déployés : dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Espace de travail.
Cliquez dans le dossier Utilisateurs ><your-username>> .bundle > baby-names > développement > fichiers. Les deux blocs-notes doivent se trouver dans ce dossier.
Vérifiez si le travail a été créé : dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Flux de travail.
Dans l’onglet Travaux, cliquez sur retrieve-filter-baby-names-job.
Cliquez sur l’onglet Tâches. Il doit y avoir deux tâches : retrieve-baby-names-task et filter-baby-names-task.

Si vous apportez des modifications à votre pack après cette étape, vous devez répéter les étapes 6 à 7 pour vérifier si la configuration de votre pack est toujours valide, puis redéployer le projet.

Étape 8 : exécuter le projet déployé

Dans cette étape, vous allez exécuter le travail Azure Databricks dans votre espace de travail.

Utilisez l'interface Databricks CLI pour exécuter la commande bundle run comme suit :
```
databricks bundle run -t development retrieve-filter-baby-names-job
```
Copiez la valeur Run URL qui apparaît dans votre terminal et collez cette valeur dans votre navigateur web pour ouvrir votre espace de travail Azure Databricks.
Dans votre espace de travail Azure Databricks, une fois les deux tâches terminées avec succès et les barres de titre vertes affichées, cliquez sur la tâche filter-baby-names-task pour afficher les résultats de la requête.

Si vous apportez des modifications à votre pack après cette étape, vous devez répéter les étapes 6 à 8 pour vérifier si la configuration de votre pack est toujours valide, puis redéployer le projet et exécuter le projet redéployé.

Étape 9 : nettoyer

Au cours de cette étape, vous allez supprimer les deux blocs-notes déployés et le travail de votre espace de travail.

Utilisez l'interface Databricks CLI pour exécuter la commande bundle destroy comme suit :
```
databricks bundle destroy
```
Confirmez la demande de suppression de travail : lorsque l’option de détruire définitivement des ressources s’affiche, tapez y et appuyez sur Enter.
Confirmez la demande de suppression des notebooks : lorsque l’option de détruire définitivement le dossier précédemment déployé et tous ses fichiers s’affiche, tapez y et appuyez sur Enter.

L’exécution de la commande bundle destroy supprime uniquement le travail déployé et le dossier contenant les deux notebooks déployés. Cette commande ne supprime aucun effet secondaire, tel que le fichier babynames.csv créé par le premier bloc-notes. Pour supprimer le fichier babybnames.csv, procédez comme suit :

Dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Catalogues.
Cliquez sur Parcourir DBFS.
Cliquez sur le fichier FileStore.
Cliquez sur la flèche déroulante à côté de babynames.csv, puis cliquez sur Supprimer.
Si vous souhaitez également supprimer le pack de votre ordinateur de développement, vous pouvez maintenant supprimer le répertoire local de l’étape 1.

Ajouter une définition de tâche existante à un pack

Vous pouvez utiliser une définition de tâche existante comme base pour définir une nouvelle tâche dans un fichier de configuration du pack. Pour cela, procédez comme suit :

Remarque

Les étapes suivantes créent une tâche qui a les mêmes paramètres que la tâche existante. Toutefois, la nouvelle tâche a un ID de tâche différent de celui de la tâche existante. Vous ne pouvez pas importer automatiquement un ID de tâche existant dans un pack.

Étape 1 : Obtenir la définition de tâche existante au format YAML

Dans cette étape, utilisez l’interface utilisateur de l’espace de travail Azure Databricks pour obtenir la représentation YAML de la définition de tâche existante.

Dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Catalogue.
Sous l'onglet Tâches, cliquez sur le lien du Nom de votre tâche.
En regard du bouton Exécuter maintenant, cliquez sur les points de suspension, puis sur Afficher YAML.
Sous l’onglet Créer, copiez le code YAML de la définition de tâche dans votre presse-papiers local en cliquant sur Copier.

Étape 2 : Ajouter la définition de tâche YAML à un fichier de configuration groupé

Dans votre fichier de configuration du pack, ajoutez le fichier YAML que vous avez copié à l'étape précédente à l'un des emplacements suivants appelés <job-yaml-can-go-here> dans vos fichiers de configuration du pack, comme suit :

resources:
  jobs:
    <some-unique-programmatic-identifier-for-this-job>:
      <job-yaml-can-go-here>

targets:
  <some-unique-programmatic-identifier-for-this-target>:
    resources:
      jobs:
        <some-unique-programmatic-identifier-for-this-job>:
          <job-yaml-can-go-here>

Étape 3 : Ajouter des notebooks, des fichiers Python et d’autres artefacts au pack

Tous les fichiers et notebooks Python référencés dans la tâche existante doivent être déplacés vers les sources du pack.

Pour une meilleure compatibilité avec les packs, les notebooks doivent utiliser le format de notebook IPython (.ipynb). Si vous développez le pack localement, vous pouvez exporter un notebook existant à partir d'un espace de travail Azure Databricks dans le format .ipynb en cliquant sur File> Export > IPython Notebook à partir de l'interface utilisateur du notebook Azure Databricks. Par convention, vous devez ensuite placer le notebook téléchargé dans le répertoire src/ de votre pack.

Après avoir ajouté vos notebooks, fichiers Python et autres artefacts au pack, assurez-vous que votre définition de tâche les référence. Par exemple, pour un notebook dont le nom de fichier se trouve dans un répertoire src/ et que le répertoire src/ se trouve dans le même dossier que le fichier de configuration du pack qui référence le répertoire src/, la définition de tâche hello.ipynb peut être exprimée comme suit :

resources:
  jobs:
    hello-job:
      name: hello-job
      tasks:
      - task_key: hello-task
        notebook_task:
          notebook_path: ./src/hello.ipynb

Étape 4 : Valider, déployer et exécuter la nouvelle tâche

Vérifiez que les fichiers de configuration du pack sont correctement synchronisés en exécutant la commande suivante :
```
databricks bundle validate
```
Déployez le pack en exécutant la commande suivante. Dans cette commande, remplacez <target-identifier> par l'identificateur programmatique unique de la cible à partir de la configuration du pack :
```
databricks bundle deploy -t <target-identifier>
```
Exécutez la tâche à l’aide de la commande suivante.
```
databricks bundle run -t <target-identifier> <job-identifier>
```
- Remplacez <target-identifier> par l'identificateur programmatique unique de la cible à partir de la configuration du pack.
- Remplacez <job-identifier> par un identificateur programmatique unique pour la tâche à partir de la configuration du pack.

Configurez une tâche qui utilise le calcul serverless

Important

Le calcul serverless pour les flux de travail est disponible en préversion publique. Pour plus d’informations sur l’éligibilité et l’activation, consultez Activer le calcul serverless en préversion publique.

Les exemples suivants présentent des configurations de packs pour créer une tâche qui utilise le calcul serverless.

Pour utiliser le calcul serverless afin d’exécuter une tâche qui inclut des tâches de notebook, omettez la configuration job_clusters à partir du fichier de configuration groupé.

# yaml-language-server: $schema=bundle_config_schema.json
bundle:
  name: baby-names

resources:
  jobs:
    retrieve-filter-baby-names-job-serverless:
      name: retrieve-filter-baby-names-job-serverless
      tasks:
        - task_key: retrieve-baby-names-task
          notebook_task:
            notebook_path: ./retrieve-baby-names.py
        - task_key: filter-baby-names-task
          depends_on:
            - task_key: retrieve-baby-names-task
          notebook_task:
            notebook_path: ./filter-baby-names.py

  targets:
    development:
      workspace:
        host: <workspace-url>

Pour utiliser le calcul serverless pour exécuter un travail qui inclut des tâches Python, incluez la configuration environments.

# yaml-language-server: $schema=bundle_config_schema.json
bundle:
  name: serverless-python-tasks

resources:
jobs:
  serverless-python-job:
    name: serverless-job-with-python-tasks

    tasks:
      - task_key: wheel-task-1
        python_wheel_task:
          entry_point: main
          package_name: wheel_package
        environment_key: Default

    environments:
      - environment_key: Default
        spec:
          client: "1"
          dependencies:
            - workflows_authoring_toolkit==0.0.1

targets:
  development:
    workspace:
      host: <workspace-url>

Consultez Exécuter votre tâche Azure Databricks avec un calcul serverless pour les flux de travail.

Share via

Développer une tâche sur Azure Databricks à l’aide des packs de ressources Databricks

Spécifications

Décision : créer le pack manuellement ou à l’aide d’un modèle

Créer l’offre groupée à l’aide d’un modèle

Étape 1 : Configurer l’authentification

Étape 2 : Créer le pack

Étape 3 : Explorer le pack

Étape 4 : valider le fichier de configuration du pack du projet

Étape 5 : Déployer le projet local sur l’espace de travail distant

Étape 6 : Exécuter le projet déployé

Étape 7 : Nettoyer

Créer l’offre groupée manuellement

Étape 1 : créer le pack

Étape 2 : ajouter des notebooks au projet

Étape 3 : ajouter un fichier de schéma de configuration du pack au projet

Visual studio code

Pycharm professsional

Intellij idea ultimate

Étape 4 : configurer l’authentification

Étape 5 : ajouter un fichier de configuration du pack au projet

Étape 6 : valider le fichier de configuration du pack du projet

Étape 7 : déployer le projet local sur l’espace de travail distant

Étape 8 : exécuter le projet déployé

Étape 9 : nettoyer

Ajouter une définition de tâche existante à un pack

Étape 1 : Obtenir la définition de tâche existante au format YAML

Étape 2 : Ajouter la définition de tâche YAML à un fichier de configuration groupé

Étape 3 : Ajouter des notebooks, des fichiers Python et d’autres artefacts au pack

Étape 4 : Valider, déployer et exécuter la nouvelle tâche

Configurez une tâche qui utilise le calcul serverless

Commentaires

Commentaires

Ressources supplémentaires