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

Configurare un agente ospitato autonomamente

Il download delle versioni di Python non è supportato in agenti di compilazione self-hosted. Per usare il tuo agente ospitato autonomamente, devi configurarlo affinché esegua Python.

Per evitare problemi di compatibilità, fai in modo che la versione di Python corrisponda alla versione di runtime nell'app Web di app Azure Services, 3.11 in questo caso. È necessario preinstallare la versione di Python. Usare il programma di installazione completo per ottenere una versione compatibile con pip di Python.

La versione di Python desiderata deve essere aggiunta alla cache degli strumenti nell'agente self-hosted in modo che l'attività della pipeline possa usarla. In genere, la cache degli strumenti si trova nella directory _work/_tool dell'agente. In alternativa, è possibile eseguire l'override del percorso con la variabile AGENT_TOOLSDIRECTORYdi ambiente . Nella directory degli strumenti creare la struttura di directory seguente in base alla versione di Python:

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

Il numero di versione deve seguire il formato 1.2.3. La piattaforma deve essere x86 o x64. I file degli strumenti devono essere i file di versione di Python decompressi. Deve {platform}.complete essere un file a 0 byte simile x86.complete o x64.complete e indica semplicemente che lo strumento è installato correttamente nella cache.

Ad esempio, per usare Python 3.11 in un computer Windows a 64 bit, creare la struttura di directory seguente:

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

Se il computer che ospita l'agente ha già la versione python che si vuole usare, è possibile copiare i file nella cache degli strumenti. Se non si ha la versione di Python, è possibile scaricarla dal sito Web Python.

Creare un principale di servizio

Un'entità servizio è un'identità creata per le applicazioni, i servizi ospitati e gli strumenti automatizzati per accedere alle risorse di Azure. Questo accesso è limitato ai ruoli assegnati all'entità servizio e ti consente di controllare a quali risorse è possibile accedere e a quale livello.

Per creare un'entità servizio, eseguire il comando seguente in Bash Cloud Shell. Sostituire <service-principal-name> con un nome dell'entità servizio, <your-subscription-id> con l'ID della sottoscrizione di Azure e <your-resource-group> con il gruppo di risorse per l'app Web.

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

Il comando restituisce l'oggetto JSON seguente:

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

Prendi nota dei valori appId, password e tenantId da utilizzare per creare una connessione al servizio nella sezione successiva.

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

2. Da Project Settings, selezionare Pipelines>Service connections.

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. In Credenziale, seleziona 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.

   

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

2. In Impostazioni progetto, selezionare Pipelines>Connessioni di 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. Selezionare Entità servizio (manuale) e quindi selezionare Avanti.

   

6. Nella schermata Nuova connessione al servizio di Azure completare i campi seguenti:

   • Ambiente: selezionare Cloud di Azure.
   • Livello di ambito: selezionare Sottoscrizione.
   • ID sottoscrizione: immettere l'ID sottoscrizione di Azure.
   • Nome sottoscrizione: immettere il nome della sottoscrizione di Azure.

7. Nella sezione Autenticazione completare i campi seguenti:

   • ID dell'entità servizio: Immettere il valore appId restituito dal comando az ad sp create-for-rbac.
   • Credenziale: seleziona Chiave dell'entità servizio.
   • Chiave dell'entità servizio: Immettere il valore restituito dal comando az ad sp create-for-rbac.
   • ID tenant: immettere il tenant valore restituito dal az ad sp create-for-rbac comando.
   • Selezionare Verifica per verificare la connessione.

8. Nella sezione Dettagli , in Nome connessione del servizio immettere un nome per la connessione al servizio.

9. Selezionare la casella di controllo Concedi autorizzazioni di accesso a tutte le pipeline.

10. Selezionare Verifica e salva.

    

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 App Web Linux in Azure per Python.

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.

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 pagina Dove si trova il codice, seleziona GitHub Enterprise Server. Potrebbe essere richiesto di accedere a GitHub.

   

4. Nella scheda Selezionare un repository, seleziona il repository di esempio di cui hai creato un fork. GitHub potrebbe richiedere di immettere nuovamente la password di GitHub o installare l'estensione GitHub di Azure Pipelines o l'app. Seguire le istruzioni visualizzate per installare l'app. Per altre informazioni, vedere Accedere ai repository GitHub.

   

5. Nella pagina Configura la pipeline selezionare Pipeline di avvio.

6. Nella pagina Verifica YAML della pipeline sostituire il contenuto del file di azure-pipelines.yml iniziale con il file di pipeline YAML seguente. Nel file YAML:

   • Sostituisci i segnaposto <your-service-connection-name> e <your-web-app-name> con i tuoi valori.

   • Sostituire <your-pool-name> con il nome del pool di agenti che si vuole usare e sostituire <your-python-version> con la versione di Python in esecuzione nell'agente. Questa versione deve corrispondere a runtime_version nell'output JSON del comando az webapp up.

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

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'

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)

La fase di build contiene un singolo job eseguito su un agente nel pool identificato dal parametro name.

È possibile specificare le funzionalità dell'agente con la demands parola chiave . Ad esempio, demands: python specifica che l'agente deve avere Installato Python. Per specificare un agente ospitato autonomamente per nome, è possibile usare demands: Agent.Name -equals <agent-name>.

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

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

  - deployment: DeploymentJob
    pool:
      name: <your-pool-name>
    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 deve contenere un agente con la possibilità di eseguire la versione di Python specificata nella pipeline.