Cvičení – povýšení do fáze vývoje

Dokončeno

Tým má plán a je připravený začít s implementací vydávacího procesu. Váš projekt Azure DevOps je nastavený a vaše instance Azure App Service jsou připravené přijímat artefakty sestavení.

V tuto chvíli mějte na paměti, že pipeline týmu má pouze dvě fáze. První fáze vytvoří výsledný produkt sestavení. Druhá fáze nasadí webovou aplikaci Space Game do služby App Service. Tady budete postupovat spolu s Andym a Marou, když upravují potrubí. Nasadí se do prostředí App Service, které odpovídá vývojové fázi .

Fáze Dev se podobá fázi nasazení, kterou jste vytvořili v modulu Vytvoření kanálu verze v Azure Pipelines. Tam jste použili trigger CI ke spuštění procesu sestavení. Děláte to tady stejně.

Stáhněte větev z GitHubu

Tady načtete větev release z GitHubu. Větev si také můžete zobrazit nebo se na ni přepnout.

Tato větev slouží jako vaše vydávací větev . Obsahuje projekt Space Game použitý v předchozích modulech. Obsahuje také konfiguraci Azure Pipelines, se kterou můžete začít.

Načtení a přepnutí do větve:

1. V editoru Visual Studio Code otevřete integrovaný terminál.

2. Pokud chcete načíst větev s názvem release z úložiště Microsoftu a přepnout na ni, spusťte následující příkazy git.

   git fetch upstream release
   git checkout -B release upstream/release
   

   Formát těchto příkazů umožňuje získat počáteční kód z úložiště Microsoft GitHub, označovaného jako upstream. Za chvíli tuto větev nahrajete do úložiště GitHub, označovaného jako origin.

3. Jako volitelný krok otevřete z editoru Visual Studio Code soubor azure-pipelines.yml. Seznamte se s počáteční konfigurací.

   Konfigurace se podobá základní konfiguraci, kterou jste vytvořili v Vytvoření kanálu vydání pomocí modulu Azure Pipelines. Sestaví pouze konfiguraci verze aplikace. Pro účely výuky tato konfigurace nespouští kontroly kvality ani zabezpečení, které jste nastavili v předchozích modulech.

   Poznámka

   Robustnější konfigurace může určovat větve, které se účastní procesu sestavení. Pokud chcete například ověřit kvalitu kódu, můžete jednotkové testy spouštět při každém odeslání změny na libovolnou větev. Aplikaci můžete také nasadit do prostředí, které provádí podrobnější testování. Toto nasazení však provedete pouze v případě, že máte pull request, pokud máte kandidáta na vydání, nebo když sloučíte kód do hlavní.

   Další informace najdete v části Implementace pracovního postupu kódu ve vaší sestavovací pipeline pomocí Gitu a GitHubu a Spouštěče sestavovací pipeline.

Propagace změn do vývojové fáze

Tady upravíte konfiguraci pipeline tak, aby postoupila sestavení do fáze Dev.

1. V editoru Visual Studio Code upravte azure-pipelines.yml.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   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'
   

   Tato konfigurace se podobá té, kterou jste vytvořili v předchozím modulu. Vytvořili jste s týmem důkaz konceptu pro průběžné nasazování. Všimněte si ale těchto rozdílů, které jsou zvýrazněné v předchozím příkladu kódu:

   • Tato konfigurace definuje proměnné na začátku souboru. Proměnné se používají v celém zpracovatelském potrubí. Definují, která konfigurace se má sestavit (Release). Také definují název vaší větve pro vydání (release).
   • Fáze Deploy z testování konceptu se teď jmenuje dev.
   • Fáze dev používá podmínku, která nasměruje systém ke spuštění fáze pouze v případech, kdy předchozí fáze proběhne úspěšně a aktuální větev je release. Toto nastavení zajistí, že se funkce vydané verze nasadí jenom do prostředí Dev.
   • Krok nasazení používá proměnnou WebAppNameDev k nasazení do instance App Service, která je spojena s vývojovým prostředím .

   Poznámka

   V praxi můžete nasadit z nějaké jiné větve, například main. Můžete zahrnout logiku, která umožňuje povýšení změn do fáze dev z více větví, jako jsou release a main.

2. Z integrovaného terminálu přidejte do indexu azure-pipelines.yml. Potvrďte změnu a nasdílíte ji do GitHubu.

   Rada

   Před spuštěním těchto příkazů Gitu uložte azure-pipelines.yml.

   git add azure-pipelines.yml
   git commit -m "Deploy to the Dev stage"
   git push origin release
   

3. V Azure Pipelines přejděte na build. Při jeho spuštění sledujte sestavení.

4. Až se sestavení dokončí, vraťte se na stránku souhrnu a vyberte tlačítko Zpět.

   

   Uvidíte, že nasazení bylo úspěšně dokončeno.

5. Ve webovém prohlížeči přejděte na adresu URL přidruženou k instanci služby App Service pro vaše prostředí Dev.

   Pokud máte pořád otevřenou kartu prohlížeče, aktualizujte stránku. Pokud si adresu URL nepamatujete, najděte ji na webu Azure Portal na podrobnostech služby App Service stránce.

   Uvidíte, že web Space Game je nasazený do služby App Service a běží.

   

6. Jako volitelný krok v Azure Pipelines vyberte prostředí. Pak vyberte vývojové prostředí.

   Azure Pipelines zaznamenává historii nasazení. V historii můžete sledovat změny prostředí zpět na potvrzení kódu a pracovní položky.