Övning – Implementera det blågröna distributionsmönstret

10 minuter

I Skapa en pipeline för flera steg med hjälp av Azure Pipelinesskapar du en grundläggande distributionspipeline som distribuerar ett webbprogram till Azure App Service i dessa steg: Dev, Testoch Mellanlagring.

Här lägger du till det arbetsflödet genom att använda distributionsmönstret blågrön under mellanlagring.

För att göra det gör du:

Lägg till distributionsplats i App Service-instans som motsvarar Staging.
Lägg till en uppgift i pipelinen för att växla distributionsplatserna.

Lägg till en distributionsplats

Här lägger du till en distributionsplats i App Service-instansen som motsvarar Staging.

Som standard tillhandahåller varje App Service-instans ett standardfack med namnet produktion. I föregående avsnitt implementerade du till -produktionsplatsen när du konfigurerade pipelinen.

En App Service-instans kan ha flera platser. Här lägger du till en andra distributionsplats till App Service-instansen som motsvarar Staging. Distributionsfacket heter swap.

Så här lägger du till platsen:

Gå till Azure-portalen och logga in.
På menyn väljer du Cloud Shell-. När du blir uppmanad, välj Bash-upplevelse.
Kör följande kommando för att hämta namnet på App Service-instansen som motsvarar mellanlagring och för att lagra resultatet i en Bash-variabel med namnet staging.
```
staging=$(az webapp list \
  --resource-group tailspin-space-game-rg \
  --query "[?contains(@.name, 'tailspin-space-game-web-staging')].{name: name}" \
  --output tsv)
```
Argumentet --query använder JMESPath, som är ett frågespråk för JSON. Argumentet väljer den App Service-instans vars name fält innehåller "tailspin-space-game-web-staging".
Skriv ut variabeln staging för att kontrollera att du får rätt namn.
```
echo $staging
```
Här är ett exempel på utdata:
```
tailspin-space-game-web-staging-1234
```

Kör följande kommando för att lägga till ett fack med namnet växla till din mellanlagring miljö.

az webapp deployment slot create \
  --name $staging \
  --resource-group tailspin-space-game-rg \
  --slot swap

Kör följande kommando för att visa distributionsfackets värdnamn.

az webapp deployment slot list \
    --name $staging \
    --resource-group tailspin-space-game-rg \
    --query [].hostNames \
    --output tsv

Resultatet liknar dessa utdata:

tailspin-space-game-web-staging-25391-swap.azurewebsites.net

Anteckna värdnamnet för senare.

Som ett valfritt steg går du till din webbplats i en webbläsare. Du ser standardsidan eftersom du ännu inte har distribuerat din kod till denna slot.

Som standardinställning är en distributionsplats tillgänglig från internet. I praktiken kan du konfigurera ett virtuellt Azure-nätverk som placerar din swap slot i ett nätverk som inte kan routas från internet, men som bara ditt team kan komma åt. Din produktionsplats kan fortfarande nås från Internet.

Byt distributionsplatser i staging-miljö

Här använder du uppgiften AzureAppServiceManage@0 för att växla distributionsslotar i din Staging-miljö.

Du kan också använda den här uppgiften för att starta, stoppa eller ta bort ett fack. Du kan också använda det för att installera webbplatstillägg eller för att aktivera kontinuerlig övervakning på App Service.

I Visual Studio Code ändrar du azure-pipelines.yml med hjälp av den här koden:

Tips

Du kan ersätta hela filen eller bara uppdatera den del som är markerad.

trigger:
- '*'

variables:
  buildConfiguration: '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
  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
  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'
              deployToSlotOrASE: 'true'
              resourceGroupName: 'tailspin-space-game-rg'
              slotName: 'swap'
              appName: '$(WebAppNameStaging)'
              package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
          - task: AzureAppServiceManage@0
            displayName: 'Swap deployment slots'
            inputs:
              azureSubscription: 'Resource Manager - Tailspin - Space Game'
              resourceGroupName: 'tailspin-space-game-rg'
              webAppName: '$(WebAppNameStaging)'
              sourceSlot: 'swap'
              targetSlot: 'production'
              action: 'Swap Slots'

Observera dessa ändringar:

Den AzureWebApp@1 aktiviteten anger nu följande värden:
- deployToSlotOrASEdistribueras när den är inställd på truetill en befintlig distributionsplats.
- resourceGroupName anger namnet på resursgruppen. Det här värdet krävs när deployToSlotOrASE är true.
- slotName anger namnet på distributionsplatsen. Här distribuerar du till facket med namnet och växlar till.
Den nya uppgiften, AzureAppServiceManage@0, växlar driftsplatserna.
- sourceSlot och targetSlot anger vilka platser som ska bytas.
- action anger vilken åtgärd som ska vidtas. Kom ihåg att du kan använda den här uppgiften för att starta, stoppa eller ta bort ett fack. Här specificerar "Byt platser" att käll- och målplatserna ska bytas.

Den här konfigurationen distribueras alltid till swapplats. Den byter sedan ut produktions- och växla fack. Växlingsprocessen säkerställer att produktionen av pekar på den senaste distributionen.

Lägg till azure-pipelines.yml i indexet i den integrerade terminalen. Genomför ändringarna och push-överför sedan grenen till GitHub.

Tips

Spara azure-pipelines.yml innan du kör dessa Git-kommandon.
```
git add azure-pipelines.yml
git commit -m "Swap deployment slots"
git push origin blue-green
```
I Azure Pipelines spårar du bygget genom vart och ett av stegen.

Not

Om du stöter på följande fel ...'staging' slot did not respond to http ping. (CODE: 417) prova att starta om apptjänsten. Om problemet kvarstår, återställ automatisk växling för din plats.

Som ett valfritt steg går du till den URL som motsvarar varje steg i en webbläsare.

Trots att du ännu inte har gjort några ändringar på webbplatsen, ser du att webbplatsen för Space Game har distribuerats framgångsrikt till varje App Service-miljö.

Övning – Implementera det blågröna distributionsmönstret

Lägg till en distributionsplats

Byt distributionsplatser i staging-miljö

Feedback