Compartilhar via

Criar um modelo personalizado do Pacote de Ativos do Databricks

Neste tutorial, você criará um modelo personalizado do Pacote de Ativos do Databricks para criar pacotes que executam um trabalho com uma tarefa Python específica 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

A primeira etapa na criação de um modelo de pacote é definir as variáveis de usuário do prompt databricks bundle init. Na linha de comando:

  1. Crie um diretório vazio chamado dab-container-template:

    mkdir dab-container-template

  2. Na raiz do diretório, crie um arquivo chamado databricks_template_schema.json:

    cd dab-container-template
touch databricks_template_schema.json

  3. Adicione os conteúdos a seguir ao databricks_template_schema.json e salve o arquivo. Cada variável será traduzida para um prompt de usuário durante a criação do pacote.

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

Crie a estrutura de pastas do pacote

Em seguida, no diretório de modelo, crie subdiretórios nomeados resources e src. A template pasta contém a estrutura de diretório para os pacotes gerados. Os nomes dos subdiretórios e arquivos seguirão a sintaxe do modelo de pacote Go quando derivados de valores de usuário.

  mkdir -p "template/resources"
  mkdir -p "template/src"

Adicionar modelos de configuração yaml

template No diretório, crie um arquivo nomeado databricks.yml.tmpl e adicione o YAML a seguir. Este exemplo usa assistentes de modelo de pacote.

  touch template/databricks.yml.tmpl

  # This is a Databricks asset 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 :re[LDP].
      mode: development
      default: true
      workspace:
        host: {{workspace_host}}

    # The 'prod' target, used for production deployment.
    prod:
      # For production deployments, we only have a single copy, so we 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.
      #
      # 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: /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
        # (see Databricks documentation).
        user_name: {{user_name}}
      {{end -}}

Crie outro arquivo YAML nomeado {{.project_name}}_job.yml.tmpl e coloque-o no template/resources diretório. Esse novo arquivo YAML divide as definições de trabalho do projeto do restante da definição do pacote. Adicione o SEGUINTE YAML a este arquivo para descrever o trabalho de modelo, que contém uma tarefa específica do Python a ser executada em um cluster de trabalho usando uma imagem de contêiner específica do Docker:

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

  # 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/{{.project_name}}/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

Neste exemplo, você usa uma imagem padrão de contêiner base do Docker do Databricks, mas pode especificar sua própria imagem personalizada.

Adicionar arquivos referenciados em sua configuração

Em seguida, crie um template/src/{{.project_name}} diretório e crie o arquivo de tarefa Python referenciado pelo trabalho no modelo:

  mkdir -p template/src/{{.project_name}}
  touch template/src/{{.project_name}}/task.py

Agora, adicione o seguinte a task.py:

  import pyspark
  from pyspark.sql import SparkSession

  spark = SparkSession.builder.master('local[*]').appName('example').getOrCreate()

  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:

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

Testar o modelo

Por fim, teste seu 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:

mkdir my-new-container-bundle
cd my-new-container-bundle
databricks bundle init dab-container-template

Próximas etapas

Recursos

  • Last updated on