Utilisez Azure Pipelines pour construire et déployer une application web Python sur Azure App Service.

Azure DevOps Services

Ce tutoriel vous montre comment utiliser Azure Pipelines pour l’intégration continue et la livraison continue (CI/CD) pour générer et déployer une application web Python sur Azure App Service sur Linux. Votre pipeline génère et déploie automatiquement votre application web Python sur App Service chaque fois qu’il existe une validation dans votre référentiel de code d’application.

Dans ce tutoriel, vous allez :

Pour en savoir plus sur les concepts d’Azure Pipelines, regardez la vidéo suivante :

Prérequis

$AGENT_TOOLSDIRECTORY/
    Python/
        {version number}/
            {platform}/
                {tool files}
            {platform}.complete

$AGENT_TOOLSDIRECTORY/
    Python/
        3.11.4/
            x64/
                {python files}
            x64.complete

Préparer l’application d’exemple

1. Dupliquez (fork) le référentiel d’exemple sur https://github.com/Microsoft/python-sample-vscode-flask-tutorial vers votre compte GitHub.

2. Clonez votre fork sur votre machine locale en utilisant git clone <your-forked-repository-url>.git.

3. Accédez à votre clone local à l’aide cd python-sample-vscode-flask-tutorialde , puis générez et exécutez l’application localement pour vous assurer qu’elle fonctionne.

   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. ** Pour tester l’application, accédez à http://localhost:5000 dans une fenêtre de navigateur et vérifiez que vous voyez le titre Didacticiel Flask de Visual Studio.

5. Fermez la fenêtre du navigateur et arrêtez le serveur Flask à l’aide de Ctrl+C.

Créer et déployer l’application web App Service

Créez votre application web Azure App Service à l’aide de Cloud Shell dans le portail Azure. Pour utiliser Cloud Shell, connectez-vous au portail Azure et sélectionnez le bouton Cloud Shell dans la barre d’outils.

Cloud Shell apparaît en bas du navigateur. Vérifiez que Bash est sélectionné comme environnement dans le menu déroulant. Vous pouvez optimiser la fenêtre Cloud Shell pour vous donner plus de place.

Créer et déployer l’application web

1. Dans Cloud Shell, clonez votre dépôt forké vers Azure avec la commande suivante, en remplaçant <your-forked-repository-url> par l'URL de votre dépôt forké.

   git clone <your-forked-repository-url>
   

2. Remplacez le répertoire par le dossier de référentiel cloné.

   cd python-sample-vscode-flask-tutorial
   

3. Exécutez la commande az webapp up pour provisionner l’application web App Service et effectuer le premier déploiement. Utilisez le --name <your-web-app-name> paramètre pour affecter un nom unique dans Azure, tel qu’un nom personnel ou d’entreprise, ainsi qu’un identificateur d’application, comme --name <your-name>-flaskpipelines. L’exécution az webapp up sans paramètre affecte un nom d’application web généré de manière aléatoire unique dans Azure.

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

La az webapp up commande reconnaît l’application en tant qu’application Python et effectue les actions suivantes :

1. Crée un groupe de ressources par défaut.
2. Crée un plan App Service par défaut.
3. Crée une application web avec le nom attribué. L’application URL est <your-web-app-name>.azurewebsites.net.
4. Déploie tous les fichiers du répertoire de travail actuel dans une archive ZIP, avec l’automatisation de build activée.
5. Met en cache les paramètres localement dans le fichier .azure/config . Vous n’avez donc pas besoin de les spécifier à nouveau lors du déploiement à partir du dossier du projet avec az webapp up ou d’autres az webapp commandes. Les commandes utilisent automatiquement les valeurs mises en cache par défaut.

Vous pouvez remplacer les actions par défaut par vos propres valeurs à l’aide des paramètres de commande. Pour plus d’informations, consultez az webapp up.

La az webapp up commande produit la sortie JSON suivante pour l’exemple d’application web :

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

Enregistrez les valeurs de URL, resourcegroup, et runtime_version pour les utiliser plus tard dans ce didacticiel.

Définir la commande de démarrage

L’application python-sample-vscode-flask-tutorial dispose d’un fichier startup.txt qui contient la commande de démarrage spécifique pour l’application web. Définissez la propriété de configuration de l'application web startup-file sur startup.txt en entrant la commande suivante, en utilisant vos noms de groupe de ressources et de web app.

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

Une fois la commande terminée, la sortie JSON affiche tous les paramètres de configuration de votre application web.

Pour voir l’application en cours d’exécution, ouvrez un navigateur et allez à l’URL URL indiquée dans la sortie de la commande az webapp up. Si vous voyez une page générique, attendez quelques secondes que le service App démarre, puis actualisez la page. Vérifiez que vous voyez le titre du didacticiel Visual Studio Flask.

Connecter votre projet Azure DevOps à votre abonnement Azure

Pour utiliser Azure Pipelines pour effectuer un déploiement sur votre application web Azure App Service, vous devez connecter votre projet Azure DevOps à vos ressources Azure.

az ad sp create-for-rbac --display-name <service-principal-name> --role contributor --scopes /subscriptions/<your-subscription-id>/resourceGroups/<your-resource-group>

{
  "appId": "<client GUID>",
  "displayName": "<service-principal-name">,
  "password": "<password-string>",
  "tenant": "<tenant GUID>"
  ...
}

Créer une connexion de service

Une connexion de service fournit un accès authentifié à partir d’Azure Pipelines vers des services externes et distants. Pour effectuer un déploiement sur votre application web Azure App Service, créez une connexion de service au groupe de ressources de votre application web.

La nouvelle connexion apparaît dans la liste des connexions de service et est prête à être utilisée dans votre pipeline.

Créer une chaîne de traitement

Créez un pipeline pour construire et déployer votre application web Python sur Azure App Service.

Fichier YAML de pipeline

Sur la page Révision de votre YAML de pipeline, examinez le pipeline afin de comprendre son fonctionnement. Assurez-vous que toutes les entrées par défaut sont adaptées à votre code. Pour en savoir plus sur le schéma de fichier YAML du pipeline, consultez la référence de schéma YAML.

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

trigger:
- main

variables:
  # Azure Resource Manager connection created during pipeline creation
  azureServiceConnectionId: '<your-service-connection-name>'

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

  # Environment name
  environmentName: '<your-web-app-name>'

  # Project root folder. 
  projectRoot: $(System.DefaultWorkingDirectory)

  # Python version: 
  pythonVersion: '<your-python-version>'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: BuildJob
pool:
      name: '<your-pool-name>'
      demands: python
    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 -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

    - task: PublishBuildArtifacts@1
      inputs:
        PathtoPublish: '$(Build.ArtifactStagingDirectory)'
        ArtifactName: 'drop'
        publishLocation: 'Container'

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

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

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

Variables

La variables section au début du fichier YAML définit les variables suivantes :

Phases de génération et de déploiement

Le pipeline se compose des phases de construction et de déploiement.

Étape de construction

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

  - job: BuildJob
    pool:
      name: <your-pool-name>
      demands: python

Le travail contient plusieurs étapes :

1. Tout d’abord, la tâche UsePythonVersion sélectionne la version de Python à utiliser, comme défini dans la pythonVersion variable.

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

2. L’étape suivante utilise un script qui crée un environnement Python virtuel et installe les dépendances de l’application à partir de requirements.txt. Le workingDirectory paramètre spécifie l’emplacement du code de l’application.

      - 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. La tâche ArchiveFiles crée une archive ZIP qui contient l’application web générée.

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

   Les paramètres sont définis comme suit :

   Paramètre	Description
   rootFolderOrFile	L’emplacement du code de l’application.
   includeRootFolder	Indique s’il faut inclure le dossier racine dans le fichier .zip . Réglez sur false. Si la valeur est définie true, le contenu du fichier .zip est placé dans un dossier nommé s et la tâche ne peut pas trouver le code de l’application.
   archiveType	Le type d’archive à créer. Réglez sur zip.
   archiveFile	L’emplacement du fichier .zip à créer.
   replaceExistingArchive	Indique si une archive existante doit être remplacée si le fichier existe déjà. Réglez sur true.

4. Le fichier .zip est ensuite téléchargé vers le pipeline en tant qu’artefact nommé drop. L’étape de déploiement utilise le fichier .zip pour déployer l’application.

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

   • Le upload paramètre définit l’emplacement et le nom du fichier .zip à charger.
   • Le artifact paramètre définit le nom de l’artefact créé sur drop.

Phase de déploiement

L’étape de déploiement s’exécute si l’étape de compilation se termine correctement. Les mots clés dependsOn et condition définissent ce comportement.

  dependsOn: Build
  condition: succeeded()

L’étape de déploiement contient un travail de déploiement unique configuré comme suit.

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

  - deployment: DeploymentJob
    pool:
      name: <your-pool-name>
    environment: $(environmentName)

Le strategy mot clé définit la stratégie de déploiement.

  strategy:
    runOnce:
      deploy:
        steps:

• Le mot-clé runOnce spécifie que le travail de déploiement s’exécute une fois.
• Le deploy mot clé spécifie l’exécution steps dans le travail de déploiement.

Dans steps cette étape, exécutez les tâches suivantes :

1. UsePythonVersion@0 sélectionne la version de Python à utiliser, comme dans la phase de génération.
2. AzureWebApp@1 déploie l’application web et l’artefact drop ZIP.

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

• Le azureSubscription paramètre contient les azureServiceConnectionId variables de pipeline spécifiées.
• La appName contient la valeur de la variable webAppName.
• Spécifie package le nom et l’emplacement du fichier .zip à déployer.

En outre, étant donné que le référentiel python-vscode-flask-tutorial contient la commande de démarrage de l’application dans un fichier nommé startup.txt, vous pouvez spécifier la commande de démarrage de l’application en ajoutant le paramètre : startUpCommand: 'startup.txt'.

Exécuter le pipeline

Vous êtes maintenant prêt à essayer le pipeline.

1. Dans l’éditeur de pipeline, sélectionnez Enregistrer et exécuter.

2. Dans l’écran Enregistrer et exécuter , ajoutez un message de validation si vous le souhaitez, puis sélectionnez Enregistrer et exécuter.

   Vous pouvez surveiller l’exécution du pipeline en sélectionnant les étapes ou les travaux sur la page Résumé du pipeline. Chaque tâche et chaque étape affichent une coche verte au fur et à mesure qu'elles sont terminées avec succès. Si des erreurs se produisent, elles apparaissent dans le résumé ou dans les étapes du travail.

   

   Vous pouvez rapidement revenir à l’éditeur YAML en sélectionnant les points verticaux en haut à droite de la page Résumé et en sélectionnant Modifier le pipeline.

   

3. À partir du travail de déploiement, sélectionnez la tâche Déployer Azure Web App pour afficher sa sortie.

   

4. Dans la sortie, sélectionnez l’URL après l’URL de l’application App Service. L’application doit apparaître comme suit :

   

Déclencher une exécution du pipeline

Ce pipeline est défini pour s’exécuter chaque fois qu’une modification est effectuée dans le référentiel de code. Pour déclencher l’exécution d’un pipeline, apportez une modification au référentiel. Par exemple, vous pouvez ajouter une nouvelle fonctionnalité à l’application ou mettre à jour les dépendances de l’application.

1. Accédez au dépôt GitHub de votre application.
2. Apportez une modification au code, comme changer le titre de l’application.
3. Validez la modification.
4. Accédez à votre pipeline et vérifiez qu’une nouvelle exécution est créée et est en cours d’exécution.
5. Une fois que l’exécution est terminée, vérifiez que les modifications ont été correctement déployées sur votre application web.
6. Dans le portail Azure, accédez à votre application web et sélectionnez Centre de déploiement dans le menu de navigation de gauche.
7. Sélectionnez l’onglet Journaux et vérifiez que le nouveau déploiement est répertorié.

Déployer des applications Django sur App Service

Vous pouvez utiliser Azure Pipelines pour déployer des applications Django sur App Service sur Linux si vous utilisez une base de données distincte. Vous ne pouvez pas utiliser une base de données SQLite, car App Service verrouille le fichier db.sqlite3, empêchant les lectures et les écritures. Ce comportement n’affecte pas les bases de données externes.

Comme expliqué dans le processus de démarrage du conteneur, App Service recherche automatiquement un fichier wsgi.py dans le code de votre application, qui contient généralement l’objet d’application. Si vous souhaitez personnaliser la commande de démarrage, utilisez le startUpCommand paramètre à l’étape AzureWebApp@1 de votre fichier de pipeline YAML.

Lorsque vous utilisez Django, vous souhaitez généralement migrer les modèles de données à l’aide manage.py migrate d’après le déploiement du code de l’application. Vous pouvez ajouter startUpCommand avec un script post-déploiement à cette fin. Par exemple, voici la propriété startUpCommand dans la tâche AzureWebApp@1.

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

Exécuter des tests sur l’agent de build

Dans le cadre de votre processus de build, vous voudrez peut-être exécuter des tests sur le code de votre application. Les tests s’exécutent sur l’agent de build, vous devez donc installer vos dépendances dans un environnement virtuel sur l’agent de build. Une fois les tests exécutés, supprimez l’environnement virtuel de test avant de créer le fichier .zip pour le déploiement.

Les éléments de script suivants illustrent ce processus. Placez-les avant la tâche ArchiveFiles@2 dans le fichier azure-pipelines.yml. Pour plus d’informations, consultez Exécuter des scripts multiplateformes.

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

Vous pouvez également utiliser une tâche comme PublishTestResults@2 pour publier les résultats des tests dans votre pipeline. Pour plus d’informations, consultez Exécuter des tests.

Nettoyer les ressources

Si vous avez terminé avec les ressources Azure que vous avez créées dans ce tutoriel, supprimez-les pour éviter les frais supplémentaires.

• Supprimez le projet Azure DevOps que vous avez créé. La suppression du projet supprime le pipeline et la connexion au service.
• Supprimez le groupe de ressources Azure contenant le service d’application et le plan du service d’application. Dans le portail Azure, accédez au groupe de ressources, sélectionnez Supprimer le groupe de ressources et suivez les invites.
• Supprimez le compte de stockage Azure qui gère le système de fichiers Cloud Shell. Fermez Cloud Shell, puis recherchez le groupe de ressources qui commence par cloud-shell-storage-. Sélectionnez Supprimer le groupe de ressources, puis suivez les invites.

Contenu connexe

• Personnaliser les applications Python dans Azure Pipelines
• Configurer une application Python sur App Service