Partager via

Tutoriel : Créer votre premier modèle de bundle de ressources Databricks personnalisé

  • Article

Dans ce tutoriel, vous allez créer un modèle Databricks Asset Bundle personnalisé pour créer des packs qui exécutent un travail avec une tâche Python spécifique sur un cluster à l’aide d’une image conteneur Docker spécifique.

Avant de commencer

Installez Databricks CLI version 0.205 ou ultérieure. Si vous l’avez déjà installée, vérifiez que la version est 0.205 ou ultérieure en exécutant databricks -version depuis une ligne de commande.

Définir des variables d’invite utilisateur

La première étape de la création d’un modèle de pack consiste à définir les variables d’invite utilisateur databricks bundle init. Depuis la ligne de commande :

  1. Créez un répertoire vide nommé dab-container-template :

    mkdir dab-container-template

  2. À la racine du répertoire, créez un fichier nommé databricks_template_schema.json :

    cd dab-container-template
touch databricks_template_schema.json

  3. Ajoutez le contenu suivant à databricks_template_schema.json et enregistrez le fichier. Chaque variable est traduite en invite utilisateur lors de la création d’un pack.

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

Créer la structure de dossiers de pack

Ensuite, dans le répertoire du modèle, créez des sous-répertoires nommés resources et src. Le dossier template contient la structure de répertoires de vos bundles générés. Les noms des sous-répertoires et fichiers suivent la syntaxe de modèle de package Go lorsqu’ils sont dérivés de valeurs utilisateur.

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

Ajouter des modèles de configuration YAML

Dans le répertoire template, créez un fichier nommé databricks.yml.tmpl et ajoutez l’YAML suivant :

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

Créez un autre fichier YAML nommé {{.project_name}}_job.yml.tmpl et placez-le dans le répertoire template/resources. Ce nouveau fichier YAML fractionne les définitions de travaux du projet à partir du reste de la définition du pack. Ajoutez l’YAML suivant à ce fichier pour décrire le travail de modèle, qui contient une tâche Python spécifique à exécuter sur un cluster de travaux à l’aide d’une image conteneur Docker spécifique :

  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

Dans cet exemple, vous allez utiliser une image conteneur Docker de base Databricks par défaut, mais vous pouvez spécifier votre propre image personnalisée à la place.

Ajouter des fichiers référencés dans votre configuration

Ensuite, créez un répertoire template/src/{{.project_name}} et créez le fichier de tâche Python référencé par le travail dans le modèle :

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

Maintenant, ajoutez ce qui suit à task.py :

  import pyspark
  from pyspark.sql import SparkSession

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

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

Vérifier la structure du modèle de pack

Passez en revue la structure de dossiers de votre projet de modèle de pack. Il doit se présenter comme suit :

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

Tester votre modèle

Enfin, testez votre modèle de pack. Pour générer un pack basé sur votre nouveau modèle personnalisé, utilisez la commande databricks bundle init, en spécifiant le nouvel emplacement du modèle. À partir de votre dossier racine de projets de pack :

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

Étapes suivantes

Ressources