Een Databricks-app implementeren

Nadat u uw Azure Databricks-app hebt gemaakt en ontwikkeld, implementeert u deze om deze toegankelijk te maken in de Azure Databricks-werkruimte. Implementatie bouwt uw app, installeert afhankelijkheden en voert deze uit met behulp van de configuratie die is gedefinieerd in uw projectbestanden. U kunt apps implementeren met behulp van de Azure Databricks-gebruikersinterface of de Databricks CLI.

Implementatielogica

Databricks Apps ondersteunt het implementeren van toepassingen die gebruikmaken van Python, Node.jsof een combinatie van beide. Dit maakt flexibele architecturen mogelijk, zoals een Node.js front-end met een Python back-end.

Tijdens de implementatie controleert het buildproces op een package.json bestand in de hoofdmap van uw app-map om te bepalen of Node.js wordt gebruikt. Indien aanwezig, bevat het Node.js-specifieke buildstappen naast Python-stappen. De implementatielogica volgt dit patroon:

Als package.json aanwezig is:

1. Voer npm install uit
2. Installeer Python afhankelijkheden:
   • Als requirements.txt bestaat, voer pip install -r requirements.txt uit
   • Als requirements.txt niet bestaat en zowel pyproject.toml als uv.lock bestaan, voert u uv sync uit om afhankelijkheden te installeren.
3. Voer npm run build uit (als een build script is gedefinieerd in package.json)
4. Voer de opdracht uit die is opgegeven in app.yamlof npm run start als er geen opdracht is opgegeven

Als package.json niet aanwezig is

1. Installeer Python afhankelijkheden:
   • Als requirements.txt bestaat, voer pip install -r requirements.txt uit
   • Als requirements.txt niet bestaat en zowel pyproject.toml als uv.lock bestaan, voert u uv sync uit om afhankelijkheden te installeren.
2. Voer de opdracht uit die is opgegeven in app.yamlof python <my-app>.py als er geen opdracht is opgegeven

Implementatie voorbereiden

Controleer voordat u uw app implementeert of uw project de benodigde onderdelen bevat:

• Hoofdscript : het invoerpuntbestand, zoals app.py of app.js.
• Optioneel app.yaml bestand : als uw app een aangepaste opdracht of omgevingsvariabelen vereist, neemt u een app.yaml bestand op om de uitvoering te configureren. Zie De uitvoering van de Databricks-app configureren met app.yaml.
• Afhankelijkheden : zorg ervoor dat alle afhankelijkheden beschikbaar zijn. Zie Afhankelijkheden beheren voor een Databricks-app.
• Geheimen of omgevingswaarden : als u de env sectie in app.yamlgebruikt, controleert u of de geheimen waarnaar wordt verwezen of externe bronnen correct zijn geconfigureerd en toegankelijk zijn. Zie Resources toevoegen aan een Databricks-app.

Zorg er bovendien voor dat de app-service-principal toegang heeft tot de broncodemap.

Een implementatiebron kiezen

U kunt Databricks-apps implementeren vanuit de volgende bronnen:

• Werkruimtemap : upload app-bestanden naar een werkruimtemap en implementeer van daaruit. Dit is de standaardimplementatiemethode.
• Git-opslagplaats : configureer een Git-opslagplaats voor een app en implementeer rechtstreeks zonder bestanden naar de werkruimte te uploaden. De app leest code uit de geconfigureerde Git-verwijzing (vertakking, tag of doorvoer) telkens wanneer u implementeert. U kunt ook een broncodepad opgeven dat moet worden geïmplementeerd vanuit een specifieke map in de opslagplaats. Alle belangrijke Git-providers worden ondersteund, waaronder GitHub, GitLab en Bitbucket. Zie Uw Git-provider verbinden met Databricks voor een volledige lijst met ondersteunde providers.

U kunt op elk gewenst moment schakelen tussen werkruimte- en Git-bronnen voor dezelfde app, tenzij een werkruimtebeheerder alleen Git-implementaties afdwingt. Zie Alleen-Git-implementaties afdwingen.

Alleen Git-implementaties afdwingen

Werkruimtebeheerders kunnen vereisen dat alle apps in een werkruimte worden geïmplementeerd vanuit Git-opslagplaatsen. Als u deze instelling wilt inschakelen, gaat u naar Instellingen>ontwikkelings-apps> en schakelt u alleen app-implementaties vanuit Git toe. Deze instelling is standaard uitgeschakeld.

Wanneer u deze instelling inschakelt:

• Gebruikers moeten een Git-opslagplaats configureren voordat ze een app maken.
• Gebruikers kunnen alleen implementeren vanuit Git, niet vanuit werkruimtemappen.
• Databricks schakelt app-sjablonen uit in de werkruimte.
• Gebruikers kunnen een Git-opslagplaats niet verwijderen uit apps die er een hebben.
• Bestaande apps blijven actief, maar gebruikers kunnen ze niet opnieuw implementeren of starten, tenzij de app een Git-opslagplaats heeft.

De app implementeren

In de volgende secties wordt beschreven hoe u implementeert vanuit een werkruimtemap of rechtstreeks vanuit een Git-opslagplaats.

Implementeren vanuit een werkruimtemap

Databricks-gebruikersinterface

Een app implementeren vanuit de gebruikersinterface van Azure Databricks:

1. Upload de app-bestanden naar uw Azure Databricks werkruimte. Zie Een bestand importeren voor instructies.
2. Klik op Compute in de zijbalk.
3. Ga naar het tabblad Apps en klik op de koppeling naar uw app in de kolom Naam .
4. Klik op Implementeren en selecteer de map in uw werkruimte waar u de app-bestanden hebt geüpload.
5. Klik op Selecteren en vervolgens implementeren.
6. Controleer de configuratie en klik op Implementeren.

Databricks-CLI

Een app implementeren met behulp van de CLI:

1. Open een terminal en navigeer naar de map met uw app-bestanden.

2. Upload uw app-bestanden naar de Azure Databricks werkruimte met behulp van de opdracht sync. Vervang het pad door de locatie van de werkruimte waar u de bestanden wilt uploaden.

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

   Met de --watch vlag blijft het synchronisatieproces actief en worden wijzigingen automatisch geüpload wanneer u bestanden lokaal wijzigt. Als u specifieke bestanden of mappen wilt uitsluiten van synchronisatie, voegt u deze toe aan een .gitignore bestand in uw lokale app-map. Veelvoorkomende bestanden die moeten worden uitgesloten, zijn node_modules/, .env, __pycache__/, .DS_Store, en eventuele grote gegevensbestanden of buildartefacten.

3. Controleer het uploaden door de bestanden in uw werkruimte weer te geven. Klik op Werkruimte in de zijbalk en navigeer naar de map die u voor uw app hebt gemaakt.

4. Implementeer de app door de volgende opdracht uit te voeren. Vervang de app-naam en het broncodepad door uw waarden.

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

   De CLI geeft de voortgang van de implementatie weer en bevestigt wanneer de app wordt uitgevoerd.

Implementeren vanuit een Git-opslagplaats

Als u een app vanuit een Git-opslagplaats wilt implementeren, voegt u de opslagplaats toe op app-niveau en geeft u vervolgens de Git-verwijzing op wanneer u deze implementeert. Uw Git-opslagplaats moet de app-bestanden bevatten, waaronder app.yaml, afhankelijkheden en toegangspunt. Alle belangrijke Git-providers worden ondersteund, waaronder GitHub, GitLab en Bitbucket. U kunt ook door Git ondersteunde apps implementeren met behulp van de gebruikersinterface, CLI, API of declaratieve Automation-bundels.

Een app configureren en implementeren vanuit Git:

1. Upload uw app-bestanden naar een Git-opslagplaats.
2. Klik in uw Azure Databricks werkruimte op Compute in de zijbalk.
3. Ga naar het tabblad Apps en selecteer een bestaande app die u wilt bewerken of klik op App maken.
4. Voer in de stap Git-opslagplaats configureren de URL van de Git-opslagplaats in (bijvoorbeeld https://github.com/org/repo) en selecteer een Git-provider.
5. Klik op App maken of Opslaan om terug te keren naar de pagina met app-details.
6. Voor privéopslagplaatsen moet de service-principal van de app een Git-referentie hebben geconfigureerd. Klik op de pagina met app-details op Git-referenties configureren of bewerk de app en voeg de referentie toe in de stap Git-opslagplaats configureren . U moet machtigingen voor de app hebben CAN MANAGE om een Git-referentie toe te voegen. Voor openbare opslagplaatsen is geen Git-referentie vereist. Zie Uw Git-provider verbinden met Databricks voor instructies voor elke provider.

Implementeer vervolgens de app:

1. Klik op de pagina met app-details op Implementeren.
2. Selecteer Van Git.
3. Voer voor Git-naslaginformatie de naam van de vertakking, tag of doorvoer-SHA in (bijvoorbeeldmainv1.0.0, of een doorvoer-hash).
4. Geef voor verwijzingstype het type verwijzing op, zoals een vertakking, tag of doorvoer.
5. (Optioneel) Voer voor broncodepad een pad in naar een specifieke map in de opslagplaats. De app behandelt die map als de map op het hoogste niveau en heeft geen toegang tot bestanden buiten de map. Als u geen pad opgeeft, gebruikt Databricks de hoofdmap van de repository.
6. Klik op Implementeren.

Voor referenties naar branches of tags gebruikt Azure Databricks de meest recente commit van die branch of tag. Voor commit SHA-referenties implementeert Azure Databricks altijd die specifieke commit. Als de Git-referentie van de service-principal ongeldig of verlopen is, mislukt de implementatie.

Gedrag na implementatie

Nadat de implementatie is voltooid, start Azure Databricks uw app op basis van de gedefinieerde command in het bestand app.yaml of voert standaard python app.py uit. Op de pagina met app-details ziet u de huidige status en verleent u toegang tot logboeken, implementatiegeschiedenis en omgevingsinformatie.

Als u de uitvoer van de geïmplementeerde app wilt weergeven, klikt u op de app-koppeling.

Ga naar het tabblad Logboeken voor foutopsporing en runtimebewaking. Zie Logboekregistratie en bewaking voor Databricks-apps.

De app bijwerken of opnieuw implementeren

Implementeer uw app opnieuw nadat u wijzigingen hebt aangebracht in de broncode of configuratie. Opnieuw implementeren past uw meest recente updates toe zonder de app opnieuw te maken. U kunt op elk gewenst moment opnieuw implementeren vanuit de werkruimte of Git-opslagplaats.

Opnieuw implementeren vanuit een werkruimtemap

Opnieuw implementeren vanuit een werkruimtemap:

1. Werk uw app-bestanden bij in de werkruimtemap.
2. Selecteer de app en klik op Implementeren.
3. Als het broncodepad is gewijzigd of als u overschakelt van een Git-bron, klikt u op de pijl naast Implementeren en selecteert u Implementeren met een andere bron.

Opnieuw implementeren vanuit een Git-opslagplaats

Opnieuw implementeren vanuit een Git-opslagplaats:

1. Push uw wijzigingen naar de Git-opslagplaats.
2. Selecteer uw app in uw Azure Databricks werkruimte en klik op Deploy.
3. Als de Git-verwijzing is gewijzigd of als u overschakelt van een werkruimtebron, klikt u op de pijl naast Implementeren en selecteert u Implementeren met een andere bron.

Als u de Git-opslagplaats of -referentie wilt wijzigen, bewerkt u de app-configuratie. Gebruik de opdracht create-update om de Git-opslagplaats bij te werken met behulp van de CLI of API. Als u de Git-opslagplaats uit de app verwijdert, wordt implementatie vanuit de werkruimte afgedwongen.

Implementatieproblemen oplossen

Als uw app niet kan worden geïmplementeerd of niet wordt uitgevoerd zoals verwacht, voert u de volgende stappen voor probleemoplossing uit:

• Controleer de logboeken op foutberichten of runtime-uitvoer.
• De syntaxis en instellingen valideren app.yaml .
• Controleer of geheimen en omgevingsvariabelen in de env sectie goed worden opgelost.
• Controleer of alle vereiste afhankelijkheden zijn opgenomen of geïnstalleerd.

Voor implementaties van Git-opslagplaatsen:

• Controleer voor privéopslagplaatsen of de service-principal van de app een Git-referentie heeft geconfigureerd.
• Controleer of de URL van de Git-opslagplaats juist is en of de Git-verwijzing (vertakking, tag of doorvoer) in de opslagplaats bestaat.
• Als een werkruimtebeheerder alleen Git-implementaties afdwingt, kunt u een app niet implementeren of starten, tenzij er een Git-opslagplaats is geconfigureerd.
• Als u implementeert vanuit de CLI, API of declaratieve Automation-bundels, maakt u eerst de app en voegt u vervolgens de Git-referentie toe aan de service-principal van de app.

Volgende stappen

• Logboekregistratie en bewaking voor Databricks-apps
• Machtigingen configureren voor een Databricks-app
• De uitvoering van de Databricks-app configureren met app.yaml