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.

Anmärkning

Om du skapar en app från en mall distribuerar Azure Databricks den automatiskt när du först skapar den. Du kan dock fortfarande distribuera om den senare när du har ändrat den. Se Skapa en Databricks-app från en mall.

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. Kör pip install -r requirements.txt (om den finns)
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

Anmärkning

Om inget kommando anges i app.yamlkör npm run startAzure Databricks , även om appen innehåller Python-kod. Om du vill köra både Python- och Node.js-processer definierar du ett anpassat start skript som använder ett verktyg som concurrently för att starta båda. Till exempel: concurrently "npm run start:node" "python my_app.py".

Om package.json inte finns:

1. Kör pip install -r requirements.txt (om den finns)
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. 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 arbetsyta och Git-källor för samma app när som helst.

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 sync kommandot . 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

Viktigt!

Den här funktionen finns i Beta. Om en administratör inaktiverar funktionen fortsätter befintliga appar som distribuerats från Git att köras, men du kan inte distribuera om eller starta om dem förrän du återaktiverar förhandsversionen eller tar bort lagringsplatsen från appen.

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.

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å Beräkning 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. Du kan också redigera appen och lägga 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. Anvisningar för varje provider finns i Ansluta din Git-provider till Databricks.

Viktigt!

För säkerhet tar Azure Databricks bort alla Git-autentiseringsuppgifter som är associerade med appens tjänsthuvudnamn när du ändrar distributionskällan (från Git till arbetsyta eller arbetsyta till Git) eller när du ändrar Git-lagringsplatsen. Om du bara ändrar Git-referensen tas inte autentiseringsuppgifterna bort. När du har ändrat distributionskällan eller lagringsplatsen måste du konfigurera om Git-autentiseringsuppgifterna för att distribuera från Git igen.

Anmärkning

Appskapare får automatiskt CAN MANAGE behörigheter för service principal endast när Beta-funktionen för Git-implementation är aktiverad. Om du skapade en app när funktionen var inaktiverad kanske du inte har behörighet att lägga till en Git-autentiseringsuppgift.

Serviceprincipaler stöder en Git-autentiseringsuppgift per leverantör. Uppdatering av autentiseringsuppgifter, till exempel via kontokonsolen, ersätter den befintliga autentiseringsuppgiften för providern och påverkar alla appar som använder tjänstens huvudnamn med den providern.

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. Klicka på Distribuera.

För gren- eller taggreferenser distribuerar Azure Databricks den senaste ändringen från den 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 standardmässigt 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å Distribuera.
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 tar bort Git-lagringsplatsen från appen säkerställer det att distributionen sker från arbetsytan.

Viktigt!

Om du ändrar Git-lagringsplatsen eller växlar mellan distributionskällor (Git och arbetsyta) tas alla Git-autentiseringsuppgifter bort för appens tjänsthuvudnamn. Du måste konfigurera om autentiseringsuppgifterna innan du distribuerar från Git igen.

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 Url:en för Git-lagringsplatsen är korrekt.
• Kontrollera att Git-referensen (gren, tagg eller incheckning) finns på lagringsplatsen.

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