Zarządzanie aplikacjami usługi Databricks przy użyciu pakietów zasobów usługi Databricks

Usługa Databricks Apps umożliwia tworzenie bezpiecznych danych i aplikacji sztucznej inteligencji na platformie Databricks, którą można łatwo udostępniać użytkownikom. Wdrożenia aplikacji można zarządzać przy użyciu pakietów zasobów usługi Databricks. Aby uzyskać więcej informacji na temat aplikacji i pakietów, zobacz Aplikacje usługi Databricks i Co to są pakiety zasobów usługi Databricks?.

W tym artykule opisano proces tworzenia aplikacji usługi Databricks lokalnie, a następnie konfigurowanie pakietu w celu zarządzania wdrożeniami aplikacji w obszarze roboczym usługi Databricks przy użyciu pakietów zasobów usługi Databricks.

Wskazówka

Aby zainicjować przykładowy pakiet za pomocą aplikacji Streamlit, użyj szablonu pakietu streamlit-app za pomocą polecenia bundle init.

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

Wymagania

Obszar roboczy usługi Databricks i lokalne środowisko programistyczne muszą spełniać wymagania dotyczące usługi Databricks Apps. Zobacz Konfigurowanie obszaru roboczego usługi Databricks Apps i środowiska programistycznego.
Interfejs wiersza polecenia usługi Databricks w wersji 0.250.0 lub nowszej. Aby sprawdzić zainstalowaną wersję Databricks CLI, uruchom polecenie databricks -v. Aby zainstalować interfejs wiersza polecenia usługi Databricks, zobacz Instalowanie lub aktualizowanie interfejsu wiersza polecenia usługi Databricks.

Lokalne tworzenie aplikacji

Najpierw utwórz aplikację Databricks. Aplikacje są opracowywane w języku Python przy użyciu popularnych struktur, takich jak Dash lub Gradio. Aplikację usługi Databricks można utworzyć lokalnie od podstaw, utworzyć aplikację w obszarze roboczym usługi Databricks, a następnie zsynchronizować pliki z maszyną lokalną lub pobrać przykładową aplikację usługi Databricks z usługi GitHub.

Aby utworzyć aplikację od podstaw:
1. Postępuj zgodnie z samouczkiem „Szybki start” dotyczącym frameworku.
  - Myślnik
  - Flask
  - Gradio
  - Błyszczący
  - Streamlit
2. app.yaml Dodaj plik do katalogu głównego projektu, aby zdefiniować sposób uruchamiania głównej aplikacji w języku Python. Przykład:
  
  W przypadku aplikacji Streamlit:
```
command: ['streamlit', 'run', 'app.py']
```
  Lub dla aplikacji Dash:
```
command: ['python', 'app.py']
```
Aby utworzyć aplikację w obszarze roboczym i zsynchronizować ją lokalnie:
1. Wykonaj kroki opisane w temacie Wprowadzenie do usługi Databricks Apps , aby utworzyć aplikację w interfejsie użytkownika.
2. Utwórz katalog lokalny dla aplikacji i przejdź do niego:
```
mkdir hello-world-app
cd hello-world-app
```
3. Zsynchronizuj pliki aplikacji lokalnie. Możesz skopiować polecenie databricks workspace export-dir ze strony instalacji aplikacji w interfejsie obszaru roboczego i uruchomić je na wierszu poleceń. Przykład:
```
databricks workspace export-dir /Workspace/Users/someone@example.com/databricks_apps/hello-world_2025_05_09-17_43/hello-world-app .
```
  Spowoduje to pobranie plików aplikacji w katalogu obszaru roboczego do hello-world-app katalogu na komputerze lokalnym.
Aby uzyskać przykładową aplikację usługi Databricks z usługi GitHub:
1. Sklonuj repozytorium GitHub szablonów aplikacji Databricks:
```
git clone https://github.com/databricks/app-templates
```
2. Wybierz jedną z przykładowych aplikacji jako prosty projekt aplikacji.

Dodawanie istniejącej aplikacji do istniejącego pakietu

Jeśli masz aplikację Databricks w swoim obszarze roboczym i posiadasz istniejący pakiet, do którego chcesz dodać aplikację, możesz użyć polecenia databricks bundle generate app. To polecenie generuje plik konfiguracji dla aplikacji i pobiera wszystkie pliki kodu źródłowego dla aplikacji i dodaje je do pakietu. Przykład:

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

Po wygenerowaniu konfiguracji aplikacji w pakiecie użyj polecenia databricks bundle bind, aby aplikacja pozostała w synchronizacji z obszarem roboczym i pakietem.

Aby uzyskać więcej informacji o databricks bundle generate i databricks bundle bind, zobacz grupę poleceń bundle.

Programowanie i debugowanie aplikacji lokalnie

Następnie kontynuuj tworzenie aplikacji lokalnie. Uruchom i debuguj aplikację przy użyciu databricks apps run-local polecenia . To polecenie uruchamia serwer proxy aplikacji, który służy do proxyfikacji żądań do aplikacji i wprowadza niezbędne nagłówki powiązane z aplikacją Databricks.

Aby zainstalować wszystkie zależności, przygotować środowisko wirtualne i uruchomić aplikację i debuger, użyj run-local polecenia z opcjami --prepare-environment i :--debug
```
databricks apps run-local --prepare-environment --debug
```
To polecenie używa uv do przygotowania środowiska wirtualnego, a debuger jest oparty na debugpy.
Przejdź do http://localhost:8001, aby wyświetlić swoją aplikację.
Ustaw punkty przerwania, aby debugować aplikację. W programie Visual Studio Code zainstaluj debuger języka Python, a następnie wybierz pozycję Uruchom debugowanie>, a następnie pozycję Dołączanie zdalne.

Serwer proxy jest uruchamiany na porcie 5678, ale można go skonfigurować przy użyciu --port opcji .

Wdrażanie aplikacji w obszarze roboczym

Gdy wszystko będzie gotowe do wdrożenia aplikacji w obszarze roboczym, dodaj konfigurację pakietu, która tworzy aplikację, a następnie wdróż pakiet.

Utwórz plik databricks.yml w katalogu głównym projektu aplikacji. Interfejs wiersza polecenia usługi Databricks rozpoznaje folder z plikiem databricks.yml w katalogu głównym jako pakiet, który umożliwia polecenia pakietu usługi Databricks.

Skopiuj i wklej następujący kod YAML do pliku databricks.yml, zastępując wartości zastępcze obszaru roboczego i nazwy użytkownika własnymi.

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

Zweryfikuj, a następnie wdróż pakiet. Domyślnie spowoduje to utworzenie aplikacji i pakietu w dev obiekcie docelowym w obszarze roboczym.
```
databricks bundle validate
databricks bundle deploy
```
Wdrożenie pakietu nie powoduje automatycznego wdrożenia aplikacji do środowiska obliczeniowego. Aby wdrożyć aplikację, użyj interfejsu użytkownika (ze strony aplikacji w obszarze roboczym usługi Databricks) lub interfejsu wiersza polecenia usługi Databricks (databricks apps deploy). Zobacz Wdróż aplikację Databricks.

Użyj polecenia , bundle summary aby pobrać informacje o wdrożonej aplikacji:

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

Opracowywanie, testowanie, iterowanie

Kontynuuj wprowadzanie zmian w aplikacji lokalnie, a następnie ponownie wdróż pakiet, aby zaktualizować aplikację w obszarze roboczym. Podczas testowania możesz skonfigurować uprawnienia użycia dla aplikacji dla innych użytkowników w obszarze roboczym usługi Azure Databricks, co można zrobić, określając uprawnienia:

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

Aby uruchomić aplikację w obszarze roboczym, uruchom aplikację w pakiecie, określając klucz zasobu dla aplikacji w poleceniu :

databricks bundle run hello_world_app

Wdrażanie w środowisku produkcyjnym

Databricks zaleca używanie konta usługi do uwierzytelniania w środowisku produkcyjnym. Gdy będziesz gotowy do udostępnienia aplikacji w środowisku produkcyjnym, zaktualizuj konfigurację pakietu aplikacji, aby użyć głównej jednostki usługi, a następnie wdroż pakiet w docelowym obszarze roboczym produkcyjnym. Aby uzyskać informacje o głównych obiektach zabezpieczeń usługi, zobacz Główne obiekty zabezpieczeń usługi dla CI/CD.

Modyfikowanie pakietu w celu używania jednostki usługi

Przed wdrożeniem do środowiska produkcyjnego skonfiguruj przyznanie w pakiecie, które daje uprawnienia głównemu użytkownikowi usługi. Można skonfigurować przyznanie podczas tworzenia aplikacji lub uruchamiania pakietu.

Aby udzielić uprawnień principalowi usługi podczas tworzenia aplikacji w ramach wdrożenia pakietu, zmodyfikuj pakiet databricks.yml, aby zdefiniować uprawnienie dla aplikacji. Użyj podstawienia pakietu, aby przypisać jednostkę usługi:

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

Alternatywnie zdefiniuj zadanie w pakiecie, które konfiguruje grant po uruchomieniu pakietu:

Dodaj notes o nazwie grant_notebook.ipynb z następującą zawartością w ramach jednej komórki. Zastąp <schema-name> nazwą użytkownika administratora.

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

Zdefiniuj zadanie w pakiecie databricks.yml , aby uruchomić notes, który udziela uprawnień do głównego użytkownika usługi. Użyj podstawień pakietów, aby przypisać wartość jednostki usługi:

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

Wdrażanie zaktualizowanego pakietu

Teraz wdróż pakiet w produkcyjnym obszarze roboczym i uruchom aplikację:

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

Dodatkowe zasoby

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2026-02-06