Azure Pipelines gebruiken om een Python-web-app te bouwen en te implementeren in Azure-app Service

Azure DevOps Services

Gebruik Azure Pipelines voor continue integratie en continue levering (CI/CD) om een Python-web-app te bouwen en te implementeren in Azure-app Service op Linux. Uw pijplijn bouwt en implementeert uw Python-web-app automatisch in App Service wanneer er een doorvoer naar de opslagplaats is.

In dit artikel leert u het volgende:

• Een web-app maken in Azure App Service.
• Maak een project in Azure DevOps.
• Verbind uw DevOps-project met Azure.
• Maak een Python-specifieke pijplijn.
• Voer de pijplijn uit om uw app te bouwen en te implementeren in uw web-app in App Service.

Vereisten

• Een Azure-abonnement. Als u nog geen account hebt, kunt u een gratis account maken.
• Een GitHub-account. Als u dit niet hebt, kunt u er gratis een maken.
• Een Azure DevOps Services-organisatie. Maak gratis een account.

Een opslagplaats voor uw app-code maken

Fork de voorbeeldopslagplaats in https://github.com/Microsoft/python-sample-vscode-flask-tutorial uw GitHub-account.

Kloon uw GitHub-opslagplaats op uw lokale host. Gebruik de volgende opdracht en vervang deze <repository-url> door de URL van uw geforkte opslagplaats.

git clone <repository-url>

Uw app lokaal testen

Bouw en voer de app lokaal uit om ervoor te zorgen dat deze werkt.

1. Ga naar de gekloonde opslagplaatsmap.

   cd python-sample-vscode-flask-tutorial
   

2. Ontwikkel de app en voer deze uit

   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. Als u de app wilt weergeven, opent u een browservenster en gaat u naar http://localhost:5000. Controleer of u de titel Visual Studio Flask Tutorialziet.

4. Wanneer u klaar bent, sluit u het browservenster en stopt u de Flask-server met Ctrl+C.

Cloud Shell openen

1. Meld u aan bij de Azure Portal op https://portal.azure.com.

2. Open de Azure CLI door de Cloud Shell-knop op de portalwerkbalk te selecteren.

   

3. De Cloud Shell wordt onder aan de browser weergegeven. Selecteer Bash in de vervolgkeuzelijst.

   

4. Als u meer ruimte wilt geven om te werken, selecteert u de knop Maximaliseren.

Een Azure-app Service-web-app maken

Maak uw Azure-app Service-web-app vanuit de Cloud Shell in Azure Portal.

Tip

Als u in Cloud Shell wilt plakken, gebruikt u Ctrl+Shift+V of klikt u met de rechtermuisknop en selecteert u Plakken in het contextmenu.

1. Kloon uw opslagplaats met de volgende opdracht, waarbij u <repository-url> de URL van uw geforkte opslagplaats vervangt.

   git clone <repository-url>
   

2. Wijzig de map in de gekloonde opslagplaatsmap, zodat de az webapp up opdracht de app herkent als een Python-app.

   cd python-sample-vscode-flask-tutorial
   

3. Gebruik de opdracht az webapp up om de App Service in te richten en de eerste implementatie van uw app uit te voeren. Vervang door <your-web-app-name> een naam die uniek is in Azure. Normaal gesproken gebruikt u een persoonlijke of bedrijfsnaam samen met een app-id, zoals <your-name>-flaskpipelines. De URL van de app wordt uw-appservice.azurewebsites.net>.<

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

   In de JSON-uitvoer van de az webapp up opdracht ziet u:

   {
     "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>
   }
   

   Noteer de URL waarden en de runtime_version waarden. U gebruikt het runtime_version YAML-bestand in de pijplijn. Dit URL is de URL van uw web-app. U kunt deze gebruiken om te controleren of de app wordt uitgevoerd.

   Notitie

   Met de opdracht az webapp up worden de volgende acties uitgevoerd:

   • Er wordt een standaardresourcegroep gemaakt.

   • Maak een standaard App Service-plan.

   • Er wordt een app met de opgegeven naam gemaakt.

   • Zip implementeert alle bestanden uit de huidige werkmap, waarbij buildautomatisering is ingeschakeld.

   • Sla de parameters lokaal in het .azure/config-bestand op, zodat u ze niet opnieuw hoeft op te geven wanneer u ze later implementeert met az webapp up of andere az webapp opdrachten uit de projectmap. De waarden in de cache worden standaard automatisch gebruikt.

   U kunt de standaardactie overschrijven met uw eigen waarden met behulp van de opdrachtparameters. Zie az webapp up voor meer informatie.

4. De python-sample-vscode-flask-tutorial-app heeft een startup.txt-bestand dat de specifieke opstartopdracht voor de web-app bevat. Stel de configuratie-eigenschap van de web-app startup-file in op startup.txt.

   1. Kopieer resourcegroup de waarde in de uitvoer van de az webapp up opdracht.

   2. Voer de volgende opdracht in met behulp van de resourcegroep en de naam van uw app.

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

   Wanneer de opdracht is voltooid, wordt de JSON-uitvoer weergegeven die alle configuratie-instellingen voor uw web-app bevat.

5. Als u de actieve app wilt zien, opent u een browser en gaat u naar de URL weergegeven in de az webapp up opdrachtuitvoer. Als u een algemene pagina ziet, wacht u enkele seconden totdat de App Service is gestart en vernieuwt u de pagina. Controleer of u de titel Visual Studio Flask Tutorialziet.

Een Azure DevOps-project maken

Maak een nieuw Azure DevOps-project.

1. Ga in een browser naar dev.azure.com en meld u aan.
2. Selecteer uw organisatie.
3. Maak een nieuw project door Nieuw project of Project maken te selecteren als u het eerste project in de organisatie maakt.
4. Voer een projectnaam in.
5. Selecteer de zichtbaarheid voor uw project.
6. Selecteer Maken.

Een serviceverbinding maken

Met een serviceverbinding kunt u een verbinding maken om geverifieerde toegang van Azure Pipelines te bieden aan externe en externe services. Als u wilt implementeren in uw Azure-app Service-web-app, maakt u een serviceverbinding met de resourcegroep die de web-app bevat.

1. Selecteer projectinstellingen op de projectpagina.

   

2. Selecteer Serviceverbindingen in de sectie Pijplijnen van het menu.

3. Selecteer Serviceverbinding maken.

4. Selecteer Azure Resource Manager en selecteer Volgende.

   

5. Selecteer uw verificatiemethode en selecteer Volgende.

6. Voer in het dialoogvenster Nieuwe Azure-serviceverbinding de informatie in die specifiek is voor de geselecteerde verificatiemethode. Zie Verbinding maken met Azure met behulp van een Azure Resource Manager-serviceverbinding voor meer informatie over verificatiemethoden.

   Als u bijvoorbeeld een verificatiemethode voor workloadidentiteitsfederatie (automatisch) of service-principal (automatisch) gebruikt, voert u de vereiste gegevens in.

   

   Veld	Beschrijving
   Bereikniveau	Selecteer Abonnement.
   Abonnement	Uw Azure-abonnementnaam.
   Resourcegroep	De naam van de resourcegroep die uw web-app bevat.
   Serviceverbindingsnaam	Een beschrijvende naam voor de verbinding.
   Toegangsmachtigingen verlenen aan alle pijplijnen	Selecteer deze optie om toegang te verlenen tot alle pijplijnen.

7. Selecteer Opslaan.

De nieuwe verbinding wordt weergegeven in de lijst met serviceverbindingen en is klaar voor gebruik in uw Azure Pipeline.

Een pipeline maken

Maak een pijplijn om uw Python-web-app te bouwen en te implementeren in Azure-app Service. Bekijk het volgende voor meer informatie over pijplijnconcepten:

1. Selecteer Pijplijnen in het linkernavigatiemenu.

   

2. Selecteer Pipeline maken.

   

3. Selecteer GitHub in het dialoogvenster Waar is de code. Mogelijk wordt u gevraagd u aan te melden bij GitHub.

   

4. Selecteer in het scherm Een opslagplaats selecteren de geforkte voorbeeldopslagplaats.

   

5. Mogelijk wordt u gevraagd uw GitHub-wachtwoord opnieuw in te voeren als bevestiging.

6. Als de Azure Pipelines-extensie niet is geïnstalleerd op GitHub, wordt u gevraagd om de Azure Pipelines-extensie te installeren.

   

   Schuif op deze pagina omlaag naar de sectie Opslagplaatstoegang , kies of u de extensie wilt installeren op alle opslagplaatsen of alleen geselecteerde opslagplaatsen en selecteer vervolgens Goedkeuren en installeren.

   

7. Selecteer In het dialoogvenster Uw pijplijn configureren Python naar Linux-web-app in Azure.

8. Selecteer uw Azure-abonnement en selecteer Doorgaan.

9. Als u uw gebruikersnaam en wachtwoord gebruikt om te verifiëren, wordt er een browser geopend om u aan te melden bij uw Microsoft-account.

10. Selecteer de naam van uw web-app in de vervolgkeuzelijst en selecteer Valideren en configureren.

Azure Pipelines maakt een azure-pipelines.yml bestand en geeft dit weer in de YAML-pijplijneditor. Het pijplijnbestand definieert uw CI/CD-pijplijn als een reeks fasen, taken en stappen, waarbij elke stap de details voor verschillende taken en scripts bevat. Bekijk de pijplijn om te zien wat die doet. Zorg ervoor dat alle standaardinvoer geschikt is voor uw code.

YAML-pijplijnbestand

In de volgende uitleg wordt het YAML-pijplijnbestand beschreven. Zie de YAML-schemareferentie voor het YAML-schema voor pijplijnen voor meer informatie over het YAML-bestandsschema.

Hieronder ziet u het volledige YAML-bestand voor de pijplijn:

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

Variabelen

De variables sectie bevat de volgende variabelen:

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'

Veranderlijk	Beschrijving
azureServiceConnectionId	De id of naam van de Azure Resource Manager-serviceverbinding.
webAppName	De naam van de Azure-app Service-web-app.
vmImageName	De naam van het besturingssysteem dat moet worden gebruikt voor de buildagent.
environmentName	De naam van de omgeving die in de implementatiefase wordt gebruikt. De omgeving wordt automatisch gemaakt wanneer de fasetaak wordt uitgevoerd.
projectRoot	De hoofdmap met de app-code.
pythonVersion	De versie van Python die moet worden gebruikt voor de build- en implementatieagents.

Buildfase

De buildfase bevat één taak die wordt uitgevoerd op het besturingssysteem dat is gedefinieerd in de variabele vmImageName.

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

De taak bevat meerdere stappen:

1. De taak UsePythonVersion selecteert de te gebruiken versie van Python. De versie wordt gedefinieerd in de pythonVersion variabele.

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

2. In deze stap wordt een script gebruikt om een virtuele Python-omgeving te maken en de afhankelijkheden van de app in de requirements.txt parameter de workingDirectory locatie van de app-code op te geven.

     - 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. De taak ArchiveFiles maakt het .zip archief met de web-app. Het .zip bestand wordt geüpload naar de pijplijn als het artefact met de naam drop. Het .zip bestand wordt gebruikt in de implementatiefase om de app in de web-app te implementeren.

      - 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	Beschrijving
   rootFolderOrFile	De locatie van de app-code.
   includeRootFolder	Geeft aan of de hoofdmap moet worden opgenomen in het .zip-bestand . Stel deze parameter in op false anders, de inhoud van het bestand .zip wordt in een map met de naam s geplaatst en App Service op Linux container de app-code niet kan vinden.
   archiveType	Het type archief dat moet worden gemaakt. Ingesteld op zip.
   archiveFile	De locatie van het .zip-bestand dat u wilt maken.
   replaceExistingArchive	Geeft aan of een bestaand archief moet worden vervangen als het bestand al bestaat. Ingesteld op true.
   upload	De locatie van het .zip-bestand dat u wilt uploaden.
   artifact	De naam van het artefact dat moet worden gemaakt.

Implementatiefase

De implementatiefase wordt uitgevoerd als de buildfase is voltooid. Met de volgende trefwoorden wordt dit gedrag gedefinieerd:

  dependsOn: Build
  condition: succeeded()

De implementatiefase bevat één implementatietaak die is geconfigureerd met de volgende trefwoorden:

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

Trefwoord	Beschrijving
deployment	Geeft aan dat de taak een implementatietaak is die gericht is op een omgeving.
pool	Hiermee geeft u de implementatieagentgroep op. De standaardagentgroep als de naam niet is opgegeven. Het vmImage trefwoord identificeert het besturingssysteem voor de installatiekopieën van de virtuele machine van de agent
environment	Hiermee geeft u de omgeving op waarin moet worden geïmplementeerd. De omgeving wordt automatisch in uw project gemaakt wanneer de taak wordt uitgevoerd.

Het strategy trefwoord wordt gebruikt om de implementatiestrategie te definiëren. Het runOnce trefwoord geeft aan dat de implementatietaak eenmaal wordt uitgevoerd. Het deploy trefwoord geeft de stappen op die moeten worden uitgevoerd in de implementatietaak.

  strategy:
    runOnce:
      deploy:
        steps:

De steps in de pijplijn zijn:

1. Gebruik de taak UsePythonVersion om de versie van Python op te geven die op de agent moet worden gebruikt. De versie wordt gedefinieerd in de pythonVersion variabele.

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

2. Implementeer de web-app met behulp van de AzureWebApp@1. Met deze taak wordt het pijplijnartefact drop geïmplementeerd in uw web-app.

   - 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	Beschrijving
   azureSubscription	De verbindings-id of naam van de Azure Resource Manager-service die moet worden gebruikt.
   appName	de naam van de web-app.
   package	De locatie van het .zip-bestand dat moet worden geïmplementeerd.

   Omdat de opslagplaats python-vscode-flask-tutorial dezelfde opstartopdracht bevat in een bestand met de naam startup.txt, kunt u dat bestand opgeven door de parameter toe te voegen: startUpCommand: 'startup.txt'.

De pijplijn uitvoeren

U bent nu klaar om het uit te proberen!

1. Selecteer Opslaan en uitvoeren in de editor.

2. Voeg in het dialoogvenster Opslaan en uitvoeren een doorvoerbericht toe en selecteer Opslaan en uitvoeren.

   U kunt de pijplijn bekijken terwijl deze wordt uitgevoerd door de fasen of taken te selecteren in het samenvatting van de pijplijnuitvoering.

   

   Er zijn groene vinkjes naast elke fase en taak wanneer deze is voltooid. Als er fouten optreden, worden ze weergegeven in de samenvatting of in de taakstappen.

   

   U kunt snel terugkeren naar de YAML-editor door de verticale puntjes in de rechterbovenhoek van de pagina Samenvatting te selecteren en pijplijn bewerken te selecteren:

   

3. Selecteer in de implementatietaak de taak Azure-web-app implementeren om de uitvoer ervan weer te geven. Als u de geïmplementeerde site wilt bezoeken, houdt u Ctrl ingedrukt en selecteert u de URL ernaApp Service Application URL.

   Als u de voorbeeld-app gebruikt, moet de app er als volgt uitzien:

   

Belangrijk

Als uw app mislukt vanwege een ontbrekende afhankelijkheid, is uw requirements.txt bestand niet verwerkt tijdens de implementatie. Dit gedrag treedt op als u de web-app rechtstreeks in de portal hebt gemaakt in plaats van de az webapp up opdracht te gebruiken, zoals wordt weergegeven in dit artikel.

Met az webapp up de opdracht wordt de build-actie SCM_DO_BUILD_DURING_DEPLOYMENT specifiek ingesteld op true. Als u de app-service via de portal hebt ingericht, wordt deze actie niet automatisch ingesteld.

Met de volgende stappen stelt u de actie in:

1. Open Azure Portal, selecteer uw App Service en selecteer vervolgens Configuratie.
2. Selecteer Op het tabblad Toepassingsinstellingen de optie Nieuwe toepassingsinstelling.
3. Stel in het pop-upvenster dat wordt weergegeven de naam SCM_DO_BUILD_DURING_DEPLOYMENTin, stel Waarde truein op en selecteer OK.
4. Selecteer Opslaan boven aan de pagina Configuratie .
5. Voer de pijplijn opnieuw uit. Uw afhankelijkheden moeten worden geïnstalleerd tijdens de implementatie.

Een pijplijnuitvoering activeren

Als u een pijplijnuitvoering wilt activeren, voert u een wijziging door naar de opslagplaats. U kunt bijvoorbeeld een nieuwe functie toevoegen aan de app of de afhankelijkheden van de app bijwerken.

1. Ga naar uw GitHub-opslagplaats.
2. Breng een wijziging aan in de code, zoals het wijzigen van de titel van de app.
3. Voer de wijziging door in uw opslagplaats.
4. Ga naar uw pijplijn en controleer of er een nieuwe uitvoering is gemaakt.
5. Wanneer de uitvoering is voltooid, controleert u of de nieuwe build is geïmplementeerd in uw web-app.
   1. Ga in Azure Portal naar uw web-app.
   2. Selecteer Implementatiecentrum en selecteer het tabblad Logboeken .
   3. Controleer of de nieuwe implementatie wordt vermeld.

Overwegingen voor Django

U kunt Azure Pipelines gebruiken om Django-apps te implementeren in Azure-app Service in Linux als u een afzonderlijke database gebruikt. U kunt geen SQLite-database gebruiken, omdat App Service het bestand db.sqlite3 vergrendelt, waardoor zowel lees- als schrijfbewerkingen worden voorkomen. Dit gedrag heeft geen invloed op een externe database.

Zoals beschreven in De Python-app configureren in App Service - Container opstarten, zoekt App Service automatisch naar een wsgi.py-bestand in uw app-code, dat meestal het app-object bevat. Als u de opstartopdracht op welke manier dan ook wilt aanpassen, gebruikt u de startUpCommand parameter in de AzureWebApp@1 stap van uw YAML-pijplijnbestand, zoals beschreven in de vorige sectie.

Wanneer u Django gebruikt, wilt u doorgaans de gegevensmodellen migreren met behulp van manage.py migrate de app-code. U kunt hiervoor een script na de implementatie toevoegen startUpCommand . Hier ziet u bijvoorbeeld de startUpCommand eigenschap in de AzureWebApp@1 taak.

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

Tests uitvoeren op de buildagent

Als onderdeel van het buildproces wilt u mogelijk tests uitvoeren op uw app-code. Tests worden uitgevoerd op de buildagent, dus u moet uw afhankelijkheden installeren in een virtuele omgeving op de buildagent. Nadat de tests zijn uitgevoerd, verwijdert u de virtuele omgeving voordat u het .zip-bestand voor implementatie maakt. De volgende scriptelementen illustreren dit proces. Plaats deze vóór de ArchiveFiles@2 taak in het azure-pipelines.yml-bestand . Zie Platformoverschrijdende scripts uitvoeren voor meer informatie.

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

U kunt ook een taak zoals PublishTestResults@2 gebruiken om de testresultaten naar uw pijplijn te publiceren. Zie Python-apps bouwen - Tests uitvoeren voor meer informatie.

Resources opschonen

Ga als volgt te werk om te voorkomen dat er kosten in rekening worden gebracht voor de Azure-resources die in deze zelfstudie zijn gemaakt:

• Verwijder het project dat u hebt gemaakt. Als u het project verwijdert, wordt de pijplijn- en serviceverbinding verwijderd.

• Verwijder de Azure-resourcegroep die de App Service en het App Service-plan bevat. Ga in Azure Portal naar de resourcegroep, selecteer Resourcegroep verwijderen en volg de aanwijzingen.

• Verwijder het opslagaccount dat het bestandssysteem voor Cloud Shell onderhoudt. Sluit Cloud Shell en ga vervolgens naar de resourcegroep die begint met cloud-shell-opslag, selecteer Resourcegroep verwijderen en volg de aanwijzingen.

Volgende stappen

• Python-apps aanpassen in Azure Pipelines
• Python-app configureren in App Service