Développer un fichier wheel Python à l’aide de packs de ressources Databricks

Article
08/30/2024

Cet article explique comment générer, déployer et exécuter un fichier wheel Python dans le cadre d’un projet de pack de ressources Databricks. Consultez Que sont les packs de ressources Databricks ?

Spécifications

Databricks CLI 0.218.0 ou une version 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.
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 ?.

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

Déterminez si vous souhaitez créer un bundle de démarrage à l’aide d’un modèle ou pour créer le bundle manuellement. La création de l’offre groupée à l’aide d’un modèle est plus rapide et plus facile, mais le bundle peut produire du contenu qui n’est pas nécessaire, et les paramètres par défaut du bundle doivent être davantage personnalisés pour les applications réelles. La création manuelle du bundle vous donne un contrôle total sur les paramètres de l’offre groupée, mais vous devez être familiarisé avec le fonctionnement des offres groupées, car vous effectuez tout le travail à partir du début. Choisissez l’un des ensembles d’étapes suivants :

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. Ces étapes vous guident pour créer un bundle constitué de fichiers à générer dans un fichier wheel Python et la définition d’un travail Azure Databricks pour générer ce fichier wheel Python. Vous validez, déployez et générez les fichiers déployés dans un fichier wheel Python à partir du travail wheel Python au sein de votre espace de travail Azure Databricks.

Le modèle de pack par défaut d’Azure Databricks pour Python utilise setuptools pour générer le fichier wheel Python. Si vous préférez utiliser Poetry pour créer le fichier wheel Python, suivez les instructions plus loin dans cette section pour remplacer l’implémentation setuptools par une implémentation Poetry.

É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 la version de l’interface CLI Databricks 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 no et appuyez sur Enter. Cela indique à l’interface CLI Databricks de ne pas ajouter d’exemple de notebook à votre offre groupée.
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 bundle.
Pour Include a stub (sample) Python package, conservez la valeur par défaut en yes appuyant surEnter . Cela indique à l’interface CLI Databricks d’ajouter des exemples de fichiers de package de roue Python et des instructions de génération associées à votre offre groupée.

Étape 3 : Explorer le bundle

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 bundle, inclut une référence à la définition du travail de roue Python 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 de roue Python.
src/<project-name> : ce répertoire inclut les fichiers utilisés par le travail wheel Python pour générer le fichier wheel Python.

Remarque

Si vous voulez installer le fichier wheel Python sur un cluster cible sur lequel Databricks Runtime 12.2 LTS ou version inférieure est installé, vous devez ajouter le mappage de niveau supérieur suivant au fichier databricks.yml :

# Applies to all tasks of type python_wheel_task.
experimental:
  python_wheel_wrapper: true

Ce mappage indique à l’interface CLI Databricks d’effectuer les opérations suivantes :

Déployer une copie du fichier wheel Python en arrière-plan. Ce chemin de déploiement est généralement ${workspace.artifact_path}/.internal/<random-id>/<wheel-filename>.whl.
Créer un notebook en arrière-plan qui contient des instructions pour installer le fichier wheel Python précédent déployé sur le cluster cible. Le chemin d’accès de ce notebook est généralement ${workspace.file_path}/.databricks/bundle/<target-name>/.internal/notebook_<job-name>_<task-key>.
Quand vous exécutez un travail qui contient une tâche wheel Python et que cette tâche référence le fichier wheel Python précédent, un travail qui exécute le notebook précédent est créé en arrière-plan.

Vous n’avez pas besoin de spécifier ce mappage pour les clusters cibles avec Databricks Runtime 13.1 ou ultérieur installé, car les installations de fichier wheel Python depuis le système de fichiers de l’espace de travail Azure Databricks sont effectuées automatiquement sur ces clusters cibles.

Étape 4 : Mettre à jour le pack du projet pour utiliser Poetry

Par défaut, le modèle de pack spécifie la génération du fichier wheel Python en utilisant setuptools avec les fichiers setup.py et requirements-dev.txt. Si vous voulez conserver ces valeurs par défaut, passez à l’Étape 5 : Valider le fichier de configuration du pack du projet.

Pour mettre à jour le pack du projet pour utiliser Poetry au lieu de setuptools, vérifiez que votre machine de développement locale répond aux exigences suivantes :

Poetry version 1.6 ou ultérieure. Pour vérifier la version installée de Poetry, exécutez la commande poetry -V ou poetry --version. Pour installer ou mettre à niveau Poetry, consultez Installation.
Python version 3.10 ou ultérieure. Pour vérifier votre version de Python, exécutez la commande python -V ou python --version.
Databricks CLI version 0.209.0 ou ultérieure. Pour vérifier votre version de Databricks CLI, exécutez la commande databricks -v ou databricks --version. Consultez Installer ou mettre à jour l’interface CLI Databricks.

Apportez les modifications suivantes au pack du projet :

Depuis le répertoire racine du pack, indiquez à poetry d’initialiser les builds de paquet wheel Python pour Poetry en exécutant la commande suivante :
```
poetry init
```
Poetry affiche plusieurs invites pour vous permettre de terminer. Pour les builds de paquet wheel Python, répondez à ces invites comme suit pour respecter la correspondance avec les paramètres par défaut associés dans le pack du projet :
1. Pour Package name, tapez le nom du dossier enfant sous /src, puis appuyez sur Enter. Il doit également s’agir de la valeur de name du package qui est définie dans le fichier setup.py du pack.
2. Pour Version, tapez 0.0.1 et appuyez sur Enter. Ceci correspond au numéro de version défini dans le fichier src/<project-name>/__init__.py du pack.
3. Pour Description, tapez wheel file based on <project-name>/src (en remplaçant <project-name> par le nom du projet), puis appuyez sur Enter. Ceci correspond à la valeur de description définie dans le fichier setup.py du modèle.
4. Pour Author, appuyez sur Enter. Cette valeur par défaut correspond à l’auteur défini dans le fichier setup.py du modèle.
5. Pour License, appuyez sur Enter. Aucune licence n’est définie dans le modèle.
6. Pour Compatible Python versions, entrez la version de Python qui correspond à celle de vos clusters Azure Databricks cibles (par exemple ^3.10), puis appuyez sur Enter.
7. Pour Would you like to define your main dependencies interactively?, tapez no, puis appuyez sur Enter. Vous définirez vos dépendances plus tard.
8. Pour Would you like to define your development dependencies interactively?, tapez no, puis appuyez sur Enter. Vous définirez vos dépendances plus tard.
9. Pour Do you confirm generation?, appuyez sur Enter.
Une fois que vous avez répondu aux invites, Poetry ajoute un fichier pyproject.toml à votre projet de pack. Pour plus d’informations sur le fichier pyproject.toml, consultez le fichier pyproject.toml.
Dans le répertoire racine du pack, indiquez à poetry de lire le fichier pyproject.toml, de résoudre les dépendances et de les installer, de créer un fichier poetry.lock pour verrouiller ces dépendances, et enfin de créer un environnement virtuel. Pour ce faire, exécutez la commande suivante :
```
poetry install
```
Ajoutez la section suivante à la fin du fichier pyproject.toml, en remplaçant <project-name> par le nom du répertoire qui contient le fichier src/<project-name>/main.py (par exemple my_project) :
```
[tool.poetry.scripts]
main = "<project-name>.main:main"
```
La section spécifie le point d’entrée du paquet wheel Python pour le travail du paquet wheel Python.
Ajoutez le mappage suivant en haut du fichier databricks.yml du pack :
```
artifacts:
  default:
    type: whl
    build: poetry build
    path: .
```
Ce mappage indique à Databricks CLI d’utiliser Poetry pour créer un fichier wheel Python.
Supprimez les fichiers setup.py et requirements-dev.txt du pack, car Poetry n’en a pas besoin.

Étape 5 : 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 6 : Générer le fichier wheel Python et déployer le projet local sur l’espace de travail distant

Lors de cette étape, vous générez le fichier wheel Python, déployez le fichier wheel Python généré sur votre espace de travail Azure Databricks distant, et créez le travail Azure Databricks dans votre espace de travail.

Si vous utilisez setuptools, si vous ne l’avez pas déjà fait, installez les packages wheel et setuptools en exécutant la commande suivante :
```
pip3 install --upgrade wheel setuptools
```
Dans le terminal Visual Studio Code, utilisez l’interface CLI Databricks pour exécuter la commande bundle deploy comme suit :
```
databricks bundle deploy -t dev
```
Si vous voulez vérifier que le fichier wheel Python généré localement a été déployé :
1. Dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Espace de travail.
2. Cliquez dans le dossier suivant : Espace de travail> Utilisateurs ><your-username>> .bundle ><project-name>> dev > artifacts > .internal ><random-guid>.
Le fichier wheel Python doit se trouver dans ce dossier.
Si vous voulez vérifier que le travail a été créé :
1. Dans la barre latérale de votre espace de travail Azure Databricks, cliquez sur Catalogue.
2. Sous l’onglet Travaux , cliquez sur [dev <your-username>] <project-name>_job.
3. Cliquez sur l'onglet Tâches.
Il doit y avoir une tâche : main_task.

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

Étape 7 : 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 la tâche terminée avec succès et afficher une barre de titre verte, cliquez sur la tâche main_task pour afficher les résultats.

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

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

Créer l’offre groupée manuellement

Dans ces étapes, vous créez le pack manuellement, à partir de zéro. Ces étapes vous guident pour créer un pack constitué de fichiers à générer dans un fichier wheel Python et la définition d’un travail Databricks pour générer ce fichier wheel Python. Ensuite, vous validez, déployez et générez les fichiers déployés dans un fichier wheel Python à partir du travail wheel Python au sein de votre espace de travail Databricks.

Ces étapes incluent l’ajout de contenu à un fichier YAML. Si vous le souhaitez, vous pouvez utiliser un environnement de développement intégré (IDE) qui fournit des suggestions et des actions de schéma automatiques lors de l’utilisation de fichiers YAML. Les étapes suivantes utilisent Visual Studio Code avec l’extension YAML installée à partir de Place de marché Visual Studio Code.

Ces étapes supposent que vous connaissez déjà :

Comment créer, générer et utiliser des fichier wheel Python avec Poetry ou setuptools. Pour Poetry, consultez Utilisation de base. Pour setuptools, consultez le Guide de l’utilisateur pour la création de packages Python.
Comment utiliser des fichiers wheel Python dans le cadre d’un travail Azure Databricks. Consultez Utiliser un fichier wheel Python dans un travail Azure Databricks.

Suivez ces instructions pour créer un exemple de pack qui génère un fichier wheel Python avec Poetry ou setuptools, déploie le fichier wheel Python, puis exécute le fichier wheel Python déployé.

Si vous avez déjà créé un fichier wheel Python et que vous voulez simplement le déployer et l’exécuter, passez directement à la spécification des paramètres du fichier wheel Python dans le fichier de configuration du pack à l’Étape 3 : Créer le fichier de configuration du pack.

Étape 1 : 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 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.

Dans la racine de votre pack, créez les dossiers et fichiers suivants, selon que vous utilisez Poetry ou setuptools pour générer des fichiers wheel Python :

Poetry

├── src
│     └── my_package
│           ├── __init__.py
│           ├── main.py
│           └── my_module.py
└── pyproject.toml

Setuptools

├── src
│     └── my_package
│           ├── __init__.py
│           ├── main.py
│           └── my_module.py
└── setup.py

Laissez le fichier __init__.py vide.

Ajoutez le code suivant au fichier main.py, puis enregistrez-le :

from my_package.my_module import *

def main():

  first = 200
  second = 400

  print(f"{first} + {second} = {add_two_numbers(first, second)}")
  print(f"{second} - {first} = {subtract_two_numbers(second, first)}")
  print(f"{first} * {second} = {multiply_two_numbers(first, second)}")
  print(f"{second} / {first} = {divide_two_numbers(second, first)}")

if __name__ == "__main__":
  main()

Ajoutez le code suivant au fichier my_module.py, puis enregistrez-le :

def add_two_numbers(a, b):
  return a + b

def subtract_two_numbers(a, b):
  return a - b

def multiply_two_numbers(a, b):
  return a * b

def divide_two_numbers(a, b):
  return a / b

Ajoutez le code suivant au fichier pyproject.toml ou setup.py, puis enregistrez-le :

Pyproject.toml

[tool.poetry]
name = "my_package"
version = "0.0.1"
description = "<my-package-description>"
authors = ["my-author-name <my-author-name>@<my-organization>"]

[tool.poetry.dependencies]
python = "^3.10"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

[tool.poetry.scripts]
main = "my_package.main:main"

Remplacez my-author-name par le nom du contact principal de votre organisation.
Remplacez my-author-name>@<my-organization par l’adresse e-mail de contact principale de votre organisation.
Remplacez <my-package-description> par une description de votre fichier wheel Python.

Setup.py

from setuptools import setup, find_packages

import src

setup(
  name = "my_package",
  version = "0.0.1",
  author = "<my-author-name>",
  url = "https://<my-url>",
  author_email = "<my-author-name>@<my-organization>",
  description = "<my-package-description>",
  packages=find_packages(where='./src'),
  package_dir={'': 'src'},
  entry_points={
    "packages": [
      "main=my_package.main:main"
    ]
  },
  install_requires=[
    "setuptools"
  ]
)

Remplacez https://<my-url> par l’ID de votre organisation.
Remplacez <my-author-name> par le nom du contact principal de votre organisation.
Remplacez <my-author-name>@<my-organization> par l’adresse e-mail de contact principale de votre organisation.
Remplacez <my-package-description> par une description de votre fichier wheel Python.

Étape 3 : Créer le fichier de configuration du pack

Un fichier de configuration de pack décrit les artefacts que vous voulez déployer et les flux de travail que vous voulez exécuter.

Dans la racine de votre pack, ajoutez un fichier de configuration de pack nommé databricks.yml. Ajoutez le code suivant à ce fichier :

Poetry

Remarque

Si vous avez déjà créé un fichier wheel Python et que vous voulez simplement le déployer, modifiez le fichier de configuration de pack suivant en omettant le mappage artifacts. L’interface CLI Databricks va alors partir du principe que le fichier wheel Python est déjà généré, et va déployer automatiquement les fichiers qui sont spécifiés dans les entrées whl du tableau libraries.
```
bundle:
  name: my-wheel-bundle

artifacts:
  default:
    type: whl
    build: poetry build
    path: .

resources:
  jobs:
    wheel-job:
      name: wheel-job
      tasks:
        - task_key: wheel-task
          new_cluster:
            spark_version: 13.3.x-scala2.12
            node_type_id: Standard_DS3_v2
            data_security_mode: USER_ISOLATION
            num_workers: 1
          python_wheel_task:
            entry_point: main
            package_name: my_package
          libraries:
            - whl: ./dist/*.whl

targets:
  dev:
    workspace:
    host: <workspace-url>
```
Setuptools
```
bundle:
  name: my-wheel-bundle

resources:
  jobs:
    wheel-job:
      name: wheel-job
      tasks:
        - task_key: wheel-task
          new_cluster:
            spark_version: 13.3.x-scala2.12
            node_type_id: Standard_DS3_v2
            data_security_mode: USER_ISOLATION
            num_workers: 1
          python_wheel_task:
            entry_point: main
            package_name: my_package
          libraries:
            - whl: ./dist/*.whl

targets:
  dev:
    workspace:
    host: <workspace-url>
```
Remplacez <workspace-url> par votre URL par espace de travail, par exemple https://adb-1234567890123456.7.azuredatabricks.net.

Le mappage artifacts est nécessaire pour générer des fichiers wheel Python avec Poetry, et il est facultatif pour générer des fichiers wheel Python avec setuptools. Le mappage artifacts contient une ou plusieurs définitions d’artefacts avec les mappages suivants :
- Le mappage type doit être présent et défini sur whl pour spécifier qu’un fichier wheel Python doit être généré. Pour setuptools, whl est la valeur par défaut si aucune définition d’artefact n’est spécifiée.
- Le mappage path indique le chemin du fichier pyproject.toml pour Poetry ou du fichier setup.py pour setuptools. Ce chemin est relatif au fichier databricks.yml. Pour setuptools, ce chemin est . (le même répertoire que celui du fichier databricks.yml) par défaut.
- Le mappage build indique les commandes de build personnalisées à exécuter pour générer le fichier wheel Python. Pour setuptools, cette commande est python3 setup.py bdist wheel par défaut.
- Le mappage files se compose d’un ou plusieurs mappages source qui spécifient les fichiers supplémentaires à inclure dans la build du paquet wheel Python. Il n'y a pas de valeur par défaut.
Remarque

Si vous voulez installer le fichier wheel Python sur un cluster cible sur lequel Databricks Runtime 12.2 LTS ou version inférieure est installé, vous devez ajouter le mappage de niveau supérieur suivant au fichier databricks.yml :
```
# Applies to jobs with python_wheel_task and that use
# clusters with Databricks Runtime 13.0 or below installed.
experimental:
  python_wheel_wrapper: true
```
Ce mappage indique à l’interface CLI Databricks d’effectuer les opérations suivantes :
- Déploie une copie du fichier wheel Python en arrière-plan. Ce chemin de déploiement est généralement ${workspace.artifact_path}/.internal/<random-id>/<wheel-filename>.whl.
- Crée un notebook en arrière-plan qui contient des instructions pour installer le fichier wheel Python précédent déployé sur le cluster cible. Le chemin d’accès de ce notebook est généralement ${workspace.file_path}/.databricks/bundle/<target-name>/.internal/notebook_<job-name>_<task-key>.
- Quand vous exécutez un travail qui contient une tâche wheel Python et que cette tâche référence le fichier wheel Python précédent, un travail qui exécute le notebook précédent est créé en arrière-plan.
Vous n’avez pas besoin de spécifier ce mappage pour les clusters cibles avec Databricks Runtime 13.1 ou ultérieur installé, car les installations de fichier wheel Python depuis le système de fichiers de l’espace de travail Azure Databricks sont effectuées automatiquement sur ces clusters cibles.
Si vous utilisez Poetry, procédez comme suit :
- Installez Poetry version 1.6 ou ultérieure, si elle n’est pas déjà installée. Pour vérifier la version installée de Poetry, exécutez la commande poetry -V ou poetry --version.
- Vérifiez que la version 3.10 ou ultérieure de Python est installée. Pour vérifier votre version de Python, exécutez la commande python -V ou python --version.
- Vérifiez que vous disposez de la version 0.209.0 ou ultérieure de Databricks CLI. Pour vérifier votre version de Databricks CLI, exécutez la commande databricks -v ou databricks --version. Consultez Installer ou mettre à jour l’interface CLI Databricks.
Si vous utilisez setuptools, ils ne sont pas déjà installés, installez les packages wheel et setuptools en exécutant la commande suivante :
```
pip3 install --upgrade wheel setuptools
```
Si vous envisagez de stocker ce pack avec un fournisseur Git, ajoutez un fichier .gitignore à la racine du projet et ajoutez les entrées suivantes à ce fichier :

Poetry
```
.databricks
dist
```
Setuptools
```
.databricks
build
dist
src/my_package/my_package.egg-info
```

É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, validez le fichier de configuration du pack :
```
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 : Générer le fichier wheel Python et déployer le projet local sur l’espace de travail distant

Générez le fichier wheel Python localement, déployez le fichier wheel Python généré dans votre espace de travail, déployez le notebook dans votre espace de travail, et créez le travail dans votre espace de travail :

databricks bundle deploy -t dev

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

Exécutez le travail déployé, qui utilise le notebook déployé pour appeler le fichier wheel Python déployé :
```
databricks bundle run -t dev wheel-job
```
Dans la sortie, copiez le Run URL et collez-le dans la barre d’adresse de votre navigateur web.
Dans la page Sortie de l’exécution de la tâche, les résultats suivants s’affichent :
```
200 + 400 = 600
400 - 200 = 200
200 * 400 = 80000
400 / 200 = 2.0
```

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

Générer et installer un fichier wheel Python pour un travail

Pour générer un fichier wheel Python avec Poetry ou setuptools, puis utiliser ce fichier wheel Python dans un travail, vous devez ajouter un ou deux mappages à votre fichier databricks.yml.

Si vous utilisez Poetry, vous devez inclure le mappage artifacts suivant dans le fichier databricks.yml. Ce mappage exécute la commande poetry build et utilise le fichier pyproject.toml qui se trouve dans le même répertoire que le fichier databricks.yml :

artifacts:
  default:
    type: whl
    build: poetry build
    path: .

Remarque

Le mappage artifacts est facultatif pour setuptools. Par défaut, pour setuptools, Databricks CLI exécute la commande python3 setup.py bdist_wheel et utilise le fichier setup.py qui se trouve dans le même répertoire que le fichier databricks.yml. Databricks CLI suppose que vous avez déjà exécuté une commande telle que pip3 install --upgrade wheel setuptools pour installer les packages wheel et setuptools s’ils ne sont pas déjà installés.

En outre, le mappage de libraries de la tâche du travail doit contenir une valeur whl qui spécifie le chemin du fichier wheel Python créé, relativement au fichier config dans lequel il est déclaré. L’exemple suivant montre ceci dans une tâche de notebook (les points de suspension indiquent du contenu omis pour des raisons de concision) :

resources:
  jobs:
    my-notebook-job:
      name: my-notebook-job
      tasks:
        - task_key: my-notebook-job-notebook-task
          notebook_task:
            notebook_path: ./my_notebook.py
          libraries:
            - whl: ./dist/*.whl
          new_cluster:
            # ...

Générer et installer un fichier wheel Python pour un pipeline

Pour générer un fichier wheel Python avec Poetry ou setuptools, puis référencer ce fichier wheel Python dans un pipeline Delta Live Tables, vous devez ajouter un mappage à votre fichier databricks.yml si vous utilisez Poetry, et vous devez ajouter une commande %pip install au notebook de votre pipeline, comme suit.

artifacts:
  default:
    type: whl
    build: poetry build
    path: .

Remarque

En outre, le notebook de pipeline associé doit inclure une commande %pip install pour installer le fichier wheel Python généré. Consultez Bibliothèques Python.

Partager via

Développer un fichier wheel Python à l’aide de packs de ressources Databricks

Spécifications

Décision : Créer le bundle 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 bundle

Étape 4 : Mettre à jour le pack du projet pour utiliser Poetry

Étape 5 : Valider le fichier de configuration du pack du projet

Étape 6 : Générer le fichier wheel Python et déployer le projet local sur l’espace de travail distant

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

Créer l’offre groupée manuellement

Étape 1 : Configurer l’authentification

Étape 2 : Créer le pack

Poetry

Setuptools

Pyproject.toml

Setup.py

Étape 3 : Créer le fichier de configuration du pack

Poetry

Setuptools

Poetry

Setuptools

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

Étape 5 : Générer le fichier wheel Python et déployer le projet local sur l’espace de travail distant

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

Générer et installer un fichier wheel Python pour un travail

Générer et installer un fichier wheel Python pour un pipeline

Commentaires

Ressources supplémentaires