Folyamatos integráció és teljesítés az Azure Databricksben az Azure DevOpsszal

Cikk
04/24/2024

Feljegyzés

Ez a cikk az Azure DevOpsról szól, amelyet a Databricks nem biztosít és nem támogat. A szolgáltatóval való kapcsolatfelvételhez tekintse meg az Azure DevOps Services ügyfélszolgálatát.

Ez a cikk végigvezeti az Azure DevOps automatizálásának konfigurálásán az Azure Databricksszel működő kódhoz és összetevőkhöz. Pontosabban konfigurál egy folyamatos integrációs és kézbesítési (CI/CD) munkafolyamatot egy Git-adattárhoz való csatlakozáshoz, feladatok futtatásához az Azure Pipelines használatával egy Python-kerék (*.whl) létrehozására és egységtesztelésére, és üzembe helyezi a Databricks-jegyzetfüzetekben való használatra.

CI/CD fejlesztési munkafolyamat

A Databricks az alábbi munkafolyamatot javasolja a CI/CD-fejlesztéshez az Azure DevOps használatával:

Hozzon létre egy adattárat, vagy használjon egy meglévő adattárat a külső Git-szolgáltatóval.
Csatlakozás a helyi fejlesztőgépet ugyanahhoz a külső adattárhoz. Útmutatásért tekintse meg a külső Git-szolgáltató dokumentációját.
A meglévő frissített összetevőket (például jegyzetfüzeteket, kódfájlokat és buildszkripteket) lekérheti a helyi fejlesztői gépre a külső adattárból.
Szükség esetén hozzon létre, frissítse és tesztelje az összetevőket a helyi fejlesztőgépen. Ezután küldjön le minden új és módosított összetevőt a helyi fejlesztőgépről a külső adattárba. Útmutatásért tekintse meg a külső Git-szolgáltató dokumentációját.
Szükség szerint ismételje meg a 3. és a 4. lépést.
Az Azure DevOps rendszeres használatával integrált megközelítésként automatikusan leküldheti az összetevőket a külső adattárból, létrehozhatja, tesztelheti és futtathatja a kódot az Azure Databricks-munkaterületen, valamint jelentéseket készíthet a tesztelési és futtatási eredményekről. Bár manuálisan is futtathatja az Azure DevOpst, a valós implementációkban arra utasítaná a külső Git-szolgáltatót, hogy minden alkalommal futtassa az Azure DevOpst, amikor egy adott esemény történik, például egy adattár lekéréses kérése.

A folyamat kezeléséhez és végrehajtásához számos CI/CD-eszköz használható. Ez a cikk az Azure DevOps használatát mutatja be. A CI/CD egy tervezési minta, ezért a jelen cikk példájában ismertetett lépéseknek és szakaszoknak az egyes eszközök folyamatdefiníciós nyelvére kell átvinnie néhány módosítással. Ezenkívül a példafolyamatban szereplő kód nagy része standard Python-kód, amely más eszközökben is meghívható.

Tipp.

A Jenkins és az Azure DevOps helyett az Azure Databricks használatával kapcsolatos információkért tekintse meg a CI/CD és a Jenkins azure Databricks szolgáltatással való használatát.

A cikk további része az Azure DevOpsban található példafolyamatokat ismerteti, amelyek az Azure Databricks saját igényeihez igazíthatók.

Tudnivalók a példáról

A cikk példája két folyamatot használ egy távoli Git-adattárban tárolt Python-kód- és Python-jegyzetfüzetek gyűjtésére, üzembe helyezésére és futtatására.

Az első, buildelési folyamatként ismert folyamat előkészíti a buildösszetevőket a második folyamathoz, más néven a kiadási folyamathoz. A buildelési folyamatnak a kiadási folyamattól való elkülönítésével anélkül hozhat létre buildösszetevőt, hogy üzembe helyezte volna, vagy egyszerre több buildből is telepíthet összetevőket. A buildelési és kiadási folyamatok létrehozása:

Hozzon létre egy Azure-beli virtuális gépet a buildelési folyamathoz.
Másolja a fájlokat a Git-adattárból a virtuális gépre.
Hozzon létre egy gzip'ed tar fájlt, amely tartalmazza a Python-kódot, a Python-jegyzetfüzeteket és a kapcsolódó buildelési, üzembe helyezési és futtatási beállítások fájljait.
Másolja a gzip'ed tar fájlt zip-fájlként a kiadási folyamat elérésére szolgáló helyre.
Hozzon létre egy másik Azure-beli virtuális gépet a kiadási folyamathoz.
Kérje le a zip-fájlt a buildelési folyamat helyére, majd csomagolja ki a zip-fájlt a Python-kód, a Python-jegyzetfüzetek és a kapcsolódó buildelési, üzembe helyezési és futtatási beállítások fájljainak lekéréséhez.
Helyezze üzembe a Python-kódot, a Python-jegyzetfüzeteket és a kapcsolódó buildelési, üzembe helyezési és futtatási beállítások fájljait a távoli Azure Databricks-munkaterületen.
A Python-kerékkódtár összetevőkódfájljait Python-kerékfájlba építi.
A Python-kerékfájl logikájának ellenőrzéséhez futtasson egységteszteket az összetevő kódján.
Futtassa a Python-jegyzetfüzeteket, amelyek közül az egyik meghívja a Python-kerekes fájl funkcióit.

Tudnivalók a Databricks parancssori felületéről

A cikk példája bemutatja, hogyan használhatja a Databricks parancssori felületét nem interaktív módban egy folyamaton belül. A cikk példafolyamata kódot helyez üzembe, kódtárat hoz létre, és jegyzetfüzeteket futtat az Azure Databricks-munkaterületen.

Ha a Databricks parancssori felületét használja a folyamatban a jelen cikk példakódjának, kódtárának és jegyzetfüzeteinek implementálása nélkül, kövesse az alábbi lépéseket:

Készítse elő az Azure Databricks-munkaterületet OAuth machine-to-machine (M2M) hitelesítés használatára egy szolgáltatásnév hitelesítéséhez. Mielőtt hozzákezdene, ellenőrizze, hogy rendelkezik-e Microsoft Entra-azonosítóval (korábbi nevén Azure Active Directory) egy Azure Databricks OAuth-titkos kóddal. Lásd: OAuth machine-to-machine (M2M) hitelesítés.
Telepítse a Databricks parancssori felületét a folyamatba. Ehhez adjon hozzá egy Bash-szkriptfeladatot a folyamathoz, amely a következő szkriptet futtatja:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
```
Ha Bash-szkriptfeladatot szeretne hozzáadni a folyamathoz, olvassa el a 3.6. lépést. Telepítse a Databricks CLI- és Python-keréképítési eszközöket.
Konfigurálja a folyamatot úgy, hogy a telepített Databricks parancssori felület hitelesítse a szolgáltatásnevet a munkaterülettel. Ehhez tekintse meg a 3.1. lépést: Környezeti változók definiálása a kiadási folyamathoz.
A Databricks CLI-parancsok futtatásához szükség szerint adjon hozzá további Bash-szkriptfeladatokat a folyamathoz. Lásd: Databricks CLI-parancsok.

Mielőtt elkezdené

A cikk példájának használatához az alábbiakra van szükség:

Egy meglévő Azure DevOps-projekt . Ha még nem rendelkezik projektel, hozzon létre egy projektet az Azure DevOpsban.
Egy meglévő adattár egy Git-szolgáltatóval, amelyet az Azure DevOps támogat. Ehhez az adattárhoz hozzáadja a Python-példakódot, a példa Python-jegyzetfüzetet és a kapcsolódó kiadási beállítások fájljait. Ha még nem rendelkezik tárházzal, hozzon létre egyet a Git-szolgáltató utasításait követve. Ezután csatlakoztassa az Azure DevOps-projektet ehhez az adattárhoz, ha még nem tette meg. Útmutatásért kövesse a támogatott forrástárak hivatkozásait.
Ez a cikk az OAuth machine-to-machine (M2M) hitelesítést használja a Microsoft Entra ID (korábbi nevén Azure Active Directory) szolgáltatásnév hitelesítéséhez egy Azure Databricks-munkaterületen. Rendelkeznie kell egy Microsoft Entra ID szolgáltatásnévvel, amely rendelkezik egy Azure Databricks OAuth-titkos kóddal az adott szolgáltatásnévhez. Lásd: OAuth machine-to-machine (M2M) hitelesítés.

1. lépés: A példa fájljainak hozzáadása az adattárhoz

Ebben a lépésben a külső Git-szolgáltató adattárában hozzáadja a jelen cikk összes példafájlját, amelyeket az Azure DevOps-folyamatok létrehoznak, üzembe helyeznek és futtatnak a távoli Azure Databricks-munkaterületen.

1.1. lépés: A Python-kerék összetevőfájljainak hozzáadása

A cikk példájában az Azure DevOps-folyamatok létrehoznak és tesztelnek egy Python-kerekes fájlt. Egy Azure Databricks-jegyzetfüzet ezután meghívja a pythonkerekes fájl beépített funkcióit.

A jegyzetfüzetek által futtatott Python-kerékfájl logikai és egységtesztjeinek meghatározásához az adattár gyökerében hozzon létre két fájlt, addcol.py és test_addcol.pyadja hozzá őket egy Libraries mappában elnevezett python/dabdemo/dabdemo mappastruktúrához, az alábbiak szerint:

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

A addcol.py fájl tartalmaz egy kódtárfüggvényt, amely később egy Python-kerékfájlba van beépítve, majd az Azure Databricks-fürtökre van telepítve. Ez egy egyszerű függvény, amely egy új, konstanssal kitöltött oszlopot ad hozzá egy Apache Spark DataFrame-hez:

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

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

A test_addcol.py fájl olyan teszteket tartalmaz, hogy átadjon egy dataFrame-objektumot a függvénynek, amely a with_status következőben van definiálva addcol.py: . Ezt követően a rendszer összehasonlítja az eredményt egy DataFrame-objektummal, amely a várt értékeket tartalmazza. Ha az értékek egyeznek, a teszt a következőn megy át:

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

Ha engedélyezni szeretné a Databricks parancssori felületének, hogy megfelelően csomagolja be ezt a kódtárkódot egy Python-kerékfájlba, hozzon létre két fájlt __init__.py , amelyek neve és __main__.py ugyanabban a mappában van, mint az előző két fájl. Emellett hozzon létre egy fájlt setup.py a python/dabdemo mappában, a következőképpen vizualizálva:

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

A __init__.py fájl tartalmazza a kódtár verziószámát és szerzőjét. Cserélje le <my-author-name> a nevét:

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

import sys, os

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

A __main__.py fájl tartalmazza a kódtár belépési pontját:

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

A setup.py fájl további beállításokat tartalmaz a kódtár Python-kerékfájlba való létrehozásához. Cserélje le <my-url>a , <my-author-name>@<my-organization>és <my-package-description> az érvényes értékeket:

# 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"]
)

1.2. lépés: Egységtesztelési jegyzetfüzet hozzáadása a Python-kerékfájlhoz

Később a Databricks parancssori felület egy jegyzetfüzet-feladatot futtat. Ez a feladat egy Python-jegyzetfüzetet futtat a következő fájlnévvel run_unit_tests.py: . Ez a jegyzetfüzet a Python-kerekes kódtár logikájával fut pytest .

A cikk példájához tartozó egységtesztek futtatásához adjon hozzá egy jegyzetfüzetfájlt az adattár gyökeréhez a következő tartalommal:run_unit_tests.py

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

1.3. lépés: A Python-kerékfájlt meghívó jegyzetfüzet hozzáadása

Később a Databricks parancssori felület egy másik jegyzetfüzet-feladatot futtat. Ez a jegyzetfüzet létrehoz egy DataFrame-objektumot, továbbítja azt a Python-kerekes kódtár függvényének with_status , kinyomtatja az eredményt, és jelentést készít a feladat futtatási eredményeiről. Hozza létre az adattár gyökerét a következő tartalommal elnevezett dabdemo_notebook.py jegyzetfüzetfájlban:

# 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 │
# +------------+-----------+-------------------------+---------+

1.4. lépés: A csomagkonfiguráció létrehozása

Ez a cikk a Databricks Asset Bundles használatával határozza meg a Python-kerékfájl, a két jegyzetfüzet és a Python-kódfájl létrehozásának, üzembe helyezésének és futtatásának beállításait és viselkedését. A Databricks Asset Bundles, más néven kötegek lehetővé teszik a teljes adatok, elemzések és ml-projektek forrásfájlok gyűjteményeként való kifejezését. Lásd: Mik azok a Databricks-eszközcsomagok?.

A cikk példájához tartozó csomag konfigurálásához hozzon létre egy fájlt databricks.ymlaz adattár gyökerében. Ebben a példafájlban databricks.yml cserélje le a következő helyőrzőket:

Cserélje le <bundle-name> a köteg egyedi programozott nevére. Például: azure-devops-demo.
Cserélje le <job-prefix-name> egy sztringre, hogy egyedileg azonosíthassa az Azure Databricks-munkaterületen létrehozott feladatokat ebben a példában. Például: azure-devops-demo.
Cserélje le <spark-version-id> például a Feladatfürtök 13.3.x-scala2.12Databricks Runtime verzióazonosítóját.
Cserélje le <cluster-node-type-id> például a feladatfürtök Standard_DS3_v2fürtcsomópont-típusazonosítóját.
Figyelje meg, hogy dev a targets leképezés a gazdagépet és a kapcsolódó üzembe helyezési viselkedést határozza meg. A valós implementációkban a célnak más nevet adhat a saját kötegeiben.

A példafájl databricks.yml tartalma a következő:

# 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

A fájl szintaxisával kapcsolatos további információkért lásd a databricks.yml Databricks Asset Bundle konfigurációit.

2. lépés: A buildelési folyamat meghatározása

Az Azure DevOps egy felhőalapú felhasználói felületet biztosít a CI/CD-folyamat szakaszainak YAML használatával történő meghatározásához. Az Azure DevOpsról és a folyamatokról az Azure DevOps dokumentációjában talál további információt.

Ebben a lépésben YAML-korrektúra használatával határozza meg a buildelési folyamatot, amely üzembehelyezési összetevőt hoz létre. Ha egy Azure Databricks-munkaterületen szeretné üzembe helyezni a kódot, a folyamat buildösszetevőjét adja meg bemenetként egy kiadási folyamatba. Ezt a kiadási folyamatot később definiálhatja.

A buildelési folyamatok futtatásához az Azure DevOps felhőalapú, igény szerinti végrehajtási ügynököket biztosít, amelyek támogatják a Kubernetes, a virtuális gépek, az Azure Functions, az Azure Web Apps és még sok más cél üzembe helyezését. Ebben a példában egy igény szerinti ügynökkel automatizálja az üzembehelyezési összetevő összeállítását.

A cikk példa buildelési folyamatának meghatározása az alábbiak szerint:

Jelentkezzen be az Azure DevOpsba, majd kattintson a Bejelentkezési hivatkozásra az Azure DevOps-projekt megnyitásához.

Feljegyzés

Ha az Azure Portal az Azure DevOps-projekt helyett jelenik meg, kattintson a További szolgáltatásokra > Az Azure DevOps-szervezetek > Saját Azure DevOps-szervezetek , majd nyissa meg az Azure DevOps-projektet.
Az oldalsávon kattintson a Folyamatok elemre, majd a Folyamatok menü Folyamatok parancsára.
Kattintson az Új folyamat gombra, és kövesse a képernyőn megjelenő utasításokat. (Ha már rendelkezik folyamatokkal, kattintson a Folyamat létrehozása helyett.) Az utasítások végén megnyílik a folyamatszerkesztő. Itt definiálhatja a buildelési folyamat parancsfájlját a azure-pipelines.yml megjelenő fájlban. Ha a folyamatszerkesztő nem látható az utasítások végén, válassza ki a buildelési folyamat nevét, majd kattintson a Szerkesztés gombra.

A Git-ágválasztóval testre szabhatja a Git-adattár egyes ágainak buildelési folyamatát. A CI/CD ajánlott eljárása, hogy nem végez éles munkát közvetlenül az adattár ágában main . Ez a példa feltételezi, hogy egy elnevezett release ág létezik az adattárban, amelyet ahelyett mainkell használni.

A azure-pipelines.yml buildelési folyamat szkriptje alapértelmezés szerint a folyamathoz társított távoli Git-adattár gyökerében van tárolva.

Írja felül a folyamat fájljának azure-pipelines.yml kezdő tartalmát az alábbi definícióval, majd kattintson a Mentés gombra.

# 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'

3. lépés: A kiadási folyamat meghatározása

A kiadási folyamat üzembe helyezi a buildelési összetevőket a buildelési folyamatból egy Azure Databricks-környezetbe. Ha az ebben a lépésben szereplő kiadási folyamatot elválasztja a buildelési folyamattól az előző lépésekben, lehetővé teszi, hogy üzembe helyezés nélkül hozzon létre egy buildet, vagy egyszerre több buildből telepítsen összetevőket.

Az Azure DevOps-projektben az oldalsáv Pipelines menüjében kattintson a Releases (Kiadások) elemre.
Kattintson az Új > kiadási folyamat elemre. (Ha már rendelkezik folyamatokkal, kattintson a Új folyamat helyett.)
A képernyő oldalán a gyakori üzembehelyezési minták kiemelt sablonjainak listája látható. Ebben a példában a kiadási folyamathoz kattintson a gombra .
Kattintson a képernyő oldalán található Artifacts (Összetevők) mezőbe. A Forrás (buildfolyamat) összetevő hozzáadása panelen válassza ki a korábban létrehozott buildelési folyamatot. Ezután kattintson az Add (Hozzáadás) gombra.
A folyamat aktiválását úgy konfigurálhatja, hogy a képernyő oldalán az aktiválási beállítások megjelenítéséhez kattint . Ha azt szeretné, hogy a kiadás automatikusan elinduljon a buildösszetevő rendelkezésre állása vagy egy lekéréses kérelem munkafolyamata alapján, engedélyezze a megfelelő eseményindítót. Ebben a példában egyelőre a cikk utolsó lépésében manuálisan aktiválja a buildelési folyamatot, majd a kiadási folyamatot.
Kattintson a Mentés > OK gombra.

3.1. lépés: Környezeti változók definiálása a kiadási folyamathoz

A példa kiadási folyamata a következő környezeti változókra támaszkodik, amelyeket a Változók lap Folyamatváltozók szakaszában a Hozzáadás gombra kattintva adhat hozzá az 1. fázis hatókörével:

BUNDLE_TARGET, amelynek meg kell egyeznie a targetdatabricks.yml fájlban lévő névvel. A cikk példájában ez a következő dev.
DATABRICKS_HOST, amely az Azure Databricks-munkaterület munkaterületenkénti URL-címét jelöli, kezdve például https://adb-<workspace-id>.<random-number>.azuredatabricks.neta következővelhttps://: . Ne adja meg a záró elemet / a következő után .net.
DATABRICKS_CLIENT_ID, amely a Microsoft Entra ID szolgáltatásnév alkalmazásazonosítóját jelöli.
DATABRICKS_CLIENT_SECRET, amely a Microsoft Entra ID szolgáltatásnév Azure Databricks OAuth-titkos kódját jelöli.

3.2. lépés: A kiadási folyamat kiadási ügynökének konfigurálása

Kattintson az 1. fázis objektumában található 1 feladat, 0 tevékenység hivatkozásra.
A Feladatok lapon kattintson az Ügynökfeladat elemre.
Az Ügynökválasztás szakaszban az Ügynökkészlet területen válassza az Azure Pipelines lehetőséget.
Az Ügynök specifikációja beállításnál válassza ki ugyanazt az ügynököt, mint korábban a buildügynökhöz, ebben a példában ubuntu-22.04.
Kattintson a Mentés > OK gombra.

3.3. lépés: A kiadási ügynök Python-verziójának beállítása

Kattintson a pluszjelre az Ügynökfeladat szakaszban, amelyet az alábbi ábrán látható piros nyíl jelez. Megjelenik az elérhető tevékenységek kereshető listája. A külső beépülő modulokhoz egy Marketplace-lap is tartozik, amely a szokásos Azure DevOps-feladatok kiegészítésére használható. A következő lépések során több feladatot fog hozzáadni a kiadási ügynökhöz.
Az első hozzáadott feladat a Python-verzió használata, amely az Eszköz lapon található. Ha nem találja ezt a feladatot, a Keresőmezővel keresse meg. Ha megtalálta, jelölje ki, majd kattintson a Python-verzió használata feladat melletti Hozzáadás gombra.
A buildelési folyamathoz hasonlóan meg kell győződnie arról, hogy a Python-verzió kompatibilis a későbbi feladatokban meghívott szkriptekkel. Ebben az esetben kattintson a Python 3.x használata feladatra az Ügynökfeladat mellett, majd állítsa a Verzió specifikációt a következőre3.10: A Megjelenítendő név beállítását is állítsa be a következőreUse Python 3.10: Ez a folyamat feltételezi, hogy a Databricks Runtime 13.3 LTS-t használja azon fürtökön, amelyeken telepítve van a Python 3.10.12.
Kattintson a Mentés > OK gombra.

3.4. lépés: A buildösszetevő kicsomagolása a buildelési folyamatból

Ezután a kiadási ügynök kinyerje a Python-kerékfájlt, a kapcsolódó kiadási beállítások fájljait, a jegyzetfüzeteket és a Python-kódfájlt a zip-fájlból a Fájlok kinyerése feladat használatával: kattintson a pluszjelre az Ügynökfeladat szakaszban, válassza ki a Fájlok kinyerése feladatot a Segédprogram lapon, majd kattintson a Hozzáadás gombra.
Kattintson az Ügynökfeladat melletti Fájlok kinyerése feladatra, állítsa be az archív fájlmintákat**/*.zip, és állítsa a Cél mappát a rendszerváltozóra$(Release.PrimaryArtifactSourceAlias)/Databricks. A Megjelenítendő név beállítását is állítsa be a következőreExtract build pipeline artifact:

Feljegyzés

$(Release.PrimaryArtifactSourceAlias) Egy Azure DevOps által létrehozott aliast jelöl, amely azonosítja például a kiadási ügynök _<your-github-alias>.<your-github-repo-name>elsődleges összetevőforrásának helyét. A kiadási folyamat ezt az értéket környezeti változóként RELEASE_PRIMARYARTIFACTSOURCEALIAS állítja be a kiadási ügynök Inicializálási feladat fázisában. Lásd a klasszikus kiadási és összetevő-változókat.
Megjelenítési név beállítása a következőreExtract build pipeline artifact: .
Kattintson a Mentés > OK gombra.

3.5. lépés: A BUNDLE_ROOT környezeti változó beállítása

Ahhoz, hogy a cikk a várt módon működjön, be kell állítania egy, a kiadási folyamatban elnevezett BUNDLE_ROOT környezeti változót. A Databricks Asset Bundles ezzel a környezeti változóval határozza meg a databricks.yml fájl helyét. A környezeti változó beállítása:

Használja a Környezeti változók feladatot: kattintson ismét a pluszjelre az Ügynök feladat szakaszban, válassza ki a Környezeti változók tevékenységet a Segédprogram lapon, majd kattintson a Hozzáadás gombra.

Feljegyzés

Ha a Környezeti változók tevékenység nem látható a Segédprogram lapon, írja be Environment Variables a Keresőmezőbe , és a képernyőn megjelenő utasításokat követve adja hozzá a feladatot a Segédprogram laphoz. Ehhez el kell hagynia az Azure DevOpsot, majd vissza kell térnie arra a helyre, ahol abbahagyta.
Környezeti változók (vesszővel elválasztva) esetén adja meg a következő definíciót: BUNDLE_ROOT=$(Agent.ReleaseDirectory)/$(Release.PrimaryArtifactSourceAlias)/Databricks.

Feljegyzés

$(Agent.ReleaseDirectory) Egy Azure DevOps által létrehozott aliast jelöl, amely azonosítja például a kiadási ügynök /home/vsts/work/r1/akiadási könyvtárának helyét. A kiadási folyamat ezt az értéket környezeti változóként AGENT_RELEASEDIRECTORY állítja be a kiadási ügynök Inicializálási feladat fázisában. Lásd a klasszikus kiadási és összetevő-változókat. További információ $(Release.PrimaryArtifactSourceAlias): az előző lépés megjegyzése.
Megjelenítési név beállítása a következőreSet BUNDLE_ROOT environment variable: .
Kattintson a Mentés > OK gombra.

3.6. lépés. A Databricks CLI és a Python keréképítési eszközeinek telepítése

Ezután telepítse a Databricks CLI-t és a Python-kerék buildelési eszközeit a kiadási ügynökre. A kiadási ügynök a következő néhány feladatban meghívja a Databricks CLI- és Python-keréképítési eszközöket. Ehhez használja a Bash-feladatot: kattintson ismét a pluszjelre az Ügynökfeladat szakaszban, válassza ki a Bash-feladatot a Segédprogram lapon, majd kattintson a Hozzáadás gombra.
Kattintson az Ügynökfeladat melletti Bash-szkript feladatra.
A Típus beállításnál válassza a Beágyazott elemet.
Cserélje le a szkript tartalmát a következő parancsra, amely telepíti a Databricks CLI- és Python-keréképítési eszközöket:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
pip install wheel
```
Megjelenítési név beállítása a következőreInstall Databricks CLI and Python wheel build tools: .
Kattintson a Mentés > OK gombra.

3.7. lépés: A Databricks-eszközcsomag ellenőrzése

Ebben a lépésben győződjön meg arról, hogy a databricks.yml fájl szintaktikailag helyes.

Használja a Bash-feladatot: kattintson ismét a pluszjelre az Ügynökfeladat szakaszban, válassza a Bash-feladatot a Segédprogram lapon, majd kattintson a Hozzáadás gombra.
Kattintson az Ügynökfeladat melletti Bash-szkript feladatra.
A Típus beállításnál válassza a Beágyazott elemet.
Cserélje le a szkript tartalmát a következő parancsra, amely a Databricks parancssori felületével ellenőrzi, hogy a databricks.yml fájl szintaktikailag helyes-e:
```
databricks bundle validate -t $(BUNDLE_TARGET)
```
Megjelenítési név beállítása a következőreValidate bundle: .
Kattintson a Mentés > OK gombra.

3.8. lépés: A csomag üzembe helyezése

Ebben a lépésben létrehozza a Python-kerékfájlt, és üzembe helyezi a beépített Python-kerékfájlt, a két Python-jegyzetfüzetet és a Python-fájlt a kiadási folyamatból az Azure Databricks-munkaterületre.

Használja a Bash-feladatot: kattintson ismét a pluszjelre az Ügynökfeladat szakaszban, válassza a Bash-feladatot a Segédprogram lapon, majd kattintson a Hozzáadás gombra.
Kattintson az Ügynökfeladat melletti Bash-szkript feladatra.
A Típus beállításnál válassza a Beágyazott elemet.
Cserélje le a szkript tartalmát a következő parancsra, amely a Databricks parancssori felületével hozza létre a Python-kerékfájlt, és helyezze üzembe a cikk példafájljait a kiadási folyamatból az Azure Databricks-munkaterületre:
```
databricks bundle deploy -t $(BUNDLE_TARGET)
```
Megjelenítési név beállítása a következőreDeploy bundle: .
Kattintson a Mentés > OK gombra.

3.9. lépés: A Python-kerék egységteszt-jegyzetfüzetének futtatása

Ebben a lépésben futtat egy feladatot, amely az egységteszt-jegyzetfüzetet futtatja az Azure Databricks-munkaterületen. Ez a jegyzetfüzet egységteszteket futtat a Python-kerékkódtár logikáján.

Használja a Bash-feladatot: kattintson ismét a pluszjelre az Ügynökfeladat szakaszban, válassza a Bash-feladatot a Segédprogram lapon, majd kattintson a Hozzáadás gombra.
Kattintson az Ügynökfeladat melletti Bash-szkript feladatra.
A Típus beállításnál válassza a Beágyazott elemet.
Cserélje le a szkript tartalmát a következő parancsra, amely a Databricks parancssori felülettel futtatja a feladatot az Azure Databricks-munkaterületen:
```
databricks bundle run -t $(BUNDLE_TARGET) run-unit-tests
```
Megjelenítési név beállítása a következőreRun unit tests: .
Kattintson a Mentés > OK gombra.

3.10. lépés: A Python-kereket hívó jegyzetfüzet futtatása

Ebben a lépésben egy olyan feladatot futtat, amely egy másik jegyzetfüzetet futtat az Azure Databricks-munkaterületen. Ez a jegyzetfüzet meghívja a Python-kerekes kódtárat.

Használja a Bash-feladatot: kattintson ismét a pluszjelre az Ügynökfeladat szakaszban, válassza a Bash-feladatot a Segédprogram lapon, majd kattintson a Hozzáadás gombra.
Kattintson az Ügynökfeladat melletti Bash-szkript feladatra.
A Típus beállításnál válassza a Beágyazott elemet.
Cserélje le a szkript tartalmát a következő parancsra, amely a Databricks parancssori felülettel futtatja a feladatot az Azure Databricks-munkaterületen:
```
databricks bundle run -t $(BUNDLE_TARGET) run-dabdemo-notebook
```
Megjelenítési név beállítása a következőreRun notebook: .
Kattintson a Mentés > OK gombra.

Ezzel befejezte a kiadási folyamat konfigurálását. Ennek a következőképpen kell kinéznie:

Az Azure DevOps befejezte a kiadási folyamat konfigurálását

4. lépés: A buildelési és kiadási folyamatok futtatása

Ebben a lépésben manuálisan futtatja a folyamatokat. A folyamatok automatikus futtatásának módjáról további információt a folyamatok aktiválását és a kiadási eseményindítókat kiváltó események megadása című témakörben talál.

A buildelési folyamat manuális futtatása:

Az oldalsáv Folyamatok menüjében kattintson a Folyamatok elemre.
Kattintson a buildelési folyamat nevére, majd a Folyamat futtatása parancsra.
Ág/címke esetén válassza ki annak az ágnak a nevét a Git-adattárban, amely tartalmazza az összes hozzáadott forráskódot. Ez a példa feltételezi, hogy ez az release ágban van.
Kattintson a Futtatás elemre. Megjelenik a buildelési folyamat futtatási oldala.
A buildelési folyamat előrehaladásának megtekintéséhez és a kapcsolódó naplók megtekintéséhez kattintson a Feladat melletti forgó ikonra.
Miután a Feladat ikon zöld pipára vált, futtassa a kiadási folyamatot.

A kiadási folyamat manuális futtatása:

Miután a buildelési folyamat sikeresen lefutott, az oldalsáv Folyamatok menüjében kattintson a Kiadások elemre.
Kattintson a kiadási folyamat nevére, majd a Kiadás létrehozása parancsra.
Kattintson a Létrehozás gombra.
A kiadási folyamat előrehaladásának megtekintéséhez kattintson a legújabb kiadás nevére a kiadások listájában.
A Szakaszok párbeszédpanelen kattintson az 1. szakasz, majd a Naplók elemre.