Distribuera en Databricks-app

När du har skapat och utvecklat din Azure Databricks app distribuerar du den för att göra den tillgänglig på Azure Databricks arbetsytan. Distributionen skapar din app, installerar beroenden och kör den med hjälp av konfigurationen som definieras i projektfilerna. Du kan distribuera appar med hjälp av Azure Databricks användargränssnittet eller Databricks CLI.

Distributionslogik

Databricks Apps stöder distribution av program som använder antingen Python, Node.jseller en kombination av båda. Detta möjliggör flexibla arkitekturer, till exempel en Node.js klientdel med en Python serverdel.

Under distributionen söker byggprocessen efter en package.json fil i roten av appkatalogen för att avgöra om Node.js används. Om den finns innehåller den nodspecifika byggsteg tillsammans med Python steg. Distributionslogik följer det här mönstret:

Om package.json finns:

1. Kör npm install
2. Installera Python-biblioteksberoenden:
   • Om requirements.txt finns, kör pip install -r requirements.txt
   • Om requirements.txt inte finns, och både pyproject.toml och uv.lock finns, kör du uv sync för att installera beroenden.
3. Kör npm run build (om ett build skript har definierats i package.json)
4. Kör kommandot som anges i app.yamleller npm run start om inget kommando har angetts

Om package.json inte finns:

1. Installera Python-beroenden:
   • Om requirements.txt finns, kör pip install -r requirements.txt
   • Om requirements.txt inte finns, och både pyproject.toml och uv.lock finns, kör du uv sync för att installera beroenden.
2. Kör kommandot som anges i app.yamleller python <my-app>.py om inget kommando har angetts

Förbereda för distribution

Innan du distribuerar din app kontrollerar du att projektet innehåller nödvändiga komponenter:

• Huvudskript – din startpunktsfil, till exempel app.py eller app.js.
• Valfri app.yaml fil – Om din app kräver ett anpassat kommando eller miljövariabler inkluderar du en app.yaml fil för att konfigurera körning. Se Konfigurera Databricks-appens körning med app.yaml.
• Beroenden – Kontrollera att alla beroenden är tillgängliga. Se Hantera beroenden för en Databricks-app.
• Hemligheter eller miljövärden – Om du använder env avsnittet i app.yamlkontrollerar du att de refererade hemligheterna eller externa källorna är korrekt konfigurerade och tillgängliga. Se Lägga till resurser i en Databricks-app.

Kontrollera dessutom att apptjänstens huvudnamn har åtkomst till källkodsmappen.

Välj en distributionskälla

Du kan distribuera Databricks-appar från följande källor:

• Arbetsytemapp – Ladda upp appfiler till en arbetsytemapp och distribuera därifrån. Det här är standarddistributionsmetoden.
• Git-lagringsplats – Konfigurera en Git-lagringsplats för en app och distribuera direkt utan att ladda upp filer till arbetsytan. Appen läser kod från den konfigurerade Git-referensen (gren, tagg eller incheckning) varje gång du distribuerar. Du kan också ange en källkodssökväg som ska distribueras från en specifik katalog på lagringsplatsen. Alla större Git-leverantörer stöds, inklusive GitHub, GitLab och Bitbucket. En fullständig lista över leverantörer som stöds finns i Ansluta din Git-provider till Databricks.

Du kan växla mellan arbetsyte- och Git-källor för samma app när som helst, såvida inte en administratör av arbetsytan tvingar Git-enbart-distributioner. Se Framtvinga endast Git-distributioner.

Framtvinga endast Git-distributioner

Arbetsyteadministratörer kan kräva att alla appar på en arbetsyta distribueras från Git-lagringsplatser. Om du vill aktivera den här inställningen går du till Inställningar>Utvecklingsappar> och aktiverar Endast tillåta appdistributioner från Git. Den här inställningen är avstängd som standard.

När du aktiverar den här inställningen:

• Användarna måste konfigurera en Git-lagringsplats innan de skapar en app.
• Användare kan bara distribuera från Git, inte från arbetsytemappar.
• Databricks inaktiverar appmallar på arbetsytan.
• Användare kan inte ta bort en Git-lagringsplats från appar som har en.
• Befintliga appar fortsätter att köras, men användarna kan inte distribuera eller starta dem igen om inte appen har en Git-lagringsplats.

Distribuera appen

I följande avsnitt beskrivs hur du distribuerar från en arbetsytemapp eller direkt från en Git-lagringsplats.

Distribuera från en arbetsmapp

Databricks-användargränssnitt

Så här distribuerar du en app från Azure Databricks användargränssnittet:

1. Ladda upp appfilerna till din Azure Databricks arbetsyta. Anvisningar finns i Importera en fil.
2. Klicka på Beräkna i sidofältet.
3. Gå till fliken Appar och klicka på länken till din app i kolumnen Namn .
4. Klicka på Distribuera och välj den mapp på arbetsytan där du laddade upp appfilerna.
5. Klicka på Välj och sedan på Distribuera.
6. Granska konfigurationen och klicka på Distribuera.

Databricks kommandoradsgränssnitt (CLI)

Så här distribuerar du en app med hjälp av CLI:

1. Öppna en terminal och navigera till katalogen som innehåller dina appfiler.

2. Ladda upp dina appfiler till Azure Databricks-arbetsytan med hjälp av kommandot sync. Ersätt sökvägen med arbetsytans plats där du vill ladda upp filerna.

   databricks sync --watch . /Workspace/Users/my-email@org.com/my-app
   

   Flaggan --watch håller synkroniseringsprocessen igång och laddar automatiskt upp ändringar när du ändrar filer lokalt. Om du vill undanta specifika filer eller kataloger från synkronisering lägger du till dem i en .gitignore fil i din lokala appkatalog. Vanliga filer att exkludera är node_modules/, .env, __pycache__/, .DS_Storeoch alla stora datafiler eller kompileringsartefakter.

3. Verifiera uppladdningen genom att visa filerna på arbetsytan. Klicka på Arbetsyta i sidofältet och gå till den katalog som du skapade för din app.

4. Distribuera appen genom att köra följande kommando. Ersätt appnamnet och källkodssökvägen med dina värden.

   databricks apps deploy my-app-name \
      --source-code-path /Workspace/Users/my-email@org.com/my-app
   

   CLI visar distributionsframsteg och bekräftar när appen körs.

Distribuera från en Git-lagringsplats

Om du vill distribuera en app från en Git-lagringsplats lägger du till lagringsplatsen på appnivå och anger sedan Git-referensen när du distribuerar den. Git-lagringsplatsen måste innehålla appfilerna, inklusive app.yaml, beroenden och startpunkten. Alla större Git-leverantörer stöds, inklusive GitHub, GitLab och Bitbucket. Du kan också distribuera Git-backade appar med hjälp av UI, CLI, API eller deklarativa Automation-paket.

Så här konfigurerar och distribuerar du en app från Git:

1. Ladda upp dina appfiler till en Git-lagringsplats.
2. Från din Azure Databricks arbetsyta klickar du på ikonen Compute i sidofältet.
3. Gå till fliken Appar och välj antingen en befintlig app för att redigera eller klicka på Skapa app.
4. I steget Konfigurera Git-lagringsplats anger du URL:en för Git-lagringsplatsen (till exempel https://github.com/org/repo) och väljer en Git-provider.
5. Klicka på Skapa app eller Spara för att återgå till sidan med appinformation.
6. För privata lagringsplatser måste appens tjänsthuvudnamn ha konfigurerat en Git-autentiseringsuppgift. På sidan appinformation klickar du på Konfigurera Git-autentiseringsuppgifter eller redigerar appen och lägger till autentiseringsuppgifterna i steget Konfigurera Git-lagringsplats . Du måste ha CAN MANAGE behörighet för appen för att lägga till en Git-autentiseringsuppgift. Offentliga lagringsplatser kräver ingen Git-autentiseringsuppgift. Anvisningar för varje provider finns i Ansluta din Git-provider till Databricks.

Distribuera sedan appen:

1. På sidan med appinformation klickar du på Distribuera.
2. Välj Från Git.
3. Som Git-referens anger du grennamnet, taggen eller inchecknings-SHA (till exempel main, v1.0.0eller en incheckningshash).
4. För Referenstyp anger du typen av referens, till exempel en gren, tagg eller commit.
5. (Valfritt) För Källkodssökväg anger du en sökväg till en specifik katalog på lagringsplatsen. Appen behandlar katalogen som den översta katalogen och kan inte komma åt filer utanför den. Om du inte anger en sökväg använder Databricks lagringsplatsens rot.
6. Klicka på Distribuera.

För gren- eller taggreferenser distribuerar Azure Databricks den senaste commit från den aktuella grenen eller taggen. För inchecknings-SHA-referenser distribuerar Azure Databricks alltid den specifika incheckningen. Om tjänstens huvudnamns Git-autentiseringsuppgifter är ogiltiga eller har upphört att gälla misslyckas distributionen.

Beteende efter distribution

När distributionen är klar startar Azure Databricks din app baserat på den definierade command i app.yaml-filen eller standardinställningen att köra python app.py. Sidan med appinformation visar aktuell status och ger åtkomst till loggar, distributionshistorik och miljöinformation.

Om du vill visa den distribuerade appens utdata klickar du på applänken.

Gå till fliken Loggar för felsökning och körningsövervakning. Se Loggning och övervakning för Databricks-appar.

Uppdatera eller distribuera om appen

Distribuera om din app när du har gjort ändringar i källkoden eller konfigurationen. Att distribuera på nytt tillämpar dina senaste uppdateringar utan att skapa en kopia av appen. Du kan distribuera om från antingen arbetsytan eller Git-lagringsplatsen när som helst.

Återdistribuera från en arbetsmapp

För att distribuera om från en arbetskatalog:

1. Uppdatera appfilerna i arbetsytans mapp.
2. Välj appen och klicka på Distribuera.
3. Om källkodssökvägen har ändrats eller om du växlar från en Git-källa klickar du på pilen bredvid Distribuera och väljer Distribuera med en annan källa.

Distribuera om från en Git-lagringsplats

Så här distribuerar du om från en Git-lagringsplats:

1. Skicka ändringarna till Git-lagringsplatsen.
2. I din Azure Databricks arbetsyta väljer du din app och klickar på Deploy.
3. Om Git-referensen har ändrats eller om du växlar från en arbetsytekälla klickar du på pilen bredvid Distribuera och väljer Distribuera med en annan källa.

Om du vill ändra Git-lagringsplatsen eller autentiseringsuppgifterna redigerar du appkonfigurationen. Om du vill uppdatera Git-lagringsplatsen med hjälp av CLI eller API använder du kommandot create-update . Om du tar bort Git-lagringsplatsen från appen säkerställer det att distributionen sker från arbetsytan.

Felsöka distributionsproblem

Om appen inte kan distribueras eller inte körs som förväntat kan du prova följande felsökningssteg:

• Kontrollera om det finns felmeddelanden eller körningsutdata i loggarna.
• Verifiera app.yaml syntax och inställningar.
• Kontrollera att hemligheter och miljövariabler i avsnittet env matchar korrekt.
• Kontrollera att alla nödvändiga beroenden ingår eller installeras.

För distributioner av Git-lagringsplatser:

• För privata lagringsplatser kontrollerar du att appens tjänsthuvudnamn har konfigurerat en Git-autentiseringsuppgift.
• Kontrollera att Git-lagringsplatsens URL är korrekt och att Git-referensen (gren, tagg eller incheckning) finns på lagringsplatsen.
• Om en arbetsyteadministratör tillämpar endast Git-distributioner kan du inte distribuera eller starta en app om den inte har en Konfigurerad Git-lagringsplats.
• Om du distribuerar från CLI-, API- eller deklarativa Automation-paket skapar du appen först och lägger sedan till Git-autentiseringsuppgifterna i appens tjänsthuvudnamn.

Nästa steg

• Loggning och övervakning för Databricks-appar
• Konfigurera behörigheter för en Databricks-app
• Konfigurera Databricks-applikationskörning med app.yaml