Creare un file ruota Python utilizzando i bundle di risorse di Databricks

Questo articolo descrive come creare, distribuire ed eseguire un file Wheel Python come parte di un progetto del pacchetto di asset di Databricks. Vedere Che cosa sono i bundle di asset di Databricks?.

Per un esempio di configurazione che compila un file JAR e lo carica in Unity Catalog, vedere Bundle che carica un file JAR in Unity Catalog.

Requisiti

• L'interfaccia della riga di comando di Databricks versione 0.218.0 o successiva è installata e l'autenticazione è configurata. Per controllare la versione installata dell'interfaccia della riga di comando di Databricks, eseguire il comando databricks -v. Per installare l'interfaccia della riga di comando di Databricks, vedere Installare o aggiornare l'interfaccia della riga di comando di Databricks. Per configurare l'autenticazione, vedere Configurare l'accesso all'area di lavoro.
• L'area di lavoro remota deve avere abilitati i file dell'area di lavoro. Vedere Che cosa sono i file dell'area di lavoro?.

Decisione: creare il bundle manualmente o usando un modello

Decidere se creare un bundle usando un modello o manualmente. La creazione del bundle con un modello è più veloce e più semplice in quanto vengono creati automaticamente i file necessari, ma il bundle potrebbe produrre contenuto non necessario e le impostazioni predefinite del bundle devono essere ulteriormente personalizzate per le applicazioni reali.

• Creare il bundle usando un modello
• Creare manualmente il bundle

Creare il bundle usando un modello

In questi passaggi viene creato il bundle usando il modello di bundle predefinito di Azure Databricks per Python. Questi passaggi illustrano come creare un bundle costituito da file da compilare in un file con rotellina Python e la definizione di un processo di Azure Databricks per compilare questo file con rotellina Python. È quindi possibile convalidare, distribuire e compilare i file distribuiti in un file wheel di Python dal job Python per il wheel all'interno dell'area di lavoro di Azure Databricks.

Il modello di bundle predefinito di Azure Databricks per Python usa setuptools per compilare il file wheel python. Se invece si vuole usare Poetry per compilare il file wheel python, seguire le istruzioni riportate più avanti in questa sezione per sostituire l'implementazione setuptools per un'implementazione Di Poesia.

Passaggio 1: Creare il bundle

Un bundle contiene gli artefatti da distribuire e le impostazioni per i flussi di lavoro da eseguire.

1. Usare il terminale o il prompt dei comandi per navigare verso una directory sulla propria macchina di sviluppo locale che conterrà il bundle generato dal template.

2. Usare la versione dell'interfaccia a riga di comando di Databricks per eseguire il comando bundle init:

   databricks bundle init
   

3. Per Template to use, lasciare il valore predefinito di default-python premendo Enter.

4. Per Unique name for this project, lasciare il valore predefinito di my_project o digitare un valore diverso e quindi premere Enter. Questo determina il nome della directory radice per questo bundle. Questa directory principale viene creata all’interno della directory di lavoro corrente.

5. Per Include a stub (sample) notebookselezionare no e premere Enter. Ciò indica al CLI di Databricks di non aggiungere un notebook di esempio nel pacchetto.

6. Per Include a stub (sample) Delta Live Tables pipelineselezionare no e premere Enter. Questo istruisce il CLI di Databricks a non definire una pipeline di esempio nel tuo bundle.

7. Per Include a stub (sample) Python package, lasciare il valore predefinito di yes premendo Enter. In questo modo si indica al CLI di Databricks di aggiungere file di pacchetto Python di esempio e istruzioni di compilazione correlate al bundle.

Passaggio 2: Esplorare il bundle

Per visualizzare i file generati dal modello, passare alla directory radice del bundle appena creato e aprire questa directory con l'IDE preferito, ad esempio Visual Studio Code. I file seguenti sono di particolare interesse:

• databricks.yml: questo file specifica il nome programmatico del bundle, include un riferimento alla definizione del processo wheel python e specifica le impostazioni relative all'area di lavoro di destinazione.
• resources/<project-name>_job.yml: questo file specifica le impostazioni del job della wheel di Python.
• src/<project-name>: Questa directory include i file usati dal processo del wheel di Python per compilare il file wheel di Python.

Nota

Se si vuole installare il file wheel di Python in un cluster di destinazione con Databricks Runtime 12.2 LTS o versione inferiore, è necessario aggiungere il seguente mapping di primo livello al file databricks.yml:

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

Questo mapping indica all'interfaccia della riga di comando di Databricks di eseguire le operazioni seguenti:

• Distribuire una copia del file Wheel Python in secondo piano. Questo percorso di distribuzione è di solito ${workspace.artifact_path}/.internal/<random-id>/<wheel-filename>.whl.
• Creare un notebook in secondo piano contenente le istruzioni per installare il file wheel Python precedentemente distribuito nel cluster di destinazione. Il percorso di questo notebook è in genere ${workspace.file_path}/.databricks/bundle/<target-name>/.internal/notebook_<job-name>_<task-key>.
• Quando si esegue un processo che contiene un'attività di tipo ruota Python e tale attività fa riferimento al file ruota Python precedente, viene creato un processo in background che esegue il notebook precedente.

Non è necessario specificare questo mapping per i cluster di destinazione con Databricks Runtime 13.1 o versione successiva installata, perché le installazioni di ruote Python dal file system dell'area di lavoro di Azure Databricks verranno installate automaticamente in questi cluster di destinazione.

Passaggio 3: Aggiornare il bundle del progetto per usare Poesia

Per impostazione predefinita, il modello del bundle specifica la compilazione del file Wheel di Python usando setuptools insieme ai file setup.py e requirements-dev.txt. Per mantenere queste impostazioni predefinite, passare al passaggio 4: Convalidare il file di configurazione del bundle del progetto.

Per aggiornare il bundle del progetto in modo da usare Poetry invece di setuptools, assicurarsi che il computer di sviluppo locale soddisfi i requisiti seguenti:

• Poetry versione 1.6 o successiva. Per controllare la versione installata di Poetry, eseguire il comando poetry -V o poetry --version. Per installare o aggiornare Poetry, vedi Installazione.
• Python versione 3.10 o successiva. Per controllare la versione di Python, eseguire il comando python -V o python --version.
• CLI di Databricks versione 0.209.0 o successiva. Per eseguire il comando sulla tua versione del Databricks CLI, usa databricks -v oppure databricks --version. Vedere Installare o aggiornare l'interfaccia della riga di comando di Databricks.

Apportare le modifiche seguenti al bundle del progetto:

1. Dalla directory radice del bundle, istruisci poetry ad avviare le build delle ruote Python per Poetry eseguendo il seguente comando:

   poetry init
   

2. Poetry mostra diversi prompt da completare. Per le compilazioni della rotellina Python, rispondere a queste richieste come indicato di seguito per corrispondere alle impostazioni predefinite correlate nel bundle del progetto:

   1. Per Package name, digitare il nome della cartella figlia in /src e quindi premere Enter. Deve trattarsi anche del valore del name pacchetto definito nel file del setup.py bundle.
   2. Per Version, digitare 0.0.1 e premere Enter. Corrisponde al numero di versione definito nel file del src/<project-name>/__init__.py bundle.
   3. Per Description, digitare wheel file based on <project-name>/src (sostituendo <project-name> con il nome del progetto) e premere Enter. Questo corrisponde al valore description che è definito nel file del modello setup.py
   4. Per Author, premere Enter. Questo valore predefinito corrisponde all'autore definito nel file del setup.py modello.
   5. Per License, premere Enter. Nel modello non è definita alcuna licenza.
   6. Per Compatible Python versionsimmettere la versione python corrispondente a quella nei cluster Azure Databricks di destinazione (ad esempio, ^3.10) e premere Enter.
   7. Per Would you like to define your main dependencies interactively? Tipo no e premere Enter. Le dipendenze verranno definite in un secondo momento.
   8. Per Would you like to define your development dependencies interactively? Tipo no e premere Enter. Le dipendenze verranno definite in un secondo momento.
   9. Per Do you confirm generation? Premere Enter.

3. Dopo aver completato le richieste, Poetry aggiunge un file pyproject.toml al progetto del pacchetto. Per informazioni sul pyproject.toml file, vedere Il file pyproject.toml.

4. Dalla directory radice del bundle, indicare a poetry di leggere il file pyproject.toml, risolvere le dipendenze e installarle, creare un file poetry.lock per bloccare le dipendenze e infine creare un ambiente virtuale. A tale scopo, usare il comando seguente:

   poetry install
   

5. Aggiungere la sezione seguente alla fine del pyproject.toml file, sostituendo <project-name> con il nome della directory che contiene il src/<project-name>/main.py file , ad esempio my_project:

   [tool.poetry.scripts]
   main = "<project-name>.main:main"
   

   La sezione specifica il punto di ingresso della rotellina Python per il processo con rotellina Python.

6. Aggiungere il mapping seguente al livello superiore del file del databricks.yml bundle:

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

   Questa mappatura istruisce l'interfaccia della riga di comando di Databricks a usare Poetry per creare un file Wheel Python.

7. Eliminare i setup.py file e requirements-dev.txt dal bundle, perché Poesia non ne ha bisogno.

Passaggio 4: Convalidare il file di configurazione del bundle del progetto

In questo passaggio si verifica se la configurazione del bundle è valida.

1. Dalla directory radice usare l'interfaccia della riga di comando di Databricks per eseguire il comando bundle validate, come indicato di seguito:

   databricks bundle validate
   

2. Se viene restituito un riepilogo della configurazione del bundle, la convalida ha avuto esito positivo. Se vengono restituiti errori, correggerli e ripetere questo passaggio.

Se si apportano modifiche al bundle dopo questo passaggio, è necessario ripetere questo passaggio per verificare se la configurazione del bundle è ancora valida.

Passaggio 5: Compilare il file wheel python e distribuire il progetto locale nell'area di lavoro remota

In questo passaggio si compila il file wheel python, si distribuisce il file wheel Python compilato nell'area di lavoro remota di Azure Databricks e si crea il processo di Azure Databricks all'interno dell'area di lavoro.

1. Se si usa setuptools, installare i wheel pacchetti e setuptools se non è già stato fatto, eseguendo il comando seguente:

   pip3 install --upgrade wheel setuptools
   

2. Nel terminale di Visual Studio Code usare l'interfaccia della riga di comando di Databricks per eseguire il bundle deploy comando come indicato di seguito:

   databricks bundle deploy -t dev
   

3. Se si vuole verificare se è stato distribuito il file wheel python creato in locale:

   1. Nella barra laterale dell'area di lavoro di Azure Databricks fare clic su Area di lavoro.
   2. Fare clic nella cartella seguente: Area di lavoro > Utenti ><your-username>> .bundle ><project-name>> dev > artifacts > .internal ><random-guid>.

   Il file wheel python deve trovarsi in questa cartella.

4. Per controllare se il lavoro è stato creato:

   1. Nella barra laterale dell'area di lavoro di Azure Databricks fare clic su Processi e pipeline.
   2. Opzionalmente, selezionare i filtri Attività e Di mia proprietà.
   3. Fare clic su [dev <your-username>] <project-name>_job.
   4. Fare clic sulla scheda Attività .

   Deve essere presente un'attività: main_task.

Se si apportano modifiche al bundle dopo questo passaggio, è necessario ripetere i passaggi da 5 a 6 per verificare se la configurazione del bundle è ancora valida e quindi ridistribuire il progetto.

Passaggio 6: eseguire il progetto distribuito

In questo passaggio, esegui il job di Azure Databricks nella tua area di lavoro.

1. Dalla directory radice, usa il CLI di Databricks per eseguire il comando bundle run, come indicato di seguito, sostituendo <project-name> con il nome del tuo progetto dal passaggio 2:

   databricks bundle run -t dev <project-name>_job
   

2. Copiare il valore di Run URL visualizzato nel terminale e incollare questo valore nel Web browser per aprire l'area di lavoro di Azure Databricks.

3. Nell'area di lavoro di Azure Databricks, dopo che l'attività è stata completata con successo e viene visualizzata una barra del titolo verde, fare clic sull'attività main_task per vedere i risultati.

Se si apportano modifiche al bundle dopo questo passaggio, è necessario ripetere i passaggi da 5 a 7 per verificare se la configurazione del bundle è ancora valida, ridistribuire il progetto ed eseguire il progetto ridistribuito.

È stata raggiunta la fine dei passaggi per la creazione di un bundle usando un modello.

Creare manualmente il bundle

In questi passaggi si crea il bundle da zero. Questi passaggi illustrano come creare un bundle costituito da file da compilare in un file con rotellina Python e la definizione di un processo di Databricks per compilare questo file con rotellina Python. È quindi possibile convalidare, distribuire e costruire i file distribuiti in un file wheel di Python dal processo Python wheel all'interno dell'area di lavoro di Databricks.

Questi passaggi includono l'aggiunta di contenuto a un file YAML. Facoltativamente, è possibile usare un ambiente di sviluppo integrato (IDE) che fornisce suggerimenti e azioni automatici dello schema quando si usano i file YAML. La procedura seguente usa Visual Studio Code con l'estensione YAML installata da Visual Studio Code Marketplace.

Questi passaggi presuppongono che l'utente sappia già:

• Come creare, costruire e lavorare con i file wheel di Python usando Poetry o setuptools. Per La poesia, vedi Utilizzo di base. Per setuptools, vedere la Guida per l'utente per la creazione di pacchetti Python.
• Come utilizzare i file wheel di Python all'interno di un processo di Azure Databricks. Vedi Usare un file wheel Python nei job di Lakeflow.

Segui queste istruzioni per creare un bundle di esempio che genera un file wheel di Python utilizzando Poetry o setuptools, distribuisce il file wheel di Python e quindi esegue il file wheel di Python distribuito.

Se si è già creato un file ruota Python e si desidera semplicemente distribuirlo ed eseguirlo, procedere direttamente alla specifica delle impostazioni della ruota Python nel file di configurazione del bundle nel Passaggio 2: Creare il file di configurazione del bundle.

Passaggio 1: Creazione del bundle

Un bundle contiene gli artefatti da distribuire e le impostazioni per i flussi di lavoro da eseguire.

1. Nella radice del pacchetto, crea le cartelle e i file seguenti, a seconda che si usi Poetry o setuptools per la creazione di file wheel di Python:

   Poesia

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

   Strumenti di installazione

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

2. Lasciare vuoto il __init__.py file.

3. Aggiungere il codice seguente al main.py file e quindi salvare il file:

   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()
   

4. Aggiungere il codice seguente al my_module.py file e quindi salvare il file:

   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
   

5. Aggiungere il codice seguente al pyproject.toml file o setup.py e quindi salvare il file:

   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"
   

   • Sostituire my-author-name con il nome del contatto principale dell'organizzazione.
   • Sostituire my-author-name>@<my-organization con l'indirizzo di contatto di posta elettronica principale dell'organizzazione.
   • Sostituire <my-package-description> con una descrizione di visualizzazione per il file 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"
     ]
   )
   

   • Sostituire https://<my-url> con l'URL dell'organizzazione.
   • Sostituire <my-author-name> con il nome del contatto principale dell'organizzazione.
   • Sostituire <my-author-name>@<my-organization> con l'indirizzo di contatto di posta elettronica principale dell'organizzazione.
   • Sostituire <my-package-description> con una descrizione di visualizzazione per il file wheel python.

Passaggio 2: Creare il file di configurazione del bundle

Un file di configurazione bundle descrive gli artefatti da distribuire e i flussi di lavoro da eseguire.

1. Nella radice del bundle aggiungere un file di configurazione del bundle denominato databricks.yml. Aggiungere il codice seguente al file:

   Poesia

   Nota

   Se hai già creato un file wheel Python e desideri semplicemente distribuirlo, modifica il file di configurazione del bundle seguente omettendo il artifacts mapping. L'interfaccia della riga di comando di Databricks si assicurerà quindi che il file wheel di Python sia già compilato e distribuirà automaticamente i file specificati nelle libraries voci dell'array whl.

   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>
   

   Strumenti di installazione

   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>
   

   Sostituire <workspace-url> con l'URL per area di lavoro, ad esempio https://adb-1234567890123456.7.azuredatabricks.net.

   Il artifacts mapping è necessario per creare file wheel Python con Poetry ed è facoltativo per creare file wheel Python con setuptools. Il artifacts mapping contiene una o più definizioni di artefatto con i mapping seguenti:

   • Il type mapping deve essere presente e impostato su whl per specificare che un file wheel Python deve essere compilato. Per setuptools, whl è l'impostazione predefinita se non vengono specificate definizioni di artefatti.
   • Il path mapping indica il percorso al file pyproject.toml per Poetry o al file setup.py per setuptools. Questo percorso è relativo al databricks.yml file. Per setuptools, questo percorso è . (la stessa directory del databricks.yml file) per impostazione predefinita.
   • Il build mapping indica i comandi di compilazione personalizzati da eseguire per compilare il file wheel python. Per setuptools, questo comando è python3 setup.py bdist wheel per impostazione predefinita.
   • Il files mapping è costituito da uno o più source mapping che specificano eventuali file aggiuntivi da includere nella compilazione della rotellina Python. Non c'è nessun predefinito.

   Nota

   Se si vuole installare il file wheel di Python in un cluster di destinazione con Databricks Runtime 12.2 LTS o versione inferiore, è necessario aggiungere il seguente mapping di primo livello al file 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
   

   Questo mapping indica all'interfaccia della riga di comando di Databricks di eseguire le operazioni seguenti:

   • Distribuisce una copia del file wheel Python in background. Questo percorso di distribuzione è di solito ${workspace.artifact_path}/.internal/<random-id>/<wheel-filename>.whl.

   • Crea un notebook in secondo piano che contiene istruzioni per installare il file wheel Python precedentemente distribuito nel cluster di destinazione. Il percorso di questo notebook è in genere ${workspace.file_path}/.databricks/bundle/<target-name>/.internal/notebook_<job-name>_<task-key>.

   • Quando si esegue un processo che contiene un'attività con rotellina Python e tale attività fa riferimento al file della rotellina Python precedente, viene creato un processo in background che esegue il notebook precedente.

   Non è necessario specificare questo mapping per i cluster di destinazione con Databricks Runtime 13.1 o versione successiva installata, perché le installazioni di ruote Python dal file system dell'area di lavoro di Azure Databricks verranno installate automaticamente in questi cluster di destinazione.

2. Se si usa Poesia, eseguire le operazioni seguenti:

   • Installare Poetry, versione 1.6 o successiva, se non è già installato. Per controllare la versione installata di Poetry, eseguire il comando poetry -V o poetry --version.
   • Assicurarsi di avere installato Python versione 3.10 o successiva. Per controllare la versione di Python, eseguire il comando python -V o python --version.
   • Assicurarsi di avere la CLI di Databricks versione 0.209.0 o successiva. Per eseguire il comando sulla tua versione del Databricks CLI, usa databricks -v oppure databricks --version. Vedere Installare o aggiornare l'interfaccia della riga di comando di Databricks.

3. Se si usa setuptools, installare i wheel pacchetti e setuptools se non sono già installati, eseguendo il comando seguente:

   pip3 install --upgrade wheel setuptools
   

4. Se si intende archiviare questo bundle con un provider Git, aggiungere un .gitignore file nella radice del progetto e aggiungere le voci seguenti a questo file:

   Poesia

   .databricks
   dist
   

   Strumenti di installazione

   .databricks
   build
   dist
   src/my_package/my_package.egg-info
   

Passaggio 3: Convalidare il file di configurazione del bundle del progetto

In questo passaggio si verifica se la configurazione del bundle è valida.

1. Dalla directory radice convalidare il file di configurazione del bundle:

   databricks bundle validate
   

2. Se viene restituito un riepilogo della configurazione del bundle, la convalida ha avuto esito positivo. Se vengono restituiti errori, correggerli e ripetere questo passaggio.

Se si apportano modifiche al bundle dopo questo passaggio, è necessario ripetere questo passaggio per verificare se la configurazione del bundle è ancora valida.

Passaggio 4: Compilare il file wheel python e distribuire il progetto locale nell'area di lavoro remota

Compilare il file wheel di Python in locale, distribuire il file wheel di Python compilato nell'area di lavoro, distribuire il notebook nell'area di lavoro e creare il processo nell'area di lavoro.

databricks bundle deploy -t dev

Passaggio 5: Eseguire il progetto distribuito

1. Esegui il processo distribuito, che utilizza il notebook distribuito per chiamare il file wheel Python distribuito.

   databricks bundle run -t dev wheel-job
   

2. Nell'output copiare Run URL e incollarlo nella barra degli indirizzi del Web browser.

3. Nella pagina Output dell'esecuzione del processo vengono visualizzati i risultati seguenti:

   200 + 400 = 600
   400 - 200 = 200
   200 * 400 = 80000
   400 / 200 = 2.0
   

Se si apportano modifiche al bundle dopo questo passaggio, è necessario ripetere i passaggi da 3 a 5 per verificare se la configurazione del bundle è ancora valida, ridistribuire il progetto ed eseguire il progetto ridistribuito.

Compilare e installare un file wheel di Python per un'attività

Per creare un file wheel Python con Poetry o setuptools e quindi usare il file wheel Python in un'attività, è necessario aggiungere uno o due mapping al file databricks.yml.

Se usi Poetry, devi includere il seguente mapping artifacts nel file databricks.yml. Questo mapping esegue il poetry build comando e usa il pyproject.toml file che si trova nella stessa directory del databricks.yml file:

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

Nota

Il artifacts mapping è facoltativo per setuptools. Per impostazione predefinita, per setuptools l'interfaccia della riga di comando di Databricks esegue il comando python3 setup.py bdist_wheel e usa il setup.py file che si trova nella stessa directory del databricks.yml file. L'interfaccia della riga di comando di Databricks presuppone che sia già stato eseguito un comando, ad esempio pip3 install --upgrade wheel setuptools, per installare i pacchetti wheel e setuptools se non sono già installati.

Inoltre, il mapping dell'attività di libraries processo deve contenere un whl valore che specifica il percorso del file wheel Python costruito rispetto al file di configurazione in cui viene dichiarato. Nell'esempio seguente viene illustrato in un'attività del notebook (i puntini di sospensione indicano che il contenuto viene omesso per brevità):

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:
            # ...

Compilare e installare un file di tipo wheel di Python per una pipeline

Per creare un file wheel di Python con Poetry o setuptools e quindi fare riferimento a quel file wheel di Python nelle Lakeflow Declarative Pipelines, è necessario aggiungere un mapping al file databricks.yml se si usa Poetry e aggiungere un comando %pip install al notebook della pipeline, come indicato di seguito.

Se usi Poetry, devi includere il seguente mapping artifacts nel file databricks.yml. Questo mapping esegue il poetry build comando e usa il pyproject.toml file che si trova nella stessa directory del databricks.yml file:

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

Nota

Il artifacts mapping è facoltativo per setuptools. Per impostazione predefinita, per setuptools l'interfaccia della riga di comando di Databricks esegue il comando python3 setup.py bdist_wheel e usa il setup.py file che si trova nella stessa directory del databricks.yml file. L'interfaccia della riga di comando di Databricks presuppone che sia già stato eseguito un comando, ad esempio pip3 install --upgrade wheel setuptools, per installare i pacchetti wheel e setuptools se non sono già installati.

Inoltre, il notebook della pipeline correlato deve includere il comando %pip install per installare il file wheel Python compilato. Vedere Librerie Python.