Databricks projeto ativo Bundle padrão

Este artigo descreve a sintaxe do siteDatabricks ativo Bundle padrão. Os pacotes permitem o gerenciamento programático do Databricks fluxo de trabalho. Veja o que são Databricks ativo Bundles?

Os padrões de pacotes permitem que os usuários criem pacotes de forma consistente e repetível, estabelecendo estruturas de pastas, construindo os passos e tarefas, testes e outros atributos de DevOps Infrastructure-as-Code (IaC) comuns em um pipeline de implantação de ambiente de desenvolvimento.

Por exemplo, se o senhor executa rotineiramente o Databricks Job que requer pacotes personalizados com uma compilação demorada ou passo a passo após a instalação, poderá acelerar seu ciclo de desenvolvimento criando um padrão de pacote que ofereça suporte a ambientes de contêineres personalizados.

O padrão de pacote define a estrutura de diretório do pacote que será criado e inclui um padrão de arquivo de configuração databricks.yml.tmpl, bem como um arquivo databricks_template_schema.json que contém variáveis de prompt do usuário.

Usar um modelo de pacote padrão

Para usar um modelo de pacote do Databricks default para criar seu pacote, use o comando Databricks CLI bundle init, especificando o nome do modelo default a ser usado. Por exemplo, o comando a seguir cria um pacote usando o modelo de pacote do default Python:

databricks bundle init default-python

Se o senhor não especificar um default padrão, o comando bundle init apresentará o conjunto de modelos disponíveis entre os quais poderá escolher.

A Databricks fornece os seguintes modelos de pacotes default:

Template	Descrição
`default-python`	Um padrão para usar Python com Databricks. Esse padrão cria um pacote com um pipeline Job e Delta Live Tables. Consulte default-Python.
`default-sql`	Um padrão para usar SQL com Databricks. Esse padrão contém um arquivo de configuração que define um Job que executa consultas SQL em um SQL warehouse. Consulte default-sql.
`dbt-sql`	Um padrão que aproveita o dbt-core para desenvolvimento local e pacotes para implementação. Esse padrão contém a configuração que define um Job com uma tarefa dbt, bem como um arquivo de configuração que define perfis dbt para o trabalho dbt implantado. Consulte dbt-sql.
`mlops-stacks`	Um padrão avançado de pilha completa para iniciar novos projetos MLOps Stacks. Consulte mlops-stacks e Databricks ativo Bundles for MLOps Stacks.

Usar um padrão de pacote personalizado

Para usar um padrão de pacote diferente dos modelos de pacote do Databricks default, passe o caminho local ou o URL remoto do padrão para o comando Databricks CLI bundle init.

Por exemplo, o comando a seguir usa o padrão dab-container-template criado no tutorial Custom Bundle padrão:

databricks bundle init /projects/my-custom-bundle-templates/dab-container-template

Criar um padrão de pacote personalizado

O pacote padrão usa a sintaxe de modelo de pacote Go. Consulte a documentação padrão do pacote Go .

No mínimo, um projeto de bundle padrão deve ter:

Um arquivo databricks_template_schema.json na raiz do projeto que define uma variável de prompt de usuário para o nome do projeto do pacote.
Um arquivo databricks.yml.tmpl localizado em uma pasta template que define a configuração de todos os pacotes criados com o padrão. Se o arquivo databricks.yml.tmpl fizer referência a qualquer padrão de configuração *.yml.tmpl adicional, especifique o local desses padrões no mapeamento include.

Opcionalmente, o senhor pode adicionar subpastas e arquivos à pasta template que deseja espelhar nos pacotes criados pelo padrão.

Definir variáveis de prompt do usuário

O primeiro passo na criação de um pacote padrão básico é criar uma pasta de projeto padrão e um arquivo chamado databricks_template_schema.json na raiz do projeto. Esse arquivo contém as variáveis para as quais os usuários fornecem valores de entrada quando usam o padrão para criar um pacote usando bundle init. O formato desse arquivo segue a especificação do esquema JSON.

mkdir basic-bundle-template
touch basic-bundle-template/databricks_template_schema.json

Adicione o seguinte ao arquivo databricks_template_schema.json e salve o arquivo:

{
   "properties": {
   "project_name": {
      "type": "string",
      "default": "basic_bundle",
      "description": "What is the name of the bundle you want to create?",
      "order": 1
   }
   },
   "success_message": "\nYour bundle '{{.project_name}}' has been created."
}

Neste arquivo:

project_name é o único nome de variável de entrada.
default é um valor opcional default se um valor não for fornecido pelo usuário com --config-file como parte do comando bundle init ou substituído pelo usuário no prompt de comando.
description é o prompt do usuário associado à variável de entrada, se um valor não for fornecido pelo usuário com --config-file como parte do comando bundle init.
order é uma ordem opcional em que cada prompt de usuário aparece se um valor não for fornecido pelo usuário com --config-file como parte do comando bundle init. Se order não for fornecido, os prompts do usuário serão exibidos na ordem em que estão listados no esquema.
success_message é uma mensagem opcional exibida após a criação bem-sucedida do projeto.

Criar a estrutura de pastas

Em seguida, crie a pasta template necessária e construa a estrutura de pastas dentro dela. Essa estrutura será espelhada pelos pacotes criados com esse padrão. Além disso, coloque todos os arquivos que o senhor deseja incluir nessas pastas. Esse pacote padrão básico armazena os arquivos em uma pasta src e inclui um simples Notebook.

mkdir -p basic-bundle-template/template/src
touch basic-bundle-template/template/src/simple_notebook.ipynb

Adicione o seguinte ao arquivo simple_notebook.ipynb:

print("Hello World!")

Preencher os arquivos padrão de configuração

Agora, crie o arquivo databricks.yml.tmpl necessário na pasta template:

touch basic-bundle-template/template/databricks.yml.tmpl

Preencha esse arquivo com a configuração básica padrão YAML. Esse padrão de configuração estabelece o nome do pacote, um trabalho usando o arquivo do Notebook especificado e dois ambientes de destino para os pacotes criados usando esse padrão. Ele também aproveita as substituições de pacotes, o que é altamente recomendado. Veja as substituições de pacotes.

# This is the configuration for the Databricks Asset Bundle {{.project_name}}.

bundle:
  name: {{.project_name}}

# The main job for {{.project_name}}
resources:
    jobs:
        {{.project_name}}_job:
        name: {{.project_name}}_job
        tasks:
            - task_key: notebook_task
            job_cluster_key: job_cluster
            notebook_task:
                notebook_path: ../src/simple_notebook.ipynb
        job_clusters:
            - job_cluster_key: job_cluster
            new_cluster:
                node_type_id: i3.xlarge
                spark_version: 13.3.x-scala2.12

targets:
  # The deployment targets. See https://docs.databricks.com/en/dev-tools/bundles/deployment-modes.html
  dev:
    mode: development
    default: true
    workspace:
      host: {{workspace_host}}

  prod:
    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
      user_name: {{user_name}}
    {{end -}}

Teste o padrão do pacote

Por fim, teste seu padrão. Crie uma nova pasta de projeto de pacote e, em seguida, use a CLI do Databricks para inicializar um novo pacote usando o padrão:

mkdir my-test-bundle
cd my-test-bundle
databricks bundle init ../basic-bundle-template

No prompt What is your bundle project name?, digite my_test_bundle.

Depois que o pacote de teste é criado, a mensagem de sucesso do arquivo de esquema é emitida. Se o senhor examinar o conteúdo da pasta my-test-bundle, verá o seguinte:

my-test-bundle
   ├── databricks.yml
   └── src
      └── simple_notebook.ipynb

E o arquivo databricks.yml agora está personalizado:

# This is the configuration for the Databricks Asset Bundle my-test-bundle.

bundle:
  name: my-test-bundle

# The main job for my-test-bundle
resources:
    jobs:
        my-test-bundle_job:
        name: my-test-bundle_job
        tasks:
            - task_key: notebook_task
                job_cluster_key: job_cluster
                notebook_task:
                    notebook_path: ../src/simple_notebook.ipynb
        job_clusters:
            - job_cluster_key: job_cluster
                new_cluster:
                    node_type_id: i3.xlarge
                    spark_version: 13.3.x-scala2.12

targets:
  # The 'dev' target, used for development purposes. See [_](https://docs.databricks.com/en/dev-tools/bundles/deployment-modes.html#development-mode)
  dev:
    mode: development
    default: true
    workspace:
      host: https://my-host.cloud.databricks.com

  # The 'prod' target, used for production deployment. See [_](https://docs.databricks.com/en/dev-tools/bundles/deployment-modes.html#production-mode)
  prod:
    mode: production
    workspace:
      host: https://my-host.cloud.databricks.com
      root_path: /Shared/.bundle/prod/${bundle.name}
    run_as:
      # This runs as someone@example.com in production. Alternatively,
      # a service principal could be used here using service_principal_name
      user_name: someone@example.com

Próximos passos

Procure padrões adicionais criados e mantidos pelo Databricks. Consulte o repositório de amostras de pacotes no GitHub.
Para usar MLOps Stacks com Databricks ativo Bundle padrão, consulte Databricks ativo Bundles for MLOps Stacks.
Saiba mais sobre o modelo de pacote Go. Consulte a documentação padrão do pacote Go .