Dela via

Paketkonfiguration i Python

Viktigt!

Python-stöd för Databricks-tillgångspaket finns i offentlig förhandsversion.

Python for Databricks Asset Bundles utökar Databricks-tillgångspaket så att du kan:

Referensdokumentation för Python-stöd för Databricks Asset Bundles databricks-bundles-paket finns på https://databricks.github.io/cli/experimental/python/.

Krav

Om du vill använda Python-stöd för Databricks-tillgångspaket måste du först:

  1. Installera Databricks CLI, version 0.248.0 eller senare. Se Installera eller uppdatera Databricks CLI-.

  2. Autentisera till databricks-arbetsytan om du inte redan har gjort det:

    databricks configure

  3. Installera uv. Se Installera uv. Python for Databricks Asset Bundles använder uv för att skapa en virtuell miljö och installera nödvändiga beroenden. Du kan också konfigurera Python-miljön med hjälp av andra verktyg, till exempel venv.

Skapa ett projekt från mallen

Om du vill skapa ett nytt Python-stöd för Databricks Asset Bundles-projektet initierar du ett paket med hjälp av mallen experimental-jobs-as-code :

databricks bundle init experimental-jobs-as-code

När du uppmanas att ge projektet ett namn, till exempel my_jobs_as_code_project, och acceptera att inkludera en notebook-fil och ett Python-paket.

Skapa nu en ny virtuell miljö i den nya projektmappen:

cd my_jobs_as_code_project
uv sync

Som standard innehåller mallen ett exempel på ett jobb som definierats som Python i resources/my_jobs_as_code_project_job.py filen:

from databricks.bundles.jobs import Job


my_jobs_as_code_project_job = Job.from_dict(
    {
        "name": "my_jobs_as_code_project_job",
        "tasks": [
            {
                "task_key": "notebook_task",
                "notebook_task": {
                    "notebook_path": "src/notebook.ipynb",
                },
            },
        ],
    },
)

Funktionen Job.from_dict accepterar en Python-ordlista med samma format som YAML. Jobb kan också konstrueras med hjälp av dataklasssyntax:

from databricks.bundles.jobs import Job, Task, NotebookTask


my_jobs_as_code_project_job = Job(
    name="my_jobs_as_code_project_job",
    tasks=[
        Task(
            task_key="notebook_task",
            notebook_task=NotebookTask(
                notebook_path="src/notebook.ipynb",
            ),
        ),
    ],
)

Python-filer läses in via en startpunkt som anges i experimental avsnittet i databricks.yml:

experimental:
  python:
    # Activate the virtual environment before loading resources defined in
    # Python. If disabled, it defaults to using the Python interpreter
    # available in the current shell.
    venv_path: .venv
    # Functions called to load resources defined in Python.
    # See resources/__init__.py
    resources:
      - 'resources:load_resources'

Som standard resources/__init__.py innehåller en funktion som läser in alla Python-filer i resurspaketet.

from databricks.bundles.core import (
    Bundle,
    Resources,
    load_resources_from_current_package_module,
)


def load_resources(bundle: Bundle) -> Resources:
    """
    'load_resources' function is referenced in databricks.yml and is responsible for loading
    bundle resources defined in Python code. This function is called by Databricks CLI during
    bundle deployment. After deployment, this function is not used.
    """

    # the default implementation loads all Python files in 'resources' directory
    return load_resources_from_current_package_module()

Fördela och kör arbetsuppgifter eller pipelines

Om du vill distribuera paketet till utvecklingsmål använder du kommandot bundle deploy från paketprojektets rot:

databricks bundle deploy --target dev

Det här kommandot distribuerar allt som definierats för paketprojektet. Ett projekt som skapats med standardmallen distribuerar till exempel ett jobb som heter [dev yourname] my_jobs_as_code_project_job till din arbetsyta. Du hittar jobbet genom att navigera till Jobb och pipelines i Databricks-arbetsytan.

När paketet har distribuerats kan du använda samlingssammanfattningskommandot för att granska allt som har distribuerats:

databricks bundle summary --target dev

Om du vill köra ett jobb eller en pipeline använder du slutligen kommandot bundle run:

databricks bundle run my_jobs_as_code_project_job

Uppdatera befintliga paket

Om du vill uppdatera befintliga paket modellerar du projektmallsstrukturen enligt beskrivningen i Skapa ett projekt från en mall. Befintliga paket med YAML kan uppdateras så att de innehåller jobb eller pipelines som definierats som Python-kod genom att lägga till ett experimental.python avsnitt i databricks.yml:

experimental:
  python:
    # Activate the virtual environment before loading resources defined in
    # Python. If disabled, it defaults to using the Python interpreter
    # available in the current shell.
    venv_path: .venv
    # Functions called to load resources defined in Python.
    # See resources/__init__.py
    resources:
      - 'resources:load_resources'

Den angivna virtuella miljön måste innehålla det installerade PyPi-paketet databricks-bundles .

pip install databricks-bundles==0.248.0

Resursmappen måste innehålla __init__.py filen:

from databricks.bundles.core import (
    Bundle,
    Resources,
    load_resources_from_current_package_module,
)


def load_resources(bundle: Bundle) -> Resources:
    """
    'load_resources' function is referenced in databricks.yml and
    is responsible for loading bundle resources defined in Python code.
    This function is called by Databricks CLI during bundle deployment.
    After deployment, this function is not used.
    """

    # default implementation loads all Python files in 'resources' folder
    return load_resources_from_current_package_module()

Konvertera befintliga jobb till Python

Om du vill konvertera befintliga jobb till Python kan du använda funktionen Visa som kod . Se även Visa jobb som kod.

  1. Öppna en jobbsida i Databricks-arbetsflöden.
  2. Klicka på kebaben till vänster om knappen Kör nu och klicka sedan på Visa som kod:

Visa som kodmenyobjekt

  1. Välj Python och sedan Databricks-tillgångspaket

Visa som kod, Python

  1. Klicka på Kopiera och spara den genererade Python som en Python-fil i resursmappen för paketprojektet.

Tips/Råd

Du kan också visa och kopiera YAML för befintliga jobb och pipelines som du kan klistra in direkt i YAML-filer för paketkonfiguration.

Skapa resurser med metadata

Standardimplementeringen av load_resources funktionen läser in Python-filer i resources paketet. Du kan använda Python för att skapa resurser programmatiskt. Du kan till exempel läsa in konfigurationsfiler och skapa jobb i en loop:

from databricks.bundles.core import (
    Bundle,
    Resources,
    load_resources_from_current_package_module,
)


from databricks.bundles.jobs import Job


def create_job(country: str):
    my_notebook = {
        "task_key": "my_notebook",
        "notebook_task": {
            "notebook_path": "files/my_notebook.py",
        },
    }


    return Job.from_dict(
        {
            "name": f"my_job_{country}",
            "tasks": [my_notebook],
        }
    )


def load_resources(bundle: Bundle) -> Resources:
    resources = load_resources_from_current_package_module()


    for country in ["US", "NL"]:
        resources.add_resource(f"my_job_{country}", create_job(country))


    return resources

Åtkomstpaketvariabler

Parametern bundle kan användas för att komma åt paketvariabler och distributionsmålet:

from databricks.bundles.core import Bundle, Resources, Variable, variables

@variables
class Variables:
    warehouse_id: Variable[str]


def load_resources(bundle: Bundle) -> Resources:
    warehouse_id = bundle.resolve_variable(Variables.warehouse_id)

    ...

Mer information finns i klassreferensen Resources och Bundle.

Ändra jobb som definierats i YAML eller Python

Du kan referera till jobbmutatorfunktioner i databricks.yml, liknande funktioner där resurser laddas. Den här funktionen kan användas oberoende av inläsning av jobb som definierats i Python och muterar resurser som definierats i både YAML och Python.

Skapa först mutators.py i paketets rot med följande innehåll:

from dataclasses import replace


from databricks.bundles.core import Bundle, job_mutator
from databricks.bundles.jobs import Job, JobEmailNotifications


@job_mutator
def add_email_notifications(bundle: Bundle, job: Job) -> Job:
    if job.email_notifications:
        return job


    email_notifications = JobEmailNotifications.from_dict(
        {
            "on_failure": ["${workspace.current_user.userName}"],
        }
    )


    return replace(job, email_notifications=email_notifications)

Använd nu följande konfiguration för att köra add_email_notifications funktionen under paketdistributionen. Detta uppdaterar varje jobb som definierats i paketet med e-postmeddelanden om de är frånvarande. Mutatorfunktioner måste anges i databricks.ymloch körs i den angivna ordningen. Jobbmutatorer körs för varje jobb som definieras i ett paket och kan antingen returnera en uppdaterad kopia eller oförändrade indata. Mutatorer kan också användas för andra fält, till exempel att konfigurera standardjobbkluster eller SQL-lager.

experimental:
  python:
    mutators:
      - 'mutators:add_email_notifications'

Om funktioner utlöser ett undantag under mutatorkörningen avbryts paketdistributionen.