Delen via

Zelfstudie: Uw eerste aangepaste Databricks Asset Bundle-sjabloon maken

  • Artikel

In deze zelfstudie maakt u een aangepaste Databricks Asset Bundle-sjabloon voor het maken van bundels die een taak uitvoeren met een specifieke Python-taak in een cluster met behulp van een specifieke Docker-containerinstallatiekopieën.

Voordat u begint

Installeer de Databricks CLI versie 0.218.0 of hoger. Als u deze al hebt geïnstalleerd, controleert u of de versie 0.218.0 of hoger is door vanaf de opdrachtregel uit te voeren databricks -version .

Gebruikerspromptvariabelen definiëren

De eerste stap bij het ontwikkelen van een bundelsjabloon is het definiëren van de databricks bundle init gebruikerspromptvariabelen. Vanaf de opdrachtregel:

  1. Maak een lege map met de naam dab-container-template:

    mkdir dab-container-template

  2. Maak in de hoofdmap van de map een bestand met de naam databricks_template_schema.json:

    cd dab-container-template
touch databricks_template_schema.json

  3. Voeg de volgende inhoud toe aan het databricks_template_schema.json bestand en sla het op. Elke variabele wordt vertaald naar een gebruikersprompt tijdens het maken van de bundel.

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

De structuur van de bundelmap maken

Maak vervolgens in de sjabloonmap submappen met de naam resources en src. De template map bevat de mapstructuur voor uw gegenereerde bundels. De namen van de submappen en bestanden volgen de syntaxis van de Go-pakketsjabloon wanneer ze zijn afgeleid van gebruikerswaarden.

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

YAML-configuratiesjablonen toevoegen

Maak in de map een bestand met de template naam databricks.yml.tmpl en voeg de volgende YAML toe:

  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 Delta Live Tables pipelines.
      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 -}}

Maak een ander YAML-bestand met de naam {{.project_name}}_job.yml.tmpl en plaats het in de template/resources map. Met dit nieuwe YAML-bestand worden de projecttaakdefinities gesplitst van de rest van de definitie van de bundel. Voeg de volgende YAML toe aan dit bestand om de sjabloontaak te beschrijven, die een specifieke Python-taak bevat die moet worden uitgevoerd op een taakcluster met behulp van een specifieke Docker-containerinstallatiekopieën:

  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

In dit voorbeeld gebruikt u een standaard-Docker-containerinstallatiekopieën voor Databricks, maar u kunt in plaats daarvan uw eigen aangepaste installatiekopieën opgeven.

Bestanden toevoegen waarnaar wordt verwezen in uw configuratie

Maak vervolgens een template/src/{{.project_name}} map en maak het Python-taakbestand waarnaar wordt verwezen door de taak in de sjabloon:

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

Voeg nu het volgende toe aan task.py:

  import pyspark
  from pyspark.sql import SparkSession

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

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

De structuur van de bundelsjabloon controleren

Controleer de mapstructuur van uw bundelsjabloonproject. Dit ziet er als volgt uit:

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

Uw sjabloon testen

Test ten slotte uw bundelsjabloon. Als u een bundel wilt genereren op basis van uw nieuwe aangepaste sjabloon, gebruikt u de databricks bundle init opdracht en geeft u de nieuwe sjabloonlocatie op. Vanuit de hoofdmap van uw bundelprojecten:

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

Volgende stappen

Resources