Compartir vía

Configuración de agrupación en Python

Python para Conjuntos de recursos de Databricks amplía los conjuntos de recursos de Databricks para que pueda:

La documentación de referencia para la compatibilidad de Python con databricks Asset Bundles databricks-bundles está disponible en https://databricks.github.io/cli/python/.

Requisitos

Para usar la compatibilidad de Python con conjuntos de recursos de Databricks, primero debe:

  1. Instale la CLI de Databricks, versión 0.275.0 o posterior. Consulte Instalación o actualización de la CLI de Databricks.

  2. Autentíquese en el área de trabajo de Databricks si aún no lo ha hecho:

    databricks configure

  3. Instale uv. Consulte Instalación de uv. Python para Databricks Asset Bundles usa uv para crear un entorno virtual e instalar las dependencias necesarias. Como alternativa, puede configurar el entorno de Python mediante otras herramientas, como venv.

Creación de un proyecto a partir de la plantilla

Para crear una nueva compatibilidad con Python para el proyecto de Conjuntos de recursos de Databricks, inicialice una agrupación mediante la pydabs plantilla:

databricks bundle init pydabs

Cuando se le solicite, asigne un nombre al proyecto, como my_pydabs_project, y acepte la inclusión de un cuaderno y un paquete de Python.

Ahora cree un nuevo entorno virtual en la nueva carpeta del proyecto:

cd my_pydabs_project
uv sync

De forma predeterminada, la plantilla incluye un ejemplo de un trabajo definido como Python en el resources/my_pydabs_project_job.py archivo:

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 función acepta un diccionario de Python con el mismo formato que YAML. Los recursos también se pueden construir mediante la sintaxis de la clase de datos:

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

Los archivos de Python se cargan a través de un punto de entrada especificado en la python sección de 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'

De forma predeterminada, resources/__init__.py contiene una función que carga todos los archivos de Python en el paquete de recursos.

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

Implementar y ejecutar trabajos o canalizaciones

Para implementar la agrupación en el destino de desarrollo, use el comando bundle deploy desde la raíz del proyecto de agrupación:

databricks bundle deploy --target dev

Este comando implementa todo lo definido para el proyecto de agrupación. Por ejemplo, un proyecto creado con la plantilla predeterminada implementa un trabajo llamado [dev yourname] my_pydabs_project_job al área de trabajo. Para encontrar ese trabajo, vaya a Trabajos y canalizaciones en el área de trabajo de Databricks.

Una vez implementada la agrupación, puede usar el comando de resumen del lote para revisar todo lo que se implementa:

databricks bundle summary --target dev

Por último, para ejecutar un trabajo o una canalización, use el comando bundle run:

databricks bundle run my_pydabs_project_job

Actualización de agrupaciones existentes

Para actualizar los conjuntos existentes, modele la estructura de la plantilla de proyecto como se describe en Creación de un proyecto a partir de una plantilla. Las agrupaciones existentes con YAML se pueden actualizar para incluir recursos definidos como código de Python agregando una python sección en 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'

El entorno virtual especificado debe contener el paquete PyPi de databricks-bundles instalado.

pip install databricks-bundles==0.275.0

La carpeta de recursos debe contener el archivo __init__.py

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

Conversión de trabajos existentes en Python

Para convertir trabajos existentes en Python, puede usar la característica Ver como código . Consulte Visualizar trabajos como código.

  1. Abra la página del trabajo existente en el área de trabajo de Databricks.

  2. Haga clic en el kebab situado a la izquierda del botón Ejecutar ahora y, a continuación, haga clic en Ver como código:

    Ver como elemento de menú de código

  3. Seleccione Python y, después, Conjuntos de recursos de Databricks.

    Visualización como código, Python

  4. Haga clic en Copiar y guarde el archivo de Python generado como un archivo de Python en la carpeta resources del proyecto de agrupación.

    Sugerencia

    También puede ver y copiar YAML para trabajos y canalizaciones existentes que puede pegar directamente en los archivos YAML de configuración de agrupación.

Creación de recursos mediante metadatos

La implementación predeterminada de la load_resources función carga los archivos de Python en el resources paquete. Puede usar Python para crear recursos mediante programación. Por ejemplo, puede cargar archivos de configuración y crear trabajos en un bucle:

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

Acceder a las variables del paquete

El bundle parámetro se puede usar para acceder a variables de agrupación y el destino de implementación:

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)

    ...

Consulte la referencia de la clase Resources and Bundle para obtener más información.

Modificación de recursos definidos en YAML o Python

Puede hacer referencia a funciones mutadoras en databricks.yml, de forma similar a las funciones que cargan recursos. Esta característica se puede usar independientemente de cargar recursos definidos en Python y mutar los recursos definidos en YAML y Python.

En primer lugar, cree mutators.py en la raíz del lote con el siguiente contenido:

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)

Ahora utilice la siguiente configuración para ejecutar la add_email_notifications función durante la implementación del paquete. Esto actualiza todos los trabajos definidos en la agrupación con notificaciones por correo electrónico si están ausentes. Las funciones mutadoras deben especificarse en databricks.ymly se ejecutan en el orden especificado. Los mutadores de trabajo se ejecutan para cada trabajo definido en una agrupación y pueden devolver una copia actualizada o una entrada sin modificar. Los mutadores también se pueden usar para otros campos, como la configuración de clústeres de trabajos predeterminados o almacenes de SQL.

python:
  mutators:
    - 'mutators:add_email_notifications'

Si las funciones arrojan una excepción durante la ejecución del mutador, se aborta la implementación del paquete.

  • Last updated on