Gérer les applications Databricks à l’aide de bundles de ressources Databricks

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 des utilisateurs. Vous pouvez gérer les déploiements de vos applications à l’aide de Bundles de ressources Databricks. Pour plus d’informations sur les applications et les offres groupées, consultez Databricks Apps and What are Databricks Asset Bundles ?.

Cet article vous guide tout au long du développement d’une application Databricks localement, puis la configuration d’un bundle pour gérer les déploiements de l’application sur l’espace de travail Databricks à l’aide de Bundles de ressources Databricks.

Conseil / Astuce

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

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

Spécifications

• Votre espace de travail Databricks et votre environnement de développement local doivent répondre aux exigences de Databricks Apps. Consultez Configurer votre espace de travail Databricks Apps et votre environnement de développement.
• Databricks CLI version 0.250.0 ou ultérieure. Pour vérifier la version de Databricks CLI installée, exécutez la commande databricks -v. Pour installer l’interface CLI Databricks, consultez Installer ou mettre à jour l’interface CLI Databricks.

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 populaires, tels que Dash ou Gradio. Vous pouvez créer une application Databricks localement à partir de zéro, en créer une dans l’espace de travail Databricks, puis synchroniser les fichiers sur votre ordinateur local, ou obtenir un exemple d’application Databricks à partir de GitHub.

• Pour générer une application à partir de zéro :

  1. Suivez un didacticiel de démarrage rapide pour un framework :

     • Tiret
     • Fiole
     • Gradio
     • Brillant
     • Streamlit

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

     Pour une application Streamlit :

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

     Ou pour une application Dash :

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

• Pour créer une application dans l’espace de travail et la synchroniser localement :

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

  2. Créez un répertoire local pour l’application et cd dans celui-ci :

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

  3. Synchronisez les fichiers d’application localement. Vous pouvez copier la databricks workspace export-dir commande à partir de la page d’installation de l’application dans l’interface utilisateur de l’espace de travail et l’exécuter sur votre ligne de commande. Par exemple:

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

     Cela télécharge les fichiers d’application depuis le répertoire de l’espace de travail vers le répertoire hello-world-app de votre ordinateur local.

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

  1. Clonez le référentiel GitHub des modèles d’application Databricks :

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

  2. Choisissez l’un des exemples d’applications en tant que projet d’application simple.

Ajouter une application existante à un bundle existant

Si vous disposez d’une application Databricks dans votre espace de travail et que vous disposez d’un bundle existant auquel vous souhaitez ajouter l’application, vous pouvez utiliser la databricks bundle generate app commande. Cette commande génère un fichier de configuration pour l’application et télécharge tous les fichiers de code source de l’application, puis les ajoute à votre offre groupée. Par exemple:

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

Une fois que vous avez généré la configuration de l’application dans votre paquet, utilisez la commande databricks bundle bind pour conserver l’application dans l’espace de travail et le paquet synchronisés.

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

Développer et déboguer l’application localement

Ensuite, poursuivez le développement de votre application localement. Lancez et déboguez l’application à l’aide de la databricks apps run-local commande. Cette commande démarre un proxy d’application qui est utilisé pour proxyr les demandes à l’application elle-même et injecte les en-têtes d’application Databricks nécessaires.

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

   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 voir votre application.

3. Définissez les 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 débogage et ensuite Attacher à distance.

   Le proxy démarre sur le port 5678, mais vous pouvez le configurer à l’aide de l’option --port .

Déployer l’application sur l’espace de travail

Lorsque vous êtes prêt à déployer votre application sur l’espace de travail, 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. L’interface CLI Databricks reconnaît un dossier avec un databricks.yml fichier à sa racine en tant que bundle, ce qui active les commandes de bundle databricks.

2. Copiez et collez le code YAML suivant dans le fichier databricks.yml, en remplaçant les valeurs de l'espace et du nom d'utilisateur par les vôtres.

   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 défaut, cela crée l’application et l’offre groupée dans l’espace de travail dev cible.

   databricks bundle validate
   databricks bundle deploy
   

4. Le déploiement d’un bundle ne déploie pas automatiquement l’application sur l’infrastructure de calcul. Pour déployer l’application, utilisez l’interface utilisateur (à partir de la page de l’application dans l’espace de travail Databricks) ou l’interface CLI Databricks (databricks apps deploy). Consultez Déployer une application Databricks.

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

   databricks bundle summary
   

   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 l’espace de travail. Lors du test, vous pouvez configurer des autorisations d’utilisation pour l’application pour d’autres utilisateurs de votre espace de travail Azure Databricks, que vous pouvez faire en spécifiant des autorisations :

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 démarrer l’application dans l’espace de travail, exécutez l’application dans le bundle en spécifiant la clé de ressource de l’application dans la commande :

databricks bundle run hello_world_app

Déployer en production

Databricks recommande d’utiliser un principal de service pour l’authentification en production. Lorsque vous êtes prêt à rendre l’application disponible en production, mettez à jour votre configuration de bundle pour utiliser un principal de service, puis déployez le bundle sur votre espace de travail de production cible. Pour plus d’informations sur les principaux de service, consultez les principaux de service pour CI/CD.

Modifier l’offre groupée pour utiliser un principal de service

Avant de déployer en production, configurez une autorisation dans le bundle permettant à un principal de service d'obtenir l'autorisation. Vous pouvez configurer l’octroi lorsque l’application est créée ou quand l’offre groupée est exécutée.

Pour accorder l'autorisation au principal de service lors de la création de l'application sur le déploiement groupé, modifiez le databricks.yml du paquet afin de définir une autorisation pour l'application. Utilisez une substitution de bundle pour affecter le principal de service :

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:
        # highlight-next-line
        - 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

Vous pouvez également définir un travail dans le bundle qui configure une allocation lors de l’exécution de l’offre groupée :

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

   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 travail dans le databricks.yml du bundle pour exécuter un notebook qui accorde l’autorisation au principal du service. Utilisez des substitutions de paquet pour attribuer la valeur du principal de service :

   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
             # highlight-next-line
             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éployer l’offre groupée mise à jour

Déployez maintenant le bundle sur l’espace de travail de production et exécutez l’application :

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

• Qu’est-ce que l’interface CLI Databricks ?
• bundle groupe de commandes
• Informations de référence sur la configuration
• Bien démarrer avec Databricks Apps