Använda Azure Pipelines för att skapa och distribuera en Python-webbapp till Azure App Service

Azure DevOps Services

Använd Azure Pipelines för kontinuerlig integrering och kontinuerlig leverans (CI/CD) för att skapa och distribuera en Python-webbapp till Azure App Service på Linux. Din pipeline skapar och distribuerar automatiskt din Python-webbapp till App Service när det finns en incheckning till lagringsplatsen.

I den här artikeln kan du se hur du:

• Skapa en webbapp i Azure App Service.
• Skapa ett projekt i Azure DevOps.
• Anslut ditt DevOps-projekt till Azure.
• Skapa en Python-specifik pipeline.
• Kör pipelinen för att skapa och distribuera din app till webbappen i App Service.

Förutsättningar

• En Azure-prenumeration. Om du inte har en skapar du ett kostnadsfritt konto.
• Ett GitHub-konto. Om du inte har en kan du skapa en kostnadsfritt.
• En Azure DevOps Services-organisation. Skapa en kostnadsfritt.

Skapa en lagringsplats för din appkod

Förgrena exempellagringsplatsen till https://github.com/Microsoft/python-sample-vscode-flask-tutorial ditt GitHub-konto.

Klona din GitHub-lagringsplats på din lokala värd. Använd följande kommando och <repository-url> ersätt med URL:en för din förgrenade lagringsplats.

git clone <repository-url>

Testa din app lokalt

Skapa och kör appen lokalt för att se till att den fungerar.

1. Ändra till den klonade lagringsplatsens mapp.

   cd python-sample-vscode-flask-tutorial
   

2. Kompilera och köra appen

   Linux

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

   PowerShell

   py -m venv .env
   .env\scripts\activate
   pip install -r ./requirements.txt
   $env:FLASK_APP = "hello_app.webapp"
   flask run
   

3. Om du vill visa appen öppnar du ett webbläsarfönster och går till http://localhost:5000. Kontrollera att du ser rubriken Visual Studio Flask Tutorial.

4. När du är klar stänger du webbläsarfönstret och stoppar Flask-servern med Ctrl+C.

Öppna ett Cloud Shell-fönster

1. Logga in på Azure Portal på https://portal.azure.com.

2. Öppna Azure CLI genom att välja knappen Cloud Shell i portalens verktygsfält.

   

3. Cloud Shell visas längst ned i webbläsaren. Välj Bash på den nedrullningsbara menyn.

   

4. Om du vill ge dig mer utrymme att arbeta väljer du knappen Maximera.

Skapa en Azure App Service-webbapp

Skapa din Azure App Service-webbapp från Cloud Shell i Azure Portal.

Dricks

Om du vill klistra in i Cloud Shell använder du Ctrl+Skift+V eller högerklickar och väljer Klistra in på snabbmenyn.

1. Klona lagringsplatsen med följande kommando och ersätt <repository-url> med URL:en för din förgrenade lagringsplats.

   git clone <repository-url>
   

2. Ändra katalogen till den klonade lagringsplatsens mapp, så az webapp up att kommandot identifierar appen som en Python-app.

   cd python-sample-vscode-flask-tutorial
   

3. Använd kommandot az webapp up för att både etablera App Service och göra den första distributionen av din app. Ersätt <your-web-app-name> med ett namn som är unikt i Azure. Vanligtvis använder du ett personligt namn eller ett företagsnamn tillsammans med en appidentifierare, till exempel <your-name>-flaskpipelines. Appens URL blir your-appservice.azurewebsites.net>.<

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

   JSON-utdata för az webapp up kommandot visar:

   {
     "URL": <your-web-app-url>,
     "appserviceplan": <your-app-service-plan-name>,
     "location": <your-azure-location>,
     "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>
   }
   

   URL Anteckna värdena och runtime_version . Du använder runtime_version YAML-filen i pipelinen. URL Är webbadressen till din webbapp. Du kan använda den för att kontrollera att appen körs.

   Kommentar

   Kommandot az webapp up utför följande åtgärder:

   • Skapa en standardresursgrupp.

   • Skapa en standardplan för App Service.

   • Skapa en app med det angivna namnet.

   • Zip-distribuera alla filer från den aktuella arbetskatalogen, med build automation aktiverat.

   • Cachelagra parametrarna lokalt i .azure/config-filen så att du inte behöver ange dem igen när du distribuerar dem senare med az webapp up eller andra az webapp kommandon från projektmappen. De cachelagrade värdena används automatiskt som standard.

   Du kan åsidosätta standardåtgärden med dina egna värden med hjälp av kommandoparametrarna. Mer information finns i az webapp up.

4. Python-sample-vscode-flask-tutorial-appen har en startup.txt fil som innehåller det specifika startkommandot för webbappen. Ange konfigurationsegenskapen för webbappen startup-file till startup.txt.

   1. Kopiera värdet från az webapp up kommandots utdata resourcegroup .

   2. Ange följande kommando med hjälp av resursgruppen och appnamnet.

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

   När kommandot har slutförts visas JSON-utdata som innehåller alla konfigurationsinställningar för webbappen.

5. Om du vill se appen som körs öppnar du en webbläsare och går till den URL som visas i az webapp up kommandoutdata. Om du ser en allmän sida väntar du några sekunder tills App Service startar och uppdaterar sedan sidan. Kontrollera att du ser rubriken Visual Studio Flask Tutorial.

Skapa ett Azure DevOps-projekt

Skapa ett nytt Azure DevOps-projekt.

1. I en webbläsare går du till dev.azure.com och loggar in.
2. Välj din organisation.
3. Skapa ett nytt projekt genom att välja Nytt projekt eller Skapa projekt om du skapar det första projektet i organisationen.
4. Ange ett projektnamn.
5. Välj Synlighet för projektet.
6. Välj Skapa.

Skapa en tjänstanslutning

Med en tjänstanslutning kan du skapa en anslutning för att ge autentiserad åtkomst från Azure Pipelines till externa tjänster och fjärrtjänster. Om du vill distribuera till din Azure App Service-webbapp skapar du en tjänstanslutning till resursgruppen som innehåller webbappen.

1. På projektsidan väljer du Projektinställningar.

   

2. Välj Tjänstanslutningar i avsnittet Pipelines på menyn.

3. Välj Skapa tjänst anslutning.

4. Välj Azure Resource Manager och välj Nästa.

   

5. Välj din autentiseringsmetod och välj Nästa.

6. I dialogrutan Ny Azure-tjänstanslutning anger du den information som är specifik för den valda autentiseringsmetoden. Mer information om autentiseringsmetoder finns i Ansluta till Azure med hjälp av en Azure Resource Manager-tjänstanslutning.

   Om du till exempel använder en autentiseringsmetod för arbetsbelastningsidentitetsfederation (automatisk) eller tjänstens huvudnamn (automatisk) anger du nödvändig information.

   

   Fält	Beskrivning
   Omfångsnivå	Välj Prenumeration.
   Abonnemang	Ditt Azure-prenumerationsnamn.
   Resursgrupp	Namnet på resursgruppen som innehåller webbappen.
   Namn på tjänstanslutning	Ett beskrivande namn för anslutningen.
   Bevilja åtkomstbehörigheter till alla pipelines	Välj det här alternativet om du vill bevilja åtkomst till alla pipelines.

7. Välj Spara.

Den nya anslutningen visas i listan Tjänstanslutningar och är redo att användas i Din Azure Pipeline.

Skapa en pipeline

Skapa en pipeline för att skapa och distribuera din Python-webbapp till Azure App Service. Om du vill förstå pipelinekoncept kan du titta på:

1. Välj Pipelines på den vänstra navigeringsmenyn.

   

2. Välj Skapa pipeline.

   

3. I dialogrutan Var är din kod väljer du GitHub. Du kan uppmanas att logga in på GitHub.

   

4. På skärmen Välj en lagringsplats väljer du den förgrenade exempellagringsplatsen.

   

5. Du kan uppmanas att ange ditt GitHub-lösenord igen som en bekräftelse.

6. Om Azure Pipelines-tillägget inte är installerat på GitHub uppmanar GitHub dig att installera Azure Pipelines-tillägget .

   

   På den här sidan bläddrar du ned till avsnittet Lagringsplatsåtkomst , väljer om tillägget ska installeras på alla lagringsplatser eller endast valda och väljer sedan Godkänn och installera.

   

7. I dialogrutan Konfigurera din pipeline väljer du Python till Linux-webbapp i Azure.

8. Välj din Azure-prenumeration och välj Fortsätt.

9. Om du använder ditt användarnamn och lösenord för att autentisera öppnas en webbläsare där du kan logga in på ditt Microsoft-konto.

10. Välj webbappens namn i listrutan och välj Verifiera och konfigurera.

Azure Pipelines skapar en azure-pipelines.yml-fil och visar den i YAML-pipelinesredigeraren. Pipelinefilen definierar DIN CI/CD-pipeline som en serie steg, jobb och steg, där varje steg innehåller information om olika uppgifter och skript. Ta en titt på pipelinen för att se vad den gör. Kontrollera att alla standardindata är lämpliga för din kod.

YAML-pipelinefil

Följande förklaring beskriver YAML-pipelinefilen. Mer information om YAML-filschemat för pipeline finns i YAML-schemareferens.

Den fullständiga YAML-filen för pipelinen visas nedan:

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 setup
        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

Variabler

Avsnittet variables innehåller följande variabler:

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.
projectRoot: $(System.DefaultWorkingDirectory)

# Python version: 3.11. Change this to match the Python runtime version running on your web app.
pythonVersion: '3.11'

Variabel	Beskrivning
azureServiceConnectionId	ID:t eller namnet på Azure Resource Manager-tjänstanslutningen.
webAppName	Namnet på Azure App Service-webbappen.
vmImageName	Namnet på det operativsystem som ska användas för byggagenten.
environmentName	Namnet på den miljö som används i distributionsfasen. Miljön skapas automatiskt när fasjobbet körs.
projectRoot	Rotmappen som innehåller appkoden.
pythonVersion	Den version av Python som ska användas på bygg- och distributionsagenterna.

Byggfas

Byggsteget innehåller ett enda jobb som körs på det operativsystem som definierats i variabeln vmImageName.

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

Jobbet innehåller flera steg:

1. Uppgiften UsePythonVersion väljer vilken version av Python som ska användas. Versionen definieras i variabeln pythonVersion .

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

2. Det här steget använder ett skript för att skapa en virtuell Python-miljö och installera appens beroenden som finns i requirements.txt parametern Anger workingDirectory platsen för appkoden.

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

3. Uppgiften ArchiveFiles skapar det .zip arkiv som innehåller webbappen. Filen .zip laddas upp till pipelinen som artefakten med namnet drop. Filen .zip används i distributionsfasen för att distribuera appen till webbappen.

      - 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
   

   Parameter	Beskrivning
   rootFolderOrFile	Platsen för appkoden.
   includeRootFolder	Anger om rotmappen ska inkluderas i .zip-filen. Ange den här parametern till false annars placeras innehållet i den .zip filen i en mapp med namnet s och App Service på Linux containern inte kan hitta appkoden.
   archiveType	Vilken typ av arkiv som ska skapas. Ange till zip.
   archiveFile	Platsen för den .zip fil som ska skapas.
   replaceExistingArchive	Anger om du vill ersätta ett befintligt arkiv om filen redan finns. Ange till true.
   upload	Platsen för den .zip fil som ska laddas upp.
   artifact	Namnet på artefakten som ska skapas.

Distributionssteg

Distributionssteget körs om byggfasen har slutförts. Följande nyckelord definierar det här beteendet:

  dependsOn: Build
  condition: succeeded()

Distributionssteget innehåller ett enda distributionsjobb som konfigurerats med följande nyckelord:

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

Nyckelord	Beskrivning
deployment	Anger att jobbet är ett distributionsjobb som riktar sig mot en miljö.
pool	Anger distributionsagentpoolen. Standardagentpoolen om namnet inte har angetts. Nyckelordet vmImage identifierar operativsystemet för agentens virtuella datoravbildning
environment	Anger den miljö som ska distribueras till. Miljön skapas automatiskt i projektet när jobbet körs.

Nyckelordet strategy används för att definiera distributionsstrategin. Nyckelordet runOnce anger att distributionsjobbet körs en gång. Nyckelordet deploy anger de steg som ska köras i distributionsjobbet.

  strategy:
    runOnce:
      deploy:
        steps:

I steps pipelinen är:

1. Använd uppgiften UsePythonVersion för att ange vilken version av Python som ska användas på agenten. Versionen definieras i variabeln pythonVersion .

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

2. Distribuera webbappen med hjälp av AzureWebApp@1. Den här uppgiften distribuerar pipelineartefakten drop till webbappen.

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

   Parameter	Beskrivning
   azureSubscription	Azure Resource Manager-tjänstens anslutnings-ID eller namn som ska användas.
   appName	Namnet på webbappen.
   package	Platsen för den .zip fil som ska distribueras.

   Eftersom python-vscode-flask-tutorial-lagringsplatsen innehåller samma startkommando i en fil med namnet startup.txt kan du ange filen genom att lägga till parametern: startUpCommand: 'startup.txt'.

Köra pipelinen

Nu är du redo att prova!

1. I redigeraren väljer du Spara och kör.

2. I dialogrutan Spara och kör lägger du till ett incheckningsmeddelande och väljer sedan Spara och kör.

   Du kan titta på pipelinen när den körs genom att välja Faser eller Jobb i sammanfattningen av pipelinekörningen.

   

   Det finns gröna bockmarkeringar bredvid varje steg och jobb när det har slutförts. Om fel uppstår visas de i sammanfattningen eller i jobbstegen.

   

   Du kan snabbt återgå till YAML-redigeraren genom att välja de lodräta punkterna längst upp till höger på sidan Sammanfattning och välja Redigera pipeline:

   

3. I distributionsjobbet väljer du aktiviteten Distribuera Azure Web App för att visa dess utdata. Om du vill besöka den distribuerade webbplatsen håller du ned Ctrl och väljer URL:en efter App Service Application URL.

   Om du använder exempelappen bör appen visas på följande sätt:

   

Viktigt!

Om appen misslyckas på grund av ett beroende som saknas bearbetades inte din requirements.txt-fil under distributionen. Det här beteendet inträffar om du har skapat webbappen direkt på portalen i stället för att az webapp up använda kommandot som du ser i den här artikeln.

Kommandot az webapp up anger specifikt byggåtgärden SCM_DO_BUILD_DURING_DEPLOYMENT till true. Om du har etablerat apptjänsten via portalen anges inte den här åtgärden automatiskt.

Följande steg anger åtgärden:

1. Öppna Azure Portal, välj din App Service och välj sedan Konfiguration.
2. Under fliken Programinställningar väljer du Ny programinställning.
3. I popup-fönstret som visas anger du Namn till SCM_DO_BUILD_DURING_DEPLOYMENT, anger Värde till trueoch väljer OK.
4. Välj Spara överst på sidan Konfiguration .
5. Kör pipelinen igen. Dina beroenden bör installeras under distributionen.

Utlös en pipelinekörning

Om du vill utlösa en pipelinekörning checkar du in en ändring på lagringsplatsen. Du kan till exempel lägga till en ny funktion i appen eller uppdatera appens beroenden.

1. Gå till din GitHub-lagringsplats.
2. Gör en ändring i koden, till exempel ändra appens rubrik.
3. Checka in ändringen på lagringsplatsen.
4. Gå till din pipeline och kontrollera att en ny körning har skapats.
5. När körningen är klar kontrollerar du att den nya versionen har distribuerats till webbappen.
   1. I Azure Portal går du till din webbapp.
   2. Välj Distributionscenter och välj fliken Loggar .
   3. Kontrollera att den nya distributionen visas.

Överväganden för Django

Du kan använda Azure Pipelines för att distribuera Django-appar till Azure App Service på Linux om du använder en separat databas. Du kan inte använda en SQLite-databas eftersom App Service låser filen db.sqlite3 , vilket förhindrar både läsningar och skrivningar. Det här beteendet påverkar inte en extern databas.

Enligt beskrivningen i Konfigurera Python-app på App Service – Startprocess för container söker App Service automatiskt efter en wsgi.py fil i din appkod, som vanligtvis innehåller appobjektet. Om du vill anpassa startkommandot på något sätt använder du parametern startUpCommand i steget i AzureWebApp@1 YAML-pipelinefilen enligt beskrivningen i föregående avsnitt.

När du använder Django vill du vanligtvis migrera datamodellerna med hjälp av manage.py migrate när du har distribuerat appkoden. Du kan lägga till startUpCommand med ett skript efter distributionen för det här ändamålet. Här är startUpCommand till exempel egenskapen i den AzureWebApp@1 uppgiften.

  - 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'

Köra tester på byggagenten

Som en del av byggprocessen kanske du vill köra tester på din appkod. Tester körs på byggagenten, så du måste installera dina beroenden i en virtuell miljö på byggagenten. När testerna har körts tar du bort den virtuella miljön innan du skapar .zip-filen för distribution. Följande skriptelement illustrerar den här processen. Placera dem före ArchiveFiles@2 uppgiften i filen azure-pipelines.yml . Mer information finns i Köra plattformsoberoende skript.

# 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'

Du kan också använda en uppgift som PublishTestResults@2 för att publicera testresultaten till din pipeline. Mer information finns i Skapa Python-appar – Kör tester.

Rensa resurser

Så här undviker du avgifter för De Azure-resurser som skapats i den här självstudien:

• Ta bort projektet som du skapade. Om du tar bort projektet tas pipeline- och tjänstanslutningen bort.

• Ta bort den Azure-resursgrupp som innehåller App Service och App Service-planen. I Azure Portal går du till resursgruppen, väljer Ta bort resursgrupp och följer anvisningarna.

• Ta bort lagringskontot som underhåller filsystemet för Cloud Shell. Stäng Cloud Shell och gå sedan till resursgruppen som börjar med cloud-shell-storage-, välj Ta bort resursgrupp och följ anvisningarna.

Nästa steg

• Anpassa Python-appar i Azure Pipelines
• Konfigurera Python-app i App Service