Partage via

Créer un modèle de bundle personnalisé

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

Pour plus d’informations sur les modèles de bundle personnalisés, consultez Modèles de bundle personnalisés.

Spécifications

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

Définir des variables de requête utilisateur

Tout d’abord, définissez les variables d'invite pour l'utilisateur databricks bundle init. Depuis la ligne de commande :

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

    mkdir dab-container-template

  2. Dans la racine du dossier, créez un fichier nommé databricks_template_schema.json:

    cd dab-container-template
touch databricks_template_schema.json

  3. Ajoutez le code JSON suivant au databricks_template_schema.json fichier pour définir une invite d’utilisateur pour le nom du projet groupé :

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

Créer la structure de dossiers de paquet

Ensuite, créez un template dossier pour contenir la structure de dossiers de vos bundles générés. Les noms des sous-répertoires et fichiers suivent la syntaxe du modèle de package Go.

Ce modèle crée le dossier de projet groupé en fonction de l’invite du nom du projet :

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

Créez maintenant les sous-répertoires resources et src pour les fichiers groupés :

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

Ajouter des modèles de configuration YAML

Dans le template/{{.project_name}} dossier, créez un fichier nommé databricks.yml.tmpl:

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

Ajoutez le yaML suivant à databricks.yml.tmpl. Cet exemple utilise des assistants de modèles groupés.

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

Créez un autre fichier YAML nommé {{.project_name}}_job.yml.tmpl dans le template/{{.project_name}}/resources dossier. Ce nouveau fichier YAML contient la définition du travail.

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

Ajoutez le yaML suivant à ce fichier pour décrire le travail de modèle, qui contient une tâche Python à exécuter sur un cluster de travaux à l’aide d’une image de conteneur Docker spécifique. Cet exemple utilise une image conteneur Docker de base Databricks par défaut, mais vous pouvez spécifier votre propre image personnalisée à la place.

# 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

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

Ensuite, créez le fichier de tâche Python référencé par le travail dans le modèle :

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

À présent, ajoutez les éléments suivants à task.py:

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

Vérifier la structure du modèle d’offre groupée

Passez en revue la structure de dossiers de votre projet de modèle d’offre groupée. Il doit ressembler à ceci :

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

Tester votre modèle

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

databricks bundle init dab-container-template

Étapes suivantes

Ressources

  • Last updated on