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

Servizi di Azure DevOps

Usare Azure Pipelines per l'integrazione continua e il recapito continuo (CI/CD) per compilare e distribuire un'app Web Python in app Azure Servizio in Linux. La pipeline compila e distribuisce automaticamente l'app Web Python in servizio app ogni volta che è presente un commit nel repository.

In questo articolo vengono illustrate le operazioni seguenti:

• Creare un'app Web nel servizio app di Azure.
• Creare un progetto in Azure DevOps.
• Connettere il progetto DevOps ad Azure.
• Creare una pipeline specifica di Python.
• Eseguire la pipeline per compilare e distribuire l'app nell'app Web in servizio app.

Prerequisiti

• Una sottoscrizione di Azure. Se non se ne ha una, creare un account gratuito.
• Un account GitHub. Se non è disponibile, crearne uno gratuitamente.
• Un'organizzazione di Azure DevOps Services. Crearne una gratuitamente.

Creare un repository per il codice dell'app

Creare una copia tramite fork del repository di esempio all'account https://github.com/Microsoft/python-sample-vscode-flask-tutorial GitHub.

Nell'host locale clonare il repository GitHub. Usare il comando seguente, sostituendo <repository-url> con l'URL del repository copiato tramite fork.

git clone <repository-url>

Testare l'app in locale

Compilare ed eseguire l'app in locale per assicurarsi che funzioni.

1. Passare alla cartella del repository clonata.

   cd python-sample-vscode-flask-tutorial
   

2. Compilare ed eseguire l'app

   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. Per visualizzare l'app, aprire una finestra del browser e passare a http://localhost:5000. Verificare di visualizzare il titolo Visual Studio Flask Tutorial.

4. Al termine, chiudere la finestra del browser e arrestare il server Flask con CTRL+C.

Apri un'istanza di Cloud Shell

1. Accedere al portale di Azure all'indirizzohttps://portal.azure.com.

2. Aprire l'interfaccia della riga di comando di Azure selezionando il pulsante Cloud Shell sulla barra degli strumenti del portale.

   

3. Cloud Shell viene visualizzato nella parte inferiore del browser. Selezionare Bash dal menu a discesa.

   

4. Per assegnare più spazio al lavoro, selezionare il pulsante ingrandisci.

Creare un'app Web del servizio app Azure

Creare l'app Web del servizio app Azure da Cloud Shell nel portale di Azure.

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.

1. Clonare il repository con il comando seguente, sostituendo <repository-url> con l'URL del repository copiato tramite fork.

   git clone <repository-url>
   

2. Passare alla cartella del repository clonata, in modo che il az webapp up comando riconosca l'app come app Python.

   cd python-sample-vscode-flask-tutorial
   

3. Usare il comando az webapp up per effettuare il provisioning del servizio app ed eseguire la prima distribuzione dell'app. Sostituire <your-web-app-name> con un nome univoco in Azure. In genere, si usa un nome personale o aziendale insieme a un identificatore dell'app, ad esempio <your-name>-flaskpipelines. L'URL dell'app diventa your-appservice.azurewebsites.net>.<

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

   L'output JSON del az webapp up comando mostra:

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

   Prendere nota dei URL valori e runtime_version . Usare nel runtime_version file YAML della pipeline. URL è l'URL dell'app Web. È possibile usarlo per verificare che l'app sia in esecuzione.

   Nota

   Il comando az webapp up esegue le azioni seguenti:

   • Crea un gruppo di risorse predefinito.

   • Creare un piano di servizio app predefinito.

   • Crea un'app con il nome specificato.

   • Zip distribuisce tutti i file dalla directory di lavoro corrente, con l'automazione della compilazione abilitata.

   • Memorizzare nella cache i parametri in locale nel file .azure/config in modo che non sia necessario specificarli di nuovo durante la distribuzione successiva con az webapp up o altri comandi az webapp della cartella del progetto. I valori memorizzati nella cache vengono usati automaticamente per impostazione predefinita.

   È possibile eseguire l'override dell'azione predefinita con i propri valori usando i parametri del comando. Per altre informazioni, vedere az webapp up.

4. 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à di configurazione dell'app startup-file Web su startup.txt.

   1. Nell'output del az webapp up comando copiare il resourcegroup valore.

   2. Immettere il comando seguente, usando il gruppo di risorse e il nome dell'app.

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

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

5. Per visualizzare l'app in esecuzione, aprire un browser e passare all'oggetto URL visualizzato nell'output del az webapp up comando. 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.

Creare un progetto Azure DevOps

Creare un nuovo progetto Azure DevOps.

1. In un browser passare a dev.azure.com e accedere.
2. Selezionare l'organizzazione.
3. Creare un nuovo progetto selezionando Nuovo progetto o Crea progetto se si crea il primo progetto nell'organizzazione.
4. Immettere il nome del progetto.
5. Selezionare visibilità per il progetto.
6. Seleziona Crea.

Creare una connessione al servizio

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

1. Nella pagina del progetto selezionare Impostazioni progetto.

   

2. Selezionare Connessioni al servizio nella sezione Pipeline del menu.

3. Seleziona Crea connessione al servizio.

4. Selezionare Azure Resource Manager e selezionare Avanti.

   

5. Selezionare il metodo di autenticazione e selezionare Avanti.

6. Nella finestra di dialogo Nuova connessione al servizio di Azure immettere le informazioni specifiche del metodo di autenticazione selezionato. Per altre informazioni sui metodi di autenticazione, vedere Connettersi ad Azure usando una connessione al servizio Azure Resource Manager.

   Ad esempio, se si usa un metodo di autenticazione dell'identità del carico di lavoro (automatico) o dell'entità servizio (automatico), immettere le informazioni necessarie.

   

   Campo	Descrizione
   Livello di ambito	Selezionare Sottoscrizione.
   Abbonamento	Il nome della sottoscrizione di Azure.
   Gruppo di risorse	Nome del gruppo di risorse contenente l'app Web.
   Nome della connessione al servizio	Nome descrittivo per la connessione.
   Concedere le autorizzazioni di accesso a tutte le pipeline	Selezionare questa opzione per concedere l'accesso a tutte le pipeline.

7. Seleziona Salva.

La nuova connessione viene visualizzata nell'elenco Connessioni al servizio ed è pronta per l'uso in Azure Pipeline.

Creare una pipeline

Creare una pipeline per compilare e distribuire l'app Web Python nel servizio app Azure. Per comprendere i concetti della pipeline, guardare:

1. Nel menu di spostamento a sinistra selezionare Pipeline.

   

2. Seleziona Crea pipeline.

   

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

   

4. Nella schermata Selezionare un repository selezionare il repository di esempio con fork.

   

5. Potrebbe essere richiesto di immettere nuovamente la password di GitHub come conferma.

6. Se l'estensione Azure Pipelines non è installata in GitHub, GitHub richiede di installare l'estensione Azure Pipelines .

   

   In questa pagina scorrere verso il basso fino alla sezione Accesso al repository, scegliere se installare l'estensione in tutti i repository o solo quelli selezionati, quindi selezionare Approva e installa.

   

7. Nella finestra di dialogo Configura la pipeline selezionare Python per Linux Web App in Azure.

8. Selezionare la sottoscrizione di Azure e selezionare Continua.

9. Se si usa il nome utente e la password per l'autenticazione, viene aperto un browser per accedere all'account Microsoft.

10. Selezionare il nome dell'app Web dall'elenco a discesa e selezionare Convalida e configura.

Azure Pipelines crea un file azure-pipelines.yml e lo visualizza nell'editor di pipeline YAML. Il file della pipeline 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. Esaminare la pipeline per verificarne il funzionamento. Assicurarsi che tutti gli input predefiniti siano appropriati per il codice.

File di pipeline YAML

La spiegazione seguente descrive il file della pipeline YAML. Per informazioni sullo schema di file YAML della pipeline, vedere Informazioni di riferimento sullo schema YAML.

Il file YAML della pipeline di esempio completo è illustrato di seguito:

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

Variabili

La variables sezione contiene le variabili seguenti:

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'

Variabile	Descrizione
azureServiceConnectionId	ID o nome della connessione al servizio Azure Resource Manager.
webAppName	Nome dell'app Web del servizio app Azure.
vmImageName	Nome del sistema operativo da usare per l'agente di compilazione.
environmentName	Nome dell'ambiente usato nella fase di distribuzione. L'ambiente viene creato automaticamente quando viene eseguito il processo di fase.
projectRoot	Cartella radice contenente il codice dell'app.
pythonVersion	Versione di Python da usare negli agenti di compilazione e distribuzione.

Fase di compilazione

La fase di compilazione contiene un singolo processo eseguito nel sistema operativo definito nella variabile vmImageName.

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

Il processo contiene più passaggi:

1. L'attività UsePythonVersion seleziona la versione di Python da usare. La versione è definita nella pythonVersion variabile .

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

2. Questo passaggio usa uno script per creare un ambiente Python virtuale e installare le dipendenze dell'app contenute nel requirements.txt parametro The workingDirectory specifica il percorso del codice dell'app.

     - 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. L'attività ArchiveFiles crea l'archivio .zip contenente l'app Web. Il .zip file viene caricato nella pipeline come artefatto denominato drop. Il .zip file viene usato nella fase di distribuzione per distribuire l'app nell'app Web.

      - 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
   

   Parametro	Descrizione
   rootFolderOrFile	Posizione del codice dell'app.
   includeRootFolder	Indica se includere la cartella radice nel file .zip . Impostare questo parametro su false in caso contrario, il contenuto del file .zip viene inserito in una cartella denominata s e servizio app nel contenitore Linux non riesce a trovare il codice dell'app.
   archiveType	Tipo di archivio da creare. Impostare su zip.
   archiveFile	Percorso del file .zip da creare.
   replaceExistingArchive	Indica se sostituire un archivio esistente se il file esiste già. Impostare su true.
   upload	Percorso del file .zip da caricare.
   artifact	Nome dell'artefatto da creare.

Fase di distribuzione

La fase di distribuzione viene eseguita se la fase di compilazione viene completata correttamente. Le parole chiave seguenti definiscono questo comportamento:

  dependsOn: Build
  condition: succeeded()

La fase di distribuzione contiene un singolo processo di distribuzione configurato con le parole chiave seguenti:

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

Parola chiave	Descrizione
deployment	Indica che il processo è un processo di distribuzione destinato a un ambiente.
pool	Specifica il pool di agenti di distribuzione. Pool di agenti predefinito se il nome non è specificato. La vmImage parola chiave identifica il sistema operativo per l'immagine della macchina virtuale dell'agente
environment	Specifica l'ambiente in cui eseguire la distribuzione. L'ambiente viene creato automaticamente nel progetto quando viene eseguito il processo.

La strategy parola chiave viene usata per definire la strategia di distribuzione. La runOnce parola chiave specifica che il processo di distribuzione viene eseguito una sola volta. La deploy parola chiave specifica i passaggi da eseguire nel processo di distribuzione.

  strategy:
    runOnce:
      deploy:
        steps:

L'oggetto steps nella pipeline è:

1. Usare l'attività UsePythonVersion per specificare la versione di Python da usare nell'agente. La versione è definita nella pythonVersion variabile .

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

2. Distribuire l'app Web usando il AzureWebApp@1. Questa attività distribuisce l'artefatto drop della pipeline nell'app Web.

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

   Parametro	Descrizione
   azureSubscription	ID o nome di connessione del servizio Azure Resource Manager da usare.
   appName	il nome dell'app Web.
   package	Percorso del file .zip da distribuire.

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

Eseguire la pipeline

È ora possibile provarlo.

1. Nell'editor selezionare Salva ed esegui.

2. Nella finestra di dialogo Salva ed esegui aggiungi un messaggio di commit e quindi seleziona Salva ed esegui.

   È possibile controllare la pipeline durante l'esecuzione selezionando fasi o processi nel riepilogo dell'esecuzione della pipeline.

   

   Accanto a ogni fase e processo sono presenti segni di spunta verdi al termine dell'operazione. 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 (Distribuisci app Web di Azure) per visualizzarne l'output. Per visitare il sito distribuito, tenere premuto CTRL e selezionare l'URL dopo App Service Application URL.

   Se si usa l'app di esempio, l'app dovrebbe essere visualizzata come segue:

   

Importante

Se l'app non riesce a causa di una dipendenza mancante, il file requirements.txt non è stato elaborato durante la distribuzione. Questo comportamento si verifica se l'app Web è stata creata direttamente nel portale anziché usare il az webapp up comando come illustrato in questo articolo.

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

I passaggi seguenti impostano l'azione:

1. Aprire il portale di Azure, selezionare il servizio app e quindi selezionare Configurazione.
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. Eseguire di nuovo la pipeline. Le dipendenze devono essere installate durante la distribuzione.

Attivare un'esecuzione della pipeline

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.
2. Apportare una modifica al codice, ad esempio la modifica del titolo dell'app.
3. Eseguire il commit della modifica nel repository.
4. Passare alla pipeline e verificare che sia stata creata una nuova esecuzione.
5. Al termine dell'esecuzione, verificare che la nuova compilazione sia distribuita nell'app Web.
   1. Nel portale di Azure passare all'app Web.
   2. Selezionare Centro distribuzione e selezionare la scheda Log .
   3. Verificare che la nuova distribuzione sia elencata.

Considerazioni per Django

È possibile usare Azure Pipelines per distribuire app Django per app Azure Servizio 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 su un database esterno.

Come descritto in Configurare l'app Python in servizio app - Processo di avvio del contenitore, servizio app cerca automaticamente un file wsgi.py all'interno del codice dell'app, che in genere contiene l'oggetto app. Se si vuole personalizzare il comando di avvio in qualsiasi modo, usare il startUpCommand parametro nel AzureWebApp@1 passaggio del file di pipeline YAML, come descritto nella sezione precedente.

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 prima di creare il file di .zip per la distribuzione. Gli elementi di script seguenti illustrano questo processo. Posizionarli prima dell'attività ArchiveFiles@2 nel file di 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 Creare app Python - Eseguire test.

Pulire le risorse

Per evitare addebiti per le risorse di Azure create in questa esercitazione:

• Eliminare il progetto creato. L'eliminazione del progetto elimina la pipeline e la connessione al 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 che gestisce il file system per Cloud Shell. Chiudere Cloud Shell e quindi passare al gruppo di risorse che inizia con cloud-shell-storage-, selezionare Elimina gruppo di risorse e seguire le istruzioni.

Passaggi successivi

• Personalizzare le app Python in Azure Pipelines
• Configurare l'app Python in servizio app