Condividi tramite

Creare un modello di bundle personalizzato

In questa esercitazione si creerà un modello personalizzato per la creazione di bundle di automazione dichiarativa che eseguono un processo con un'attività Python in un cluster usando un'immagine del contenitore Docker specifica.

Per informazioni sui modelli di bundle personalizzati, vedere Modelli di bundle personalizzati.

Requisiti

  • Installare il CLI Databricks versione 0.218.0 o successiva. Se è già stato installato, verificare che la versione sia 0.218.0 o successiva eseguendo databricks -version dalla riga di comando.

Definire le variabili di richiesta utente

Prima di tutto, definire le variabili del prompt dell'utente databricks bundle init. Dalla riga di comando:

  1. Creare una cartella vuota denominata dab-container-template:

    mkdir dab-container-template

  2. Nella radice della cartella creare un file denominato databricks_template_schema.json:

    cd dab-container-template
touch databricks_template_schema.json

  3. Aggiungere il codice JSON seguente al databricks_template_schema.json file per definire una richiesta utente per il nome del progetto bundle:

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

Creare la struttura di cartelle del bundle

Creare quindi una template cartella per contenere la struttura di cartelle per i bundle generati. I nomi delle sottodirectory e dei file seguono la sintassi del modello di pacchetto Go.

Questo modello crea la cartella del progetto bundle in base al nome fornito dal prompt del progetto.

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

Creare ora le sottodirectory resources e src per i file di aggregazione:

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

Aggiungere modelli di configurazione YAML

template/{{.project_name}} Nella cartella creare un file denominato databricks.yml.tmpl:

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

Aggiungere il codice YAML seguente a databricks.yml.tmpl. In questo esempio vengono utilizzati gli aiutanti di template del pacchetto .

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

Creare un altro file YAML denominato {{.project_name}}_job.yml.tmpl nella template/{{.project_name}}/resources cartella . Questo nuovo file YAML contiene la definizione dell'attività.

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

Aggiungere il codice YAML seguente a questo file per descrivere il processo modello, che contiene un'attività Python da eseguire in un cluster di processo usando un'immagine del contenitore Docker specifica. In questo esempio viene usata un'immagine del contenitore Docker di base predefinita di Databricks, ma è possibile specificare invece un'immagine personalizzata.

# 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

Aggiungere file a cui si fa riferimento nella configurazione

Creare quindi il file di attività Python a cui fa riferimento il processo nel modello:

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

Aggiungere ora quanto segue per task.py:

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

Verificare la struttura del modello di bundle

Esamina la struttura delle cartelle del progetto modello di pacchetto. Dovrebbe essere come questo:

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

Testare il modello

Infine, testare il modello di bundle. Per generare un bundle basato sul nuovo modello personalizzato, usare il comando databricks bundle init specificando il nuovo percorso del modello. Dalla cartella radice dei progetti bundle:

databricks bundle init dab-container-template

Passaggi successivi

Risorse

  • Last updated on