Ressources des Asset Bundles de Databricks

Databricks Asset Bundles vous permet de spécifier des informations sur les ressources Azure Databricks utilisées par le bundle dans le mappage resources dans la configuration de l’offre groupée. Consultez la cartographie des ressources ainsi que les références clés des ressources .

Cette page fournit des informations de référence sur la configuration pour tous les types de ressources pris en charge pour les offres groupées et fournit des détails et un exemple pour chaque type pris en charge. Pour obtenir d’autres exemples, consultez les exemples de configuration du Bundle .

Le schéma JSON pour les bundles utilisés pour valider la configuration YAML se trouve dans le référentiel GitHub de l’interface CLI Databricks.

Ressources prises en charge

Le tableau suivant répertorie les types de ressources pris en charge pour les bundles (YAML et Python, le cas échéant). Certaines ressources peuvent être créées en les définissant dans un bundle et en déployant le bundle, et certaines ressources peuvent uniquement être créées en référençant une ressource existante à inclure dans le bundle.

La configuration des ressources définit un objet Databricks qui correspond à un objet API REST Databricks . Les champs de demande de création pris en charge par l’objet API REST, exprimés en tant que YAML, sont les clés prises en charge par la ressource. Les liens vers la documentation de l’objet correspondant de chaque ressource se trouvent dans le tableau ci-dessous.

alerte

Type: Map

La ressource d’alerte définit une alerte SQL (v2).

alerts:
  <alert-name>:
    <alert-field-name>: <alert-field-value>

alert.evaluation

Type: Map

Configuration de l’évaluation de l’alerte.

alerte.évaluation.notification

Type: Map

L’utilisateur ou une autre destination à notifier lorsque l’alerte est déclenchée.

alert.evaluation.notification.abonnements

Type: Sequence

Liste non ordonnée d’abonnements aux notifications.

Chaque élément de la liste est un AlertSubscription:

source.d'évaluation.d'alerte

Type: Map

Colonne source du résultat à utiliser pour évaluer l’alerte.

alert.evaluation.threshold

Type: Map

Le seuil à utiliser pour l’évaluation des alertes peut être une colonne ou une valeur.

alert.evaluation.threshold.value

Type: Map

Valeur littérale à utiliser comme seuil. Spécifiez l’un des types valeur suivants.

alerte.horaire

Type: Map

Configuration de planification de l’alerte.

Examples

L’exemple de configuration suivant définit une alerte avec une évaluation simple :

resources:
  alerts:
    my_alert:
      display_name: my_alert
      evaluation:
        comparison_operator: EQUAL
        source:
          name: '1'
        threshold:
          value:
            double_value: 2
      query_text: select 2
      schedule:
        quartz_cron_schedule: '44 19 */1 * * ?'
        timezone_id: Europe/Amsterdam
      warehouse_id: 799f096837fzzzz4

L’exemple de configuration suivant définit une alerte avec des autorisations qui évaluent l’utilisation de l’agrégation et envoient des notifications :

resources:
  alerts:
    my_alert:
      permissions:
        - level: CAN_MANAGE
          user_name: someone@example.com
      custom_summary: 'My alert'
      display_name: 'My alert'
      evaluation:
        comparison_operator: 'EQUAL'
        notification:
          notify_on_ok: false
          retrigger_seconds: 1
        source:
          aggregation: 'MAX'
          display: '1'
          name: '1'
        threshold:
          value:
            double_value: 2
      query_text: 'select 2'
      schedule:
        pause_status: 'UNPAUSED'
        quartz_cron_schedule: '44 19 */1 * * ?'
        timezone_id: 'Europe/Amsterdam'
      warehouse_id: 799f096837fzzzz4

application

Type: Map

La ressource d’application définit une application Databricks. Pour plus d’informations sur Databricks Apps, consultez Databricks Apps.

Pour ajouter une application, spécifiez les paramètres pour définir l’application, y compris les éléments requis source_code_path.

databricks bundle init https://github.com/databricks/bundle-examples --template-dir contrib/templates/streamlit-app

apps:
  <app-name>:
    <app-field-name>: <app-field-value>

app.resources

Type: Sequence

Liste des ressources de calcul pour l’application.

Chaque élément de la liste est un AppResource:

app.resources.base de données

Type: Map

Paramètres qui identifient la base de données Lakebase à utiliser.

app.resources.génie_space

Type: Map

Paramètres qui identifient l’espace Génie à utiliser.

app.resources.job

Type: Map

Paramètres qui identifient la ressource de travail à utiliser.

app.ressources.secret

Type: Map

Paramètres qui identifient la ressource secrète Azure Databricks à utiliser.

app.resources.point_de_terminaison_de_service

Type: Map

Paramètres qui identifient la ressource de point de terminaison de service du modèle à utiliser.

app.resources.sql_warehouse

Type: Map

Paramètres qui identifient l’entrepôt SQL à utiliser.

app.resources.uc_securable

Type: Map

Paramètres qui identifient le volume du catalogue Unity à utiliser.

Example

L’exemple suivant crée une application nommée my_app qui gère un travail créé par le bundle :

resources:
  jobs:
    # Define a job in the bundle
    hello_world:
      name: hello_world
      tasks:
        - task_key: task
          spark_python_task:
            python_file: ../src/main.py
          environment_key: default

      environments:
        - environment_key: default
          spec:
            environment_version: '2'

  # Define an app that manages the job in the bundle
  apps:
    job_manager:
      name: 'job_manager_app'
      description: 'An app which manages a job created by this bundle'

      # The location of the source code for the app
      source_code_path: ../src/app

      # The resources in the bundle which this app has access to. This binds the resource in the app with the bundle resource.
      resources:
        - name: 'app-job'
          job:
            id: ${resources.jobs.hello_world.id}
            permission: 'CAN_MANAGE_RUN'

Le correspondant app.yaml définit la configuration pour l’exécution de l’application :

command:
  - flask
  - --app
  - app
  - run
  - --debug
env:
  - name: JOB_ID
    valueFrom: 'app-job'

Pour l’exemple complet de l’application Databricks, consultez le dépôt GitHub bundle-examples .

Grappe

Type: Map

La ressource de cluster définit un cluster.

clusters:
  <cluster-name>:
    <cluster-field-name>: <cluster-field-value>

cluster.autoscale

Type: Map

Paramètres de mise à l’échelle automatique des clusters vers le haut et vers le bas en fonction de la charge.

cluster.aws_attributes

Type: Map

Attributs liés aux clusters s’exécutant sur Amazon Web Services.

cluster.azure_attributes

Type: Map

Attributs liés aux clusters s’exécutant sur Microsoft Azure.

cluster.gcp_attributes

Type: Map

Attributs liés aux clusters s’exécutant sur Google Cloud Platform.

cluster.cluster_log_conf

Configuration de la livraison des journaux Spark à une destination de stockage à long terme.

cluster.cluster_log_conf.dbfs

Type: Map

Emplacement DBFS pour la livraison des journaux du cluster.

cluster.cluster_log_conf.s3

Type: Map

Emplacement S3 pour la livraison des logs de cluster.

cluster.cluster_log_conf.volumes

Type: Map

Emplacement des volumes pour la livraison des journaux de clusters.

cluster.docker_image

Type: Map

La configuration de l'image Docker personnalisée.

cluster.docker_image.basic_auth

Type: Map

Authentification de base pour le référentiel Docker.

cluster.init_scripts

Type: Map

Configuration pour le stockage de scripts init. Au moins un type d’emplacement doit être spécifié.

cluster.init_scripts.dbfs

Type: Map

Emplacement DBFS du script init.

cluster.init_scripts.espace_de_travail

Type: Map

Emplacement de l’espace de travail du script init.

cluster.init_scripts.s3

Type: Map

Emplacement S3 du script d'initialisation.

cluster.init_scripts.abfss

Type: Map

Emplacement du script d'initialisation ABFSS.

cluster.init_scripts.gcs

Type: Map

Emplacement du script d'initialisation GCS.

scripts_d'initialisation_du_cluster.volumes

Type: Map

Emplacement des volumes de données pour le script d'initialisation.

cluster.type_de_charge_de_travail

Type: Map

Attributs de cluster montrant les types de charge de travail de cluster.

cluster.workload_type.clients

Type: Map

Type de clients pour cette charge de travail de calcul.

Examples

L’exemple suivant crée un cluster dédié (mono-utilisateur) pour l’utilisateur actuel avec Databricks Runtime 15.4 LTS et une stratégie de cluster :

resources:
  clusters:
    my_cluster:
      num_workers: 0
      node_type_id: 'i3.xlarge'
      driver_node_type_id: 'i3.xlarge'
      spark_version: '15.4.x-scala2.12'
      spark_conf:
        'spark.executor.memory': '2g'
      autotermination_minutes: 60
      enable_elastic_disk: true
      single_user_name: ${workspace.current_user.userName}
      policy_id: '000128DB309672CA'
      enable_local_disk_encryption: false
      data_security_mode: SINGLE_USER
      runtime_engine": STANDARD

Cet exemple crée un cluster my_cluster simple et définit celui-ci comme cluster à utiliser pour exécuter le notebook dans my_job:

bundle:
  name: clusters

resources:
  clusters:
    my_cluster:
      num_workers: 2
      node_type_id: 'i3.xlarge'
      autoscale:
        min_workers: 2
        max_workers: 7
      spark_version: '13.3.x-scala2.12'
      spark_conf:
        'spark.executor.memory': '2g'

  jobs:
    my_job:
      tasks:
        - task_key: test_task
          notebook_task:
            notebook_path: './src/my_notebook.py'
          existing_cluster_id: ${resources.clusters.my_cluster.id}

tableau de bord

Type: Map

La ressource de tableau de bord vous permet de gérer tableaux de bord IA/BI dans un bundle. Pour plus d’informations sur les tableaux de bord IA/BI, consultez Tableaux de bord.

Si vous avez déployé un bundle qui contient un tableau de bord à partir de votre environnement local, puis utilisez l’interface utilisateur pour modifier ce tableau de bord, les modifications apportées via l’interface utilisateur ne sont pas appliquées au fichier JSON du tableau de bord dans le bundle local, sauf si vous la mettez explicitement à jour à l’aide bundle generate. Vous pouvez utiliser l’option --watch pour interroger et récupérer en continu les modifications apportées au tableau de bord. Consultez l’offre groupée databricks générée.

En outre, si vous tentez de déployer un bundle à partir de votre environnement local qui contient un fichier JSON de tableau de bord différent de celui de l’espace de travail distant, une erreur se produit. Pour forcer le déploiement et remplacer le tableau de bord dans l’espace de travail distant avec celui local, utilisez l’option --force. Consultez le déploiement de l’offre groupée databricks.

sync:
  exclude:
    - src/*.lvdash.json

dashboards:
  <dashboard-name>:
    <dashboard-field-name>: <dashboard-field-value>

Example

L’exemple suivant inclut et déploie l’exemple de tableau de bord NYC Taxi Trip Analysis sur l’espace de travail Databricks.

resources:
  dashboards:
    nyc_taxi_trip_analysis:
      display_name: 'NYC Taxi Trip Analysis'
      file_path: ../src/nyc_taxi_trip_analysis.lvdash.json
      warehouse_id: ${var.warehouse_id}

catalogue_de_bases_de_données

Type: Map

La ressource de catalogue de bases de données vous permet de définir des catalogues de bases de données qui correspondent aux instances de base de données d’un bundle. Un catalogue de bases de données est une base de données Lakebase inscrite en tant que catalogue de catalogue Unity.

Pour plus d’informations sur les catalogues de bases de données, consultez Créer un catalogue.

database_catalogs:
  <database_catalog-name>:
    <database_catalog-field-name>: <database_catalog-field-value>

Example

L’exemple suivant définit une instance de base de données avec un catalogue de bases de données correspondant :

resources:
  database_instances:
    my_instance:
      name: my-instance
      capacity: CU_1
  database_catalogs:
    my_catalog:
      database_instance_name: ${resources.database_instances.my_instance.name}
      name: example_catalog
      database_name: my_database
      create_database_if_not_exists: true

instance de base de données

Type: Map

La ressource d’instance de base de données vous permet de définir des instances de base de données dans un bundle. Une instance de base de données Lakebase gère les ressources de stockage et de calcul et fournit les points de terminaison auxquels les utilisateurs se connectent.

Pour plus d’informations sur les instances de base de données, consultez Qu’est-ce qu’une instance de base de données ?.

database_instances:
  <database_instance-name>:
    <database_instance-field-name>: <database_instance-field-value>

database_instance.parent_instance_ref

Type: Map

Référence de l’instance parente. Cela n’est disponible que si l’instance est une instance enfant.

Example

L’exemple suivant définit une instance de base de données avec un catalogue de bases de données correspondant :

resources:
  database_instances:
    my_instance:
      name: my-instance
      capacity: CU_1
  database_catalogs:
    my_catalog:
      database_instance_name: ${resources.database_instances.my_instance.name}
      name: example_catalog
      database_name: my_database
      create_database_if_not_exists: true

Pour obtenir un exemple d’offre groupée qui montre comment définir une instance de base de données et un catalogue de bases de données correspondant, consultez le référentiel GitHub bundle-examples.

expérience

Type: Map

La ressource d’expérience vous permet de définir des expériences MLflow dans un pack. Pour plus d’informations sur les expériences MLflow, consultez Organiser les exécutions d’entraînement avec des expériences MLflow.

experiments:
  <experiment-name>:
    <experiment-field-name>: <experiment-field-value>

Example

L’exemple suivant définit une expérience que tous les utilisateurs peuvent afficher :

resources:
  experiments:
    experiment:
      name: /Workspace/Users/someone@example.com/my_experiment
      permissions:
        - level: CAN_READ
          group_name: users
      description: MLflow experiment used to track runs

travail

Type: Map

Les jobs sont pris en charge dans Python pour les bundles de ressources Databricks. Voir databricks.bundles.jobs.

La ressource de travail vous permet de définir des travaux et les tâches correspondantes dans votre pack.

Pour plus d’informations sur les travaux, consultez Travaux Lakeflow. Pour obtenir un didacticiel qui utilise un modèle Databricks Asset Bundles pour créer un travail, consultez Développer un travail avec databricks Asset Bundles.

jobs:
  <job-name>:
    <job-field-name>: <job-field-value>

job.continuous

Type: Map

Configuration pour l’exécution continue du travail.

job.deployment

Type: Map

Informations de déploiement pour les travaux gérés par des sources externes.

emploi.notifications_par_email

Type: Map

Paramètres de notification par e-mail pour les exécutions de travaux.

environnements.d'emploi

Type: Sequence

Liste des spécifications de l'environnement d'exécution des tâches pouvant être référencées par des tâches serverless d’un processus.

Chaque élément de la liste est un JobEnvironment:

job.environments.spec

Type: Map

Entité qui représente un environnement serverless.

job.git_source

Type: Map

Configuration du référentiel Git pour le code source du travail.

job.git_source.git_snapshot

Type: Map

Capture instantanée des informations de validation en lecture seule.

santé.du.travail

Type: Map

Configuration de la surveillance de l’état de la tâche.

règles.santé.travail

Type: Sequence

Liste des règles de santé du travail.

Chaque élément de la liste est un JobHealthRule:

tâche.tâches_regroupées

Type: Sequence

Liste des spécifications de cluster de travaux qui peuvent être partagées et réutilisées par les tâches de ce travail. Les bibliothèques ne peuvent pas être déclarées dans un cluster de travaux partagés. Vous devez déclarer des bibliothèques dépendantes dans les paramètres de tâche.

Chaque élément de la liste est un JobCluster:

tâche.paramètres_de_notification

Type: Map

Paramètres de notification qui s’appliquent à toutes les notifications pour le travail.

job.queue

Type: Map

Paramètres de file d’attente de la tâche.

job.schedule

Type: Map

Planifiez la configuration pour l’exécution périodique du travail.

job.déclencheur

Type: Map

Configuration de déclenchement pour l'exécution du travail piloté par les événements.

job.déclencheur.arrivée_fichier

Type: Map

Déclenchez la configuration en fonction de l’arrivée du fichier.

job.trigger.table

Type: Map

Déclencher la configuration en fonction d’une table.

job.trigger.table_update

Type: Map

Configuration de déclencheur basée sur les mises à jour de la table.

job.déclencheur.périodique

Type: Map

Configuration du déclencheur périodique

job.webhook_notifications

Type: Map

Paramètres de notification webhook pour les exécutions de tâches.

Examples

L'exemple suivant définit une tâche avec la clé de ressource hello-job et une tâche de carnet :

resources:
  jobs:
    hello-job:
      name: hello-job
      tasks:
        - task_key: hello-task
          notebook_task:
            notebook_path: ./hello.py

L’exemple suivant définit un travail avec un notebook SQL :

resources:
  jobs:
    job_with_sql_notebook:
      name: 'Job to demonstrate using a SQL notebook with a SQL warehouse'
      tasks:
        - task_key: notebook
          notebook_task:
            notebook_path: ./select.sql
            warehouse_id: 799f096837fzzzz4

Pour obtenir des exemples de configuration de travail supplémentaires, consultez Configuration du travail.

Pour plus d’informations sur la définition des tâches et la substitution des paramètres de travail, consultez :

• Ajouter des tâches à des travaux dans databricks Asset Bundles
• Remplacement des paramètres de tâche de travail

modèle (hérité)

Type: Map

La ressource de modèle vous permet de définir des modèles hérités dans les packs. Databricks vous recommande plutôt d'utiliser les modèles enregistrés dans le catalogue Unity .

point_de_serveur_de_modèle

Type: Map

La ressource model_serving_endpoint vous permet de définir des points de terminaison de service de modèles. Consultez Gérer les points de terminaison de mise en service de modèles.

model_serving_endpoints:
  <model_serving_endpoint-name>:
    <model_serving_endpoint-field-name>: <model_serving_endpoint-field-value>

model_serving_endpoint.ai_gateway

Type: Map

Configuration de la passerelle d'intelligence artificielle pour le terminal de service.

model_serving_endpoint.ai_gateway.garde-fous

Type: Map

Configuration des garde-fous de passerelle IA.

model_serving_endpoint.ai_gateway.inference_table_config

Type: Map

Configuration de la journalisation de l’inférence dans les tables du catalogue Unity.

model_serving_endpoint.ai_gateway.usage_tracking_config

Type: Map

Configuration de la passerelle IA pour le suivi de l’utilisation.

model_serving_endpoint.config

Type: Map

Configuration principale de l'endpoint de service.

model_serving_endpoint.config.traffic_config

Type: Map

Configuration de trafic définissant comment les requêtes vers le point d'accès doivent être routées.

point_d'accès_de_service_de_modèle.config.capture_automatique_config

Type: Map

Configuration des tables d’inférence qui journalise automatiquement les demandes et les réponses au catalogue Unity.

Example

L’exemple suivant définit un point de terminaison de mise en service de modèles pour Unity Catalog :

resources:
  model_serving_endpoints:
    uc_model_serving_endpoint:
      name: 'uc-model-endpoint'
      config:
        served_entities:
          - entity_name: 'myCatalog.mySchema.my-ads-model'
            entity_version: '10'
            workload_size: 'Small'
            scale_to_zero_enabled: 'true'
        traffic_config:
          routes:
            - served_model_name: 'my-ads-model-10'
              traffic_percentage: '100'
      tags:
        - key: 'team'
          value: 'data science'

chaîne de traitement

Type: Map

Les pipelines sont pris en charge dans Python pour les bundles de ressources Databricks. Consultez databricks.bundles.pipelines.

La ressource de pipeline vous permet de créer des pipelines. Pour plus d’informations sur les pipelines, consultez Pipelines déclaratifs Spark Lakeflow. Pour obtenir un didacticiel qui utilise le modèle Databricks Asset Bundles pour créer un pipeline, consultez Développer des pipelines déclaratifs Spark Lakeflow avec des bundles de ressources Databricks.

pipelines:
  <pipeline-name>:
    <pipeline-field-name>: <pipeline-field-value>

pipeline.deploiement

Type: Map

Configuration du type de déploiement pour le pipeline.

pipeline.environnement

Type: Map

Spécification d'environnement pour l'installation des dépendances sur une infrastructure serverless.

pipeline.journal_des_événements

Type: Map

Configuration du journal des événements pour le pipeline.

pipeline.filtres

Type: Map

Filtres qui déterminent les packages de pipeline à inclure dans le graphique déployé.

pipeline.ingestion_definition

Type: Map

Configuration d’un pipeline d’ingestion managé. Ces paramètres ne peuvent pas être utilisés avec les paramètres libraries, schema, target, ou catalog.

SchemaSpec

Type: Map

Spécification de l’objet de schéma pour l’ingestion de toutes les tables à partir d’un schéma.

TableSpec

Type: Map

Spécification de l’objet Table pour l’ingestion d’une table spécifique.

Spécification du Rapport

Type: Map

Spécification de l’objet rapport pour l’ingestion de rapports d’analyse.

pipeline.ingestion_definition.source_configuration

Type: Map

Configuration de la source.

pipeline.définition_d_ingestion.configuration_de_source.catalogue

Type: Map

Paramètres de configuration source au niveau du catalogue

pipeline.ingestion_definition.table_configuration

Type: Map

Options de configuration pour les tables d’ingestion.

pipeline.bibliothèques

Type: Sequence

Définit la liste des bibliothèques ou du code nécessaires par ce pipeline.

Chaque élément de la liste est une définition :

pipeline.bibliothèques.fichier

Type: Map

Chemin d’accès à un fichier qui définit un pipeline et qui est stocké dans databricks Repos.

pipeline.libraries.glob

Type: Map

Champ unifié pour inclure du code source. Chaque entrée peut être un chemin d’accès au bloc-notes, un chemin d’accès au fichier ou un chemin d’accès de dossier qui se termine /**. Ce champ ne peut pas être utilisé avec notebook ou file.

pipeline.libraries.notebook

Type: Map

Chemin d’accès à un notebook qui définit un pipeline et qui est stocké dans l’espace de travail Databricks.

Example

L’exemple suivant définit un pipeline avec la clé de ressource hello-pipeline:

resources:
  pipelines:
    hello-pipeline:
      name: hello-pipeline
      clusters:
        - label: default
          num_workers: 1
      development: true
      continuous: false
      channel: CURRENT
      edition: CORE
      photon: false
      libraries:
        - notebook:
            path: ./pipeline.py

Pour obtenir des exemples de configuration de pipeline supplémentaires, consultez Configuration du pipeline.

moniteur_de_qualité (Unity Catalog)

Type: Map

La ressource quality_monitor vous permet de définir un moniteur de table Unity Catalog . Pour plus d’informations sur les moniteurs, consultez Profilage des données.

quality_monitors:
  <quality_monitor-name>:
    <quality_monitor-field-name>: <quality_monitor-field-value>

quality_monitor.indicateurs_personnalisés

Type: Sequence

Liste des définitions de métrique personnalisées.

Chaque élément de la liste est un CustomMetric:

quality_monitor.data_classification_config

Type: Map

Configuration de la classification des données.

quality_monitor.inference_log

Type: Map

Configuration pour le monitoring des journaux d’inférence.

quality_monitor.notifcations

Type: Map

Paramètres de notification pour le moniteur.

monitor_qualité.notifications.échec

Type: Map

Paramètres de notification lorsque le moniteur échoue.

moniteur_qualité.notifications.lorsqu_nouveau_tag_de_classification_detecté

Type: Map

Paramètres de notification lorsque de nouvelles balises de classification sont détectées.

quality_monitor.schedule

Type: Map

Planifiez la mise à jour et l’actualisation automatique des tables de métriques.

moniteur_qualité.snapshot

Type: Map

Configuration pour le monitoring des tables d’instantanés.

quality_monitor.séries_temporelles

Configuration pour le monitoring des tables de série chronologique.

Examples

Pour obtenir un exemple complet de pack qui définit un quality_monitor, consultez le pack mlops_demo.

Les exemples suivants définissent des moniteurs de qualité pour les types de profil InferenceLog, TimeSeries et Snapshot .

# InferenceLog profile type
resources:
  quality_monitors:
    my_quality_monitor:
      table_name: dev.mlops_schema.predictions
      output_schema_name: ${bundle.target}.mlops_schema
      assets_dir: /Workspace/Users/${workspace.current_user.userName}/databricks_lakehouse_monitoring
      inference_log:
        granularities: [1 day]
        model_id_col: model_id
        prediction_col: prediction
        label_col: price
        problem_type: PROBLEM_TYPE_REGRESSION
        timestamp_col: timestamp
      schedule:
        quartz_cron_expression: 0 0 8 * * ? # Run Every day at 8am
        timezone_id: UTC

# TimeSeries profile type
resources:
  quality_monitors:
    my_quality_monitor:
      table_name: dev.mlops_schema.predictions
      output_schema_name: ${bundle.target}.mlops_schema
      assets_dir: /Workspace/Users/${workspace.current_user.userName}/databricks_lakehouse_monitoring
      time_series:
        granularities: [30 minutes]
        timestamp_col: timestamp
      schedule:
        quartz_cron_expression: 0 0 8 * * ? # Run Every day at 8am
        timezone_id: UTC

# Snapshot profile type
resources:
  quality_monitors:
    my_quality_monitor:
      table_name: dev.mlops_schema.predictions
      output_schema_name: ${bundle.target}.mlops_schema
      assets_dir: /Workspace/Users/${workspace.current_user.userName}/databricks_lakehouse_monitoring
      snapshot: {}
      schedule:
        quartz_cron_expression: 0 0 8 * * ? # Run Every day at 8am
        timezone_id: UTC

registered_model (catalogue Unity)

Type: Map

La ressource de modèle inscrite vous permet de définir des modèles dans le catalogue Unity. Pour découvrir plus d’informations sur les modèles enregistrés d’Unity Catalog, consultez Gérer le cycle de vie des modèles dans Unity Catalog.

registered_models:
  <registered_model-name>:
    <registered_model-field-name>: <registered_model-field-value>

registered_model.aliases

Type: Sequence

Liste des alias associés au modèle inscrit.

Chaque élément de la liste est un Alias:

Example

L’exemple suivant définit un modèle inscrit dans le catalogue Unity :

resources:
  registered_models:
    model:
      name: my_model
      catalog_name: ${bundle.target}
      schema_name: mlops_schema
      comment: Registered model in Unity Catalog for ${bundle.target} deployment target
      grants:
        - privileges:
            - EXECUTE
          principal: account users

schéma (Unity Catalog)

Type: Map

Les schémas sont pris en charge dans Python pour les bundles de ressources Databricks. Consultez databricks.bundles.schemas.

Le type de ressource de schéma vous permet de définir des schémas de catalogue Unity pour les tables et autres ressources de vos flux de travail et pipelines créés dans le cadre d’un bundle. Un schéma, différent des autres types de ressources, présente les limitations suivantes :

• Le propriétaire d’une ressource de schéma est toujours l’utilisateur de déploiement et ne peut pas être modifié. Si run_as est spécifié dans le bundle, il est ignoré par les opérations sur le schéma.
• Seuls les champs pris en charge par l’API de création d’objet Schemas correspondante sont disponibles pour la ressource de schéma. Par exemple, enable_predictive_optimization n’est pas pris en charge, car il n’est disponible que sur l’API de mise à jour.

schemas:
  <schema-name>:
    <schema-field-name>: <schema-field-value>

Examples

L’exemple suivant définit un pipeline avec la clé de ressource my_pipeline qui crée un schéma de catalogue Unity avec la clé my_schema comme cible :

resources:
  pipelines:
    my_pipeline:
      name: test-pipeline-{{.unique_id}}
      libraries:
        - notebook:
            path: ../src/nb.ipynb
        - file:
            path: ../src/range.sql
      development: true
      catalog: ${resources.schemas.my_schema.catalog_name}
      target: ${resources.schemas.my_schema.id}

  schemas:
    my_schema:
      name: test-schema-{{.unique_id}}
      catalog_name: main
      comment: This schema was created by Databricks Asset Bundles.

Un mappage d’octrois de niveau supérieur n’est pas pris en charge par les bundles de ressources Databricks. Par conséquent, si vous souhaitez définir des subventions pour un schéma, définissez les subventions pour le schéma au sein du mappage schemas. Pour plus d’informations sur les subventions, consultez Afficher, accorder et révoquer des privilèges.

L’exemple suivant définit un schéma de catalogue Unity avec des subventions :

resources:
  schemas:
    my_schema:
      name: test-schema
      grants:
        - principal: users
          privileges:
            - SELECT
        - principal: my_team
          privileges:
            - CAN_MANAGE
      catalog_name: main

secret_scope

Type: Map

La ressource secret_scope vous permet de définir des étendues secrètes dans un bundle. Pour plus d’informations sur les étendues de secret, consultez Gestion des secrets.

secret_scopes:
  <secret_scope-name>:
    <secret_scope-field-name>: <secret_scope-field-value>

secret_scope.keyvault_metadata

Type: Map

Métadonnées pour les étendues secrètes sauvegardées par Azure Key Vault.

Examples

L'exemple suivant définit une étendue secrète qui utilise un backend de coffre-fort de clés :

resources:
  secret_scopes:
    secret_scope_azure:
      name: test-secrets-azure-backend
      backend_type: 'AZURE_KEYVAULT'
      keyvault_metadata:
        resource_id: my_azure_keyvault_id
        dns_name: my_azure_keyvault_dns_name

L’exemple suivant définit une liste de contrôle d’accès personnalisée à l’aide d’étendues et d’autorisations secrètes :

resources:
  secret_scopes:
    my_secret_scope:
      name: my_secret_scope
      permissions:
        - user_name: admins
          level: WRITE
        - user_name: users
          level: READ

Pour obtenir un exemple de bundle illustrant comment définir une étendue de secret et un travail avec une tâche qui la lit dans un bundle, consultez le dépôt GitHub bundle-examples.

sql_warehouse

Type: Map

La ressource SQL Warehouse vous permet de définir un entrepôt SQL dans un bundle. Pour plus d’informations sur les entrepôts SQL, consultez l’entreposage de données sur Azure Databricks.

sql_warehouses:
  <sql-warehouse-name>:
    <sql-warehouse-field-name>: <sql-warehouse-field-value>

sql_warehouse.channel

Type: Map

Configuration de canal pour l'entrepôt SQL.

Example

L’exemple suivant définit un entrepôt SQL :

resources:
  sql_warehouses:
    my_sql_warehouse:
      name: my_sql_warehouse
      cluster_size: X-Large
      enable_serverless_compute: true
      max_num_clusters: 3
      min_num_clusters: 1
      auto_stop_mins: 60
      warehouse_type: PRO

table_de_base_de_données_synchronisée

Type: Map

La ressource de table de base de données synchronisée vous permet de définir des tables de base de données Lakebase dans un bundle.

Pour plus d’informations sur les tables de base de données synchronisées, consultez Qu’est-ce qu’une instance de base de données ?.

synced_database_tables:
  <synced_database_table-name>:
    <synced_database_table-field-name>: <synced_database_table-field-value>

table_de_base_de_données_synchronisée.spec

Type: Map

Spécification de la table de base de données.

synced_database_table.spec.new_pipeline_spec

Type: Map

Spécification d’un nouveau pipeline utilisé par la table de base de données synchronisée.

Examples

L’exemple suivant définit une table de base de données synchronisée dans un catalogue de bases de données correspondant :

resources:
  database_instances:
    my_instance:
      name: my-instance
      capacity: CU_1
  database_catalogs:
    my_catalog:
      database_instance_name: my-instance
      database_name: 'my_database'
      name: my_catalog
      create_database_if_not_exists: true
  synced_database_tables:
    my_synced_table:
      name: ${resources.database_catalogs.my_catalog.name}.${resources.database_catalogs.my_catalog.database_name}.my_destination_table
      database_instance_name: ${resources.database_catalogs.my_catalog.database_instance_name}
      logical_database_name: ${resources.database_catalogs.my_catalog.database_name}
      spec:
        source_table_full_name: 'my_source_table'
        scheduling_policy: SNAPSHOT
        primary_key_columns:
          - my_pk_column
        new_pipeline_spec:
          storage_catalog: 'my_delta_catalog'
          storage_schema: 'my_delta_schema'

L’exemple suivant définit une table de base de données synchronisée à l’intérieur d’un catalogue standard :

resources:
  synced_database_tables:
    my_synced_table:
      name: 'my_standard_catalog.public.synced_table'
      # database_instance_name is required for synced tables created in standard catalogs.
      database_instance_name: 'my-database-instance'
      # logical_database_name is required for synced tables created in standard catalogs:
      logical_database_name: ${resources.database_catalogs.my_catalog.database_name}
      spec:
        source_table_full_name: 'source_catalog.schema.table'
        scheduling_policy: SNAPSHOT
        primary_key_columns:
          - my_pk_column
        create_database_objects_if_missing: true
        new_pipeline_spec:
          storage_catalog: 'my_delta_catalog'
          storage_schema: 'my_delta_schema'

Cet exemple crée une table de base de données synchronisée et personnalise son calendrier de pipeline. Il part du principe que vous avez déjà :

• Instance de base de données nommée my-database-instance
• Un catalogue standard nommé my_standard_catalog
• Schéma dans le catalogue standard nommé default
• Table delta source nommée source_delta.schema.customer avec la clé primaire c_custkey

resources:
  synced_database_tables:
    my_synced_table:
      name: 'my_standard_catalog.default.my_synced_table'
      database_instance_name: 'my-database-instance'
      logical_database_name: 'test_db'
      spec:
        source_table_full_name: 'source_delta.schema.customer'
        scheduling_policy: SNAPSHOT
        primary_key_columns:
          - c_custkey
        create_database_objects_if_missing: true
        new_pipeline_spec:
          storage_catalog: 'source_delta'
          storage_schema: 'schema'

  jobs:
    sync_pipeline_schedule_job:
      name: sync_pipeline_schedule_job
      description: 'Job to schedule synced database table pipeline.'
      tasks:
        - task_key: synced-table-pipeline
          pipeline_task:
            pipeline_id: ${resources.synced_database_tables.my_synced_table.data_synchronization_status.pipeline_id}
      schedule:
        quartz_cron_expression: '0 0 0 * * ?'

volume (catalogue Unity)

Type: Map

Les volumes sont pris en charge dans Python pour les bundles de ressources Databricks. Consultez databricks.bundles.volumes.

Le type de ressource de volume vous permet de définir et de créer des volumes de catalogue Unity dans le cadre d’un bundle. Lors du déploiement d’un bundle avec un volume défini, notez que :

• Un volume ne peut pas être référencé dans le artifact_path de l’ensemble tant qu’il n’existe pas dans l’espace de travail. Par conséquent, si vous souhaitez utiliser databricks Asset Bundles pour créer le volume, vous devez d’abord définir le volume dans le bundle, le déployer pour créer le volume, puis le référencer dans le artifact_path dans les déploiements suivants.
• Les volumes dans l'ensemble ne sont pas précédés du préfixe dev_${workspace.current_user.short_name} lorsque la cible de déploiement est configurée avec mode: development. Toutefois, vous pouvez configurer manuellement ce préfixe. Consultez les Présélections personnalisées.

volumes:
  <volume-name>:
    <volume-field-name>: <volume-field-value>

Example

L’exemple suivant crée un volume de catalogue Unity avec la clé my_volume_id :

resources:
  volumes:
    my_volume_id:
      catalog_name: main
      name: my_volume
      schema_name: my_schema

Pour découvrir un exemple de pack qui exécute un travail et écrit dans un fichier du volume Unity Catalog, consultez le Référentiel d’exemples de pack dans GitHub.

Les objets courants

autorisation

Type: Map

Définit le principal et les privilèges à accorder à ce principal. Pour plus d’informations sur les subventions, consultez Afficher, accorder et révoquer des privilèges.

Example

L’exemple suivant définit un schéma de catalogue Unity avec des subventions :

resources:
  schemas:
    my_schema:
      name: test-schema
      grants:
        - principal: users
          privileges:
            - SELECT
        - principal: my_team
          privileges:
            - CAN_MANAGE
      catalog_name: main

cycle de vie

Type: Map

Contient les paramètres de cycle de vie d’une ressource. Il contrôle le comportement de la ressource lorsqu’elle est déployée ou détruite.