Usare Azure Pipelines per compilare e distribuire un'app Web Python nel servizio app Azure

Servizi di Azure DevOps

Questa esercitazione illustra come usare Azure Pipelines per l'integrazione continua e il recapito continuo (CI/CD) per compilare e distribuire un'app Web Python nel servizio app di Azure in Linux. La pipeline compila e distribuisce automaticamente l'app Web Python nel servizio app ogni volta che è presente un commit nel repository del codice dell'app.

In questa esercitazione, farai:

• Creare un'app Web Python e caricarla nel servizio app di Azure.
• Connettere il progetto Azure DevOps ad Azure.
• Creare una pipeline di distribuzione e compilazione specifica di Azure Pipelines per Python per l'app.
• Eseguire la pipeline per compilare, testare e distribuire nell'app Web del servizio app di Azure.
• Impostare un trigger per eseguire la pipeline ogni volta che si esegue il commit nel repository.

Per altre informazioni sui concetti di Azure Pipelines, guardare il video seguente:

Prerequisiti

Prodotto	Requisiti
Azure DevOps	- Un progetto Azure DevOps. - La possibilità di eseguire pipeline su agenti ospitati da Microsoft. È possibile acquistare un incarico parallelo oppure richiedere un piano gratuito. - Conoscenza di base di YAML e Azure Pipelines. Per maggiori informazioni, vedere Creare la prima pipeline. Autorizzazioni - :      - Per creare una pipeline, è necessario trovarsi nel gruppo Collaboratori e il gruppo deve avere l'autorizzazione Crea pipeline di compilazione impostata su Consenti. I membri del gruppo Project Administrators possono gestire le pipeline.     - Per creare connessioni al servizio: è necessario disporre del ruolo di Administrator o Creator per le connessioni al servizio .
GitHub	- Un account GitHub. - Una connessione al servizio GitHub per autorizzare Azure Pipelines.
Azzurro	Una sottoscrizione di Azure.

Preparare l'app di esempio

1. Fai il fork del repository di esempio nel tuo account GitHub https://github.com/Microsoft/python-sample-vscode-flask-tutorial.

2. Clonare il fork nel computer locale usando git clone <your-forked-repository-url>.git.

3. Passare al clone locale usando cd python-sample-vscode-flask-tutoriale compilare ed eseguire l'app in locale per assicurarsi che funzioni.

   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. Per testare l'app, passare a http://localhost:5000 in una finestra del browser e verificare che venga visualizzato il titolo Visual Studio Flask Tutorial.

5. Chiudere la finestra del browser e arrestare il server Flask usando CTRL+C.

Creare e distribuire l'app Web del servizio app

Creare l'app Web del servizio app di Azure usando Cloud Shell nel portale di Azure. Per usare Cloud Shell, accedere al portale di Azure e selezionare il pulsante Cloud Shell sulla barra degli strumenti.

Cloud Shell viene visualizzato nella parte inferiore del browser. Assicurarsi che Bash sia selezionato come ambiente nel menu a discesa. È possibile ingrandire la finestra di Cloud Shell per offrire maggiore spazio.

Suggerimento

Per incollare in Cloud Shell, usare CTRL+MAIUSC+V o fare clic con il pulsante destro del mouse e scegliere Incolla dal menu di scelta rapida.

Creare e distribuire l'app Web

1. In Cloud Shell clonare il repository copiato tramite fork in Azure con il comando seguente, sostituendo <your-forked-repository-url> con l'URL del repository copiato tramite fork.

   git clone <your-forked-repository-url>
   

2. Passare alla cartella del repository clonata.

   cd python-sample-vscode-flask-tutorial
   

3. Eseguire il comando az webapp up per effettuare il provisioning dell'app Web del servizio app ed eseguire la prima distribuzione. Usare il --name <your-web-app-name> parametro per assegnare un nome univoco in Azure, ad esempio un nome personale o aziendale insieme a un identificatore dell'app, ad --name <your-name>-flaskpipelinesesempio . L'esecuzione az webapp up senza parametri assegna un nome di app Web generato in modo casuale univoco in Azure.

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

Il az webapp up comando riconosce l'app come app Python e esegue le azioni seguenti:

1. Crea un gruppo di risorse predefinito.
2. Crea un piano di servizio app predefinito.
3. Crea un'app Web con il nome assegnato. L'app URL è <your-web-app-name>.azurewebsites.net.
4. Distribuisce tutti i file dalla directory di lavoro corrente a un archivio ZIP, con l'automazione della compilazione abilitata.
5. Memorizza nella cache i parametri in locale nel file .azure/config , quindi non è necessario specificarli di nuovo durante la distribuzione dalla cartella del progetto con az webapp up o altri az webapp comandi. I comandi usano automaticamente i valori memorizzati nella cache per impostazione predefinita.

È possibile eseguire l'override delle azioni predefinite con i propri valori usando i parametri del comando. Per altre informazioni, vedere az webapp up.

Il az webapp up comando produce l'output JSON seguente per l'app Web di esempio:

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

Registrare i URLvalori , resourcegroupe runtime_version da usare più avanti in questa esercitazione.

Impostare il comando di avvio

L'app python-sample-vscode-flask-tutorial include un file startup.txt che contiene il comando di avvio specifico per l'app Web. Impostare la proprietà startup-file di configurazione dell'app startup.txt Web su immettendo il comando seguente, usando il gruppo di risorse e i nomi delle app Web.

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

Al termine del comando, l'output JSON mostra tutte le impostazioni di configurazione per l'app Web.

Per visualizzare l'app in esecuzione, aprire un browser e passare al URL mostrato nell'output del comando az webapp up. Se viene visualizzata una pagina generica, attendere alcuni secondi per l'avvio del servizio app, quindi aggiornare la pagina. Verificare di visualizzare il titolo Visual Studio Flask Tutorial( Esercitazione su Flask).

Connettere il progetto Azure DevOps alla sottoscrizione di Azure

Per usare Azure Pipelines per la distribuzione nell'app Web del servizio app di Azure, è necessario connettere il progetto Azure DevOps alle risorse di Azure.

Creare una connessione al servizio

Una connessione al servizio fornisce l'accesso autenticato da Azure Pipelines a servizi esterni e remoti. Per eseguire la distribuzione nell'app Web del servizio app di Azure, creare una connessione al servizio al gruppo di risorse per l'app Web.

1. Nella pagina del progetto Azure DevOps selezionare Impostazioni progetto.

2. In Project Settings (Impostazioni progetto) selezionare PipelinesService connections (Connessioni al servizio>

3. Nella pagina Connessioni al servizio selezionare Nuova connessione al servizio o Crea connessione al servizio se la connessione al servizio è la prima nel progetto.

   

4. Nella schermata Nuova connessione al servizio selezionare Azure Resource Manager e quindi avanti.

   

5. Nella schermata Nuova connessione al servizio di Azure selezionare il tipo di identità. In questo esempio viene usata la registrazione dell'app (automatica) consigliata. Per altre informazioni sui metodi di autenticazione, vedere Connettersi ad Azure usando una connessione al servizio Azure Resource Manager.

6. Per Credenziali selezionare Federazione dell'identità del carico di lavoro (automatica).

7. Completa i seguenti campi:

   • Livello di ambito: selezionare Sottoscrizione.
   • Sottoscrizione: selezionare una sottoscrizione di Azure.
   • Gruppo di risorse: selezionare il gruppo di risorse che contiene l'app Web.
   • Nome connessione del servizio: immettere un nome descrittivo per la connessione.
   • Concedere le autorizzazioni di accesso a tutte le pipeline: selezionare questa casella di controllo per concedere l'accesso a tutte le pipeline nel progetto.

8. Seleziona Salva.

   

La nuova connessione viene visualizzata nell'elenco Connessioni al servizio ed è pronta per l'uso nella pipeline.

Creare un flusso di lavoro

Creare una pipeline per compilare e distribuire l'app Web Python nel servizio app Azure.

1. Nel menu di spostamento a sinistra per il progetto selezionare Pipeline.

2. Nella pagina Pipeline selezionare Nuova pipeline o Crea pipeline se la pipeline è la prima nel progetto.

   

3. Nella schermata Dove è il codice selezionare GitHub. Potrebbe essere richiesto di accedere a GitHub.

   

4. Nella schermata Selezionare un repository, selezionare il repository di esempio creato tramite fork. GitHub potrebbe richiedere di immettere nuovamente la password di GitHub o di installare l'app GitHub azure Pipelines . Seguire le istruzioni visualizzate per installare l'app. Per altre informazioni, vedere Autenticazione dell'app GitHub.

   

5. Nella pagina Configura la pipeline selezionare Python in App Web Linux in Azure.

6. Nella schermata successiva selezionare la sottoscrizione di Azure e selezionare Continua.

7. Nella schermata successiva selezionare l'app Web di Azure e selezionare Convalida e configura.

Azure Pipelines crea un file azure-pipelines.yml e lo visualizza nell'editor della pipeline YAML.

File di pipeline YAML

Nella pagina Review your pipeline YAML (Esaminare il file YAML della pipeline ) esaminare la pipeline per vedere le operazioni eseguite. Assicurarsi che tutti gli input predefiniti siano appropriati per il codice. Per informazioni sullo schema di file YAML della pipeline, vedere le informazioni di riferimento sullo schema YAML.

Il file di pipeline YAML di esempio seguente definisce la pipeline CI/CD come una serie di fasi, processi e passaggi, in cui ogni passaggio contiene i dettagli per attività e script diversi. Il codice YAML generato popola automaticamente i segnaposto con valori per l'app e la connessione.

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

Variabili

La variables sezione all'inizio del file YAML definisce le variabili seguenti:

Variabile	Descrizione
azureServiceConnectionId	ID della connessione al servizio Azure Resource Manager.
webAppName	Nome dell'app Web del servizio app.
vmImageName	Nome del sistema operativo da usare per l'agente di compilazione.
environmentName	Nome dell'ambiente in cui eseguire la distribuzione, che viene creato automaticamente quando viene eseguito il processo di distribuzione.
projectRoot	Cartella radice contenente il codice dell'applicazione.
pythonVersion	Versione di Python da usare negli agenti di compilazione e distribuzione.

Fasi di compilazione e distribuzione

La pipeline è costituita da fasi di compilazione e distribuzione.

Fase di costruzione

La fase di compilazione contiene un singolo processo eseguito nel sistema operativo definito nella vmImageName variabile , in questo caso ubuntu-latest.

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

Il processo contiene più passaggi:

1. Prima di tutto, l'attività UsePythonVersion seleziona la versione di Python da usare, come definito nella pythonVersion variabile .

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

2. Il passaggio successivo usa uno script che crea un ambiente Python virtuale e installa le dipendenze dell'app da requirements.txt. Il workingDirectory parametro specifica il percorso del codice dell'app.

      - 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. L'attività ArchiveFiles crea un archivio ZIP contenente l'app Web compilata.

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

   I parametri vengono impostati come segue:

   Parametro	Descrizione
   rootFolderOrFile	Posizione del codice dell'app.
   includeRootFolder	Indica se includere la cartella radice nel file .zip . Impostare su false. Se impostato su true, il contenuto del file .zip viene inserito in una cartella denominata s e l'attività non riesce a trovare il codice dell'app.
   archiveType	Tipo di archivio da creare. Impostare su zip.
   archiveFile	Posizione del file .zip da creare.
   replaceExistingArchive	Indica se sostituire un archivio esistente se il file esiste già. Impostare su true.

4. Il .zip file carica quindi nella pipeline come artefatto denominato drop. La fase di distribuzione usa il file .zip per distribuire l'app.

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

   • Il upload parametro imposta il percorso e il nome del file .zip da caricare.
   • Il artifact parametro imposta il nome dell'artefatto creato su drop.

Fase di distribuzione

La fase di distribuzione viene eseguita se la fase di compilazione viene completata correttamente. Le dependsOn parole chiave e condition definiscono questo comportamento.

  dependsOn: Build
  condition: succeeded()

La fase di distribuzione contiene un singolo processo di distribuzione configurato come indicato di seguito.

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

• La deployment parola chiave indica che il processo è un processo di distribuzione destinato a un ambiente in cui eseguire la distribuzione. L'oggetto environment viene creato automaticamente nel progetto quando viene eseguito il processo.

• Il pool parametro specifica il pool di agenti di distribuzione e usa il pool di agenti predefinito se non è specificato un oggetto name . L'agente viene eseguito nel sistema operativo definito nella vmImageName variabile , in questo caso ubuntu-latest.

La strategy parola chiave definisce la strategia di distribuzione.

  strategy:
    runOnce:
      deploy:
        steps:

• La runOnce parola chiave specifica che il processo di distribuzione viene eseguito una sola volta.
• La deploy parola chiave specifica l'oggetto steps da eseguire nel processo di distribuzione.

In steps questa fase eseguire le attività seguenti:

1. UsePythonVersion@0 seleziona la versione di Python da usare, come nella fase di compilazione.
2. AzureWebApp@1 distribuisce l'app Web e l'artefatto 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

• Il azureSubscription parametro contiene l'oggetto azureServiceConnectionId specificato nelle variabili della pipeline.
• appName Contiene il valore della webAppName variabile.
• package Specifica il nome e il percorso del file .zip da distribuire.

Inoltre, poiché il repository python-vscode-flask-tutorial contiene il comando di avvio dell'app in un file denominato startup.txt, è possibile specificare il comando di avvio dell'app aggiungendo il parametro : startUpCommand: 'startup.txt'.

Eseguire la pipeline

È ora possibile provare la pipeline.

1. Nell'editor della pipeline selezionare Salva ed esegui.

2. Nella schermata Salva ed esegui aggiungi un messaggio di commit, se necessario, quindi seleziona Salva ed esegui.

   È possibile controllare l'esecuzione della pipeline selezionando fasi o processi nella pagina Riepilogo pipeline. Ogni processo e fase visualizza un segno di spunta verde quando viene completato correttamente. Se si verificano errori, vengono visualizzati nel riepilogo o nei passaggi del processo.

   

   È possibile tornare rapidamente all'editor YAML selezionando i punti verticali in alto a destra nella pagina Riepilogo e selezionando Modifica pipeline.

   

3. Nel processo di distribuzione, selezionare l'attività Deploy Azure Web App per visualizzarne l'output.

   

4. Nell'output selezionare l'URL dopo l'URL dell'applicazione del servizio app. L'app dovrebbe essere visualizzata nel modo seguente:

   

Nota

Se la distribuzione di un'app non riesce a causa di una dipendenza mancante, il file direquirements.txt non è stato elaborato durante la distribuzione. Questo problema può verificarsi se si crea l'app Web direttamente nel portale anziché usare il az webapp up comando .

Il az webapp up comando imposta in modo specifico l'azione SCM_DO_BUILD_DURING_DEPLOYMENT di compilazione su true. Se si effettua il provisioning di un servizio app tramite il portale, questa azione non viene impostata automaticamente.

Per impostare questa azione:

1. Nella pagina del portale per l'app Web selezionare Configurazione dal menu di spostamento a sinistra.
2. Nella scheda Impostazioni applicazione selezionare Nuova impostazione applicazione.
3. Nella finestra popup visualizzata impostare Nome su SCM_DO_BUILD_DURING_DEPLOYMENT, impostare Valore su truee selezionare OK.
4. Selezionare Salva nella parte superiore della pagina Configurazione .
5. Esegui di nuovo la pipeline. Le dipendenze dovrebbero ora essere installate durante la distribuzione.

Attivare un'esecuzione della pipeline

Questa pipeline viene impostata per l'esecuzione ogni volta che una modifica esegue l'accesso al repository di codice. Per attivare un'esecuzione della pipeline, eseguire il commit di una modifica nel repository. Ad esempio, è possibile aggiungere una nuova funzionalità all'app o aggiornare le dipendenze dell'app.

1. Passare al repository GitHub per l'app.
2. Apportare una modifica al codice, ad esempio la modifica del titolo dell'app.
3. Eseguire il commit della modifica.
4. Passare alla pipeline e verificare che sia stata creata una nuova esecuzione ed è in esecuzione.
5. Al termine dell'esecuzione, verificare che la modifica distribuita nell'app Web.
6. Nel portale di Azure passare all'app Web e selezionare Centro distribuzione dal menu di spostamento a sinistra.
7. Selezionare la scheda Log e verificare che la nuova distribuzione sia elencata.

Distribuire app Django nel servizio app

È possibile usare Azure Pipelines per distribuire app Django nel servizio app in Linux se si usa un database separato. Non è possibile usare un database SQLite perché servizio app blocca il file db.sqlite3, impedendo sia letture che scritture. Questo comportamento non influisce sui database esterni.

Come illustrato nel processo di avvio del contenitore, il servizio app cerca automaticamente un file wsgi.py nel codice dell'app, che in genere contiene l'oggetto app. Se si vuole personalizzare il comando di avvio, usare il startUpCommand parametro nel AzureWebApp@1 passaggio del file di pipeline YAML.

Quando si usa Django, in genere si vuole eseguire la migrazione dei modelli di dati usando manage.py migrate dopo la distribuzione del codice dell'app. A questo scopo, è possibile aggiungere startUpCommand con uno script di post-distribuzione. Ad esempio, ecco la startUpCommand proprietà nell'attività 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'

Eseguire test sull'agente di compilazione

Come parte del processo di compilazione, è possibile eseguire test nel codice dell'app. I test vengono eseguiti nell'agente di compilazione, quindi è necessario installare le dipendenze in un ambiente virtuale nell'agente di compilazione. Dopo l'esecuzione dei test, eliminare l'ambiente virtuale di test prima di creare il file di.zip per la distribuzione.

Gli elementi di script seguenti illustrano questo processo. Posizionarli prima del compito ArchiveFiles@2 al file Azure-pipelines.yml. Per altre informazioni, vedere Eseguire script multipiattaforma.

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

È anche possibile usare un'attività come PublishTestResults@2 per pubblicare i risultati del test nella pipeline. Per altre informazioni, vedere Eseguire test.

Pulire le risorse

Se le risorse di Azure create in questa esercitazione sono state completate, eliminarle per evitare di incorrere in ulteriori addebiti.

• Eliminare il progetto Azure DevOps creato. L'eliminazione del progetto comporta anche l'eliminazione della pipeline e della connessione di servizio.
• Eliminare il gruppo di risorse di Azure che contiene il servizio app e il piano di servizio app. Nella portale di Azure passare al gruppo di risorse, selezionare Elimina gruppo di risorse e seguire le istruzioni.
• Eliminare l'account di archiviazione di Azure che gestisce il file system di Cloud Shell. Chiudere Cloud Shell, quindi trovare il gruppo di risorse che inizia con cloud-shell-storage-. Selezionare Elimina gruppo di risorse e seguire le istruzioni.

Contenuti correlati

• Personalizzare le app Python di Azure Pipelines
• Configurare l'app Python su servizio applicativo