Databricks ativo Bundle padrão

Este artigo descreve a sintaxe do Databricks ativo Bundle padrão, que funciona com as versões 0.205e acima da CLI do Databricks . Os pacotes permitem o gerenciamento programático do fluxo de trabalho do Databricks. Consulte O que são pacotes Databricks ativos?

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.

Criar um pacote baseado em um padrão

Esta seção descreve como usar um pacote padrão, seja um pacote padrão do Databricks default ou um pacote padrão personalizado.

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 Custom Bundle padrão tutorial:

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

Criar um pacote padrão

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 Job usando o arquivo Notebook especificado e dois ambientes de destino para os pacotes criados usando esse padrão. Ele também aproveita as vantagens das 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 .