Esercizio - Alza di livello la gestione temporanea

• 8 minuti

La pipeline di versione ha ora tre fasi: Compilazione, Sviluppo e Test. L'utente e il team di Tailspin hanno un'altra fase da implementare: Staging.

In questa parte:

Creare l'ambiente di gestione temporanea

In questo caso si crea un ambiente in Azure Pipelines per la gestione temporanea. Ai fini dell'apprendimento, l'utente viene assegnato come responsabile approvazione. In pratica, è necessario assegnare gli utenti che devono approvare le modifiche prima che tali modifiche passino alla fase successiva. Per il team di Tailspin, Amita approva le modifiche in modo che possano essere promosse da Test a Staging.

In precedenza in questo modulo sono state specificate environment le impostazioni per le fasi di sviluppo e test . Ecco un esempio per la fase di sviluppo .

- stage: 'Deploy'
  displayName: 'Deploy the web application'
  dependsOn: Build
  jobs:
  - deployment: Deploy
    pool:
      vmImage: 'ubuntu-20.04'
    environment: dev
    variables:
    - group: Release

È possibile definire un ambiente tramite Azure Pipelines che includa criteri specifici per la versione. Questi criteri possono includere le pipeline autorizzate per la distribuzione nell'ambiente. È anche possibile specificare le approvazioni umane necessarie per promuovere il rilascio da una fase alla successiva. Qui si specificano le approvazioni.

Per creare l'ambiente di gestione temporanea:

1. Selezionare Ambienti in Azure Pipelines.

   

2. Selezionare Nuovo ambiente.

3. In Nome immettere staging.

4. Lasciare i valori predefiniti negli altri campi.

5. Seleziona Crea.

6. Nella pagina ambiente di gestione temporanea aprire l'elenco a discesa e quindi selezionare Approvazioni e controlli.

   

7. Selezionare Approvazioni.

8. In Responsabili approvazione selezionare Aggiungi utenti e gruppi e quindi selezionare l'account.

9. In Istruzioni per i responsabili approvazione immettere Approva questa modifica quando è pronta per la gestione temporanea.

10. Seleziona Crea.

Alzare di livello le modifiche alla gestione temporanea

In questo caso si modifica la configurazione della pipeline per distribuire la compilazione nella fase di gestione temporanea .

1. In Visual Studio Code modificare azure-pipelines.yml come indicato di seguito:

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   schedules:
   - cron: '0 3 * * *'
     displayName: 'Deploy every day at 3 A.M.'
     branches:
       include:
       - release
     always: false 
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   
   - stage: 'Dev'
     displayName: 'Deploy to the dev environment'
     dependsOn: Build
     condition: |
       and
       (
         succeeded(),
         eq(variables['Build.SourceBranchName'], variables['releaseBranchName'])
       )
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: dev
       variables:
       - group: Release
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Test'
     displayName: 'Deploy to the test environment'
     dependsOn: Dev
     #condition: eq(variables['Build.Reason'], 'Schedule')
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: test
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameTest)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Staging'
     displayName: 'Deploy to the staging environment'
     dependsOn: Test
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: staging
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameStaging)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   

   Questo codice aggiunge la fase di gestione temporanea . La fase viene distribuita nell'ambiente di staging , che include un'approvazione della versione.

   Suggerimento

   Probabilmente si è notato che tutte e tre le fasi della distribuzione seguono passaggi simili. È possibile usare i modelli per definire attività di compilazione comuni una volta e riutilizzarle più volte. Questa tecnica è già stata usata nel modulo Creare una pipeline di compilazione con Azure Pipelines . Ai fini dell'apprendimento, ripeteremo i passaggi in ogni fase.

2. Dal terminale integrato aggiungere azure-pipelines.yml all'indice. Eseguire quindi il commit della modifica ed eseguirne il push in GitHub.

   Suggerimento

   Prima di eseguire questi comandi Git, salvare azure-pipelines.yml.

   git add azure-pipelines.yml
   git commit -m "Deploy to Staging"
   git push origin release
   

3. In Azure Pipelines passare alla compilazione. Tracciare quindi la compilazione durante l'esecuzione.

   Quando la compilazione raggiunge la gestione temporanea, si noterà che la pipeline attende il superamento di tutti i controlli. In questo caso, è presente un controllo, ovvero l'approvazione manuale della versione.

   

   È possibile configurare Azure DevOps per inviare una notifica tramite posta elettronica quando la compilazione richiede l'approvazione. Ecco un esempio:

   

4. Selezionare Rivedi>approva.

   In pratica, per verificare che soddisfino i requisiti, è necessario esaminare le modifiche.

5. Al termine della compilazione, aprire un Web browser. Passare all'URL associato all'istanza di servizio app per l'ambiente di gestione temporanea.

   Se la scheda del browser è ancora aperta, aggiornare la pagina. Se non si ricorda l'URL, trovarlo nella portale di Azure, nella pagina dei dettagli servizio app.

   Si noterà che il sito Web Space Game viene distribuito in servizio app ed è in esecuzione.

   

6. Come passaggio facoltativo, in Azure Pipelines selezionare Ambienti. Selezionare quindi l'ambiente di gestione temporanea .

   Azure Pipelines registra la cronologia di distribuzione, che consente di tracciare le modifiche nell'ambiente ai commit del codice e agli elementi di lavoro.

   

Il team di Tailspin si riunisce per discutere del loro progresso. Amita approva le modifiche nella fase test mentre le altre osservano.

Tim: Per dirvi la verità, all'inizio ero un po' nervoso sulle pipeline di rilascio automatizzate. Ma mi piace davvero questo ora che vedo che funziona. Ogni fase può avere un proprio ambiente, test associati e responsabili approvazione. La pipeline automatizza molte operazioni da eseguire manualmente. Ma abbiamo ancora il controllo dove ne abbiamo bisogno.

Amita: Potrei immaginarci di fare qualcosa di simile per promuovere le modifiche dalla gestione temporanea alla produzione. Parlando di... quando si aggiunge un ambiente di produzione ?

Andy: A breve. Penso che dobbiamo ancora riempire alcuni pezzi qui prima di aggiungerlo.