Criar um modelo de pacote personalizado

Neste tutorial, você criará um modelo personalizado para criar Pacotes de Automação Declarativa que executam um trabalho com uma tarefa Python em um cluster usando uma imagem de contêiner específica do Docker.

Para obter informações sobre modelos de pacote personalizados, consulte modelos de pacote personalizados.

Requisitos

  • Instale a CLI do Databricks versão 0.218.0 ou superior. Se você já o instalou, confirme se a versão é 0.218.0 ou superior executando databricks -version na linha de comando.

Definir variáveis de prompt do usuário

Primeiro, defina as variáveis de prompt do usuário databricks bundle init. Na linha de comando:

  1. Crie uma pasta vazia chamada dab-container-template:

    mkdir dab-container-template

  2. Na raiz da pasta, crie um arquivo chamado databricks_template_schema.json:

    cd dab-container-template
touch databricks_template_schema.json

  3. Adicione o seguinte JSON ao arquivo databricks_template_schema.json para definir um prompt de usuário para o nome do projeto do pacote:

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

Crie a estrutura de pastas do pacote

Em seguida, crie uma template pasta para conter a estrutura de pastas para os pacotes gerados. Os nomes dos subdiretórios e arquivos seguem a sintaxe do modelo de pacote Go.

Este modelo cria a pasta de projeto de pacote com base no prompt de nome do projeto:

mkdir -p "template/{{.project_name}}"

Agora, crie os subdiretórios resources e src os arquivos de pacote:

mkdir -p "template/{{.project_name}}/resources"
mkdir -p "template/{{.project_name}}/src"

Adicionar modelos de configuração yaml

template/{{.project_name}} Na pasta, crie um arquivo chamadodatabricks.yml.tmpl:

touch template/{{.project_name}}/databricks.yml.tmpl

Adicione o seguinte YAML em databricks.yml.tmpl. Este exemplo usa auxiliares de modelo de pacote.

# This is a 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 Lakeflow pipelines.
    mode: development
    default: true
    workspace:
      host: {{workspace_host}}

  # The 'prod' target, used for production deployment.
  prod:
    # For production deployments, there is only a single copy, so 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. Avoid /Shared, which is writable
    # by all workspace users.
    #
    # 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: /Workspace/Production/.bundle/${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 -}}

Crie outro arquivo YAML nomeado {{.project_name}}_job.yml.tmpl na template/{{.project_name}}/resources pasta. Este novo arquivo YAML contém a definição do trabalho.

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

Adicione o YAML a seguir a este arquivo para descrever o trabalho de modelo, que contém uma tarefa python a ser executada em um cluster de trabalho usando uma imagem de contêiner do Docker específica. Este exemplo usa uma imagem padrão de contêiner Docker base para Databricks, mas você pode especificar uma imagem personalizada própria.

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

Adicionar arquivos referenciados em sua configuração

Em seguida, crie o arquivo de tarefa Python referenciado pelo trabalho no modelo:

touch template/{{.project_name}}/src/task.py

Agora, adicione o seguinte a task.py:

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

Verificar a estrutura do modelo de pacote

Examine a estrutura de pastas do seu projeto de modelo de pacote. Ele deve ter esta aparência:

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

Testar o modelo

Por fim, teste o modelo de pacote. Para gerar um pacote com base em seu novo modelo personalizado, use o databricks bundle init comando, especificando o novo local do modelo. Na pasta raiz dos projetos de pacote:

databricks bundle init dab-container-template

Tip

Para disponibilizar seu modelo personalizado para outros usuários diretamente no workspace, armazene-o em um repositório Git e configure uma pasta de modelo personalizada. Os usuários podem selecioná-lo quando criam um pacote no workspace, sem usar a CLI. Consulte Configurar uma pasta de modelo personalizada no workspace.

Próximas etapas

Recursos

  • Last updated on