Aller au contenu principal
Dernière mise à jour le

Gérer les applications Databricks à l'aide des Declarative Automation Bundles

Databricks Apps vous permet de créer des applications de données et d'IA sécurisées sur la plateforme Databricks que vous pouvez facilement partager avec les utilisateurs. Vous pouvez gérer les déploiements de vos applications à l'aide des Declarative Automation Bundles. Pour plus d'informations sur les applications et les bundles, consultez Databricks Apps et What are Declarative Automation Bundles?.

Cette page vous guide à travers le développement d'une application Databricks localement, puis la configuration d'un bundle pour gérer les déploiements de l'application vers le Workspace Databricks à l'aide des Declarative Automation Bundles.

astuce

Pour initialiser un exemple de bundle avec une application Streamlit, utilisez le Template de bundle streamlit-app avec la commande bundle init :

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

Exigences​

Créer une application localement​

Tout d'abord, créez une application Databricks. Les applications sont développées en Python à l’aide de frameworks courants, tels que Dash ou Gradio. Vous pouvez créer une application Databricks localement à partir de zéro, en créer une dans le Workspace Databricks et synchroniser les fichiers avec votre machine locale, ou obtenir un exemple d'application Databricks depuis GitHub.

  • Pour élaborer une application à partir de zéro :

    1. Suivez un tutoriel de start rapide pour un framework :

    2. Ajoutez un fichier app.yaml à la racine de votre projet pour définir comment exécuter votre application Python principale. Par exemple :

      Pour une application Streamlit :

      YAML
      command: ['streamlit', 'run', 'app.py']

      Ou pour une application Dash :

      YAML
      command: ['python', 'app.py']

  • Pour créer une application dans le Workspace et la synchroniser localement :

    1. Suivez les étapes de Prise en main des Databricks Apps pour créer une application dans l’interface utilisateur.

    2. Créez un répertoire local pour l'application et cd dedans :

      Bash
      mkdir hello-world-app
      cd hello-world-app

    3. Synchronisez les fichiers de l'application localement. Vous pouvez copier la commande databricks workspace export-dir depuis la page d'installation de l'application dans l'interface utilisateur du Workspace et l'exécuter dans votre ligne de commande. Par exemple :

      Bash
      databricks workspace export-dir /Workspace/Users/someone@example.com/databricks_apps/hello-world_2025_05_09-17_43/hello-world-app .

      Ceci télécharge les fichiers de l'application du répertoire Workspace vers le répertoire hello-world-app sur votre machine locale.

  • Pour obtenir un exemple d'application Databricks à partir de GitHub :

    1. Clonez le repository GitHub des modèles d'application Databricks :

      Bash
      git clone https://github.com/databricks/app-templates

    2. Choisissez l'une des applications d'exemple comme un projet d'application simple.

Ajouter une application existante à un bundle existant​

Si vous avez une application Databricks dans votre workspace, et que vous avez un bundle existant auquel vous voulez ajouter l'application, vous pouvez utiliser la commande databricks bundle generate app. Cette commande génère un fichier de configuration pour l'application et download tous les fichiers de code source pour l'application, et les ajoute à votre bundle. Par exemple :

Bash
databricks bundle generate app --existing-app-name hello-world-app

Après avoir généré la configuration de l'application dans votre bundle, utilisez la commande databricks bundle bind pour maintenir l'application et le bundle synchronisés dans le Workspace.

Pour plus d'informations sur databricks bundle generate et databricks bundle bind, consultez le groupe de commandesbundle.

Développer et déboguer l'application localement​

Ensuite, continuez à développer votre application localement. Lancez et déboguez l'application à l'aide de la commande databricks apps run-local. Cette commande lance un proxy d'application qui est utilisé pour acheminer les requêtes vers l'application elle-même et injecte les en-têtes nécessaires liés à l'application Databricks.

  1. Pour installer toutes les dépendances, préparez l'environnement virtuel et start l'application et le débogueur, utilisez la commande run-local avec les options --prepare-environment et --debug :

    Bash
    databricks apps run-local --prepare-environment --debug

    Cette commande utilise uv pour préparer l'environnement virtuel et le débogueur est basé sur debugpy.

  2. Accédez à http://localhost:8001 pour afficher votre application.

  3. Définissez des points d'arrêt pour déboguer votre application. Dans Visual Studio Code, installez le débogueur Python, puis sélectionnez Exécuter > Démarrer le debugging et enfin Attacher à distance .

    Le proxy start sur le port 5678, mais vous pouvez le configurer en utilisant l'option --port.

Déployez l'application sur le Workspace​

Lorsque vous êtes prêt à déployer votre application sur le Workspace, ajoutez la configuration de bundle qui crée l'application, puis déployez le bundle.

  1. Créez un fichier databricks.yml à la racine de votre projet d'application. Le Databricks CLI reconnaît un dossier avec un fichier databricks.yml à sa racine comme un bundle, ce qui permet les commandes de bundle Databricks.

  2. Copiez et collez le YAML suivant dans le fichier databricks.yml, en remplaçant les valeurs d'espace réservé de Workspace et de nom d'utilisateur par les vôtres :

    YAML
    bundle:
      name: hello_world_bundle

    resources:
      apps:
        hello_world_app:
          name: 'hello-world-app'
          source_code_path: . # This assumes the app source code is at the root of the project.
          description: 'A Databricks app'

    targets:
      dev:
        mode: development
        default: true
        workspace:
          host: https://myworkspace.cloud.databricks.com
      prod:
        mode: production
        workspace:
          host: https://myworkspace.cloud.databricks.com
          root_path: /Workspace/Users/someone@example.com/.bundle/${bundle.name}/${bundle.target}
        permissions:
          - user_name: someone@example.com
            level: CAN_MANAGE

  3. Validez, puis déployez le bundle. Par default, cela crée l'application et le bundle dans la cible dev dans le Workspace.

    Bash
    databricks bundle validate
    databricks bundle deploy

  4. Le déploiement d'un bundle ne déploie pas automatiquement l'application vers compute. Pour déployer l'application, utilisez soit l'interface utilisateur (depuis la page de l'application dans le workspace Databricks), soit la CLI Databricks (databricks apps deploy). Voir Déployer une application Databricks.

  5. Utilisez la commande bundle summary pour récupérer des informations sur l'application déployée :

    Bash
    databricks bundle summary
    Output
    Name: hello_world_bundle
    Target: dev
    Workspace:
      Host: https://myworkspace.cloud.databricks.com
      User: someone@example.com
      Path: /Workspace/Users/someone@example.com/.bundle/hello_world_bundle/dev
    Resources:
      Apps:
        hello_world_app:
          Name: hello-world-app
          URL:  https://myworkspace.cloud.databricks.com/apps/hello-world-app?o=8498204313176880

Développer, tester, itérer​

Continuez à apporter des modifications à votre application localement, puis redéployez le bundle pour mettre à jour l'application dans le workspace. Pendant les tests, vous pourriez vouloir configurer les autorisations d'utilisation pour l'application pour d'autres utilisateurs dans votre workspace Databricks, ce que vous pouvez faire en spécifiant les autorisations:

YAML
resources:
  apps:
    hello_world_app:
      name: 'hello-world-app'
      source_code_path: . # This assumes the app source code is at the root of the project.
      description: 'A Databricks app'
      permissions:
        - level: CAN_USE
          group_name: users

Pour start l'application dans le Workspace, exécutez l'application dans le bundle en spécifiant la clé de Ressource de l'application dans la commande :

Bash
databricks bundle run hello_world_app

Déployer en production​

Databricks recommande d'utiliser un Service Principal pour l'authentification en production. Lorsque vous êtes prêt à rendre l'application disponible en production, mettez à jour la configuration de votre bundle pour utiliser un Service Principal, puis déployez le bundle dans votre Workspace de production cible. Pour des informations sur les Service Principal, consultez Service Principal pour CI/CD.

Modifier le bundle pour utiliser un Service Principal​

Avant de déployer en production, configurez un octroi dans le bundle qui donne l'autorisation à un Service Principal. Vous pouvez configurer l'octroi lorsque l'application est créée ou lorsque le bundle est exécuté.

Pour accorder l'autorisation au Service Principal lors de la création de l'application au moment du déploiement du bundle, modifiez le databricks.yml du bundle pour définir une subvention pour l'application. Utilisez une substitution de bundle pour attribuer le Service Principal :

YAML
bundle:
  name: hello_world_bundle

resources:
  apps:
    hello_world_app:
      name: 'hello-world-app'
      source_code_path: . # This assumes the app source code is at the root of the project.
      description: 'A Databricks app'

  schemas:
    my_schema:
      name: my_schema
      grants:
        - principal: '${resources.apps.hello_world_app.service_principal_client_id}'
          privileges:
            - CREATE_TABLE
      catalog_name: main

targets:
  dev:
    mode: development
    default: true
    workspace:
      host: https://myworkspace.cloud.databricks.com
  prod:
    mode: production
    workspace:
      host: https://myworkspace.cloud.databricks.com
      root_path: /Workspace/Users/someone@example.com/.bundle/${bundle.name}/${bundle.target}
    permissions:
      - user_name: someone@example.com
        level: CAN_MANAGE

Sinon, définissez un job dans le bundle qui configure un grant lorsque le bundle est exécuté :

  1. Ajouter un Notebook appelé grant_notebook.ipynb avec le contenu suivant dans une cellule. Remplacez <schema-name> par un nom d'utilisateur administrateur.

    Python
    app_service_principal = dbutils.widgets.get("app_service_principal")
    spark.sql(f"GRANT ALL PRIVILEGES ON SCHEMA <schema-name> TO `{app_service_principal}`")

  2. Définissez un job dans le databricks.yml du bundle pour exécuter un notebook qui accorde l'autorisation au Service Principal. Utilisez les substitutions de bundle pour affecter la valeur du Service Principal :

    YAML
    bundle:
      name: hello_world_bundle

    resources:
      apps:
        hello_world_app:
          name: 'hello-world-app'
          source_code_path: . # This assumes the app source code is at the root of the project.
          description: 'A Databricks app'

      jobs:
        grant_job:
          name: 'grant-job'
          parameters:
            - name: app_service_principal
              default: '${resources.apps.hello_world_app.service_principal_client_id}'
          tasks:
            - task_key: setup_grants
              notebook_task:
                notebook_path: ./grant_notebook.ipynb

    targets:
      dev:
        mode: development
        default: true
        workspace:
          host: https://myworkspace.cloud.databricks.com
      prod:
        mode: production
        workspace:
          host: https://myworkspace.cloud.databricks.com
          root_path: /Workspace/Users/someone@example.com/.bundle/${bundle.name}/${bundle.target}
        permissions:
          - user_name: someone@example.com
            level: CAN_MANAGE

Déployez le bundle mis à jour​

Maintenant, déployez le bundle dans le workspace de production et exécutez l'application :

Bash
databricks bundle deploy -t prod
databricks bundle run grant_job -t prod # (Optional) Run this if the grant is configured with a job
databricks bundle run hello_world_app -t prod

Ressources supplémentaires​

Sur cette page