Övning – Främja till Stagingmiljö

8 minuter

Versionspipelinen har nu tre steg: Build, Devoch Test. Du och Tailspin-teamet har ytterligare ett steg att implementera: Mellanlagring.

I den här delen ska du:

Skapa mellanlagring miljö i Azure Pipelines och tilldela dig själv som godkännare.
Definiera uppställningsfasen , som endast körs efter att en godkännare verifierar resultaten av testfasen .

Skapa testmiljön

Här skapar du en miljö i Azure Pipelines för mellanlagring. För utbildningsändamål tilldelar du dig själv som godkännare. I praktiken tilldelar du de användare som måste godkänna ändringar innan ändringarna flyttas till nästa steg. För Tailspin-teamet godkänner Amita ändringar så att de kan höjas upp från Test till Staging.

Tidigare i den här modulen angav du environment inställningar för både Dev och Test faser. Här är ett exempel för fasen Dev.

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

Du kan definiera en miljö via Azure Pipelines som innehåller specifika kriterier för din version. De här kriterierna kan omfatta de pipelines som har behörighet att distribuera till miljön. Du kan också ange de mänskliga godkännanden som behövs för att höja upp versionen från en fas till en annan. Här anger du dessa godkännanden.

Så här skapar du mellanlagring miljö:

Från Azure Pipelines väljer du Miljöer.
Välj Ny miljö.
Under Namnanger du mellanlagring.
Lämna de återstående fälten som standardvärden.
Välj Skapa.
På sidan staging miljön öppnar du listrutan och väljer sedan Godkännanden och kontroller.
Välj Godkännanden.
Under Godkännareväljer du Lägg till användare och grupperoch väljer sedan ditt konto.
Under Instruktioner för godkännareanger du Godkänn den här ändringen när den är redo för mellanlagring.
Välj Skapa.

Flytta upp ändringar till förberedelsemiljö

Här ändrar du pipelinekonfigurationen för att distribuera bygget till mellanlagring fas.

Ändra azure-pipelines.yml enligt följande i Visual Studio Code:

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'

Den här koden lägger till Staging-fasen. Fasen distribueras till stagingmiljö, som innehåller ett versionsgodkännande.

Tips

Du har förmodligen märkt att alla tre distributionsstegen följer liknande steg. Du kan använda mallar för att definiera vanliga bygguppgifter en gång och återanvända dem flera gånger. Du har redan använt den här tekniken i modulen Skapa en byggpipeline med Azure Pipelines. I utbildningssyfte upprepar vi stegen i varje steg.

Från den integrerade terminalen lägger du till azure-pipelines.yml i indexet. Genomför sedan ändringen och push-överför den till GitHub.

Tips

Innan du kör dessa Git-kommandon sparar du azure-pipelines.yml.
```
git add azure-pipelines.yml
git commit -m "Deploy to Staging"
git push origin release
```
På Azure Pipelines går du till byggningen. Spåra bygget när det körs.

När bygget når Stagingser du att pipelinen väntar på att alla kontroller ska genomföras. I det här fallet finns det en kontroll – det manuella godkännandet av versionen.

Du kan konfigurera Azure DevOps så att du får ett e-postmeddelande när bygget kräver godkännande. Här är ett exempel:
Välj Granska>Godkänn.

I praktiken kontrollerar du att de uppfyller dina krav genom att granska ändringarna.
När bygget är klart öppnar du en webbläsare. Gå till URL:n som är associerad med App Service-instansen för din stagingmiljö .

Om du fortfarande har webbläsarfliken öppen uppdaterar du sidan. Om du inte kommer ihåg URL:en hittar du den i Azure-portalen på App Service-information sidan.

Du ser att webbplatsen Space Game har distribuerats till App Service och är igång.
Som ett valfritt steg i Azure Pipelines väljer du Miljöer. Välj sedan mellanlagring miljö.

Azure Pipelines registrerar din distributionshistorik, vilket gör att du kan spåra ändringar i miljön tillbaka till kodkommit och arbetsobjekt.

Tailspin-teamet samlas för att diskutera sina framsteg. Amita godkänner ändringar i Test-fasen medan de andra tittar.

Tim: För att berätta sanningen var jag först lite nervös för automatiserade lanseringspipelines. Men jag gillar verkligen det här nu när jag ser det fungera. Varje steg kan ha en egen miljö, associerade tester och godkännare. Pipelinan automatiserar många uppgifter som vi var tvungna att göra manuellt. Men vi har fortfarande kontroll över var vi behöver det.

Amita: jag kan tänka mig att vi gör något liknande för att underlätta förändringar från Mellanlagring till Produktion. På tal om... när lägger vi till en produktionsmiljö?

Andy: inom kort. Jag tror att vi fortfarande måste fylla i några bitar här först innan vi lägger till det.

Övning – Främja till Stagingmiljö

Skapa testmiljön

Flytta upp ändringar till förberedelsemiljö

Feedback