Créer un fichier de roue Python à l’aide de Bundles de ressources Databricks

2025-06-18

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 ?.

Pour obtenir un exemple de configuration qui génère un fichier JAR et le charge dans le catalogue Unity, consultez Bundle qui charge un fichier JAR dans le catalogue Unity.

Spécifications

Databricks CLI version 0.218.0 ou ultérieure est installée et l’authentification est configurée. 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. Pour configurer l’authentification, consultez Configurer l’accès à votre espace de travail.
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 utiliser un modèle

Déterminez si vous souhaitez créer un bundle à l’aide d’un modèle ou manuellement. La création du bundle à l’aide d’un modèle est plus rapide et plus facile à mesure que les fichiers requis sont créés pour vous, mais le bundle peut produire du contenu qui n’est pas nécessaire, et les paramètres par défaut du bundle doivent être plus personnalisés pour les applications réelles.

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

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 bundle 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, puis 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) Delta Live Tables pipeline, sélectionnez no, puis appuyez sur Enter. Cela indique à l’interface CLI Databricks de ne pas définir d’exemple de pipeline dans votre bundle.
Pour Include a stub (sample) Python package, conservez la valeur par défaut yes en 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 2 : 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 bloc-notes 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 3 : Mettre à jour l’offre groupée du projet pour utiliser la poésie

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 souhaitez conserver ces valeurs par défaut, passez à l’étape 4 : Validez le fichier de configuration de bundle du projet.

Pour mettre à jour le bundle du projet afin d’utiliser Poetry au lieu de setuptools, assurez-vous que votre ordinateur de développement local 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 de ligne de commande (CLI) Databricks.

Apportez les modifications suivantes à l’offre groupée du projet :

À partir du répertoire racine du paquet, demandez à poetry d'initialiser les constructions de roues Python pour Poetry en exécutant la commande suivante :
```
poetry init
```
Poetry affiche plusieurs invites pour vous permettre de terminer. Pour les builds de roue Python, répondez à ces invites comme suit pour faire correspondre les paramètres par défaut associés dans le bundle 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 du name package définie dans le fichier du setup.py bundle.
2. Pour Version, tapez 0.0.1 et appuyez sur Enter. Cela correspond au numéro de version défini dans le fichier du src/<project-name>/__init__.py bundle.
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. Cela correspond à la description valeur définie dans le fichier du setup.py modèle.
4. Pour Author, appuyez sur Enter. Cette valeur par défaut correspond à l’auteur défini dans le fichier du setup.py 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 les invites terminées, Poetry ajoute un fichier pyproject.toml au projet du paquet. Pour plus d’informations sur le fichier pyproject.toml, consultez le fichier pyproject.toml.
À partir du répertoire racine de l’offre groupée, demandez poetry de lire le pyproject.toml fichier, de résoudre les dépendances et de les installer, de créer un poetry.lock fichier pour verrouiller les 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 de la roue Python pour le travail de roue Python.
Ajoutez le mappage suivant au niveau supérieur du fichier du databricks.yml bundle :
```
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 4 : Valider le fichier de configuration groupé 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 : 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 Travaux & Pipelines.
2. Si vous le souhaitez, sélectionnez les travaux et les filtres appartenant à moi .
3. Cliquez sur [dev <your-username>] <project-name>_job.
4. 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 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 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 le pack manuellement

Dans ces étapes, vous créez le bundle à 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 de roue Python dans Les travaux Lakeflow.

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 de roue Python et que vous souhaitez simplement le déployer et l’exécuter, passez à l’avance pour spécifier les paramètres de roue Python dans le fichier de configuration de bundle à l’étape 2 : Créez le fichier de configuration du bundle.

É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.

Dans la racine de votre bundle, créez les dossiers et fichiers suivants, selon que vous utilisez La poésie ou setuptools pour créer des fichiers de roue Python :

Poésie

├── 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 le nom de contact principal de votre organisation.
Remplacez my-author-name>@<my-organization par l’adresse de contact de messagerie 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 par https://<my-url> l’URL de votre organization.
Remplacez <my-author-name> le nom de contact principal de votre organisation.
Remplacez <my-author-name>@<my-organization> par l’adresse de contact de messagerie principale de votre organisation.
Remplacez <my-package-description> par une description de votre fichier wheel Python.

Étape 2 : Créer le fichier de configuration du bundle

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 bundle, ajoutez un fichier de configuration groupé nommé databricks.yml. Ajoutez le code suivant à ce fichier :

Poésie

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 suppose ensuite que le fichier de roue Python est déjà généré et déploie automatiquement les fichiers spécifiés dans les libraries entrées du whl tableau.
```
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 de roue 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 bloc-notes 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 de ligne de commande (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 bundle avec un fournisseur Git, ajoutez un .gitignore fichier à la racine du projet et ajoutez les entrées suivantes à ce fichier :

Poésie
```
.databricks
dist
```
Setuptools
```
.databricks
build
dist
src/my_package/my_package.egg-info
```

Étape 3 : Valider le fichier de configuration groupé 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 4 : Générer le fichier de roue 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 5 : 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 Run URL et collez-le dans la barre d’adresse de votre navigateur web.
Dans la page Sortie de l'exécution, 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 la tâche de libraries travail doit contenir une whl valeur qui spécifie le chemin d’accès au fichier de roue Python généré par rapport au fichier de configuration 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 créer un fichier wheel Python avec Poetry ou setuptools et ensuite référencer ce fichier wheel Python dans les pipelines déclaratifs Lakeflow, vous devez ajouter un mappage à votre fichier databricks.yml si vous utilisez Poetry, et vous devez ajouter une commande %pip install à votre bloc-notes de 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

Créer un fichier de roue Python à l’aide de Bundles de ressources Databricks

Spécifications

Décision : Créer le bundle manuellement ou utiliser un modèle

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

Étape 1 : Créer le bundle

Étape 2 : Explorer le bundle

Étape 3 : Mettre à jour l’offre groupée du projet pour utiliser la poésie

Étape 4 : Valider le fichier de configuration groupé 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é

Créer le pack manuellement

Étape 1 : créer le pack

Poésie

Setuptools

Pyproject.toml

Setup.py

Étape 2 : Créer le fichier de configuration du bundle

Poésie

Setuptools

Poésie

Setuptools

Étape 3 : Valider le fichier de configuration groupé du projet

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

Étape 5 : 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