Eseguire la distribuzione nel Servizio app tramite Azure Pipelines

1. Accedere all'organizzazione di Azure DevOps e passare al progetto.

2. Passare a Pipeline e quindi selezionare Nuova pipeline.

3. Quando richiesto, selezionare il percorso del codice sorgente: Git Azure Repos o GitHub.

   Si potrebbe essere reindirizzati a GitHub per l'accesso. In questo caso, immettere le credenziali di GitHub.

4. Quando viene visualizzato l’elenco dei repository, selezionare il repository.

5. È possibile che si venga reindirizzati a GitHub per installare l'app Azure Pipelines. In tal caso, selezionare Approva e installa.

6. Quando viene visualizzata la scheda Configura, selezionare ASP.NET Core.

7. Quando viene visualizzata la nuova pipeline, osservare YAML per vedere cosa fa. Quando si è pronti, selezionare Salva ed esegui.

Attività iniziali:

1. Creare una pipeline e selezionare il modello ASP.NET Core. Questa selezione aggiunge automaticamente le attività necessarie per compilare il codice nel repository di esempio.

2. Salvare la pipeline e accodare una compilazione per vederla in azione.

   Il modello di pipeline ASP.NET Core pubblica il file ZIP di distribuzione come artefatto di Azure per l’attività di distribuzione in un secondo momento.

1. Fare clic alla fine del file YAML, quindi selezionare Mostra assistente.’

2. Usare Assistente attività per aggiungere l’attività app Web di Azure.

   

   In alternativa, è possibile aggiungere l’attività di distribuzione del Servizio app di Azure (AzureRmWebAppDeployment).

3. Scegliere la sottoscrizione di Azure. Assicurarsi di Autorizzare la connessione. L’autorizzazione crea la connessione al servizio richiesta.

4. Selezionare il tipo di app, il nome dell’app e lo stack di runtime in base all’app del servizio app. Il codice YAML completo dovrebbe essere simile al seguente.

   variables:
     buildConfiguration: 'Release'
   
   steps:
   - task: DotNetCoreCLI@2
     inputs:
       command: 'publish'
       publishWebProjects: true
   - task: AzureWebApp@1
     inputs:
       azureSubscription: '<service-connection-name>'
       appType: 'webAppLinux'
       appName: '<app-name>'
       package: '$(System.DefaultWorkingDirectory)/**/*.zip'
   

   • azureSubscription: nome della connessione al servizio autorizzata alla sottoscrizione di Azure.
   • appName: nome dell’app esistente.
   • package: percorso del file al pacchetto o a una cartella contenente il contenuto del servizio app. Sono supportati caratteri jolly.

Attività iniziali:

1. Creare una pipeline di versione selezionando Versioni dal menu a sinistra e selezionare Nuova pipeline.

2. Selezionare il modello di distribuzione del Servizio app di Azure per la fase. In questo modo vengono aggiunte automaticamente le attività necessarie.

   Nota

   Se si distribuisce un’app Node.js nel servizio app in Windows, selezionare il modello di distribuzione dell’app Node.js nel Servizio app di Azure. L’unica differenza tra questi modelli è che il modello Node.js configura l’attività per generare un file web.config contenente un parametro che avvia il servizio iisnode.

3. Per collegare questa pipeline di versione all’artefatto di Azure del passaggio precedente, selezionare Aggiungi un artefatto>Compila.

4. In Origine (pipeline di compilazione), selezionare la pipeline di compilazione creata nella sezione precedente e quindi selezionare Aggiungi.

5. Salvare la pipeline di versione e creare una versione per vederla in azione.

Per distribuire un pacchetto Web .zip, ad esempio, da un’app Web ASP.NET a un’app Web di Azure, usare il frammento di codice seguente per distribuire la compilazione in un’app.

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: 'webAppLinux'
    appName: '<app-name>'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'

• azureSubscription: la sottoscrizione di Azure.
• appType: il tipo di app Web.
• appName: il nome del servizio app esistente.
• package: il percorso di file del pacchetto o di una cartella che contiene i contenuti del servizio app. Sono supportati caratteri jolly.

Per le pipeline classiche, è più semplice definire le fasi di compilazione e rilascio in pagine separate, rispettivamente Pipeline e Versioni. In generale:

• Nella pagina Pipeline, si compila e testa l’app usando il modello preferito, ad esempio ASP.NET Core, Node.js con Grunt, Maven o altri e si pubblica un artefatto.
• Nella pagina Versione, usare il modello generico di distribuzione del Servizio app di Azure per distribuire l’artefatto.

Potrebbero essere disponibili modelli per linguaggi di programmazione specifici tra cui scegliere.

Per impostazione predefinita, la distribuzione si verifica nell’applicazione radice nell’app Web di Azure. È possibile eseguire la distribuzione in un’applicazione virtuale specifica usando la proprietà VirtualApplication dell’attività di distribuzione del Servizio app di Azure (AzureRmWebAppDeployment):

- task: AzureRmWebAppDeployment@4
  inputs:
    VirtualApplication: '<name of virtual application>'

• VirtualApplication: nome dell’applicazione virtuale configurata nel portale di Azure. Per altre informazioni, vedere Configurare un’app del servizio app nel portale di Azure.

Per impostazione predefinita, la distribuzione si verifica nell’applicazione radice nell’app Web di Azure. Se si vuole eseguire la distribuzione in un’applicazione virtuale specifica, immettere il nome nella proprietà applicazione virtuale dell’attività di distribuzione del Servizio app di Azure.

Nell’esempio seguente viene illustrato come eseguire la distribuzione in uno slot di staging e quindi passare a uno slot di produzione:

- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    appName: '<app-name>'
    deployToSlotOrASE: true
    resourceGroupName: '<name of resource group>'
    slotName: staging
    package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    WebAppName: '<app-name>'
    ResourceGroupName: '<name of resource group>'
    SourceSlot: staging
    SwapWithProduction: true

• azureSubscription: la sottoscrizione di Azure.
• appType: (facoltativo) usare webAppLinux per eseguire la distribuzione in un’app Web in Linux.
• appName: il nome del servizio app esistente.
• deployToSlotOrASE: booleano. Eseguire la distribuzione in uno slot di distribuzione esistente o in un ambiente del servizio app di Azure.
• resourceGroupName: nome del gruppo di risorse. Obbligatorio se deployToSlotOrASE è true.
• slotName: nome dello slot che per impostazione predefinita è production. Obbligatorio se deployToSlotOrASE è true.
• package: il percorso di file del pacchetto o di una cartella che contiene i contenuti del servizio app. Sono supportati caratteri jolly.
• SourceSlot: slot inviato all’ambiente di produzione quando SwapWithProduction è true.
• SwapWithProduction: booleano. Scambiare il traffico dello slot di origine con quello di produzione.

Usare l’opzione Distribuire nello slot o nell’ambiente del servizio app nell’attività app Web di Azure per specificare lo slot in cui eseguire la distribuzione. Per scambiare gli slot, usare l’attività Gestione del Servizio app di Azure.

È possibile usare processi nel file YAML per configurare una pipeline di distribuzioni. Usando i processi, è possibile controllare l’ordine di distribuzione in più app Web.

jobs:
- job: buildandtest
  pool:
    vmImage: ubuntu-latest
 
  steps:
  # publish an artifact called drop
  - task: PublishPipelineArtifact@1
    inputs:
      targetPath: '$(Build.ArtifactStagingDirectory)' 
      artifactName: drop
  
  # deploy to Azure Web App staging
  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<staging-app-name>'
      deployToSlotOrASE: true
      resourceGroupName: <group-name>
      slotName: 'staging'
      package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- job: deploy
  dependsOn: buildandtest
  condition: succeeded()

  pool: 
    vmImage: ubuntu-latest  
  
  steps:
    # download the artifact drop from the previous job
  - task: DownloadPipelineArtifact@2
    inputs:
      source: 'current'
      artifact: 'drop'
      path: '$(Pipeline.Workspace)'

  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<production-app-name>'
      resourceGroupName: <group-name>
      package: '$(Pipeline.Workspace)/**/*.zip'

Se si vuole eseguire la distribuzione in più app Web, aggiungere fasi alla pipeline di versione. È possibile controllare l’ordine di distribuzione. Per altre informazioni, vedere Fasi.

Il frammento di codice seguente illustra un esempio di sostituzione delle variabili usando l’attività di distribuzione del Servizio app di Azure (AzureRmWebAppDeployment):

jobs:
- job: test
  variables:
    connectionString: <test-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Test stage Azure service connection>'
      WebAppName: '<name of test stage web app>'
      enableXmlVariableSubstitution: true

- job: prod
  dependsOn: test
  variables:
    connectionString: <prod-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Prod stage Azure service connection>'
      WebAppName: '<name of prod stage web app>'
      enableXmlVariableSubstitution: true

Per modificare connectionString usando la sostituzione delle variabili:

1. Creare una pipeline di versione con due fasi.
2. Collegare l’artefatto della versione alla compilazione che produce il pacchetto Web.
3. Definire connectionString come variabile in ognuna delle fasi. Impostare il valore appropriato.
4. Selezionare l’opzione di sostituzione delle variabili XML in Trasformazioni di file e opzioni di sostituzione delle variabili per l’attività di distribuzione del Servizio app di Azure.

A tale scopo, è possibile usare una delle tecniche seguenti in YAML:

• Isolare i passaggi di distribuzione in un processo separato e aggiungere una condizione a tale processo.
• Aggiungere una condizione al passaggio.

L’esempio seguente illustra come usare le condizioni dei passaggi per distribuire solo le compilazioni che hanno origine dal ramo principale:

- task: AzureWebApp@1
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  inputs:
    azureSubscription: '<service-connection-name>'
    appName: '<app-name>'

Per altre informazioni sulle condizioni, vedere Specificare condizioni.

Nella pipeline di versione è possibile implementare vari controlli e condizioni per controllare la distribuzione:

• Impostare filtri di ramo per configurare il trigger di distribuzione continua sull’artefatto della pipeline di versione.
• Impostare approvazioni di pre-distribuzione come precondizione per la distribuzione in una fase.
• Configurare gate come precondizione per la distribuzione in una fase.
• Specificare le condizioni per l’esecuzione di un’attività.

Per altre informazioni, vedere Trigger di release, ramo e fase, Controllo della distribuzione dei release usando le approvazioni, Controllo della distribuzione dei release usando gate e Specificare le condizioni per l’esecuzione di un’attività.

trigger:
- main

pool:
  vmImage: windows-latest

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration)'
    zipAfterPublish: true
- task: AzureRmWebAppDeployment@4
  inputs:
    ConnectionType: 'AzureRM'
    azureSubscription: '<service-connection-name>'
    appType: 'webApp'
    WebAppName: '<app-name>'
    packageForLinux: '$(System.DefaultWorkingDirectory)/**/*.zip'
    enableCustomDeployment: true
    DeploymentType: 'webDeploy'

Nella pipeline di versione, presupponendo che si stia usando il modello di distribuzione del Servizio app di Azure:

1. Selezionare la scheda Attività e quindi selezionare Distribuire Servizio app di Azure. Questa è l’attività AzureRmWebAppDeployment.

2. Nella finestra di dialogo, verificare che Tipo di connessione sia impostato su Azure Resource Manager.

3. Nella finestra di dialogo, espandere Opzioni di distribuzione aggiuntive e selezionare Selezionare metodo di distribuzione. Assicurarsi che Distribuzione Web sia selezionato come metodo di distribuzione.

4. Salvare la pipeline di versione.