Utveckla ett jobb på Azure Databricks med databricks-tillgångspaket

Artikel
10/05/2024

Databricks-tillgångspaket, även kallade paket, innehåller de artefakter som du vill distribuera och inställningarna för Azure Databricks-resurser, till exempel jobb som du vill köra, och gör det möjligt för dig att programmatiskt verifiera, distribuera och köra dem. Se Vad är Databricks-tillgångspaket?.

Den här artikeln beskriver hur du skapar ett paket för att programmatiskt hantera ett jobb. Se Schemalägg och samordna arbetsflöden. Paketet skapas med databricks-tillgångspaketens standardpaketmall för Python, som består av en notebook-fil i kombination med definitionen av ett jobb för att köra det. Sedan validerar, distribuerar och kör du det distribuerade jobbet på din Azure Databricks-arbetsyta.

Dricks

Om du har befintliga jobb som har skapats med hjälp av användargränssnittet eller API:et för Azure Databricks-jobb som du vill flytta till paket, måste du definiera dem i ett pakets konfigurationsfiler. Databricks rekommenderar att du först skapar ett paket med hjälp av stegen nedan och sedan kontrollerar om paketet fungerar. Du kan sedan lägga till ytterligare jobbdefinitioner, notebook-filer och andra källor i paketet. Se Lägga till en befintlig jobbdefinition i ett paket.

Krav

Databricks CLI version 0.218.0 eller senare. Om du vill kontrollera den installerade versionen av Databricks CLI kör du kommandot databricks -v. Information om hur du installerar Databricks CLI finns i Installera eller uppdatera Databricks CLI.
Databricks-fjärrarbetsytan måste ha arbetsytefiler aktiverade. Se Vad är arbetsytefiler?.

Skapa ett paket med hjälp av en projektmall

Skapa först ett paket med python-standardmallen Databricks Asset Bundles. Mer information om paketmallar finns i Projektmallar för Databricks Asset Bundle.

Om du vill skapa ett paket från grunden kan du läsa Skapa ett paket manuellt.

Steg 1: Konfigurera autentisering

I det här steget konfigurerar du autentisering mellan Databricks CLI på utvecklingsdatorn och Azure Databricks-arbetsytan. Den här artikeln förutsätter att du vill använda U2M-autentisering (OAuth user-to-machine) och en motsvarande Azure Databricks-konfigurationsprofil med namnet DEFAULT för autentisering.

Kommentar

U2M-autentisering är lämpligt för att prova de här stegen i realtid. För helt automatiserade arbetsflöden rekommenderar Databricks att du använder M2M-autentisering (machine-to-machine) för OAuth i stället. Se installationsinstruktionerna för M2M-autentisering i Autentisering.

Använd Databricks CLI för att initiera OAuth-tokenhantering lokalt genom att köra följande kommando för varje målarbetsyta.

I följande kommando ersätter du <workspace-url> med url:en för Azure Databricks per arbetsyta, till exempel https://adb-1234567890123456.7.azuredatabricks.net.
```
databricks auth login --host <workspace-url>
```
Databricks CLI uppmanar dig att spara den information som du angav som en Azure Databricks-konfigurationsprofil. Tryck Enter för att acceptera det föreslagna profilnamnet eller ange namnet på en ny eller befintlig profil. Alla befintliga profiler med samma namn skrivs över med den information som du angav. Du kan använda profiler för att snabbt växla autentiseringskontext över flera arbetsytor.

Om du vill hämta en lista över befintliga profiler i en separat terminal eller kommandotolk använder du Databricks CLI för att köra kommandot databricks auth profiles. Om du vill visa en specifik profils befintliga inställningar kör du kommandot databricks auth env --profile <profile-name>.
I webbläsaren slutför du anvisningarna på skärmen för att logga in på din Azure Databricks-arbetsyta.
Om du vill visa en profils aktuella OAuth-tokenvärde och tokens kommande förfallotidsstämpel kör du något av följande kommandon:
- databricks auth token --host <workspace-url>
- databricks auth token -p <profile-name>
- databricks auth token --host <workspace-url> -p <profile-name>
Om du har flera profiler med samma --host värde kan du behöva ange --host alternativen och -p tillsammans för att hjälpa Databricks CLI att hitta rätt matchande OAuth-tokeninformation.

Steg 2: Initiera paketet

Initiera ett paket med hjälp av standardprojektmallen för Python-paket.

Använd terminalen eller kommandotolken för att växla till en katalog på den lokala utvecklingsdatorn som innehåller mallens genererade paket.
Använd Databricks CLI för att köra bundle init kommandot:
```
databricks bundle init
```
För Template to uselämnar du standardvärdet för default-python genom att trycka på Enter.
För Unique name for this projectlämnar du standardvärdet my_project, eller skriver ett annat värde och trycker sedan på Enter. Detta avgör namnet på rotkatalogen för det här paketet. Den här rotkatalogen skapas i den aktuella arbetskatalogen.
För Include a stub (sample) notebookväljer och trycker du yes på Enter.
För Include a stub (sample) DLT pipelineväljer och trycker du no på Enter. Detta instruerar Databricks CLI att inte definiera en Delta Live Tables-exempelpipeline i ditt paket.
För Include a stub (sample) Python packageväljer och trycker du no på Enter. Detta instruerar Databricks CLI att inte lägga till pythonhjulspaketfiler eller relaterade bygginstruktioner i ditt paket.

Steg 3: Utforska paketet

Om du vill visa de filer som mallen genererade växlar du till rotkatalogen för det nyligen skapade paketet. Filer av särskilt intresse omfattar följande:

databricks.yml: Den här filen anger paketets programmatiska namn, innehåller en referens till jobbdefinitionen och anger inställningar för målarbetsytan.
resources/<project-name>_job.yml: Den här filen anger jobbets inställningar, inklusive en standarduppgift för notebook-filer.
src/notebook.ipynb: Den här filen är en exempelanteckningsbok som vid körning helt enkelt initierar en RDD som innehåller talen 1 till 10.

För att anpassa jobb motsvarar mappningarna i en jobbdeklaration nyttolasten för begäran, uttryckt i YAML-format, för åtgärden skapa jobb enligt beskrivningen i POST /api/2.1/jobs/create i REST API-referensen.

Dricks

Du kan definiera, kombinera och åsidosätta inställningarna för nya jobbkluster i paket med hjälp av de tekniker som beskrivs i Åsidosätt klusterinställningar i Databricks-tillgångspaket.

Steg 4: Verifiera projektets paketkonfigurationsfil

I det här steget kontrollerar du om paketkonfigurationen är giltig.

Från rotkatalogen använder du Databricks CLI för att köra bundle validate kommandot enligt följande:
```
databricks bundle validate
```
Om en sammanfattning av paketkonfigurationen returneras lyckades verifieringen. Om några fel returneras åtgärdar du felen och upprepar sedan det här steget.

Om du gör några ändringar i paketet efter det här steget bör du upprepa det här steget för att kontrollera om paketkonfigurationen fortfarande är giltig.

Steg 5: Distribuera det lokala projektet till fjärrarbetsytan

I det här steget distribuerar du den lokala notebook-filen till din fjärranslutna Azure Databricks-arbetsyta och skapar Azure Databricks-jobbet på din arbetsyta.

Från paketroten använder du Databricks CLI för att köra kommandot på bundle deploy följande sätt:
```
databricks bundle deploy -t dev
```
Kontrollera om den lokala notebook-filen har distribuerats: Klicka på Arbetsyta i sidofältet på azure Databricks-arbetsytan.
Klicka i mappen Användare ><your-username>> .bundle >><project-name>dev > files > src. Anteckningsboken ska finnas i den här mappen.
Kontrollera om jobbet har skapats: Klicka på Arbetsflöden i azure Databricks-arbetsytans sidofält.
På fliken Jobb klickar du på [dev <your-username>] <project-name>_job.
Klicka på fliken Uppgifter . Det bör finnas en uppgift: notebook_task.

Om du gör några ändringar i paketet efter det här steget bör du upprepa steg 4–5 för att kontrollera om paketkonfigurationen fortfarande är giltig och sedan distribuera om projektet.

Steg 6: Kör det distribuerade projektet

I det här steget utlöser du en körning av Azure Databricks-jobbet på din arbetsyta från kommandoraden.

Från rotkatalogen använder du Databricks CLI för att köra bundle run kommandot enligt följande och ersätter <project-name> med namnet på projektet från steg 2:
```
databricks bundle run -t dev <project-name>_job
```
Kopiera värdet Run URL för som visas i terminalen och klistra in det här värdet i webbläsaren för att öppna Azure Databricks-arbetsytan. Se Visa och köra ett jobb som skapats med ett Databricks-tillgångspaket
När jobbaktiviteten har slutförts på din Azure Databricks-arbetsyta och visar ett grönt namnlist klickar du på jobbaktiviteten för att se resultatet.

Om du gör några ändringar i paketet efter det här steget bör du upprepa steg 4–6 för att kontrollera om paketkonfigurationen fortfarande är giltig, distribuera om projektet och köra det omdistribuerade projektet.

Steg 7: Rensa

I det här steget tar du bort den distribuerade anteckningsboken och jobbet från din arbetsyta.

Från rotkatalogen använder du Databricks CLI för att köra bundle destroy kommandot enligt följande:
```
databricks bundle destroy -t dev
```
Bekräfta begäran om jobbborttagning: När du uppmanas att permanent förstöra resurser skriver y du och trycker på Enter.
Bekräfta begäran om borttagning av notebook-filer: När du uppmanas att permanent förstöra den tidigare distribuerade mappen och alla dess filer skriver y du och trycker på Enter.
Om du också vill ta bort paketet från utvecklingsdatorn kan du nu ta bort den lokala katalogen från steg 2.

Lägga till en befintlig jobbdefinition i ett paket

Du kan använda ett befintligt jobb som grund för att definiera ett jobb i en paketkonfigurationsfil. Om du vill hämta en befintlig jobbdefinition kan du hämta den manuellt med hjälp av användargränssnittet, eller så kan du generera den programmatiskt med hjälp av Databricks CLI.

Information om jobbdefinitionen i paket finns i jobbet.

Hämta en befintlig jobbdefinition med hjälp av användargränssnittet

Så här hämtar du YAML-representationen av en befintlig jobbdefinition från användargränssnittet för Azure Databricks-arbetsytan:

I sidofältet för Azure Databricks-arbetsytan klickar du på Arbetsflöden.
På fliken Jobb klickar du på jobbets namnlänk .
Bredvid knappen Kör nu klickar du på kebaben och klickar sedan på Växla till kod (YAML)..
Lägg till DEN YAML som du kopierade till paketets fil eller skapa en konfigurationsfil databricks.yml för ditt jobb i katalogen för resources ditt paketprojekt och referera till den från databricks.yml filen. Se (/dev-tools/bundles/settings.md#resources).
Ladda ned och lägg till alla Python-filer och notebook-filer som refereras i det befintliga jobbet till paketets projektkälla. Vanligtvis finns samlingsartefakter i src katalogen i ett paket.

Dricks

Du kan exportera en befintlig notebook-fil från en Azure Databricks-arbetsyta till .ipynb formatet genom att klicka på Arkivexportera > > IPython Notebook från användargränssnittet för Azure Databricks Notebook.

När du har lagt till dina notebook-filer, Python-filer och andra artefakter i paketet kontrollerar du att jobbdefinitionen refererar till dem korrekt. Till exempel för en notebook-fil med namnet hello.ipynb som finns i src katalogen i paketet:
```
resources:
  jobs:
    hello-job:
      name: hello-job
      tasks:
      - task_key: hello-task
        notebook_task:
          notebook_path: ../src/hello.ipynb
```

Generera en befintlig jobbdefinition med hjälp av Databricks CLI

Så här genererar du paketkonfiguration programmatiskt för ett befintligt jobb:

Hämta ID:t för det befintliga jobbet från panelen jobbinformation för jobbet i användargränssnittet för jobb eller använd Kommandot Databricks CLI databricks jobs list .
bundle generate job Kör Kommandot Databricks CLI och ange jobb-ID:
```
databricks bundle generate job --existing-job-id 6565621249
```
Det här kommandot skapar en paketkonfigurationsfil för jobbet i paketets resources mapp och laddar ned eventuella refererade artefakter till src mappen.

Dricks

Om du först använder bundle deployment bind för att binda en resurs i ett paket till en på arbetsytan uppdateras resursen på arbetsytan baserat på den konfiguration som definierats i paketet som den är bunden till efter nästa bundle deploy. Mer information om bundle deployment bindfinns i Bind paketresurser.

Konfigurera ett jobb som använder serverlös beräkning

I följande exempel visas paketkonfigurationer för att skapa ett jobb som använder serverlös beräkning.

Om du vill använda serverlös beräkning för att köra ett jobb som innehåller notebook-uppgifter utelämnar du konfigurationen job_clusters från paketkonfigurationsfilen.

# yaml-language-server: $schema=bundle_config_schema.json
bundle:
  name: baby-names

resources:
  jobs:
    retrieve-filter-baby-names-job-serverless:
      name: retrieve-filter-baby-names-job-serverless
      tasks:
        - task_key: retrieve-baby-names-task
          notebook_task:
            notebook_path: ./retrieve-baby-names.py
        - task_key: filter-baby-names-task
          depends_on:
            - task_key: retrieve-baby-names-task
          notebook_task:
            notebook_path: ./filter-baby-names.py

  targets:
    development:
      workspace:
        host: <workspace-url>

Om du vill använda serverlös beräkning för att köra ett jobb som innehåller Python-uppgifter inkluderar du konfigurationen environments .

# yaml-language-server: $schema=bundle_config_schema.json
bundle:
  name: serverless-python-tasks

resources:
jobs:
  serverless-python-job:
    name: serverless-job-with-python-tasks

    tasks:
      - task_key: wheel-task-1
        python_wheel_task:
          entry_point: main
          package_name: wheel_package
        environment_key: Default

    environments:
      - environment_key: Default
        spec:
          client: "1"
          dependencies:
            - workflows_authoring_toolkit==0.0.1

targets:
  development:
    workspace:
      host: <workspace-url>

Se Köra ditt Azure Databricks-jobb med serverlös beräkning för arbetsflöden.

Dela via