Databricks-apps beheren met Databricks Asset Bundles

Met Databricks-apps kunt u beveiligde gegevens en AI-toepassingen maken op het Databricks-platform dat u eenvoudig met gebruikers kunt delen. U kunt implementaties van uw apps beheren met behulp van Databricks Asset Bundles. Zie Databricks-apps en wat zijn Databricks Asset Bundles voor meer informatie over apps en bundels.

In dit artikel wordt uitgelegd hoe u een Databricks-app lokaal ontwikkelt en vervolgens een bundel configureert voor het beheren van implementaties van de app naar de Databricks-werkruimte met behulp van Databricks Asset Bundles.

Aanbeveling

Als u een voorbeeldbundel wilt initialiseren met een Streamlit-app, gebruikt u de streamlit-app-bundelsjabloon met de bundle init opdracht:

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

Behoeften

• Uw Databricks-werkruimte en lokale ontwikkelomgeving moeten voldoen aan de vereisten voor Databricks-apps. Zie Uw Databricks Apps-werkruimte en -ontwikkelomgeving instellen.
• Databricks CLI versie 0.250.0 of hoger. Voer de opdracht databricks -vuit om de geïnstalleerde versie van de Databricks CLI te controleren. Zie Installeren of updaten van de Databricks CLIom te leren hoe je de Databricks CLI installeert.

Een app lokaal maken

Maak eerst een Databricks-app. Apps worden ontwikkeld in Python met behulp van populaire frameworks, zoals Dash of Gradio. U kunt een databricks-app lokaal vanaf het begin bouwen, er een maken in de Databricks-werkruimte en vervolgens de bestanden synchroniseren met uw lokale computer of een Databricks-voorbeeld-app ophalen uit GitHub.

• Een volledig nieuwe app maken:

  1. Volg een beknopte inleiding voor een framework.

     • Scheutje
     • Flacon
     • Gradio
     • Glanzend
     • Streamlit

  2. Voeg een app.yaml bestand toe aan de hoofdmap van uw project om te definiëren hoe u de belangrijkste Python-app uitvoert. Voorbeeld:

     Voor een Streamlit-app:

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

     Of voor een Dash-app:

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

• Een app maken in de werkruimte en deze lokaal synchroniseren:

  1. Volg de stappen in Aan de slag met Databricks-apps om een app te maken in de gebruikersinterface.

  2. Maak een lokale map voor de app en ga naar cd erin:

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

  3. Synchroniseer de app-bestanden lokaal. U kunt de databricks workspace export-dir opdracht kopiëren vanaf de installatiepagina van de app in de werkruimte-interface en deze uitvoeren op de commandoregel. Voorbeeld:

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

     Hiermee worden de app-bestanden in de werkruimtemap gedownload naar de hello-world-app map op uw lokale computer.

• Een Databricks-voorbeeld-app ophalen vanuit GitHub:

  1. Kloon de GitHub-opslagplaats voor de Databricks-app-sjablonen:

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

  2. Kies een van de voorbeeld-apps als een eenvoudig app-project.

Een bestaande app toevoegen aan een bestaande bundel

Als u een Databricks-app in uw werkruimte hebt en een bestaande bundel hebt waaraan u de app wilt toevoegen, kunt u de databricks bundle generate app opdracht gebruiken. Met deze opdracht wordt een configuratiebestand voor de app gegenereerd en worden alle broncodebestanden voor de app gedownload en toegevoegd aan uw bundel. Voorbeeld:

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

Nadat u de app-configuratie in uw bundel hebt gegenereerd, gebruikt u de databricks bundle bind opdracht om de app in de werkruimte en bundel gesynchroniseerd te houden.

Zie de opdrachtgroep voor meer informatie over databricks bundle generate endatabricks bundle bind.bundle

De app lokaal ontwikkelen en fouten opsporen

Ga vervolgens door met het lokaal ontwikkelen van uw app. Start en foutopsporing in de app met behulp van de databricks apps run-local opdracht. Met deze opdracht wordt een app-proxy gestart die wordt gebruikt voor proxyaanvragen naar de app zelf en de benodigde Databricks-app-gerelateerde headers injecteert.

1. Als u alle afhankelijkheden wilt installeren, bereidt u de virtuele omgeving voor en start u de app en het foutopsporingsprogramma, gebruikt u de run-local opdracht met de --prepare-environment en --debug opties:

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

   Deze opdracht bereidt de virtuele omgeving voor met uv en het foutopsporingsprogramma is gebaseerd op debugpy.

2. Navigeer naar http://localhost:8001 om uw app te bekijken.

3. Stel onderbrekingspunten in om fouten in uw app op te sporen. Installeer in Visual Studio Code de Python-debugger, selecteer Uitvoeren>Start foutopsporing en dan Remote Attach.

   De proxy wordt gestart op poort 5678, maar u kunt deze configureren met behulp van de --port optie.

De app implementeren in de werkruimte

Wanneer u klaar bent om uw app te implementeren in de werkruimte, voegt u bundelconfiguratie toe waarmee de app wordt gemaakt en implementeert u de bundel.

1. Maak een bestand databricks.yml in de hoofdmap van uw app-project. De Databricks CLI herkent een map met een databricks.yml bestand in de hoofdmap als een bundel, waardoor databricks-bundelopdrachten mogelijk zijn.

2. Kopieer en plak de volgende YAML in het databricks.yml bestand, waarbij u tijdelijke aanduidingen voor werkruimte en gebruikersnaam vervangt door uw eigen waarden:

   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. Valideer en implementeer vervolgens de bundel. Standaard worden hiermee de app en de bundel gemaakt in de dev target in de werkruimte.

   databricks bundle validate
   databricks bundle deploy
   

4. Als je een bundel implementeert, wordt de app niet automatisch naar de compute-omgeving geïmplementeerd. Als u de app wilt implementeren, gebruikt u de gebruikersinterface (vanaf de pagina van de app in de Databricks-werkruimte) of de Databricks CLI (databricks apps deploy). Zie Een Databricks-app implementeren.

5. Gebruik de bundle summary opdracht om informatie over de geïmplementeerde app op te halen:

   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
   

Ontwikkelen, testen, herhalen

Ga door met het lokaal aanbrengen van wijzigingen in uw app en implementeer vervolgens de bundel opnieuw om de app in de werkruimte bij te werken. Tijdens het testen wilt u mogelijk gebruiksmachtigingen configureren voor de app voor andere gebruikers in uw Azure Databricks-werkruimte. Dit kunt u doen door machtigingen op te geven:

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

Als u de app in de werkruimte wilt starten, voert u de app in de bundel uit door de resourcesleutel voor de app op te geven in de opdracht:

databricks bundle run hello_world_app

Uitrollen naar productie

Databricks raadt aan een service-principal te gebruiken voor verificatie in productie. Wanneer u klaar bent om de app beschikbaar te maken in productie, werkt u uw bundelconfiguratie bij om een service-principal te gebruiken en implementeert u de bundel vervolgens in uw doelproductiewerkruimte. Voor informatie over service-principals, zie Service-principals voor CI/CD.

Bundel wijzigen om een service principal te gebruiken

Voordat u in productie implementeert, configureert u een toekenning in de bundel die toestemming geeft aan een service-principal. U kunt de toekenning configureren wanneer de app wordt gemaakt of wanneer de bundel wordt uitgevoerd.

Als u de service-principal toestemming wilt verlenen wanneer de app bij de implementatie van de bundel wordt gemaakt, wijzigt u de bundel databricks.yml om voor de app een toekenning te definiëren. Gebruik een bundelvervanging om de serviceprincipal toe te wijzen:

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

U kunt ook een taak definiëren in de bundel waarmee een subsidie wordt geconfigureerd wanneer de bundel wordt uitgevoerd:

1. Voeg een notitieblok grant_notebook.ipynb toe met de volgende inhoud in een cel. Vervang door <schema-name> een gebruikersnaam van een beheerder.

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

2. Definieer een taak in de bundel databricks.yml om een notebook uit te voeren waarmee toestemming wordt verleend aan de service-principal. Gebruik bundelvervangingen om de waarde van de service principal toe te wijzen.

   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
   

De bijgewerkte bundel implementeren

Implementeer de bundel nu in de productiewerkruimte en voer de app uit:

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

Aanvullende bronnen

• Wat is de Databricks CLI?
• bundle opdrachtgroep
• Configuratiereferentie
• Aan de slag met Databricks-apps