Exemplos de configuração de pacote

Este artigo fornece configuração de exemplo para recursos de Pacotes de Ativos do Databricks e casos de uso comuns de pacotes.

Exemplos completos de pacote, descritos na tabela a seguir, estão disponíveis no repositório GitHub de exemplos de pacote:

Cenários de agrupamento

Esta seção contém exemplos de configuração que demonstram o uso de mapeamentos de pacote de nível superior. Consulte Referência de Configuração.

Pacote que carrega um arquivo JAR no Catálogo do Unity

Você pode especificar volumes do Catálogo do Unity como um caminho de artefato para que todos os artefatos, como arquivos JAR e arquivos wheel, sejam carregados em volumes do Catálogo do Unity. O pacote de exemplo a seguir compila e carrega um arquivo JAR no Catálogo do Unity. Para obter informações sobre o mapeamento artifact_path, consulte artifact_path. Para obter informações sobre artifacts, consulte os artefatos .

bundle:
  name: jar-bundle

workspace:
  host: https://myworkspace.cloud.databricks.com
  artifact_path: /Volumes/main/default/my_volume

artifacts:
  my_java_code:
    path: ./sample-java
    build: 'javac PrintArgs.java && jar cvfm PrintArgs.jar META-INF/MANIFEST.MF PrintArgs.class'
    files:
      - source: ./sample-java/PrintArgs.jar

resources:
  jobs:
    jar_job:
      name: 'Spark Jar Job'
      tasks:
        - task_key: SparkJarTask
          new_cluster:
            num_workers: 1
            spark_version: '14.3.x-scala2.12'
            node_type_id: 'i3.xlarge'
          spark_jar_task:
            main_class_name: PrintArgs
          libraries:
            - jar: ./sample-java/PrintArgs.jar

Configuração do trabalho

Esta seção contém exemplos de configuração de trabalho. Para obter detalhes da configuração da tarefa, consulte tarefa.

Trabalho que usa computação sem servidor

Os Pacotes de Ativos do Databricks dão suporte a trabalhos executados na computação sem servidor. Consulte Executar seus Trabalhos do Lakeflow com computação sem servidor para fluxos de trabalho. Para configurar isso, você pode omitir a configuração de clusters para um trabalho com uma tarefa de notebook ou pode especificar um ambiente, conforme mostrado nos exemplos abaixo. Para o script Python, Python wheel e tarefas dbt, environment_key é necessário para computação sem servidor. Consulte environment_key.

# A serverless job (no cluster definition)
resources:
  jobs:
    serverless_job_no_cluster:
      name: serverless_job_no_cluster

      email_notifications:
        on_failure:
          - someone@example.com

      tasks:
        - task_key: notebook_task
          notebook_task:
            notebook_path: ../src/notebook.ipynb

# A serverless job (environment spec)
resources:
  jobs:
    serverless_job_environment:
      name: serverless_job_environment

      tasks:
        - task_key: task
          spark_python_task:
            python_file: ../src/main.py

          # The key that references an environment spec in a job.
          # https://docs.databricks.com/api/workspace/jobs/create#tasks-environment_key
          environment_key: default

      # A list of task execution environment specifications that can be referenced by tasks of this job.
      environments:
        - environment_key: default

          # Full documentation of this spec can be found at:
          # https://docs.databricks.com/api/workspace/jobs/create#environments-spec
          spec:
            environment_version: '2'
            dependencies:
              - my-library

Trabalho com vários arquivos wheel

As configurações de exemplo a seguir definem um pacote que contém um trabalho com vários *.whl arquivos.

# job.yml
resources:
  jobs:
    example_job:
      name: 'Example with multiple wheels'
      tasks:
        - task_key: task

          spark_python_task:
            python_file: ../src/call_wheel.py

          libraries:
            - whl: ../my_custom_wheel1/dist/*.whl
            - whl: ../my_custom_wheel2/dist/*.whl

          new_cluster:
            node_type_id: i3.xlarge
            num_workers: 0
            spark_version: 14.3.x-scala2.12
            spark_conf:
              'spark.databricks.cluster.profile': 'singleNode'
              'spark.master': 'local[*, 4]'
            custom_tags:
              'ResourceClass': 'SingleNode'

# databricks.yml
bundle:
  name: job_with_multiple_wheels

include:
  - ./resources/job.yml

workspace:
  host: https://myworkspace.cloud.databricks.com

artifacts:
  my_custom_wheel1:
    type: whl
    build: poetry build
    path: ./my_custom_wheel1

  my_custom_wheel2:
    type: whl
    build: poetry build
    path: ./my_custom_wheel2

targets:
  dev:
    default: true
    mode: development

Tarefa com parâmetros

A configuração de exemplo a seguir define um trabalho com parâmetros. Para obter mais informações sobre parametrização de trabalhos, consulte Parametrizar trabalhos.

resources:
  jobs:
    job_with_parameters:
      name: job_with_parameters

      tasks:
        - task_key: task_a
          spark_python_task:
            python_file: ../src/file.py
            parameters:
              - '--param1={{ job.parameters.param1 }}'
              - '--param2={{ job.parameters.param2 }}'

          new_cluster:
            node_type_id: i3.xlarge
            num_workers: 1
            spark_version: 14.3.x-scala2.12

      parameters:
        - name: param1
          default: value1
        - name: param2
          default: value1

Esses parâmetros podem ser definidos em runtime passando parâmetros de trabalho para bundle run, por exemplo:

databricks bundle run -- --param1=value2 --param2=value2

Trabalho que usa um arquivo requirements.txt

A configuração de exemplo a seguir define um trabalho que usa um arquivo requirements.txt.

resources:
  jobs:
    job_with_requirements_txt:
      name: 'Example job that uses a requirements.txt file'
      tasks:
        - task_key: task
          job_cluster_key: default
          spark_python_task:
            python_file: ../src/main.py
          libraries:
            - requirements: /Workspace/${workspace.file_path}/requirements.txt

Trabalho em um cronograma

Os exemplos a seguir mostram a configuração para trabalhos executados em um agendamento. Para obter informações sobre agendas e gatilhos de trabalho, consulte Automatizando trabalhos com agendas e gatilhos.

Essa configuração define um trabalho que é executado diariamente em um momento especificado:

resources:
  jobs:
    my-notebook-job:
      name: my-notebook-job
      tasks:
        - task_key: my-notebook-task
          notebook_task:
            notebook_path: ./my-notebook.ipynb
      schedule:
        quartz_cron_expression: '0 0 8 * * ?' # daily at 8am
        timezone_id: UTC
        pause_status: UNPAUSED

Nessa configuração, o trabalho é executado uma semana após a última execução do trabalho:

resources:
  jobs:
    my-notebook-job:
      name: my-notebook-job
      tasks:
        - task_key: my-notebook-task
          notebook_task:
            notebook_path: ./my-notebook.ipynb
      trigger:
        pause_status: UNPAUSED
        periodic:
          interval: 1
          unit: WEEKS

Configuração do pipeline

Esta seção contém exemplos de configuração de pipeline. Para obter informações de configuração de pipeline, consulte pipeline.

Pipeline que usa a computação sem servidor

Os Pacotes de Ativos do Databricks dão suporte a pipelines executados na computação sem servidor. Para definir essa configuração, defina a configuração do pipeline serverless como true. A configuração de exemplo a seguir define um pipeline executado na computação sem servidor com dependências instaladas e um trabalho que dispara uma atualização do pipeline a cada hora.

# A pipeline that runs on serverless compute
resources:
  pipelines:
    my_pipeline:
      name: my_pipeline
      target: ${bundle.environment}
      serverless: true
      environment:
        dependencies:
          - 'dist/*.whl'
      catalog: users
      libraries:
        - notebook:
            path: ../src/my_pipeline.ipynb

      configuration:
        bundle.sourcePath: /Workspace/${workspace.file_path}/src

# This defines a job to refresh a pipeline that is triggered every hour
resources:
  jobs:
    my_job:
      name: my_job

      # Run this job once an hour.
      trigger:
        periodic:
          interval: 1
          unit: HOURS

      email_notifications:
        on_failure:
          - someone@example.com

      tasks:
        - task_key: refresh_pipeline
          pipeline_task:
            pipeline_id: ${resources.pipelines.my_pipeline.id}