Ciągła integracja i ciągłe dostarczanie w usłudze Azure Databricks przy użyciu usługi Azure DevOps

Uwaga / Notatka

W tym artykule opisano usługę Azure DevOps, która jest opracowywana przez inną firmę. Aby skontaktować się z dostawcą, zobacz Pomoc techniczna usługi Azure DevOps Services.

Ten artykuł przeprowadzi Cię przez proces konfigurowania automatyzacji usługi Azure DevOps dla kodu i artefaktów, które współpracują z usługą Azure Databricks. W szczególności skonfigurujesz przepływ pracy ciągłej integracji i dostarczania (CI/CD) w celu nawiązania połączenia z repozytorium Git, uruchomisz zadania przy użyciu usługi Azure Pipelines w celu skompilowania i przetestowania jednostkowego koła języka Python (*.whl) i wdrożysz go do użycia w notesach usługi Databricks.

Przepływ pracy CI/CD (ciągła integracja/ciągłe dostarczanie)

Usługa Databricks sugeruje następujący przepływ pracy dla programistów tworzących rozwiązania CI/CD wraz z usługą Azure DevOps:

Utwórz repozytorium lub użyj istniejącego repozytorium z zewnętrznym dostawcą Git.
Połącz lokalną maszynę programową z tym samym repozytorium innej firmy. Aby uzyskać instrukcje, sprawdź dokumentację zewnętrznego dostawcy Git.
Pobierz wszystkie istniejące zaktualizowane artefakty (takie jak notesy, pliki kodu i skrypty kompilacji) na lokalną maszynę deweloperską z zewnętrznego repozytorium.
W razie potrzeby utwórz, zaktualizuj i przetestuj artefakty na lokalnej maszynie dewelopera. Następnie wypchnij wszystkie nowe i zmienione artefakty z lokalnej maszyny rozwoju do repozytorium zewnętrznego dostawcy. Aby uzyskać instrukcje, sprawdź dokumentację zewnętrznego dostawcy Git.
Powtórz kroki 3 i 4 zgodnie z potrzebami.
Użyj usługi Azure DevOps okresowo jako zintegrowanego podejścia do automatycznego ściągania artefaktów z repozytorium innej firmy, tworzenia, testowania i uruchamiania kodu w obszarze roboczym usługi Azure Databricks oraz raportowania wyników testu i uruchamiania. Chociaż można uruchomić usługę Azure DevOps ręcznie, w rzeczywistych implementacjach należy poinstruować dostawcę usługi Git innej firmy, aby uruchamiał usługę Azure DevOps za każdym razem, gdy wystąpi określone zdarzenie, takie jak żądanie ściągnięcia repozytorium.

Istnieje wiele narzędzi CI/CD, których można użyć do zarządzania i wykonywania pipeline. W tym artykule pokazano, jak używać usługi Azure DevOps. CI/CD jako wzorzec projektowy oznacza, że kroki i etapy opisane w przykładzie w tym artykule powinny być zastosowane z kilkoma zmianami w języku definiującym potoki w każdym z narzędzi. Ponadto większość kodu w tym przykładowym potoku to standardowy kod języka Python, który można wywołać w innych narzędziach.

Wskazówka

Aby uzyskać informacje o korzystaniu z Jenkins z Azure Databricks zamiast Azure DevOps, zobacz CI/CD z Jenkins na Azure Databricks.

W pozostałej części tego artykułu opisano parę przykładowych potoków w usłudze Azure DevOps, które można dostosować do własnych potrzeb usługi Azure Databricks.

Informacje o przykładzie

W tym artykule użyto dwóch potoków do zbierania, wdrażania i uruchamiania przykładowego kodu języka Python oraz notesów języka Python przechowywanych w zdalnym repozytorium Git.

Pierwszy potok, znany jako potok kompilacji, przygotowuje artefakty kompilacji dla drugiego potoku, znanego jako potok wydania. Oddzielenie potoku kompilacji z potoku wydania umożliwia utworzenie artefaktu kompilacji bez wdrażania go lub jednoczesnego wdrażania artefaktów z wielu kompilacji. Aby utworzyć ciągi kompilacji i wydania:

Utwórz maszynę wirtualną platformy Azure dla pipeline budowania.
Skopiuj pliki z repozytorium Git do maszyny wirtualnej.
Utwórz skompresowany gzipem plik tar zawierający kod w Pythonie, notebooki w Pythonie oraz powiązane pliki ustawień dotyczących kompilacji, wdrażania i uruchamiania.
Skopiuj spakowany do formatu gzip plik tar jako plik zip do lokalizacji dostępnej dla potoku wydawniczego.
Utwórz kolejną maszynę wirtualną Azure na potrzeby procesu wdrażania.
Pobierz plik zip z lokalizacji potoku kompilacji, a następnie rozpakuj go, aby uzyskać kod Python, notatniki oraz powiązane pliki ustawień kompilacji, wdrożenia i uruchamiania.
Wdróż kod języka Python, notesy języka Python oraz powiązane pliki kompilacji, wdrażania i uruchamiania ustawień w zdalnym obszarze roboczym usługi Azure Databricks.
Skompiluj pliki kodu składników biblioteki wheel języka Python w pliku wheel języka Python.
Uruchom testy jednostkowe w kodzie składnika, aby sprawdzić logikę w pliku wheel języka Python.
Uruchom notatniki języka Python, z których jeden wywołuje funkcjonalność pliku wheel Python.

Informacje o interfejsie wiersza polecenia usługi Databricks

Ten przykład w tym artykule pokazuje, jak używać Databricks CLI w trybie nieinterakcyjnym w potoku. W obszarze roboczym usługi Azure Databricks przykładowy pipeline z tego artykułu wdraża kod, kompiluje bibliotekę i uruchamia notatniki.

Jeśli korzystasz z Databricks CLI w swoim pipeline bez implementowania przykładowego kodu, biblioteki i notesów z tego artykułu, wykonaj następujące kroki:

Przygotuj obszar roboczy usługi Azure Databricks do używania uwierzytelniania maszyny do maszyny OAuth (M2M) na potrzeby uwierzytelniania jednostki usługi. Przed rozpoczęciem upewnij się, że masz jednostkę usługi Microsoft Entra ID z tajnym wpisem OAuth dla usługi Azure Databricks. Zobacz Autoryzowanie dostępu jednostki usługi do usługi Azure Databricks przy użyciu protokołu OAuth.
Zainstaluj CLI Databricks w pliku ciągu. W tym celu dodaj zadanie o nazwie Bash Script do potoku, które uruchamia następujący skrypt:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
```
Aby dodać zadanie skryptu Bash do potoku, zobacz Krok 3.6. Zainstaluj interfejs wiersza polecenia Databricks i narzędzia do budowy pakietów Pythona (Python wheel build tools).
Skonfiguruj pipeline, aby zainstalowany interfejs wiersza poleceń Databricks mógł uwierzytelniać jednostkę usługi w obszarze roboczym. Aby to zrobić, zobacz Krok 3.1: Definiowanie zmiennych środowiskowych dla potoku wydania.
Dodaj więcej zadań skryptowych Bash do pipeline'u zgodnie z potrzebami, aby uruchamiać polecenia CLI Databricks. Zobacz Polecenia CLI Databricks.

Zanim rozpoczniesz

Aby użyć przykładu tego artykułu, musisz mieć następujące elementy:

Istniejący projekt usługi Azure DevOps . Jeśli nie masz jeszcze projektu, utwórz projekt w usłudze Azure DevOps.
Istniejące repozytorium u dostawcy Git obsługiwane przez Azure DevOps. Do tego repozytorium dodasz przykładowy kod języka Python, przykładowy notes języka Python i powiązane pliki ustawień wydania. Jeśli nie masz jeszcze repozytorium, utwórz je, postępując zgodnie z instrukcjami dostawcy usługi Git. Następnie połącz projekt usługi Azure DevOps z tym repozytorium, jeśli jeszcze tego nie zrobiono. Aby uzyskać instrukcje, postępuj zgodnie z linkami w temacie Obsługiwane repozytoria źródłowe.
W tym artykule przykład wykorzystuje uwierzytelnianie OAuth machine-to-machine (M2M) do uwierzytelniania jednostki usługi Microsoft Entra ID w obszarze roboczym Azure Databricks. Musisz mieć główny obiekt usługi Microsoft Entra ID z tajnym kluczem OAuth dla tej jednostki usługi Azure Databricks. Zobacz Autoryzowanie dostępu jednostki usługi do usługi Azure Databricks przy użyciu protokołu OAuth.

Krok 1. Dodawanie plików przykładu do repozytorium

W tym kroku, w repozytorium z zewnętrznym dostawcą Git, dodajesz wszystkie przykładowe pliki z tego artykułu, które potoki Azure DevOps kompilują, wdrażają i uruchamiają w zdalnym obszarze roboczym Azure Databricks.

Krok 1.1. Dodawanie plików składników wheel języka Python

W tym przykładzie potoki usługi Azure DevOps kompilują i testują jednostkowy plik koła języka Python. Następnie notes usługi Azure Databricks wywołuje funkcjonalność zbudowanego pakietu wheel języka Python.

Aby zdefiniować logikę i testy jednostkowe dla pliku wheel języka Python, względem którego działają notatniki, w katalogu głównym repozytorium utwórz dwa pliki o nazwach addcol.py i test_addcol.py, a następnie dodaj je do struktury folderów o nazwie python/dabdemo/dabdemo w folderze Libraries, zwizualizowane w następujący sposób:

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

Plik addcol.py zawiera funkcję biblioteki, która jest następnie budowana w plik typu wheel języka Python i instalowana w klastrach Azure Databricks. Jest to prosta funkcja, która dodaje nową kolumnę wypełniną literałem do ramki danych platformy Apache Spark:

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

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

Plik test_addcol.py zawiera testy, które umożliwiają przekazanie pozornego obiektu ramki danych do funkcji with_status, zdefiniowanej w pliku addcol.py. Wynik jest następnie porównywany z obiektem DataFrame zawierającym oczekiwane wartości. Jeśli wartości są zgodne, test zakończy się pomyślnie:

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

Aby umożliwić interfejsowi wiersza polecenia usługi Databricks poprawne spakowanie tego kodu biblioteki do pliku koła języka Python, utwórz dwa pliki o nazwie __init__.py i __main__.py w tym samym folderze co poprzednie dwa pliki. Ponadto utwórz plik o nazwie setup.py w folderze python/dabdemo, przedstawionym w następujący sposób:

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

Plik __init__.py zawiera numer wersji biblioteki i jego autora. Zastąp <my-author-name> swoim imieniem:

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

import sys, os

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

Plik __main__.py zawiera punkt wejścia biblioteki:

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

Plik setup.py zawiera dodatkowe ustawienia do budowania biblioteki jako pliku wheel w języku Python. Zastąp <my-url>, <my-author-name>@<my-organization> i <my-package-description> prawidłowymi wartościami.

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

Krok 1.2: Dodaj notatnik testowania jednostkowego dla pliku wheel Pythona

Później interfejs wiersza polecenia Databricks uruchamia zadanie notebooka. To zadanie uruchamia notes języka Python z nazwą pliku run_unit_tests.py. Ten notatnik uruchamia pytest na logice biblioteki wheel dla języka Python.

Aby uruchomić testy jednostkowe dla przykładu z tego artykułu, do katalogu głównego repozytorium dodaj plik notebook o nazwie run_unit_tests.py z następującą zawartością:

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

Krok 1.3. Dodaj notatnik, który wywołuje plik wheel Pythona.

Później CLI Databricks uruchamia kolejne zadanie z notatnikiem. Ten notatnik tworzy obiekt DataFrame, przekazuje go do funkcji biblioteki koła Python, wyświetla wynik i raportuje wyniki uruchomienia zadania. Utwórz w katalogu głównym repozytorium plik notebooka o nazwie dabdemo_notebook.py z następującą zawartością:

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

Krok 1.4. Tworzenie konfiguracji pakietu

W tym przykładzie użyto pakietów zasobów usługi Databricks do zdefiniowania ustawień i zachowań związanych z kompilowaniem, wdrażaniem i uruchamianiem pliku wheel języka Python, dwoma notesami i plikiem kodu języka Python. Pakiety zasobów usługi Databricks, znane po prostu jako pakiety, umożliwiają wyrażanie pełnych danych, analiz i projektów uczenia maszynowego jako kolekcji plików źródłowych. Zobacz Co to są pakiety zasobów Databricks?.

Aby skonfigurować pakiet dla przykładu tego artykułu, utwórz w katalogu głównym repozytorium plik o nazwie databricks.yml. W tym przykładowym pliku databricks.yml zastąp następujące elementy zastępcze:

Zastąp <bundle-name> unikatową nazwą programową pakietu. Na przykład azure-devops-demo.
Zastąp <job-prefix-name> ciągiem znaków, aby ułatwić jednoznaczną identyfikację zadań utworzonych w obszarze roboczym usługi Azure Databricks w tym przykładzie. Na przykład azure-devops-demo.
Zastąp element <spark-version-id> identyfikatorem wersji środowiska Databricks Runtime dla klastrów zadań, na przykład 13.3.x-scala2.12.
Zastąp <cluster-node-type-id> identyfikatorem typu węzła klastra dla klastrów roboczych, na przykład Standard_DS3_v2.
Zwróć uwagę, że dev w kontekście mapowania targets określa hosta i powiązane zachowania wdrożeniowe. W rzeczywistych implementacjach możesz nadać temu celowi inną nazwę we własnych pakietach.

Oto zawartość pliku tego przykładu databricks.yml :

# 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

Aby uzyskać więcej informacji na temat składni pliku databricks.yml, zapoznaj się z konfiguracją pakietu zasobów usługi Databricks.

Krok 2. Definiowanie potoku kompilacji

Usługa Azure DevOps udostępnia interfejs użytkownika hostowany w chmurze do definiowania etapów potoku ciągłej integracji (CI) i ciągłego wdrażania (CD) przy użyciu języka YAML. Aby uzyskać więcej informacji na temat usługi Azure DevOps i potoków, zobacz dokumentację usługi Azure DevOps.

W tym kroku użyjesz składni YAML do zdefiniowania pipeline kompilacji, który buduje artefakt wdrożeniowy. Aby wdrożyć kod w obszarze roboczym usługi Azure Databricks, należy określić artefakt kompilacji tego potoku jako dane wejściowe do pipeline'u wydawniczego. Ten pipeline wydania zostanie zdefiniowany później.

Aby uruchamiać potoki kompilacji, Azure DevOps udostępnia agentów realizacji hostowanych w chmurze na żądanie, którzy obsługują wdrożenia na platformie Kubernetes, maszynach wirtualnych, usłudze Azure Functions, usłudze Azure Web Apps oraz wielu innych celach. W tym przykładzie używasz agenta na żądanie, aby zautomatyzować budowanie artefaktu wdrożeniowego.

Zdefiniuj przykładowy potok tworzenia tego artykułu w sposób następujący:

Zaloguj się do usługi Azure DevOps , a następnie kliknij link Zaloguj, aby otworzyć projekt usługi Azure DevOps.

Uwaga / Notatka

Jeśli zamiast projektu Azure DevOps wyświetli się Portal Azure, kliknij Więcej usług > Organizacje Azure DevOps > Moje organizacje Azure DevOps, a następnie otwórz swój projekt Azure DevOps.
Kliknij pozycję Potoki na pasku bocznym, a następnie kliknij pozycję Potoki w menu Potoki .
Kliknij przycisk Nowy potok i postępuj zgodnie z instrukcjami wyświetlanymi na ekranie. (Jeśli masz już potoki, kliknij przycisk Zamiast tego utwórz potok ). Na końcu tych instrukcji zostanie otwarty edytor potoku. W tym miejscu zdefiniujesz skrypt potoku kompilacji w pliku azure-pipelines.yml wyświetlonym. Jeśli edytor potoku nie jest widoczny pod koniec instrukcji, należy wybrać nazwę potoku kompilacji, a następnie kliknąć przycisk Edytuj.

Możesz użyć , aby dostosować proces kompilacji dla każdej gałęzi w repozytorium Git. Najlepszą praktyką w CI/CD jest unikanie wykonywania pracy produkcyjnej bezpośrednio w gałęzi main repozytorium. W tym przykładzie założono, że gałąź o nazwie release istnieje w repozytorium, które ma być używane zamiast main.

Skrypt azure-pipelines.yml potoku kompilacji jest domyślnie przechowywany w katalogu głównym zdalnego repozytorium Git skojarzonego z potokiem.

Zastąp zawartość początkową pliku potoku azure-pipelines.yml następującą definicją, a następnie kliknij przycisk Zapisz.

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

Krok 3: Zdefiniuj potok wydania

Ścieżka wydania wdraża wyniki kompilacji z procesu kompilacji do środowiska usługi Azure Databricks. Oddzielenie procesu wydania w tym kroku od potoku kompilacji we wcześniejszych krokach umożliwia utworzenie kompilacji bez jej wdrożenia lub wdrożenie artefaktów z wielu kompilacji jednocześnie.

W projekcie usługi Azure DevOps w menu Potoki na pasku bocznym kliknij pozycję Wydania.
Kliknij pozycję Nowy > Nowy potok wydawniczy. (Jeśli masz już potoki, kliknij przycisk Zamiast tego nowy potok ).
Po stronie ekranu znajduje się lista polecanych szablonów dla typowych wzorców wdrażania. Na potrzeby tego przykładowego potoku wydania kliknij pozycję .
W polu Artefakty po stronie ekranu kliknij pozycję . W okienku Dodawanie artefaktu w polu Źródło (potok kompilacji) wybierz utworzony wcześniej potok kompilacji. Następnie kliknij pozycję Dodaj.
Możesz skonfigurować sposób wyzwalania potoku, klikając , aby wyświetlić opcje wyzwalania z boku ekranu. Jeśli chcesz, aby wydanie zostało zainicjowane automatycznie w oparciu o dostępność artefaktu kompilacji lub po zakończeniu procesu pull request, włącz odpowiedni wyzwalacz. W tym przykładzie, na razie, w ostatnim kroku tego artykułu ręcznie wyzwolisz potok kompilacji, a następnie potok wydania.
Kliknij Zapisz > OK.

Krok 3.1: Zdefiniuj zmienne środowiskowe dla potoku wydania

Potok wydania tego przykładu opiera się na następujących zmiennych środowiskowych, które można dodać, klikając pozycję Dodaj w sekcji Zmienne potoku na karcie Zmienne z zakresemetapu 1:

BUNDLE_TARGET, który powinien być zgodny z nazwą target w pliku databricks.yml. W tym przykładzie tego artykułu jest to dev.
DATABRICKS_HOST, który reprezentuje adres URL dla każdego obszaru roboczego w usłudze Azure Databricks, zaczynając od https://, na przykład https://adb-<workspace-id>.<random-number>.azuredatabricks.net. Nie dołączaj końcowego ciągu / po .net.
DATABRICKS_CLIENT_ID, który reprezentuje identyfikator aplikacji dla jednostki usługi Microsoft Entra ID.
DATABRICKS_CLIENT_SECRET, który reprezentuje tajne dane OAuth dla usługi Azure Databricks jako jednostki usługi Microsoft Entra ID.

Krok 3.2. Konfigurowanie agenta wydania dla pipeline'u wydania

Kliknij łącze 1 praca, 0 zadań w obiekcie Etap 1.
Na karcie Zadania kliknij pozycję Zadanie agenta.
W sekcji Wybór agenta w polu Pula agentów wybierz pozycję Azure Pipelines.
W obszarze Specyfikacja agenta wybierz tego samego agenta, który został wcześniej określony dla agenta kompilacji, w tym przykładzie ubuntu-22.04.
Kliknij Zapisz > OK.

Krok 3.3. Ustawianie wersji języka Python dla agenta wydania

Kliknij znak plus w sekcji Zadanie agenta wskazywane przez czerwoną strzałkę na poniższej ilustracji. Zostanie wyświetlona lista dostępnych zadań z możliwością wyszukiwania. Istnieje również karta Marketplace dla wtyczek innych firm, które mogą służyć do uzupełnienia standardowych zadań usługi Azure DevOps. W kolejnych krokach dodasz kilka zadań agentowi wydania.
Pierwszym dodanym zadaniem jest użycie wersji języka Python znajdującej się na karcie Narzędzie . Jeśli nie możesz odnaleźć tego zadania, użyj pola Wyszukiwania , aby go wyszukać. Po znalezieniu wybierz go, a następnie kliknij przycisk Dodaj obok zadania Użyj wersji języka Python.
Podobnie jak w przypadku potoku kompilacji, chcesz upewnić się, że wersja języka Python jest zgodna ze skryptami wywoływanymi w kolejnych zadaniach. W takim przypadku kliknij zadanie Użyj języka Python 3.x obok pozycji Zadanie agenta, a następnie ustaw opcję Specyfikacja wersji na 3.10. Ustaw również wyświetlaną nazwę na Use Python 3.10. Założono, że w tej ścieżce używasz Databricks Runtime 13.3 LTS na klastrach, które mają zainstalowany Python 3.10.12.
Kliknij Zapisz > OK.

Krok 3.4. Rozpakowywanie artefaktu kompilacji z ciągu kompilacji

Następnie każ agentowi wydania, aby wyodrębnił plik wheel języka Python, powiązane pliki konfiguracyjne wydania, notebooki i plik kodu w Pythonie z pliku zip, używając zadania Wyodrębnij pliki: kliknij znak plusa w sekcji Zadanie agenta, wybierz zadanie Wyodrębnij pliki na karcie Narzędzie, a następnie kliknij przycisk Dodaj.
Kliknij zadanie Wyodrębnij pliki obok Zadanie agenta, ustaw Wzorce plików archiwum na **/*.zip, a następnie ustaw folder docelowy na zmienną systemową $(Release.PrimaryArtifactSourceAlias)/Databricks. Ustaw również wyświetlaną nazwę na Extract build pipeline artifact.

Uwaga / Notatka

$(Release.PrimaryArtifactSourceAlias) reprezentuje alias wygenerowany przez usługę Azure DevOps, aby zidentyfikować podstawową lokalizację źródła artefaktu na agencie wydania, na przykład _<your-github-alias>.<your-github-repo-name>. Potok wydania ustawia tę wartość jako zmienną środowiskową RELEASE_PRIMARYARTIFACTSOURCEALIAS w fazie inicjowania zadania agenta wydania. Zobacz zmienne wersji klasycznej i artefaktów.
Ustaw Nazwa wyświetlana na Extract build pipeline artifact.
Kliknij Zapisz > OK.

Krok 3.5. Ustawianie zmiennej środowiskowej BUNDLE_ROOT

Aby przykład tego artykułu działał zgodnie z oczekiwaniami, należy ustawić zmienną środowiskową o nazwie BUNDLE_ROOT w potoku wydania. Pakiety zasobów usługi Databricks używają tej zmiennej środowiskowej do określenia lokalizacji databricks.yml pliku. Aby ustawić tę zmienną środowiskową:

Użyj zadania Zmienne środowiskowe: kliknij ponownie znak plus w sekcji Zadanie agenta, wybierz zadanie Zmienne środowiskowe na karcie Narzędzie, a następnie kliknij przycisk Dodaj.

Uwaga / Notatka

Jeśli zadanie Zmienne środowiskowe nie jest widoczne na karcie Narzędzie, wprowadź w Environment Variablespolu Wyszukiwania i postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby dodać zadanie do karty Narzędzie. Może to wymagać opuszczenia usługi Azure DevOps, a następnie powrotu do tej lokalizacji, w której została przerwana.
W polu Zmienne środowiskowe (rozdzielone przecinkami) wprowadź następującą definicję: BUNDLE_ROOT=$(Agent.ReleaseDirectory)/$(Release.PrimaryArtifactSourceAlias)/Databricks.

Uwaga / Notatka

$(Agent.ReleaseDirectory) reprezentuje alias wygenerowany przez usługę Azure DevOps w celu zidentyfikowania lokalizacji katalogu wydania na agencie wydania, na przykład /home/vsts/work/r1/a. Potok wydania ustawia tę wartość jako zmienną środowiskową AGENT_RELEASEDIRECTORY w fazie inicjowania zadania agenta wydania. Zobacz zmienne wersji klasycznej i artefaktów. Aby uzyskać informacje o $(Release.PrimaryArtifactSourceAlias), zobacz notatkę w poprzednim kroku.
Ustaw Nazwa wyświetlana na Set BUNDLE_ROOT environment variable.
Kliknij Zapisz > OK.

Krok 3.6. Instalowanie interfejsu wiersza polecenia usługi Databricks i narzędzi kompilacji koła języka Python

Następnie zainstaluj interfejs wiersza polecenia Databricks i narzędzia do budowania pakietów Python wheel na agencie wydania. Agent wydania wywoła Databricks CLI oraz narzędzia do budowy wheel w języku Python w kilku następnych zadaniach. W tym celu użyj zadania Bash: kliknij ponownie znak plus w sekcji Agent job, wybierz zadanie Bash na karcie Narzędzia, a następnie kliknij przycisk Dodaj.
Kliknij zadanie skryptu Bash obok zadania agenta.
W polu Typ wybierz opcję Wbudowany.
Zastąp zawartość skryptu następującym poleceniem, które instaluje interfejs wiersza polecenia usługi Databricks i narzędzia kompilacji koła języka Python:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
pip install wheel
```
Ustaw Nazwa wyświetlana na Install Databricks CLI and Python wheel build tools.
Kliknij Zapisz > OK.

Krok 3.7. Weryfikowanie pakietu zasobów usługi Databricks

W tym kroku upewnij się, że databricks.yml plik jest syntaktycznie poprawny.

Użyj zadania Bash: kliknij ponownie znak plus w sekcji Zadań agenta, wybierz zadanie Bash na karcie Narzędzie, a następnie kliknij przycisk Dodaj.
Kliknij zadanie skryptu Bash obok zadania agenta.
W polu Typ wybierz opcję Wbudowany.
Zastąp zawartość skryptu następującym poleceniem, które używa interfejsu wiersza polecenia usługi Databricks, aby sprawdzić, czy databricks.yml plik jest składniowo poprawny:
```
databricks bundle validate -t $(BUNDLE_TARGET)
```
Ustaw Nazwa wyświetlana na Validate bundle.
Kliknij Zapisz > OK.

Krok 3.8. Wdrażanie pakietu

W tym kroku utworzysz plik wheel języka Python i wdrożysz utworzony plik wheel języka Python, dwa notatniki języka Python oraz plik języka Python z potoku wydawniczego do obszaru roboczego usługi Azure Databricks.

Użyj zadania Bash: kliknij ponownie znak plus w sekcji Zadań agenta, wybierz zadanie Bash na karcie Narzędzie, a następnie kliknij przycisk Dodaj.
Kliknij zadanie skryptu Bash obok zadania agenta.
W polu Typ wybierz opcję Wbudowany.
Zastąp zawartość Script następującym poleceniem, które wykorzystuje interfejs wiersza polecenia usługi Databricks do zbudowania pliku wheel Python i wdrożenia przykładowych plików z tego artykułu z potoku wydania do Twojego obszaru roboczego usługi Azure Databricks:
```
databricks bundle deploy -t $(BUNDLE_TARGET)
```
Ustaw Nazwa wyświetlana na Deploy bundle.
Kliknij Zapisz > OK.

Krok 3.9: Uruchamianie notatnika testów jednostkowych dla pakietu Python wheel

W tym kroku uruchomisz zadanie uruchamiające notes testu jednostkowego w obszarze roboczym usługi Azure Databricks. Ten notatnik uruchamia testy jednostkowe na logikę biblioteki Python wheel.

Użyj zadania Bash: kliknij ponownie znak plus w sekcji Zadań agenta, wybierz zadanie Bash na karcie Narzędzie, a następnie kliknij przycisk Dodaj.
Kliknij zadanie skryptu Bash obok zadania agenta.
W polu Typ wybierz opcję Wbudowany.
Zastąp zawartość skryptu następującym poleceniem, które używa interfejsu wiersza polecenia usługi Databricks do uruchomienia zadania w obszarze roboczym usługi Azure Databricks:
```
databricks bundle run -t $(BUNDLE_TARGET) run-unit-tests
```
Ustaw Nazwa wyświetlana na Run unit tests.
Kliknij Zapisz > OK.

Krok 3.10. Uruchamianie notesu wywołującego koło języka Python

W tym kroku uruchomisz zadanie, które uruchamia inny notatnik w obszarze roboczym usługi Azure Databricks. Ten notebook korzysta z biblioteki wheel dla Pythona.

Użyj zadania Bash: kliknij ponownie znak plus w sekcji Zadań agenta, wybierz zadanie Bash na karcie Narzędzie, a następnie kliknij przycisk Dodaj.
Kliknij zadanie skryptu Bash obok zadania agenta.
W polu Typ wybierz opcję Wbudowany.
Zastąp zawartość skryptu następującym poleceniem, które używa interfejsu wiersza polecenia usługi Databricks do uruchomienia zadania w obszarze roboczym usługi Azure Databricks:
```
databricks bundle run -t $(BUNDLE_TARGET) run-dabdemo-notebook
```
Ustaw Nazwa wyświetlana na Run notebook.
Kliknij Zapisz > OK.

Ukończyłeś teraz konfigurację potoku wydania. Powinna wyglądać następująco:

Zakończona konfiguracja potoku wydania usługi Azure DevOps

Krok 4. Uruchamianie potoków kompilacji i wydania

W tym kroku uruchamiasz potoki ręcznie. Aby dowiedzieć się, jak uruchamiać potoki automatycznie, zobacz Określanie zdarzeń wyzwalających potoki i Wyzwalacze wydania.

Aby ręcznie uruchomić potok kompilacji:

W menu Potoki na pasku bocznym kliknij pozycję Potoki.
Kliknij nazwę potoku kompilacji, a następnie kliknij pozycję Uruchom potok.
W polu Gałąź/tag wybierz nazwę gałęzi w repozytorium Git, która zawiera cały dodany kod źródłowy. W tym przykładzie przyjęto założenie, że znajduje się on w release gałęzi .
Kliknij przycisk Uruchom. Zostanie wyświetlona strona uruchamiania potoku kompilacji.
Aby wyświetlić postęp potoku kompilacji i wyświetlić powiązane dzienniki, kliknij ikonę wirowania obok pozycji Zadanie.
Gdy ikona Zadania zmieni się na zielony ptaszek, przejdź do uruchomienia pipeline'u wdrożeniowego.

Aby ręcznie uruchomić potok wydania:

Po pomyślnym uruchomieniu potoku kompilacji kliknij pozycję Wydania w menu Potok na pasku bocznym.
Kliknij nazwę pipeline'u publikacji, a następnie kliknij Utwórz wydanie.
Kliknij pozycję Utwórz.
Aby wyświetlić postęp potoku wydania, na liście wydań kliknij nazwę najnowszej wersji.
W polu Etapy kliknij pozycję Etap 1, a następnie kliknij pozycję Dzienniki.

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-10-03