Partager via

Configuration de bundle dans Python

Python pour les Databricks Asset Bundles étend les Databricks Asset Bundles afin que vous puissiez :

La documentation de référence relative à la prise en charge de Python pour le package Databricks Asset Bundles databricks-bundles est disponible à l’adresse https://databricks.github.io/cli/python/.

Spécifications

Pour utiliser la prise en charge de Python pour les bundles de ressources Databricks, vous devez d’abord :

  1. Installez l’interface CLI Databricks, version 0.275.0 ou ultérieure. Consultez Installer ou mettre à jour l’interface CLI Databricks.

  2. Authentifiez-vous auprès de votre espace de travail Databricks si vous ne l’avez pas déjà fait :

    databricks configure

  3. Installez uv. Voir Installer uv. Python pour Databricks Asset Bundles utilise uv pour créer un environnement virtuel et installer les dépendances requises. Vous pouvez également configurer votre environnement Python à l’aide d’autres outils tels que venv.

Créer un projet à partir du modèle

Pour créer une nouvelle prise en charge Python pour le projet Databricks Asset Bundles, initialisez un pack à l'aide du modèle pydabs :

databricks bundle init pydabs

Lorsque vous y êtes invité, donnez un nom à votre projet, par my_pydabs_projectexemple, et acceptez l’inclusion d’un bloc-notes et d’un package Python.

Créez maintenant un environnement virtuel dans votre nouveau dossier de projet :

cd my_pydabs_project
uv sync

Par défaut, le modèle inclut un exemple de travail défini comme Python dans le resources/my_pydabs_project_job.py fichier :

from databricks.bundles.jobs import Job


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

La Job.from_dict fonction accepte un dictionnaire Python au même format que YAML. Les ressources peuvent également être construites à l’aide de la syntaxe de la classe de données :

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


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

Les fichiers Python sont chargés via un point d’entrée spécifié dans la python section dans databricks.yml:

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'

Par défaut, resources/__init__.py contient une fonction qui charge tous les fichiers Python dans le package de ressources.

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

Déployer et exécuter des travaux ou des pipelines

Pour déployer le bundle sur la cible de développement, utilisez la commande de déploiement groupée à partir de la racine du projet groupé :

databricks bundle deploy --target dev

Cette commande déploie tout ce qui est défini pour le projet groupé. Par exemple, un projet créé à l’aide du modèle par défaut déploie un travail appelé [dev yourname] my_pydabs_project_job sur votre espace de travail. Vous pouvez trouver ce travail en accédant à Travaux & Pipelines dans votre espace de travail Databricks.

Une fois l’offre groupée déployée, vous pouvez utiliser la commande récapitulative du bundle pour passer en revue tout ce qui est déployé :

databricks bundle summary --target dev

Enfin, pour exécuter un travail ou un pipeline, utilisez la commande d’exécution de bundle :

databricks bundle run my_pydabs_project_job

Mettre à jour des offres groupées existantes

Pour mettre à jour des bundles existants, modélisez la structure du modèle de projet comme décrit dans Créer un projet à partir d’un modèle. Les bundles existants avec YAML peuvent être mis à jour pour inclure des ressources définies en tant que code Python en ajoutant une python section dans databricks.yml:

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'

L’environnement virtuel spécifié doit contenir le package PyPi databricks-bundles installé.

pip install databricks-bundles==0.275.0

Le dossier des ressources doit contenir un __init__.py fichier :

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

Convertir des travaux existants en Python

Pour convertir des travaux existants en Python, vous pouvez utiliser la fonctionnalité Affichage en tant que fonctionnalité de code . Voir Afficher les travaux en tant que code.

  1. Ouvrez la page du travail existant dans l’espace de travail Databricks.

  2. Cliquez sur le kebab à gauche du bouton Exécuter maintenant , puis cliquez sur Afficher en tant que code :

    Afficher en tant qu’élément du menu de code

  3. Sélectionnez Python, puis Databricks Asset Bundles

    Afficher comme code en Python

  4. Cliquez sur Copier et enregistrer le fichier Python généré en tant que fichier Python dans le dossier ressources du projet groupé.

    Conseil / Astuce

    Vous pouvez également afficher et copier YAML pour les travaux et les pipelines existants que vous pouvez coller directement dans vos fichiers YAML de configuration de bundle.

Créer des ressources à l’aide de métadonnées

L’implémentation par défaut de la load_resources fonction charge les fichiers Python dans le resources package. Vous pouvez utiliser Python pour créer des ressources par programmation. Par exemple, vous pouvez charger des fichiers de configuration et créer des travaux dans une boucle :

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

Accéder aux variables du package

Le bundle paramètre peut être utilisé pour accéder aux variables de bundle et à la cible de déploiement :

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)

    ...

Pour plus d’informations, consultez la référence de la classe Resources et Bundle .

Modifier les ressources définies dans YAML ou Python

Vous pouvez référencer des fonctions mutator dans databricks.yml, comme pour les fonctions qui chargent des ressources. Cette fonctionnalité peut être utilisée indépendamment du chargement des ressources définies dans Python et mute les ressources définies dans YAML et Python.

Tout d’abord, créez mutators.py dans la racine du bundle avec le contenu suivant :

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)

Utilisez maintenant la configuration suivante pour exécuter la fonction add_email_notifications pendant le déploiement du pack. Cela met à jour chaque tâche définie dans le bundle en ajoutant des notifications par e-mail si elles sont absentes. Les fonctions de mutateur doivent être spécifiées dans databricks.yml, et sont exécutées dans l’ordre spécifié. Les mutateurs de travaux sont exécutés pour chaque travail défini dans un bundle et peuvent retourner une copie mise à jour ou une entrée non modifiée. Les mutateurs peuvent également être utilisés pour d’autres champs, tels que la configuration des clusters de travaux par défaut ou des entrepôts SQL.

python:
  mutators:
    - 'mutators:add_email_notifications'

Si les fonctions lèvent une exception lors de l’exécution du mutateur, le déploiement du pack est abandonné.

  • Last updated on