Compartir a través de

Tutorial: Creación de la primera plantilla personalizada de Databricks Asset Bundle

  • Artículo

En este tutorial, creará una plantilla personalizada de Paquete de Recursos de Databricks para crear paquetes que ejecuten un trabajo con una tarea de Python específica en un clúster mediante una imagen de contenedor de Docker específica.

Para obtener información sobre las plantillas de agrupación personalizadas, consulte Plantillas de agrupación personalizadas.

Antes de empezar

Instale la CLI de Databricks versión 0.218.0 o posterior. Si ya lo ha instalado, confirme que la versión es 0.218.0 o posterior ejecutando databricks -version desde la línea de comandos.

Definición de variables de solicitud de usuario

El primer paso para crear una plantilla de conjunto es definir las variables de solicitud del usuario databricks bundle init. Desde la línea de comandos:

  1. Cree un directorio vacío denominado dab-container-template:

    mkdir dab-container-template

  2. En la raíz del directorio, cree un archivo denominado databricks_template_schema.json:

    cd dab-container-template
touch databricks_template_schema.json

  3. Agregue el siguiente contenido al databricks_template_schema.json y guarde el archivo. Cada variable se traducirá a un mensaje para el usuario durante la creación del paquete.

    {
  "properties": {
    "project_name": {
      "type": "string",
      "default": "project_name",
      "description": "Project name",
      "order": 1
    }
  }
}

Crea la estructura de carpetas del paquete

A continuación, en el directorio de plantillas, cree subdirectorios denominados resources y src. La carpeta template contiene la estructura de directorios de los conjuntos generados. Los nombres de los subdirectorios y archivos seguirán la plantilla de sintaxis de paquete Go cuando se deriven de los valores proporcionados por el usuario.

  mkdir -p "template/resources"
  mkdir -p "template/src"

Adición de plantillas de configuración de YAML

En el directorio template, cree un archivo denominado databricks.yml.tmpl y agregue el siguiente código YAML. En este ejemplo se usan asistentes de plantillas de agrupación.

  touch template/databricks.yml.tmpl

  # This is a Databricks asset bundle definition for {{.project_name}}.
  # See https://docs.databricks.com/dev-tools/bundles/index.html for documentation.
  bundle:
    name: {{.project_name}}

  include:
    - resources/*.yml

  targets:
    # The 'dev' target, used for development purposes.
    # Whenever a developer deploys using 'dev', they get their own copy.
    dev:
      # We use 'mode: development' to make sure everything deployed to this target gets a prefix
      # like '[dev my_user_name]'. Setting this mode also disables any schedules and
      # automatic triggers for jobs and enables the 'development' mode for DLT pipelines.
      mode: development
      default: true
      workspace:
        host: {{workspace_host}}

    # The 'prod' target, used for production deployment.
    prod:
      # For production deployments, we only have a single copy, so we override the
      # workspace.root_path default of
      # /Workspace/Users/${workspace.current_user.userName}/.bundle/${bundle.target}/${bundle.name}
      # to a path that is not specific to the current user.
      #
      # By making use of 'mode: production' we enable strict checks
      # to make sure we have correctly configured this target.
      mode: production
      workspace:
        host: {{workspace_host}}
        root_path: /Shared/.bundle/prod/${bundle.name}
      {{- if not is_service_principal}}
      run_as:
        # This runs as {{user_name}} in production. Alternatively,
        # a service principal could be used here using service_principal_name
        # (see Databricks documentation).
        user_name: {{user_name}}
      {{end -}}

Cree otro archivo YAML denominado {{.project_name}}_job.yml.tmpl y colóquelo en el directorio template/resources. Este nuevo archivo YAML separa las definiciones de tareas del proyecto del resto de la definición del paquete. Agregue el siguiente código YAML a este archivo para describir el trabajo de plantilla, que contiene una tarea específica de Python para ejecutarse en un clúster de trabajos mediante una imagen de contenedor de Docker específica:

  touch template/resources/{{.project_name}}_job.yml.tmpl

  # The main job for {{.project_name}}
  resources:
    jobs:
      {{.project_name}}_job:
        name: {{.project_name}}_job
        tasks:
          - task_key: python_task
            job_cluster_key: job_cluster
            spark_python_task:
              python_file: ../src/{{.project_name}}/task.py
        job_clusters:
          - job_cluster_key: job_cluster
            new_cluster:
              docker_image:
                url: databricksruntime/python:10.4-LTS
              node_type_id: i3.xlarge
              spark_version: 13.3.x-scala2.12

En este ejemplo, usará una imagen de contenedor de Docker base de Databricks predeterminada, pero puede especificar su propia imagen personalizada en su lugar.

Agregar archivos a los que se hace referencia en la configuración

A continuación, cree un directorio template/src/{{.project_name}} y cree el archivo de tareas de Python al que hace referencia el trabajo en la plantilla:

  mkdir -p template/src/{{.project_name}}
  touch template/src/{{.project_name}}/task.py

Ahora, agregue lo siguiente a task.py:

  import pyspark
  from pyspark.sql import SparkSession

  spark = SparkSession.builder.master('local[*]').appName('example').getOrCreate()

  print(f'Spark version{spark.version}')

Comprobación de la estructura de la plantilla de agrupación

Revise la estructura de carpetas del proyecto de plantilla de agrupación. Debería tener este aspecto:

  .
  ├── databricks_template_schema.json
  └── template
      ├── databricks.yml.tmpl
      ├── resources
      │   └── {{.project_name}}_job.yml.tmpl
      └── src
          └── {{.project_name}}
              └── task.py

Prueba de la plantilla

Por último, pruebe la plantilla de agrupación. Para generar una agrupación basada en la nueva plantilla personalizada, use el comando databricks bundle init y especifique la nueva ubicación de plantilla. Desde la carpeta raíz de tus paquetes de proyectos:

mkdir my-new-container-bundle
cd my-new-container-bundle
databricks bundle init dab-container-template

Pasos siguientes

Recursos