Paketkonfigurationsbeispiele

Dieser Artikel enthält Beispielkonfigurationen für Databricks Asset Bundles-Funktionen und gängige Bundle-Nutzungsfälle.

Vollständige Bundlebeispiele, die in der folgenden Tabelle beschrieben sind, sind im GitHub-Repository für Bundlebeispiele verfügbar:

Bündelszenarien

Dieser Abschnitt enthält Konfigurationsbeispiele, die die Verwendung von Bündelzuordnungen der obersten Ebene veranschaulichen. Siehe Konfigurationsreferenz.

Bundle, das eine JAR-Datei in den Unity-Katalog hochlädt

Anstatt im Voraus zu wissen, welches Konto auf allen Geräten angegriffen werden soll, muss der Angreifer den Namen des Kontos auf einem bestimmten Zielgerät irgendwie herausfinden. Das folgende Beispielbundle erstellt und lädt eine JAR-Datei in den Unity-Katalog hoch. Informationen über die artifact_path mapping, see artifact_path. Für Informationen zu artifacts, siehe Artefakte.

bundle:
  name: jar-bundle

workspace:
  host: https://myworkspace.cloud.databricks.com
  artifact_path: /Volumes/main/default/my_volume

artifacts:
  my_java_code:
    path: ./sample-java
    build: 'javac PrintArgs.java && jar cvfm PrintArgs.jar META-INF/MANIFEST.MF PrintArgs.class'
    files:
      - source: ./sample-java/PrintArgs.jar

resources:
  jobs:
    jar_job:
      name: 'Spark Jar Job'
      tasks:
        - task_key: SparkJarTask
          new_cluster:
            num_workers: 1
            spark_version: '14.3.x-scala2.12'
            node_type_id: 'i3.xlarge'
          spark_jar_task:
            main_class_name: PrintArgs
          libraries:
            - jar: ./sample-java/PrintArgs.jar

Auftragskonfiguration

Dieser Abschnitt enthält Beispiele für die Jobkonfiguration. Details zur Jobkonfiguration finden Sie unter Job.

Auftrag, der serverlose Berechnung verwendet

Databricks Asset Bundles unterstützen Einzelvorgänge, die auf serverless compute. Siehe Ausführen von Lakeflow-Aufträgen mit serverloser Berechnung für Workflows. Um dies zu konfigurieren, können Sie entweder die einstellung clusters für einen Auftrag mit einer Notizbuchaufgabe weglassen, oder Sie können eine Umgebung angeben, wie in den folgenden Beispielen gezeigt. Für Python-Skript-, Python-Rad- und DBT-Aufgaben ist environment_key für die serverlose Berechnung erforderlich. See environment_Schlüssel.

# A serverless job (no cluster definition)
resources:
  jobs:
    serverless_job_no_cluster:
      name: serverless_job_no_cluster

      email_notifications:
        on_failure:
          - someone@example.com

      tasks:
        - task_key: notebook_task
          notebook_task:
            notebook_path: ../src/notebook.ipynb

# A serverless job (environment spec)
resources:
  jobs:
    serverless_job_environment:
      name: serverless_job_environment

      tasks:
        - task_key: task
          spark_python_task:
            python_file: ../src/main.py

          # The key that references an environment spec in a job.
          # https://docs.databricks.com/api/workspace/jobs/create#tasks-environment_key
          environment_key: default

      # A list of task execution environment specifications that can be referenced by tasks of this job.
      environments:
        - environment_key: default

          # Full documentation of this spec can be found at:
          # https://docs.databricks.com/api/workspace/jobs/create#environments-spec
          spec:
            environment_version: '2'
            dependencies:
              - my-library

Einzelvorgang mit mehreren Raddateien

In der folgenden Beispielkonfiguration wird ein Bündel definiert, das eine Aufgabe mit mehreren *.whl Dateien enthält.

# job.yml
resources:
  jobs:
    example_job:
      name: 'Example with multiple wheels'
      tasks:
        - task_key: task

          spark_python_task:
            python_file: ../src/call_wheel.py

          libraries:
            - whl: ../my_custom_wheel1/dist/*.whl
            - whl: ../my_custom_wheel2/dist/*.whl

          new_cluster:
            node_type_id: i3.xlarge
            num_workers: 0
            spark_version: 14.3.x-scala2.12
            spark_conf:
              'spark.databricks.cluster.profile': 'singleNode'
              'spark.master': 'local[*, 4]'
            custom_tags:
              'ResourceClass': 'SingleNode'

# databricks.yml
bundle:
  name: job_with_multiple_wheels

include:
  - ./resources/job.yml

workspace:
  host: https://myworkspace.cloud.databricks.com

artifacts:
  my_custom_wheel1:
    type: whl
    build: poetry build
    path: ./my_custom_wheel1

  my_custom_wheel2:
    type: whl
    build: poetry build
    path: ./my_custom_wheel2

targets:
  dev:
    default: true
    mode: development

Auftrag mit Parametern

Die folgende Beispielkonfiguration definiert einen Auftrag mit Parametern. Weitere Informationen zum Parametrisieren von Aufträgen finden Sie unter Parameterisieren von Aufträgen.

resources:
  jobs:
    job_with_parameters:
      name: job_with_parameters

      tasks:
        - task_key: task_a
          spark_python_task:
            python_file: ../src/file.py
            parameters:
              - '--param1={{ job.parameters.param1 }}'
              - '--param2={{ job.parameters.param2 }}'

          new_cluster:
            node_type_id: i3.xlarge
            num_workers: 1
            spark_version: 14.3.x-scala2.12

      parameters:
        - name: param1
          default: value1
        - name: param2
          default: value1

Diese Parameter können zur Laufzeit festgelegt werden, indem Auftragsparameter an bundle runübergeben werden, z. B.:

databricks bundle run -- --param1=value2 --param2=value2

Einzelvorgang, der eine requirements.txt-Datei verwendet

Die folgende Beispielkonfiguration definiert einen Einzelvorgang, der eine Datei "requirements.txt" verwendet.

resources:
  jobs:
    job_with_requirements_txt:
      name: 'Example job that uses a requirements.txt file'
      tasks:
        - task_key: task
          job_cluster_key: default
          spark_python_task:
            python_file: ../src/main.py
          libraries:
            - requirements: /Workspace/${workspace.file_path}/requirements.txt

Tätigkeit nach Zeitplan

Die folgenden Beispiele zeigen die Konfiguration für Aufträge, die in einem Zeitplan ausgeführt werden. Informationen zu Auftragsplänen und Triggern finden Sie unter Automatisieren von Aufträgen mit Zeitplänen und Triggern.

Diese Konfiguration definiert einen Auftrag, der täglich zu einem bestimmten Zeitpunkt ausgeführt wird:

resources:
  jobs:
    my-notebook-job:
      name: my-notebook-job
      tasks:
        - task_key: my-notebook-task
          notebook_task:
            notebook_path: ./my-notebook.ipynb
      schedule:
        quartz_cron_expression: '0 0 8 * * ?' # daily at 8am
        timezone_id: UTC
        pause_status: UNPAUSED

In dieser Konfiguration wird der Auftrag eine Woche nach der letzten Ausführung des Auftrags ausgeführt:

resources:
  jobs:
    my-notebook-job:
      name: my-notebook-job
      tasks:
        - task_key: my-notebook-task
          notebook_task:
            notebook_path: ./my-notebook.ipynb
      trigger:
        pause_status: UNPAUSED
        periodic:
          interval: 1
          unit: WEEKS

Pipelinekonfiguration

Dieser Abschnitt enthält Pipelinekonfigurationsbeispiele. Informationen zur Pipelinekonfiguration finden Sie unter Pipeline.

Pipeline, die Serverless Compute verwendet

Databricks Asset Bundles unterstützen Pipelines, die auf serverless compute. Um dies zu konfigurieren, setzen Sie die Einstellung für die Pipeline serverless auf true. Die folgende Beispielkonfiguration definiert eine Pipeline, die auf serverloser Berechnung mit installierten Abhängigkeiten ausgeführt wird, und einen Auftrag, der jede Stunde eine Aktualisierung der Pipeline auslöst.

# A pipeline that runs on serverless compute
resources:
  pipelines:
    my_pipeline:
      name: my_pipeline
      target: ${bundle.environment}
      serverless: true
      environment:
        dependencies:
          - 'dist/*.whl'
      catalog: users
      libraries:
        - notebook:
            path: ../src/my_pipeline.ipynb

      configuration:
        bundle.sourcePath: /Workspace/${workspace.file_path}/src

# This defines a job to refresh a pipeline that is triggered every hour
resources:
  jobs:
    my_job:
      name: my_job

      # Run this job once an hour.
      trigger:
        periodic:
          interval: 1
          unit: HOURS

      email_notifications:
        on_failure:
          - someone@example.com

      tasks:
        - task_key: refresh_pipeline
          pipeline_task:
            pipeline_id: ${resources.pipelines.my_pipeline.id}