Exemplos de configuração de pacotes

Este artigo fornece exemplos de configuração para Declarative Automation Bundles (anteriormente conhecidos como Databricks Ativo Bundles) e casos de uso comuns de pacotes.

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

Nome do pacote	Descrição
aplicativo_com_banco_de_dados	Um pacote com um aplicativo Databricks apoiado por um banco de dados OLTP Postgres
app_with_genie_space	Um pacote que define um aplicativo Databricks que usa um espaço Genie.
dashboard_nyc_taxi	Um pacote com um AI/BI dashboard e um Job que captura um Snapshot do painel e o envia por e-mail para um assinante
banco_de_dados_com_catálogo	Um pacote que define uma instância de banco de dados OLTP e um catálogo de banco de dados
databricks_app	Um pacote que define um aplicativo Databricks
cluster_de_desenvolvimento	Um pacote que define e usa um desenvolvimento (clusters todo-propósito
genie_space_nyc_taxi	Um pacote que define um espaço Genie que responde a perguntas sobre a tabela `samples.nyctaxi.trips`.
Reabastecimento de dados	Um pacote que define um job que executa uma tarefa SQL com um parâmetro de data para preenchimento retroativo de dados.
Execução condicional	Um pacote que define um Job que usa execução condicional de tarefa baseada em verificações de qualidade de dados.
Chegada de arquivo de trabalho	Um pacote que define um Job que usa gatilhos de chegada de arquivo para processar automaticamente novos arquivos quando chegam a um volume do Unity Catalog.
job_read_secret	Um pacote que define um escopo secreto e um trabalho com uma tarefa que lê esse escopo
gatilho de atualização da tabela de trabalho	Um pacote que demonstra um fluxo de trabalho em que os produtores gravam em tabelas do Unity Catalog, e os consumidores podem acionar atualizações de tabela em vez de programações baseadas em tempo.
trabalho_com_várias rodas	Um pacote que define e usa um Job com várias dependências de roda
job_with_run_job_tasks	Um pacote com vários Job com execução Job tarefa
trabalho_com_sql_notebook	Um pacote com um trabalho que usa uma tarefa do SQL Notebook
visualização de métrica	Um pacote que cria uma view de métricas do Unity Catalog. Uma vez registrada, a view de métrica torna-se disponível para analistas e ferramentas de BI em todo o seu workspace, consultável com a função SQL `MEASURE()`.
pipeline_with_schema	Um pacote que define um esquema do Unity Catalog e um pipeline que o utiliza
pacotes_de_rodas privados	Um pacote que usa um pacote de roda privado de um trabalho
python_wheel_poetry	Um pacote que cria um `whl` com Poetry
trabalho_sem servidor	Um pacote que usa serverless compute para executar um trabalho
share_files_across_bundles	Um pacote que inclui arquivos localizados fora do diretório raiz do pacote.
spark_jar_task	Um pacote que define e usa uma tarefa Spark JAR
alvo inclui	Um pacote que demonstra o conceito de usar target_includes (ou mecanismos de inclusão semelhantes) para organizar configurações de Job em diferentes ambientes sem duplicação.
busca vetorial de descoberta de produtos	Um pacote que demonstra a pesquisa semântica de produtos usando Databricks Vector Search.
escrever_de_trabalho_para_volume	Um pacote que grava um arquivo em um volume do Unity Catalog

Pacotes de cenários

Esta seção contém exemplos de configuração que demonstram o uso de mapeamentos de pacotes de nível superior. Consulte a referência de configuração.

Pacote que faz o upload de um arquivo JAR para o Unity Catalog

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

YAML
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 painel de controle

Esta seção contém exemplos de configuração de painel de controle. Para obter detalhes sobre a configuração do painel de controle, consulte o painel de controle.

Catálogo de painéis e parametrização de esquemas

Você pode definir um único catálogo e esquema para o conjunto de dados dentro de um painel quando implantado com Declarative Automation Bundles usando os campos dataset_catalog e dataset_schema do recurso do painel.

nota

Para parametrizar referências de tabelas específicas dentro do SQL, você pode usar a função current_catalog() .

A seguinte configuração de pacote de exemplo define variáveis para definir os valores de catálogo e esquema para os destinos dev e prod . Pressupõe-se que exista um arquivo nyc_taxi_trip_analysis.lvdash.json na pasta src do pacote.

YAML
bundle:
  name: dashboard-bundle

variables:
  warehouse_id:
    description: Warehouse
    default: baf79a9e4ze90f02
  catalog_name:
    description: 'Catalog name'
    default: test_catalog
  schema_name:
    description: 'Schema name'
    default: ${workspace.current_user.short_name}

resources:
  dashboards:
    nyc_taxi_trip_analysis:
      display_name: 'NYC Taxi Trip Analysis'
      file_path: src/nyc_taxi_trip_analysis.lvdash.json
      warehouse_id: ${var.warehouse_id}
      dataset_catalog: ${var.catalog}
      dataset_schema: ${var.schema}

targets:
  dev:
    mode: development
    default: true
    workspace:
      host: https://myworkspace.cloud.databricks.com
    variables:
      catalog: dev_catalog
      schema: ${workspace.current_user.short_name}

  prod:
    mode: production
    workspace:
      host: https://myworkspace.cloud.databricks.com
      root_path: /Workspace/Users/someone@example.com/.bundle/${bundle.name}/${bundle.target}
    variables:
      catalog_name: prod_catalog
      schema_name: prod_schema
    permissions:
      - user_name: someone@example.com
        level: CAN_MANAGE

Job configuração

Esta seção contém exemplos de configuração de trabalhos. Para obter detalhes sobre a configuração do trabalho, consulte Trabalho.

Job que usa serverless compute

Os pacotes de automação declarativa oferecem suporte a trabalhos que são executados em computeserverless. Veja como executar seus trabalhos LakeFlow com compute serverless para fluxo de trabalho. Para configurar isso, você pode omitir a configuração clusters para um Job com uma tarefa Notebook ou pode especificar um ambiente conforme mostrado nos exemplos abaixo. Para script Python , Python wheel e dbt tarefa, environment_key é necessário para compute serverless . Consulte environment_key.

YAML
# 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

YAML
# 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

Job com vários arquivos de roda

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

YAML
# 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'

YAML
# 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

Job com parâmetros

O exemplo de configuração a seguir define um Job com parâmetros. Para obter mais informações sobre como parametrizar Job, consulte Parametrizar Job.

YAML
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 tempo de execução passando parâmetros de trabalho para bundle run, por exemplo:

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

Job que usa um arquivo requirements.txt

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

YAML
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

Job em um programa

Os exemplos a seguir mostram a configuração para Jobs que são executados em uma programar. Para informação sobre as programações de Job e acionadores, consulte Automatize Jobs com programações e acionadores.

Essa configuração define um trabalho que é executado diariamente em um horário específico:

YAML
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:

YAML
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 sobre a configuração do pipeline, consulte pipeline.

pipeline que usa o site serverless compute

Os pacotes de automação declarativa oferecem suporte a pipelines que executam computeserverless. Para configurar isso, defina a configuração do pipeline serverless para true. A seguinte configuração de exemplo define um pipeline que é executado em compute serverless com as dependências instaladas, e um Job que aciona uma refresh do pipeline a cada hora.

YAML
# 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

YAML
# 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}

Pacotes de cenários​

Pacote que faz o upload de um arquivo JAR para o Unity Catalog​

Configuração do painel de controle​

Catálogo de painéis e parametrização de esquemas​

Job configuração​

Job que usa serverless compute​

Job com vários arquivos de roda​

Job com parâmetros​

Job que usa um arquivo requirements.txt​

Job em um programa​

Configuração do pipeline​

pipeline que usa o site serverless compute​