Integrazione e distribuzione continue in Azure Databricks con Azure DevOps

Articolo
02/05/2025

Nota

Questo articolo illustra Azure DevOps, sviluppato da terze parti. Per contattare il provider, consultare Supporto di Azure DevOps Services.

Questo articolo illustra come configurare l'automazione di Azure DevOps per il codice e gli artefatti che funzionano con Azure Databricks. In particolare, si configurerà un flusso di lavoro di integrazione e distribuzione continue (CI/CD) per connettersi a un repository Git, eseguire processi usando Azure Pipelines per compilare e sottoporre a unit test un file wheel di Python (*.whl) e distribuirlo per l'uso nei notebook di Databricks.

Flusso di lavoro di sviluppo CI/CD

Databricks suggerisce il flusso di lavoro seguente per lo sviluppo CI/CD con Azure DevOps:

Creare un repository o usare un repository esistente con il provider Git di terze parti.
Connettere il computer di sviluppo locale allo stesso repository di terze parti. Per istruzioni, consultare la documentazione del provider Git di terze parti.
Eseguire il pull di tutti gli artefatti aggiornati esistenti (ad esempio notebook, file di codice e script di compilazione) nel computer di sviluppo locale dal repository di terze parti.
Se necessario, creare, aggiornare e testare gli artefatti nel computer di sviluppo locale. Eseguire quindi il push di tutti gli artefatti nuovi e modificati dal computer di sviluppo locale nel repository di terze parti. Per istruzioni, consultare la documentazione del provider Git di terze parti.
Ripetere i passaggi 3 e 4 come necessario.
Usare periodicamente Azure DevOps come approccio integrato per eseguire automaticamente il pull degli artefatti dal repository di terze parti, la compilazione, il test e l'esecuzione di codice nell'area di lavoro di Azure Databricks e la creazione di report sui risultati del test e dell'esecuzione. Anche se è possibile eseguire Azure DevOps manualmente, nelle implementazioni reali, è consigliabile indicare al provider Git di terze parti di eseguire Azure DevOps ogni volta che si verifica un evento specifico, ad esempio una richiesta pull del repository.

Sono disponibili numerosi strumenti CI/CD da usare per gestire ed eseguire le pipeline. Questo articolo illustra come usare Azure DevOps. CI/CD è un modello di progettazione, quindi i passaggi e le fasi descritti in questo articolo devono essere trasferiti con alcune modifiche al linguaggio di definizione della pipeline in ogni strumento. Inoltre, gran parte del codice in questa pipeline di esempio esegue codice Python standard, che è possibile richiamare in altri strumenti.

Suggerimento

Per informazioni sull'uso di Jenkins con Azure Databricks invece di Azure DevOps, consultare CI/CD con Jenkins in Azure Databricks.

Il resto di questo articolo descrive una coppia di pipeline di esempio in Azure DevOps che è possibile adattare alle proprie esigenze per Azure Databricks.

Informazioni sull'esempio

L’esempio in questo articolo usa due pipeline per raccogliere, distribuire ed eseguire il codice Python di esempio e i notebook Python archiviati in un repository Git remoto.

La prima pipeline, nota come pipeline di compilazione, prepara gli artefatti di compilazione per la seconda pipeline, nota come pipeline di versione. La separazione della pipeline di compilazione dalla pipeline di versione consente di creare un artefatto della compilazione senza distribuirlo o distribuirlo contemporaneamente da più compilazioni. Per costruire le pipeline di compilazione e versione:

Creare una macchina virtuale di Azure per la pipeline di compilazione.
Copiare i file dal repository Git alla macchina virtuale.
Creare un file tar in formato gzip che contiene il codice Python, i notebook Python e i file di impostazioni di compilazione, distribuzione ed esecuzione correlati.
Copiare il file tar in formato gzip come file zip in un percorso a cui accedere la pipeline di versione.
Creare un ambiente di Azure Pipelines per le macchine virtuali di Azure.
Ottenere il file zip dal percorso della pipeline di compilazione e quindi annullare il pacchetto del file zip per ottenere il codice Python, i notebook Python e i file di impostazioni di compilazione, distribuzione ed esecuzione correlati.
Distribuire il codice e i notebook Python e i file di impostazioni di compilazione, distribuzione ed esecuzione correlati nell'area di lavoro remota di Azure Databricks.
Compilare i file di codice del componente della libreria wheel Python in un file wheel Python.
Eseguire unit test sul codice del componente per controllare la logica nel file wheel Python.
Eseguire i notebook Python, uno dei quali chiama la funzionalità del file wheel di Python.

Informazioni sull'interfaccia della riga di comando di Databricks

Questo esempio di articolo illustra come usare la CLI di Databricks in una modalità non interattiva all'interno di una pipeline. La pipeline di esempio di questo articolo distribuisce il codice, compila una libreria ed esegue i notebook nell'area di lavoro di Azure Databricks.

Se si usa l'interfaccia della riga di comando di Databricks nella pipeline senza implementare il codice di esempio, la libreria e i notebook di questo articolo, seguire questi passaggi:

Preparare l'area di lavoro di Azure Databricks per usare l'autenticazione da computer a computer (M2M) OAuth per l'autenticazione di un'entità servizio. Prima di iniziare, verificare di avere un'entità servizio Microsoft Entra ID con un segreto OAuth di Azure Databricks. Consulta Autorizzare l'accesso non sorvegliato alle risorse di Azure Databricks con un principale del servizio usando OAuth.
Installare l'interfaccia della riga di comando di Databricks nella pipeline. A tale scopo, aggiungere un'attività Script Bash alla pipeline che esegue lo script seguente:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
```
Per aggiungere un'attività Script Bash alla pipeline, consultare Passaggio 3.6. Installare l’interfaccia della linea di comando di Databricks e gli strumenti di compilazione del wheel di Python.
Configurare la pipeline per abilitare l'interfaccia della riga di comando di Databricks installata per autenticare l'entità servizio con l'area di lavoro. A tale scopo, consultare Passaggio 3.1: Definire le variabili di ambiente per la pipeline di versione.
Aggiungere altre attività Script Bash alla pipeline in base alle esigenze per eseguire i comandi della CLI di Databricks. Consultare Comandi della CLI di Databricks.

Operazioni preliminari

Per usare l'esempio di questo articolo, è necessario disporre di:

Un progetto Azure DevOps esistente. Se non si ha ancora un progetto, creare un progetto in Azure DevOps.
Un repository esistente con un provider Git supportato da Azure DevOps. Si aggiungerà il codice di esempio Python, il notebook Python di esempio e i file delle impostazioni di versione correlati a questo repository. Se non si ha ancora un repository, crearne uno seguendo le istruzioni del provider Git. Connettere quindi il progetto Azure DevOps a questo repository, se non è già stato fatto. Per istruzioni, seguire i collegamenti in Repository di origine supportati.
Questo esempio usa l'autenticazione da computer a computer (M2M) OAuth per autenticare un'entità servizio Microsoft Entra ID in un'area di lavoro di Azure Databricks. È necessario disporre di un'entità servizio Microsoft Entra ID con un segreto OAuth di Azure Databricks per tale entità servizio. Consulta Autorizzare l'accesso non presidiato alle risorse di Azure Databricks con un'entità servizio usando OAuth.

Passaggio 1: Aggiungere i file dell'esempio al repository

In questo passaggio, nel repository con il provider Git di terze parti, si aggiungono tutti i file di esempio di questo articolo compilati, distribuiti ed eseguiti nelle pipeline di Azure DevOps nell'area di lavoro di Azure Databricks remota.

Passaggio 1.1: Aggiungere i file dei componenti wheel Python

Nell'esempio di questo articolo, le pipeline di Azure DevOps compilano ed eseguono unit test su un file wheel Python. Un notebook di Azure Databricks chiama quindi la funzionalità del file wheel Python compilato.

Per definire la logica e gli unit test per il file wheel Python in cui vengono eseguiti i notebook, nella radice del repository creare due file denominati addcol.py e test_addcol.py e aggiungerli a una struttura di cartelle denominata python/dabdemo/dabdemo in una cartella Libraries, visualizzata come segue:

└── Libraries
      └── python
            └── dabdemo
                  └── dabdemo
                        ├── addcol.py
                        └── test_addcol.py

Il file addcol.py contiene una funzione di libreria integrata in un file con il wheel di Python e quindi installata nei cluster di Azure Databricks. Si tratta di una funzione semplice che aggiunge una nuova colonna, popolata da un valore letterale, a un dataframe Apache Spark:

# Filename: addcol.py
import pyspark.sql.functions as F

def with_status(df):
  return df.withColumn("status", F.lit("checked"))

Il file test_addcol.py contiene test per passare un oggetto DataFrame fittizio alla funzione with_status, definito in addcol.py. Il risultato viene quindi confrontato con un oggetto DataFrame contenente i valori previsti. Se i valori corrispondono, si supera il test:

# Filename: test_addcol.py
import pytest
from pyspark.sql import SparkSession
from dabdemo.addcol import *

class TestAppendCol(object):

  def test_with_status(self):
    spark = SparkSession.builder.getOrCreate()

    source_data = [
      ("paula", "white", "paula.white@example.com"),
      ("john", "baer", "john.baer@example.com")
    ]

    source_df = spark.createDataFrame(
      source_data,
      ["first_name", "last_name", "email"]
    )

    actual_df = with_status(source_df)

    expected_data = [
      ("paula", "white", "paula.white@example.com", "checked"),
      ("john", "baer", "john.baer@example.com", "checked")
    ]
    expected_df = spark.createDataFrame(
      expected_data,
      ["first_name", "last_name", "email", "status"]
    )

    assert(expected_df.collect() == actual_df.collect())

Per consentire all'interfaccia della riga di comando di Databricks di creare correttamente il pacchetto di questo codice di libreria in un file wheel Python, creare due file denominati __init__.py e __main__.py nella stessa cartella dei due file precedenti. Creare anche un file denominato setup.py nella cartella python/dabdemo, visualizzato come segue:

└── Libraries
      └── python
            └── dabdemo
                  ├── dabdemo
                  │     ├── __init__.py
                  │     ├── __main__.py
                  │     ├── addcol.py
                  │     └── test_addcol.py
                  └── setup.py

Il file __init__.py contiene il numero di versione e l'autore della libreria. Sostituire <my-author-name> con il proprio nome:

# Filename: __init__.py
__version__ = '0.0.1'
__author__ = '<my-author-name>'

import sys, os

sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))

Il file __main__.py contiene il punto di ingresso della libreria:

# Filename: __main__.py
import sys, os

sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))

from addcol import *

def main():
  pass

if __name__ == "__main__":
  main()

Il file setup.py contiene impostazioni aggiuntive per la compilazione della libreria in un file wheel di Python. Sostituire <my-url>, <my-author-name>@<my-organization>, e <my-package-description> con valori validi:

# Filename: setup.py
from setuptools import setup, find_packages

import dabdemo

setup(
  name = "dabdemo",
  version = dabdemo.__version__,
  author = dabdemo.__author__,
  url = "https://<my-url>",
  author_email = "<my-author-name>@<my-organization>",
  description = "<my-package-description>",
  packages = find_packages(include = ["dabdemo"]),
  entry_points={"group_1": "run=dabdemo.__main__:main"},
  install_requires = ["setuptools"]
)

Passaggio 1.2: Aggiungere un notebook di unit test per il file wheel Python

Più avanti, l'interfaccia della riga di comando di Databricks esegue un processo notebook. Questo processo esegue un notebook Python con il nome del file run_unit_tests.py. Questo notebook esegue pytest sulla logica della libreria wheel di Python.

Per eseguire gli unit test per l'esempio di questo articolo, aggiungere alla radice del repository un file notebook denominato run_unit_tests.py con il contenuto seguente:

# Databricks notebook source

# COMMAND ----------

# MAGIC %sh
# MAGIC
# MAGIC mkdir -p "/Workspace${WORKSPACEBUNDLEPATH}/Validation/reports/junit/test-reports"

# COMMAND ----------

# Prepare to run pytest.
import sys, pytest, os

# Skip writing pyc files on a readonly filesystem.
sys.dont_write_bytecode = True

# Run pytest.
retcode = pytest.main(["--junit-xml", f"/Workspace{os.getenv('WORKSPACEBUNDLEPATH')}/Validation/reports/junit/test-reports/TEST-libout.xml",
                      f"/Workspace{os.getenv('WORKSPACEBUNDLEPATH')}/files/Libraries/python/dabdemo/dabdemo/"])

# Fail the cell execution if there are any test failures.
assert retcode == 0, "The pytest invocation failed. See the log for details."

Passaggio 1.3: Aggiungere un notebook che chiama il file wheel di Python

Più avanti, l'interfaccia della riga di comando di Databricks esegue un altro processo notebook. Questo notebook crea un oggetto DataFrame, lo passa alla funzione with_status della libreria wheel Python, stampa il risultato e segnala i risultati dell'esecuzione del processo. Creare la radice del repository un file notebook denominato dabdemo_notebook.py con il contenuto seguente:

# Databricks notebook source

# COMMAND ----------

# Restart Python after installing the Python wheel.
dbutils.library.restartPython()

# COMMAND ----------

from dabdemo.addcol import with_status

df = (spark.createDataFrame(
  schema = ["first_name", "last_name", "email"],
  data = [
    ("paula", "white", "paula.white@example.com"),
    ("john", "baer", "john.baer@example.com")
  ]
))

new_df = with_status(df)

display(new_df)

# Expected output:
#
# +------------+-----------+-------------------------+---------+
# │ first_name │ last_name │ email                   │ status  │
# +============+===========+=========================+=========+
# │ paula      │ white     │ paula.white@example.com │ checked │
# +------------+-----------+-------------------------+---------+
# │ john       │ baer      │ john.baer@example.com   │ checked │
# +------------+-----------+-------------------------+---------+

Passaggio 1.4: Creare la configurazione del bundle

Questo esempio di articolo usa i Bundle di asset di Databricks per definire le impostazioni e i comportamenti per la compilazione, la distribuzione e l'esecuzione del file wheel Python, i due notebook e il file di codice Python. I Databricks Asset Bundle, noti semplicemente come bundle, consentono di esprimere i progetti di machine learning, analisi e dati completi come raccolta di file di origine. Vedere Che cosa sono i Bundle di asset di Databricks?.

Per configurare il bundle per l'esempio di questo articolo, creare nella radice del repository un file denominato databricks.yml. In questo file di esempio databricks.yml, sostituire i segnaposto seguenti:

Sostituire <bundle-name> con un nome programmatico univoco per il bundle. Ad esempio: azure-devops-demo.
Sostituire <job-prefix-name> con una stringa per identificare in modo univoco i processi creati nell'area di lavoro di Azure Databricks per questo esempio. Ad esempio: azure-devops-demo.
Sostituire <spark-version-id> con l'ID della versione del Databricks Runtime per i tuoi cluster di lavoro, ad esempio 13.3.x-scala2.12.
Sostituire <cluster-node-type-id> con l'ID del tipo di nodo del cluster per i cluster di processo, ad esempio Standard_DS3_v2.
Si noti che dev nel mapping targets specifica l'host e i comportamenti di distribuzione correlati. Nelle implementazioni reali, è possibile assegnare a questa destinazione un nome diverso nei bundle personalizzati.

Di seguito è riportato il sommario di questo file di databricks.yml esempio:

# Filename: databricks.yml
bundle:
  name: <bundle-name>

variables:
  job_prefix:
    description: A unifying prefix for this bundle's job and task names.
    default: <job-prefix-name>
  spark_version:
    description: The cluster's Spark version ID.
    default: <spark-version-id>
  node_type_id:
    description: The cluster's node type ID.
    default: <cluster-node-type-id>

artifacts:
  dabdemo-wheel:
    type: whl
    path: ./Libraries/python/dabdemo

resources:
  jobs:
    run-unit-tests:
      name: ${var.job_prefix}-run-unit-tests
      tasks:
        - task_key: ${var.job_prefix}-run-unit-tests-task
          new_cluster:
            spark_version: ${var.spark_version}
            node_type_id: ${var.node_type_id}
            num_workers: 1
            spark_env_vars:
              WORKSPACEBUNDLEPATH: ${workspace.root_path}
          notebook_task:
            notebook_path: ./run_unit_tests.py
            source: WORKSPACE
          libraries:
            - pypi:
                package: pytest
    run-dabdemo-notebook:
      name: ${var.job_prefix}-run-dabdemo-notebook
      tasks:
        - task_key: ${var.job_prefix}-run-dabdemo-notebook-task
          new_cluster:
            spark_version: ${var.spark_version}
            node_type_id: ${var.node_type_id}
            num_workers: 1
            spark_env_vars:
              WORKSPACEBUNDLEPATH: ${workspace.root_path}
          notebook_task:
            notebook_path: ./dabdemo_notebook.py
            source: WORKSPACE
          libraries:
            - whl: "/Workspace${workspace.root_path}/files/Libraries/python/dabdemo/dist/dabdemo-0.0.1-py3-none-any.whl"

targets:
  dev:
    mode: development

Per altre informazioni sulla databricks.yml sintassi del file, consultare Configurazione del bundle di asset di Databricks.

Passaggio 2: definire la pipeline di compilazione

Azure DevOps offre un'interfaccia utente ospitata nel cloud per definire le fasi della pipeline CI/CD usando YAML. Per altre informazioni su Azure DevOps, consultare la documentazione di Azure DevOps.

In questo passaggio si usa il markup YAML per definire la pipeline di compilazione, che compila un artefatto di distribuzione. Per distribuire il codice in un'area di lavoro di Azure Databricks, specificare l'artefatto della compilazione di questa pipeline come input in una pipeline di versione. Questa pipeline di versione verrà definita in un secondo momento.

Per eseguire pipeline di compilazione, Azure DevOps offre agenti di esecuzione su richiesta ospitati nel cloud che supportano le distribuzioni in Kubernetes, macchine virtuali, Funzioni di Azure, Azure App Web e molte altre destinazioni. In questo esempio si usa un agente su richiesta per automatizzare la compilazione dell'artefatto di distribuzione.

Definire la pipeline di compilazione di esempio di questo articolo come segue:

Accedere ad Azure DevOps e quindi fare clic sul collegamento Accedi per aprire il progetto Azure DevOps.

Nota

Se il portale di Azure viene visualizzato invece del progetto Azure DevOps, fare clic su Altri servizi > Organizzazioni Azure DevOps > Azure DevOps personale e quindi aprire il progetto Azure DevOps.
Fare clic su Pipeline nella barra laterale e quindi su Pipeline dal menu Pipeline.
Fare clic sul pulsante Nuova pipeline e seguire le istruzioni visualizzate. (Se sono già presenti pipeline, allora fare clic su Creare pipeline.) Al termine di queste istruzioni, viene aperto l'editor della pipeline. Qui si definisce lo script della pipeline di compilazione nel file azure-pipelines.yml visualizzato. Se l'editor della pipeline non è visibile alla fine delle istruzioni, selezionare il nome della pipeline di compilazione e quindi fare clic su Modifica.

È possibile usare il selettore del ramo Git per personalizzare il processo di compilazione per ogni ramo nel repository Git. È consigliabile non eseguire operazioni di produzione direttamente nel ramo del repository main. In questo esempio si presuppone che nel repository sia presente un ramo denominato release anziché main.

Lo script azure-pipelines.yml della pipeline di compilazione viene archiviato per impostazione predefinita nella radice del repository Git remoto associato alla pipeline.

Sovrascrivere il contenuto iniziale del file della pipeline azure-pipelines.yml con la definizione seguente e quindi fare clic su Salva.

# Specify the trigger event to start the build pipeline.
# In this case, new code merged into the release branch initiates a new build.
trigger:
- release

# Specify the operating system for the agent that runs on the Azure virtual
# machine for the build pipeline (known as the build agent). The virtual
# machine image in this example uses the Ubuntu 22.04 virtual machine
# image in the Azure Pipeline agent pool. See
# https://learn.microsoft.com/azure/devops/pipelines/agents/hosted#software
pool:
  vmImage: ubuntu-22.04

# Download the files from the designated branch in the remote Git repository
# onto the build agent.
steps:
- checkout: self
  persistCredentials: true
  clean: true

# Generate the deployment artifact. To do this, the build agent gathers
# all the new or updated code to be given to the release pipeline,
# including the sample Python code, the Python notebooks,
# the Python wheel library component files, and the related Databricks asset
# bundle settings.
# Use git diff to flag files that were added in the most recent Git merge.
# Then add the files to be used by the release pipeline.
# The implementation in your pipeline will likely be different.
# The objective here is to add all files intended for the current release.
- script: |
    git diff --name-only --diff-filter=AMR HEAD^1 HEAD | xargs -I '{}' cp --parents -r '{}' $(Build.BinariesDirectory)
    mkdir -p $(Build.BinariesDirectory)/Libraries/python/dabdemo/dabdemo
    cp $(Build.Repository.LocalPath)/Libraries/python/dabdemo/dabdemo/*.* $(Build.BinariesDirectory)/Libraries/python/dabdemo/dabdemo
    cp $(Build.Repository.LocalPath)/Libraries/python/dabdemo/setup.py $(Build.BinariesDirectory)/Libraries/python/dabdemo
    cp $(Build.Repository.LocalPath)/*.* $(Build.BinariesDirectory)
  displayName: 'Get Changes'

# Create the deployment artifact and then publish it to the
# artifact repository.
- task: ArchiveFiles@2
  inputs:
    rootFolderOrFile: '$(Build.BinariesDirectory)'
    includeRootFolder: false
    archiveType: 'zip'
    archiveFile: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
    replaceExistingArchive: true

- task: PublishBuildArtifacts@1
  inputs:
    ArtifactName: 'DatabricksBuild'

Passaggio 3: Definire la pipeline di versione

La pipeline di versione distribuisce gli artefatti di compilazione dalla pipeline di compilazione in un ambiente Azure Databricks. La separazione della pipeline di versione in questo passaggio dalla pipeline di compilazione nei passaggi precedenti consente di creare una compilazione senza distribuirla o di distribuire elementi da più compilazioni contemporaneamente.

Nel progetto Azure DevOps scegliere Versioni dal menu Pipeline nella barra laterale.
Fare clic su Nuova > Nuova pipeline di versione. (Se sono già presenti pipeline, fare clic su Nuova pipeline.)
Sul lato della schermata è riportato un elenco di modelli in primo piano per i modelli di distribuzione comuni. Per questa pipeline di versione di esempio, fare clic su .
Nella casella Artefatti sul lato della schermata fare clic su . Nel riquadro Aggiungi un artefatto, per Origine (pipeline di compilazione), selezionare la pipeline di compilazione creata in precedenza. Fare quindi clic su Aggiungi.
È possibile configurare la modalità di attivazione della pipeline facendo clic su per visualizzare le opzioni di attivazione sul lato della schermata. Se si vuole avviare automaticamente una versione in base alla disponibilità degli artefatti della compilazione o dopo un flusso di lavoro di richiesta pull, abilitare il trigger appropriato. Per il momento, in questo esempio, nell'ultimo passaggio di questo articolo si attiva manualmente la pipeline di compilazione e quindi la pipeline di versione.
Fare clic su Salva > OK.

Passaggio 3.1: Definire le variabili di ambiente per la pipeline di versione

La pipeline di versione di questo esempio si basa sulle variabili di ambiente seguenti, che è possibile aggiungere facendo clic su Aggiungi nella sezione Variabili della pipeline della scheda Variabili, con AmbitoFase 1:

BUNDLE_TARGET, che deve corrispondere al nome target nel file databricks.yml. Nell'esempio di questo articolo si tratta di dev.
DATABRICKS_HOST, che rappresenta l'URL per area di lavoro dell'area di lavoro di Azure Databricks, a partire da https://, ad esempio https://adb-<workspace-id>.<random-number>.azuredatabricks.net. Non includere l'elemento finale / dopo .net.
DATABRICKS_CLIENT_ID, che rappresenta l'ID applicazione per l'entità servizio Microsoft Entra ID.
DATABRICKS_CLIENT_SECRET, che rappresenta il segreto OAuth di Azure Databricks per l'entità servizio Microsoft Entra ID.

Passaggio 3.2: Configurare l'agente di versione per la pipeline di versione

Fare clic sul collegamento processo 1, attività 0 all'interno dell'oggetto Fase 1.
Nella scheda Attività, fare clic su Processo dell’agente.
Nella sezione Selezione agente selezionare Azure Pipelines per pool di agenti.
Per Specifica dell’agente, selezionare lo stesso agente specificato in precedenza per l'agente di compilazione, in questo esempio ubuntu-22.04.
Fare clic su Salva > OK.

Passaggio 3.3: Impostare la versione di Python per l'agente di rilascio

Fare clic sul segno di addizione nella sezione Processo dell’agente, indicata dalla freccia rossa nella figura seguente. Viene visualizzato un elenco ricercabile di attività disponibili. È disponibile anche una scheda Marketplace per i plug-in di terze parti che possono essere usati per integrare le attività standard di Azure DevOps. Durante i passaggi successivi verranno aggiunte diverse attività all'agente di rilascio.
La prima attività aggiunta è Usa la versione Python, disponibile nella scheda Strumento. Se non è possibile trovare questa attività, usare la casella Cerca per cercarla. Quando la si trova, selezionarla e fare clic sul pulsante Aggiungi accanto all'attività Usa versione Python.
Come per la pipeline di compilazione, si vuole assicurarsi che la versione di Python sia compatibile con gli script chiamati nelle attività successive. In questo caso, fare clic sull'attività Usa Python 3.x accanto a Processo dell’agente e quindi impostare Specifiche versione su 3.10. Impostare anche Nome visualizzato su Use Python 3.10. Questa pipeline presuppone che si usi Databricks Runtime 13.3 LTS nei cluster, che includono Python 3.10.12 installato.
Fare clic su Salva > OK.

Passaggio 3.4: Annullare il pacchetto dell'artefatto della compilazione dalla pipeline di compilazione

Successivamente, fare in modo che l'agente della versione estragga il file wheel Python, i file delle impostazioni di versione correlati, i notebook e il file di codice Python dal file zip usando l'attività Estrai file: fare clic sul segno di addizione nella sezione Processo dell’agente, selezionare l'attività Estrai file nella scheda Utilità e quindi fare clic su Aggiungi.
Fare clic sull'attività Estrai file accanto a Processo dell’agente, impostare Modelli di file di archivio su **/*.zip e impostare la cartella Destinazione sulla variabile di sistema $(Release.PrimaryArtifactSourceAlias)/Databricks. Impostare anche Nome visualizzato su Extract build pipeline artifact.

Nota

$(Release.PrimaryArtifactSourceAlias) rappresenta un alias generato da Azure DevOps per identificare il percorso di origine dell'artefatto primario nell'agente di versione, ad esempio _<your-github-alias>.<your-github-repo-name>. La pipeline di versione imposta questo valore come variabile di ambiente RELEASE_PRIMARYARTIFACTSOURCEALIAS nella fase di inizializzazione del processo per l'agente della versione. Consultare Variabili di artefatti e della versione classica.
Impostare Nome visualizzato su Extract build pipeline artifact.
Fare clic su Salva > OK.

Passaggio 3.5: Impostare la variabile di ambiente BUNDLE_ROOT

Per usare l'esempio di questo articolo come previsto, è necessario impostare una variabile di ambiente denominata BUNDLE_ROOT nella pipeline di versione. I bundle di asset di Databricks usano questa variabile di ambiente per determinare dove si trova il file databricks.yml. Impostare le variabili di ambiente:

Usare l'attività Variabili di ambiente: fare di nuovo clic sul segno di addizione nella sezione Processo dell’agente, selezionare l'attività Variabili di ambiente nella scheda Utilità e quindi fare clic su Aggiungi.

Nota

Se l'attività Variabili di ambiente non è visibile nella scheda Utilità, immettere Environment Variables nella casella Cerca e seguire le istruzioni visualizzate per aggiungere l'attività alla scheda Utilità. Ciò potrebbe richiedere di lasciare Azure DevOps e quindi tornare a questa posizione in cui è stato interrotto.
Per Variabili di ambiente (delimitato da virgole) immettere la definizione seguente: BUNDLE_ROOT=$(Agent.ReleaseDirectory)/$(Release.PrimaryArtifactSourceAlias)/Databricks.

Nota

$(Agent.ReleaseDirectory) rappresenta un alias generato da Azure DevOps per identificare il percorso della directory di versione nell'agente di versione, ad esempio /home/vsts/work/r1/a. La pipeline di versione imposta questo valore come variabile di ambiente AGENT_RELEASEDIRECTORY nella fase di inizializzazione del processo per l'agente della versione. Consultare Variabili di artefatti e della versione classica. Per informazioni su $(Release.PrimaryArtifactSourceAlias), consultare la nota nel passaggio precedente.
Impostare Nome visualizzato su Set BUNDLE_ROOT environment variable.
Fare clic su Salva > OK.

Passaggio 3.6. Installare gli strumenti di compilazione dell'interfaccia della riga di comando di Databricks e Python

Installare quindi gli strumenti di compilazione dell'interfaccia della riga di comando di Databricks e Python nell'agente di rilascio. L'agente di versione chiamerà l'interfaccia della riga di comando di Databricks e gli strumenti di compilazione del wheel di Python nelle prossime attività. A tale scopo, usare l'attività Bash: fare clic sul segno di addizione di nuovo nella sezione Processo dell’agente, selezionare l'attività Bash nella scheda Utilità e quindi fare clic su Aggiungi.
Fare clic sull'attività Script Bash accanto al processo dell’agente.
Per Tipo, selezionare Inline.
Sostituire il contenuto di Script con il comando seguente, che installa gli strumenti di compilazione dell'interfaccia della riga di comando di Databricks e Python:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
pip install wheel
```
Impostare Nome visualizzato su Install Databricks CLI and Python wheel build tools.
Fare clic su Salva > OK.

Passaggio 3.7: Convalidare il bundle degli asset di Databricks

In questo passaggio assicurarsi che il file databricks.yml sia sintatticamente corretto.

Usare l'attività Bash: fare di nuovo clic sul segno di addizione nella sezione Processo dell’agente, selezionare l'attività Bash nella scheda Utilità e quindi fare clic su Aggiungi.
Fare clic sull'attività Script Bash accanto al processo dell’agente.
Per Tipo, selezionare Inline.
Sostituire il contenuto di Script con il comando seguente, che usa l'interfaccia della riga di comando di Databricks per verificare se il file databricks.yml è sintatticamente corretto:
```
databricks bundle validate -t $(BUNDLE_TARGET)
```
Impostare Nome visualizzato su Validate bundle.
Fare clic su Salva > OK.

Passaggio 3.8: Implementare il bundle

In questo passaggio si compila il file wheel di Python e si distribuisce il file wheel di Python compilato, i due notebook Python e il file Python dalla pipeline di versione all'area di lavoro di Azure Databricks.

Usare l'attività Bash: fare di nuovo clic sul segno di addizione nella sezione Processo dell’agente, selezionare l'attività Bash nella scheda Utilità e quindi fare clic su Aggiungi.
Fare clic sull'attività Script Bash accanto al processo dell’agente.
Per Tipo, selezionare Inline.
Sostituire il contenuto di Script con il comando seguente, che usa l'interfaccia della riga di comando di Databricks per compilare il file wheel di Python e distribuire i file di esempio di questo articolo dalla pipeline di versione all'area di lavoro di Azure Databricks:
```
databricks bundle deploy -t $(BUNDLE_TARGET)
```
Impostare Nome visualizzato su Deploy bundle.
Fare clic su Salva > OK.

Passaggio 3.9: Eseguire il notebook di unit test per il wheel Python

In questo passaggio si esegue un processo che esegue il notebook di unit test nell'area di lavoro di Azure Databricks. Questo notebook esegue unit test sulla logica della libreria wheel Python.

Usare l'attività Bash: fare di nuovo clic sul segno di addizione nella sezione Processo dell’agente, selezionare l'attività Bash nella scheda Utilità e quindi fare clic su Aggiungi.
Fare clic sull'attività Script Bash accanto al processo dell’agente.
Per Tipo, selezionare Inline.
Sostituire il contenuto di Script con il comando seguente, che usa l'interfaccia della riga di comando di Databricks per eseguire il processo nell'area di lavoro di Azure Databricks:
```
databricks bundle run -t $(BUNDLE_TARGET) run-unit-tests
```
Impostare Nome visualizzato su Run unit tests.
Fare clic su Salva > OK.

Passaggio 3.10: Eseguire il notebook che chiama il wheel Python

In questo passaggio si esegue un processo che esegue un altro notebook nell'area di lavoro di Azure Databricks. Questo notebook chiama la libreria wheel Python.

Usare l'attività Bash: fare di nuovo clic sul segno di addizione nella sezione Processo dell’agente, selezionare l'attività Bash nella scheda Utilità e quindi fare clic su Aggiungi.
Fare clic sull'attività Script Bash accanto al processo dell’agente.
Per Tipo, selezionare Inline.
Sostituire il contenuto di Script con il comando seguente, che usa l'interfaccia della riga di comando di Databricks per eseguire il processo nell'area di lavoro di Azure Databricks:
```
databricks bundle run -t $(BUNDLE_TARGET) run-dabdemo-notebook
```
Impostare Nome visualizzato su Run notebook.
Fare clic su Salva > OK.

La configurazione della pipeline di versione è stata completata. L'aspetto dovrebbe essere il seguente:

Configurazione della pipeline di versione completata di Azure DevOps

Passaggio 4: Eseguire le pipeline di compilazione e versione

In questo passaggio si eseguono le pipeline manualmente. Per informazioni su come eseguire automaticamente le pipeline, consultare Specificare gli eventi che attivano pipeline e trigger della versione.

Per eseguire manualmente la pipeline di compilazione:

Nella barra laterale del menu Pipeline, fare clic su Pipeline.
Fare clic sul nome della pipeline di compilazione e quindi su Esegui pipeline.
Per Branch/tag selezionare il nome del ramo nel repository Git che contiene tutto il codice sorgente aggiunto. In questo esempio si presuppone che si tratti del ramo release.
Fare clic su Esegui. Viene visualizzata la pagina di esecuzione della pipeline di compilazione.
Per visualizzare lo stato della pipeline di compilazione e visualizzare i log correlati, fare clic sull'icona rotante accanto a Processo.
Dopo che l'icona Processo diventa un segno di spunta verde, procedere con l'esecuzione della pipeline di versione.

Per eseguire manualmente la pipeline di versione:

Dopo l'esecuzione della pipeline di compilazione, scegliere Versioni dal menu Pipeline nella barra laterale.
Fare clic sul nome della pipeline di versione e quindi su Crea versione.
Cliccare su Crea.
Per visualizzare lo stato della pipeline di versione, nell'elenco delle versioni fare clic sul nome della versione più recente.
Nella casella Fasi, fare clic su Fase 1 e quindi su Log.

Condividi tramite