Python-webalkalmazás létrehozása és üzembe helyezése az Azure Pipelines használatával Azure-alkalmazás Szolgáltatásban

Azure DevOps Services

Ez az oktatóanyag bemutatja, hogyan használhatja az Azure Pipelinest a folyamatos integrációhoz és a folyamatos teljesítéshez (CI/CD) egy Python-webalkalmazás létrehozásához és üzembe helyezéséhez linuxos Azure App Service-ben. A folyamat automatikusan létrehozza és üzembe helyezi a Python-webalkalmazást az App Service-ben, amikor véglegesítés van az alkalmazáskódtárban.

Ebben az útmutatóban Ön:

• Hozzon létre egy Python-webalkalmazást, és töltse fel az Azure App Service-be.
• Az Azure DevOps-projekt csatlakoztatása az Azure-hoz.
• Hozzon létre egy Azure Pipelines Python-specifikus buildelési és üzembehelyezési folyamatot az alkalmazáshoz.
• Futtassa a folyamatot az Azure App Service-webalkalmazás összeállításához, teszteléséhez és üzembe helyezéséhez.
• Állítson be egy eseményindítót a folyamat futtatásához, amikor véglegesíti az adattárat.

Az Azure Pipelines fogalmaival kapcsolatos további információkért tekintse meg az alábbi videót:

Előfeltételek

termék	Követelmények
Azure DevOps	- Egy Azure DevOps-projekt. – Képes futtatni folyamatokat a Microsoft által üzemeltetett ügynökökön. Vásárolhat párhuzamos feladatot , vagy ingyenes szintet kérhet. - A YAML és az Azure Pipelines alapszintű ismerete. További információért lásd Az első adatfolyam létrehozása. - engedélyek:      A folyamat létrehozásához a Közreműködők csoport tagjának kell lennie, és a csoportnak rendelkeznie kell a build folyamat létrehozása engedéllyel, amelynek beállítása "Engedélyezve". A Projektgazdák csoport tagjai kezelhetik a folyamatokat.     - Szolgáltatáskapcsolatok létrehozásához: A szolgáltatáskapcsolatokhozrendszergazdai vagy létrehozói szerepkör szükséges.
GitHub	- Egy GitHub--fiók. - Egy GitHub-szolgáltatáskapcsolat az Azure Pipelines engedélyezéséhez.
Kék	Egy Azure-előfizetés.

A mintaalkalmazás előkészítése

1. A mintaadattárat forkolhatja a https://github.com/Microsoft/python-sample-vscode-flask-tutorial GitHub-fiókjába.

2. Klónozza az elágazást a helyi gépre a használatával git clone <your-forked-repository-url>.git.

3. Nyissa meg a helyi klónt a használatával cd python-sample-vscode-flask-tutorial, és helyileg hozza létre és futtassa az alkalmazást, hogy biztosan működjön.

   python -m venv .env
   source .env/Scripts/activate
   pip install --upgrade pip
   pip install -r ./requirements.txt
   export FLASK_APP=hello_app.webapp
   flask run
   

4. Az alkalmazás teszteléséhez lépjen http://localhost:5000 egy böngészőablakba, és ellenőrizze, hogy megjelenik-e a Visual Studio Flask-oktatóanyag cím.

5. Zárja be a böngészőablakot, és állítsa le a Flask-kiszolgálót a CtrlC+.

Az App Service webalkalmazás létrehozása és üzembe helyezése

Azure App Service-webalkalmazás létrehozása a Cloud Shell használatával az Azure Portalon. A Cloud Shell használatához jelentkezzen be az Azure Portalra , és válassza az eszköztár Cloud Shell gombját.

A Cloud Shell a böngésző alján jelenik meg. Győződjön meg arról, hogy a Bash van kiválasztva környezetként a legördülő menüben. Maximalizálhatja a Cloud Shell ablakát, hogy több helyet biztosítson magának.

Tipp.

A Cloud Shellbe való beillesztéshez használja a Ctrl ShiftV++, vagy kattintson a jobb gombbal, és válassza a Beillesztés lehetőséget a helyi menüből.

A webalkalmazás létrehozása és üzembe helyezése

1. A Cloud Shellben klónozza az elágazott adattárat az Azure-ba a következő paranccsal, és cserélje le <your-forked-repository-url> az elágazott adattár URL-címére.

   git clone <your-forked-repository-url>
   

2. Módosítsa a könyvtárat a klónozott adattár mappára.

   cd python-sample-vscode-flask-tutorial
   

3. Futtassa az az webapp up parancsot az App Service webalkalmazás kiépítéséhez és az első üzembe helyezés végrehajtásához. --name <your-web-app-name> A paraméterrel az Azure-ban egyedi nevet rendelhet hozzá, például egy személyes vagy cégnevet, valamint egy alkalmazásazonosítót, például--name <your-name>-flaskpipelines. Paraméterek nélkül futtatva az webapp up véletlenszerűen létrehozott webalkalmazás-nevet rendel hozzá, amely egyedi az Azure-ban.

   az webapp up --name <your-web-app-name>
   

A az webapp up parancs Python-alkalmazásként ismeri fel az alkalmazást, és a következő műveleteket hajtja végre:

1. Létrehoz egy alapértelmezett erőforráscsoportot.
2. Létrehoz egy alapértelmezett App Service-csomagot.
3. Létrehoz egy webalkalmazást a hozzárendelt névvel. Az alkalmazás URL a következő <your-web-app-name>.azurewebsites.net: .
4. Üzembe helyezi az összes fájlt az aktuális munkakönyvtárból egy ZIP-archívumba, és engedélyezve van a buildautomatizálás.
5. A paramétereket helyileg gyorsítótárazza az .azure/config fájlban, így nem kell újra megadnia őket, amikor a projektmappából vagy más az webapp up parancsokkal az webapp telepíti őket. A parancsok alapértelmezés szerint automatikusan használják a gyorsítótárazott értékeket.

Az alapértelmezett műveleteket a parancsparaméterek használatával felülbírálhatja a saját értékeivel. További információért lásd: az webapp up.

A az webapp up parancs a következő JSON-kimenetet állítja elő a minta webalkalmazáshoz:

{
  "URL": <your-web-app-url>,
  "appserviceplan": <your-app-service-plan-name>,
  "location": <your-azure-region>,
  "name": <your-web-app-name>,
  "os": "Linux",
  "resourcegroup": <your-resource-group>,
  "runtime_version": "python|3.11",
  "runtime_version_detected": "-",
  "sku": <sku>,
  "src_path": <repository-source-path>
}

Jegyezze fel az URLoktatóanyag későbbi részében használandó értékeket resourcegroupés runtime_version értékeket.

Az indítási parancs beállítása

A python-sample-vscode-flask-tutorial alkalmazás rendelkezik egy startup.txt fájllal, amely tartalmazza a webalkalmazás adott indítási parancsát. Állítsa be a webalkalmazás startup-file konfigurációs tulajdonságát startup.txt az alábbi parancs megadásával az erőforráscsoport és a webalkalmazás nevének használatával.

az webapp config set --resource-group <your-resource-group> --name <your-web-app-name> --startup-file startup.txt

A parancs befejeződésekor a JSON-kimenet megjeleníti a webalkalmazás összes konfigurációs beállítását.

A futó alkalmazás megtekintéséhez nyisson meg egy böngészőt, és lépjen a URL címen láthatóra a az webapp up parancs kimenetében. Ha általános lapot lát, várjon néhány másodpercet, amíg az App Service elindul, majd frissítse a lapot. Ellenőrizze, hogy megjelenik-e a Visual Studio Flask oktatóanyag címe.

Azure DevOps-projekt csatlakoztatása az Azure-előfizetéshez

Az Azure Pipelines Azure App Service-webalkalmazásban való üzembe helyezéséhez csatlakoztatnia kell az Azure DevOps-projektet az Azure-erőforrásokhoz.

Szolgáltatáskapcsolat létrehozása

A szolgáltatáskapcsolat hitelesített hozzáférést biztosít az Azure Pipelinesból a külső és távoli szolgáltatásokhoz. Az Azure App Service-webalkalmazásban való üzembe helyezéshez hozzon létre egy szolgáltatáskapcsolatot a webalkalmazás erőforráscsoportjához.

1. Az Azure DevOps-projekt oldalán válassza a Projektbeállítások lehetőséget.

2. A Projektbeállítások területen válassza a Pipelines>Service-kapcsolatok lehetőséget.

3. A Szolgáltatáskapcsolatok lapon válassza az Új szolgáltatáskapcsolat vagy a Szolgáltatáskapcsolat létrehozása lehetőséget, ha ez a szolgáltatáskapcsolat az első a projektben.

   

4. Az Új szolgáltatáskapcsolat képernyőn válassza az Azure Resource Managert , majd a Tovább gombot.

   

5. Az Új Azure-szolgáltatás kapcsolati képernyőjén válassza ki az identitástípust. Ez a példa alkalmazásregisztrációt (automatikus) használ, ami ajánlott. A hitelesítési módszerekkel kapcsolatos további információkért lásd : Csatlakozás az Azure-hoz Azure Resource Manager-szolgáltatáskapcsolat használatával.

6. Hitelesítő adatok esetén válassza a Számítási feladatok identitásának összevonása (automatikus) lehetőséget.

7. Töltse ki az alábbi mezőket:

   • Hatókör szintje: Válassza ki az előfizetést.
   • Előfizetés: Válassza ki az Azure-előfizetést.
   • Erőforráscsoport: Válassza ki a webalkalmazást tartalmazó erőforráscsoportot.
   • Szolgáltatáskapcsolat neve: Adjon meg egy leíró nevet a kapcsolatnak.
   • Hozzáférési engedélyek megadása az összes folyamathoz: Jelölje be ezt a jelölőnégyzetet, ha hozzáférést szeretne adni a projekt összes folyamatához.

8. Válassza a Mentés lehetőséget.

   

Az új kapcsolat megjelenik a Szolgáltatáskapcsolatok listában, és készen áll a folyamatban való használatra.

Folyamat létrehozása

Hozzon létre egy folyamatot a Python-webalkalmazás Azure-alkalmazás Szolgáltatásban való létrehozásához és üzembe helyezéséhez.

1. A projekt bal oldali navigációs menüjében válassza a Folyamatok lehetőséget.

2. A Folyamatok lapon válassza az Új folyamat vagy a Folyamat létrehozása lehetőséget, ha ez a folyamat az első a projektben.

   

3. A Hol van a kód képernyőjén válassza a GitHubot. Előfordulhat, hogy a rendszer arra kéri, hogy jelentkezzen be a GitHubra.

   

4. Az Adattár kiválasztása képernyőn válassza ki a klónozott mintaadattárat. A GitHub kérheti, hogy adja meg ismét a GitHub-jelszavát, vagy telepítse az Azure Pipelines GitHub alkalmazást. Kövesse a képernyőn megjelenő utasításokat az alkalmazás telepítéséhez. További információ: GitHub-alkalmazáshitelesítés.

   

5. A Folyamat konfigurálása lapon válassza a Python to Linux Web App lehetőséget az Azure-ban.

6. A következő képernyőn válassza ki az Azure-előfizetését, és válassza a Folytatás lehetőséget.

7. A következő képernyőn válassza ki az Azure-webalkalmazást, és válassza az Ellenőrzés és konfigurálás lehetőséget.

Az Azure Pipelines létrehoz egy azure-pipelines.yml fájlt, és megjeleníti azt a YAML-folyamatszerkesztőben.

YAML-folyamatfájl

A folyamat YAML-jének áttekintése lapon tekintse meg a folyamatot, hogy lássa, mit csinál. Győződjön meg arról, hogy az összes alapértelmezett bemenet megfelelő a kódhoz. A folyamat YAML-fájlséma megismeréséhez tekintse meg a YAML-sémareferenciát.

Az alábbi teljes példa YAML-folyamatfájl a CI/CD-folyamatot szakaszok, feladatok és lépések sorozataként határozza meg, ahol minden lépés a különböző tevékenységek és szkriptek részleteit tartalmazza. A létrehozott YAML-kód automatikusan feltölti a helyőrzőket az alkalmazás és a kapcsolat értékeivel.

trigger:
- main

variables:
  # Azure Resource Manager connection created during pipeline creation
  azureServiceConnectionId: '<GUID>'

  # Web app name
  webAppName: '<your-webapp-name>'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

  # Environment name
  environmentName: '<your-webapp-name>'

  # Project root folder. Point to the folder containing manage.py file.
  projectRoot: $(System.DefaultWorkingDirectory)

  pythonVersion: '3.11'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: BuildJob
    pool:
      vmImage: $(vmImageName)
    steps:
    - task: UsePythonVersion@0
      inputs:
        versionSpec: '$(pythonVersion)'
      displayName: 'Use Python $(pythonVersion)'

    - script: |
        python -m venv antenv
        source antenv/bin/activate
        python -m pip install --upgrade pip
        pip install setuptools
        pip install -r requirements.txt
      workingDirectory: $(projectRoot)
      displayName: "Install requirements"

    - task: ArchiveFiles@2
      displayName: 'Archive files'
      inputs:
        rootFolderOrFile: '$(projectRoot)'
        includeRootFolder: false
        archiveType: zip
        archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
        replaceExistingArchive: true

    - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
      displayName: 'Upload package'
      artifact: drop

- stage: Deploy
  displayName: 'Deploy Web App'
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: DeploymentJob
    pool:
      vmImage: $(vmImageName)
    environment: $(environmentName)
    strategy:
      runOnce:
        deploy:
          steps:

          - task: UsePythonVersion@0
            inputs:
              versionSpec: '$(pythonVersion)'
            displayName: 'Use Python version'

          - task: AzureWebApp@1
            displayName: 'Deploy Azure Web App : $(webAppName)'
            inputs:
              azureSubscription: $(azureServiceConnectionId)
              appName: $(webAppName)
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip

Változók

A variables YAML-fájl elején található szakasz a következő változókat határozza meg:

Változó	Leírás
azureServiceConnectionId	Az Azure Resource Manager szolgáltatáskapcsolat azonosítója.
webAppName	Az App Service webalkalmazás neve.
vmImageName	A buildügynökhöz használandó operációs rendszer neve.
environmentName	Az üzembe helyezendő környezet neve, amely automatikusan létrejön az üzembe helyezési feladat futtatásakor.
projectRoot	Az alkalmazáskódot tartalmazó gyökérmappa.
pythonVersion	A Python buildelési és üzembe helyezési ügynökökön használható verziója.

Létrehozási és üzembe helyezési fázisok

A folyamat összeállítási és üzembe helyezési szakaszokból áll.

Építési szakasz

A buildelési szakasz egyetlen feladatot tartalmaz, amely a változóban definiált operációs rendszeren fut, ebben az vmImageName esetben ubuntu-latest.

  - job: BuildJob
    pool:
      vmImage: $(vmImageName)

A feladat több lépést tartalmaz:

1. Először a UsePythonVersion feladat kiválasztja a Python használni kívánt verzióját a pythonVersion változóban meghatározott módon.

      - task: UsePythonVersion@0
         inputs:
           versionSpec: '$(pythonVersion)'
           displayName: 'Use Python $(pythonVersion)'
   

2. A következő lépés egy szkriptet használ, amely létrehoz egy virtuális Python-környezetet, és telepíti az alkalmazás függőségeit.requirements.txt A workingDirectory paraméter megadja az alkalmazáskód helyét.

      - script: |
           python -m venv antenv
           source antenv/bin/activate
           python -m pip install --upgrade pip
           pip install setuptools
           pip install  -r ./requirements.txt
         workingDirectory: $(projectRoot)
         displayName: "Install requirements"
   

3. Az ArchiveFiles feladat létrehoz egy ZIP-archívumot, amely tartalmazza a beépített webalkalmazást.

       - task: ArchiveFiles@2
         displayName: 'Archive files'
         inputs:
           rootFolderOrFile: '$(projectRoot)'
           includeRootFolder: false
           archiveType: zip
           archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
           replaceExistingArchive: true
   

   A paraméterek a következőképpen vannak beállítva:

   Paraméter	Leírás
   rootFolderOrFile	Az alkalmazáskód helye.
   includeRootFolder	A gyökérmappa belefoglalása a .zip fájlba. Állítsa false értékre. Ha be van állítva true, a .zip fájl tartalma egy s nevű mappába kerül, és a feladat nem találja az alkalmazáskódot.
   archiveType	A létrehozandó archívum típusa. Állítsa zip értékre.
   archiveFile	A létrehozandó .zip fájl helye.
   replaceExistingArchive	Azt jelzi, hogy lecserél-e egy meglévő archívumot, ha a fájl már létezik. Állítsa true értékre.

4. A .zip fájl ezután egy elnevezett dropösszetevőként tölt fel a folyamatba. Az üzembe helyezési szakasz a .zip fájlt használja az alkalmazás üzembe helyezéséhez.

       - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
         displayName: 'Upload package'
         artifact: drop
   

   • A upload paraméter beállítja a feltölteni kívánt .zip fájl helyét és nevét.
   • A artifact paraméter a létrehozott összetevő nevét a következőre dropállítja be: .

Üzembe helyezési szakasz

Az üzembe helyezési szakasz akkor fut, ha a buildelési szakasz sikeresen befejeződött. Ezt a dependsOn viselkedést a kulcsszavak és condition a kulcsszavak határozzák meg.

  dependsOn: Build
  condition: succeeded()

Az üzembe helyezési szakasz egyetlen üzembehelyezési feladatot tartalmaz, amely az alábbiak szerint van konfigurálva.

  - deployment: DeploymentJob
    pool:
      vmImage: $(vmImageName)
    environment: $(environmentName)

• A deployment kulcsszó azt jelzi, hogy a feladat egy üzembe helyezési feladat , amely egy környezetre irányul. A environment feladat futtatásakor a rendszer automatikusan létrehozza a projektet.

• A pool paraméter megadja az üzembehelyezési ügynökkészletet, és az alapértelmezett ügynökkészletet name használja, ha nincs megadva. Az ügynök a változóban vmImageName meghatározott operációs rendszeren fut, ebben az esetben ubuntu-latest.

A strategy kulcsszó határozza meg az üzembe helyezési stratégiát.

  strategy:
    runOnce:
      deploy:
        steps:

• A runOnce kulcsszó azt határozza meg, hogy az üzembehelyezési feladat egyszer fusson.
• A deploy kulcsszó az steps üzembe helyezési feladatban futtatandó elemet adja meg.

Ebben steps a szakaszban a következő feladatok futnak:

1. UsePythonVersion@0 kiválasztja a Használni kívánt Python-verziót, ugyanúgy, mint a Build szakaszban.
2. AzureWebApp@1 telepíti a webalkalmazást és a ZIP-összetevőt drop .

- task: AzureWebApp@1
    displayName: 'Deploy Azure Web App : <your-web-app-name>'
  inputs:
    azureSubscription: $(azureServiceConnectionId)
    appName: $(webAppName)
    package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip

• A azureSubscription paraméter a azureServiceConnectionId folyamatváltozókban megadott értéket tartalmazza.
• A appName változó értékét webAppName tartalmazza.
• Ez package adja meg az üzembe helyezendő .zip fájl nevét és helyét.

Mivel a python-vscode-flask-tutorial adattár egy startup.txtnevű fájlban tartalmazza az alkalmazásindítási parancsot, a következő paraméter hozzáadásával adhatja meg az alkalmazás indítási parancsát: startUpCommand: 'startup.txt'.

Csővezeték futtatása

Most már készen áll a folyamat kipróbálására.

1. A folyamatszerkesztőben válassza a Mentés és futtatás lehetőséget.

2. A Mentés és futtatás képernyőn szükség esetén adjon hozzá véglegesítési üzenetet, majd válassza a Mentés és futtatás lehetőséget.

   A folyamat futtatásának megtekintéséhez válassza a Fázisok vagy feladatok lehetőséget a folyamat összegzési lapján. Minden feladat és szakasz zöld pipát jelenít meg a sikeres befejezéskor. Ha hibák lépnek fel, azok megjelennek az összegzésben vagy a feladat lépéseiben.

   

   Gyorsan visszatérhet a YAML-szerkesztőhöz az Összegzés lap jobb felső sarkában lévő függőleges pontokkal, majd a Folyamat szerkesztése lehetőséggel.

   

3. Az üzembe helyezési feladatban válassza az Azure Web App üzembe helyezése feladatot a kimenet megjelenítéséhez.

   

4. A kimenetben válassza ki az Url-címet az App Service-alkalmazás URL-címe után. Az alkalmazásnak a következőképpen kell megjelennie:

   

Megjegyzés

Ha egy alkalmazástelepítés hiányzó függőség miatt meghiúsul, a requirements.txt fájl nem lett feldolgozva az üzembe helyezés során. Ez a probléma akkor fordulhat elő, ha a parancs használata helyett közvetlenül a portálon hozza létre a webalkalmazást az webapp up .

A az webapp up parancs kifejezetten a build műveletet SCM_DO_BUILD_DURING_DEPLOYMENT-re állítja be true. Ha appszolgáltatást épít ki a portálon keresztül, a művelet nem lesz automatikusan beállítva.

A művelet beállítása:

1. A webalkalmazás portállapján válassza a Bal oldali navigációs menü Konfiguráció elemét .
2. Az Alkalmazásbeállítások lapon válassza az Új alkalmazásbeállítás lehetőséget.
3. A megjelenő előugró ablakban állítsa be a NévSCM_DO_BUILD_DURING_DEPLOYMENTbeállítást, állítsa az Érték értékét az értékretrue, és válassza az OK gombot.
4. Válassza a Konfiguráció lap tetején található Mentés lehetőséget.
5. A folyamat újbóli futtatása. A függőségeknek most telepíteniük kell az üzembe helyezés során.

Folyamatlánc futtatásának indítása

Ez a folyamat úgy van beállítva, hogy minden alkalommal fusson, amikor egy módosítás bejelentkezik a kódtárba. Folyamatfuttatás indításához véglegesítsen egy módosítást az adattárban. Hozzáadhat például egy új funkciót az alkalmazáshoz, vagy frissítheti az alkalmazás függőségeit.

1. Nyissa meg az alkalmazás GitHub-adattárát.
2. Módosítsa a kódot, például módosítsa az alkalmazás címét.
3. Véglegesítse a módosítást.
4. Lépjen a folyamathoz, és ellenőrizze, hogy létrejön-e egy új futtatás, és fut-e.
5. Amikor a futtatás befejeződik, ellenőrizze, hogy a módosítás telepítve van-e a webalkalmazásban.
6. Az Azure Portalon nyissa meg a webalkalmazást, és válassza az Üzembe helyezési központ lehetőséget a bal oldali navigációs menüből.
7. Válassza a Naplók lapot, és ellenőrizze, hogy az új üzembe helyezés szerepel-e a listában.

Django-alkalmazások üzembe helyezése az App Service-ben

Ha külön adatbázist használ, az Azure Pipelines használatával django-alkalmazásokat helyezhet üzembe az App Service-ben Linuxon. Nem használhat SQLite-adatbázist, mert az App Service zárolja a db.sqlite3 fájlt, megakadályozva az olvasást és az írást. Ez a viselkedés nem befolyásolja a külső adatbázisokat.

A Tárolóindítási folyamat ismertetése szerint az App Service automatikusan keres egy wsgi.py fájlt az alkalmazáskódban, amely általában az alkalmazásobjektumot tartalmazza. Ha testre szeretné szabni az indítási parancsot, használja a startUpCommand paramétert a AzureWebApp@1 YAML-folyamatfájl lépésében.

A Django használatakor általában az alkalmazáskód üzembe helyezése után szeretné migrálni az adatmodelleket manage.py migrate . Ehhez egy üzembe helyezés utáni szkriptet adhat hozzá startUpCommand-vel. Itt látható például a startUpCommand AzureWebApp@1 feladat tulajdonsága.

  - task: AzureWebApp@1
      displayName: 'Deploy Azure Web App : $(webAppName)'
      inputs:
        azureSubscription: $(azureServiceConnectionId)
        appName: $(webAppName)
        package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
        startUpCommand: 'python manage.py migrate'

Tesztek futtatása a build szerveren

A buildelési folyamat részeként érdemes lehet teszteket futtatni az alkalmazás kódján. A tesztek a buildügynökön futnak, ezért a függőségeket egy virtuális környezetbe kell telepítenie a buildügynökön. A tesztek futtatása után törölje a teszt virtuális környezetet, mielőtt létrehozza a .zip fájlt az üzembe helyezéshez.

A következő szkriptelemek ezt a folyamatot szemléltetik. Helyezze őket a ArchiveFiles@2 feladat elé a azure-pipelines.yml fájlban. További információ: Platformfüggetlen szkriptek futtatása.

# The | symbol is a continuation character, indicating a multi-line script.
# A single-line script can immediately follow "- script:".
- script: |
    python -m venv .env
    source .env/bin/activate
    pip install setuptools
    pip install -r requirements.txt

  # The displayName shows in the pipeline UI when a build runs
  displayName: 'Install dependencies on build agent'

- script: |
    # Put commands to run tests here
    displayName: 'Run tests'

- script: |
    echo Deleting .env
    deactivate
    rm -rf .env
  displayName: 'Remove .env before zip'

Az olyan feladatokat, mint a PublishTestResults@2, szintén használhatja a teszteredmények folyamatba való közzétételéhez. További információ: Tesztek futtatása.

Az erőforrások tisztítása

Ha befejezte az oktatóanyagban létrehozott Azure-erőforrások használatát, törölje őket, hogy ne merüljenek fel további költségek.

• Törölje a létrehozott Azure DevOps-projektet. A projekt törlése törli a folyamatot és a szolgáltatáskapcsolatot.
• Törölje az App Service-t és az App Service-csomagot tartalmazó Azure-erőforráscsoportot. Az Azure Portalon lépjen az erőforráscsoportra, válassza az Erőforráscsoport törlése lehetőséget, és kövesse az utasításokat.
• Törölje a Cloud Shell fájlrendszert karbantartó Azure Storage-fiókot. Zárja be a Cloud Shellt, majd keresse meg a cloud-shell-storage-val kezdődő erőforráscsoportot. Válassza az Erőforráscsoport törlése lehetőséget, és kövesse az utasításokat.

Kapcsolódó tartalom

• Python-alkalmazások testreszabása az Azure Pipelinesban
• Python-alkalmazás konfigurálása az App Service-ben